Creación de un nodo de salida o de proceso de mensajes en Java

Un nodo de proceso de mensajes se utiliza para procesar un mensaje y un nodo de salida se utiliza para producir un mensaje como una corriente de bits.

Antes de empezar

WebSphere Message Broker proporciona el origen de dos nodos definidos por el usuario de ejemplo denominados SwitchNode y TransformNode. Puede utilizar estos nodos en su estado actual o puede modificarlos.

Cuando codifica un nodo de proceso de mensajes o un nodo de salida, los dos tipos proporcionan esencialmente las mismas funciones. Puede realizar el proceso de mensajes en un nodo de salida y, del mismo modo, puede propagar un mensaje de salida en una corriente de bits desde un nodo de proceso de mensajes. Para una mayor sencillez, este tema hace referencia principalmente al nodo como nodo de proceso de mensajes, pero describe la funcionalidad de ambos tipos de nodo.

Un nodo Java definido por el usuario se distribuye como un archivo .jar.

Creación de un nuevo proyecto Java

Para poder crear nodos Java en el entorno de trabajo, debe crear un nuevo proyecto Java:
  1. Vaya a la perspectiva Java.
  2. Pulse Archivo > Nuevo > Proyecto. Seleccione Java en el menú de la izquierda y, a continuación, seleccione Proyecto Java en el menú de la derecha.
  3. Déle un nombre al proyecto.

    Se visualiza el panel Valores Java.

  4. Seleccione el separador Bibliotecas y pulse Añadir JAR externos.
  5. Seleccione dir_instalación\classes\jplugin2.jar.
  6. Siga las solicitudes de los demás separadores para definir otros valores de creación.
  7. Pulse Finalizar.
Ahora puede desarrollar el origen del nodo Java en este proyecto.

Declaración de la clase de nodo de proceso de mensajes

Cualquier clase que implemente MbNodeInterface, y esté contenida en la vía de acceso de LIL del intermediario, se registra en el intermediario como un nodo de proceso de mensajes. Cuando implemente MbNodeInterface, también deberá implementar un método de evaluación para esta clase. El intermediario invoca el método de evaluación para cada mensaje que pasa a través del flujo.

Por ejemplo, para declarar la clase de nodo de proceso de mensajes:
package com.ibm.jplugins;

import com.ibm.broker.plugin.*;

public class BasicNode extends MbNode implements MbNodeInterface
Declare la clase en el entorno de trabajo:
  1. Pulse Archivo > Nuevo > Clase.
  2. Establezca los campos de nombre de paquete y clase en los valores apropiados.
  3. Suprima el texto en el campo de texto Superclase y pulse Examinar.
  4. Seleccione MbNode y pulse Aceptar.
  5. Pulse el botón Añadir situado junto al campo de texto de interfaces y seleccione MbNodeInterface.
  6. Pulse Finalizar.

Definición del constructor de nodos

Cuando se crea una instancia del nodo, se invoca el constructor de la clase de nodo del usuario. Cree los terminales del nodo e inicialice los valores predeterminados para los atributos en este constructor.

Un nodo de proceso de mensajes tiene asociados varios terminales de entrada y terminales de salida. Utilice los métodos createInputTerminal y createOutputTerminal para añadir terminales a un nodo cuando se crea una instancia del nodo.

Por ejemplo, para crear un nodo con un terminal de entrada y dos terminales de salida:

public MyNode() throws MbException
{
		// crear terminales aquí
		createInputTerminal ("in");
		createOutputTerminal ("out");
		createOutputTerminal ("failure");
}

Acceso a los datos de mensaje

En muchos casos, el nodo definido por el usuario necesita acceder al contenido del mensaje recibido en el terminal de entrada. El mensaje se representa como un árbol de elementos de sintaxis. Utilice la función de utilidad suministrada para evaluar métodos de gestión de mensajes, acceso al almacenamiento intermedio de mensajes, navegación por los elementos de sintaxis y acceso a los elementos de sintaxis.

La clase MbElement proporciona la interfaz con los elementos de sintaxis.

Por ejemplo:

  1. Para navegar al elemento de sintaxis pertinente del mensaje XML:
        MbElement rootElement = assembly.getMessage().getRootElement();
        MbElement switchElement = 
    			rootElement.getLastChild().getFirstChild().getFirstChild();
  2. Para seleccionar el terminal indicado por el valor de este elemento:
        String terminalName;
        String elementValue = (String)switchElement.getValue();
        if(elementValue.equals("add"))
          terminalName = "add";
        else if(elementValue.equals("change"))
          terminalName = "change";
        else if(elementValue.equals("delete"))
          terminalName = "delete";
        else if(elementValue.equals("hold"))
          terminalName = "hold";
        else
          terminalName = "failure";
        
        MbOutputTerminal out = getOutputTerminal(terminalName);

Transformación de un objeto de mensaje

El mensaje de entrada recibido es de sólo lectura, por lo que para poder transformar el mensaje debe escribirlo en un nuevo mensaje de salida. Puede copiar los elementos del mensaje de entrada o puede crear nuevos elementos en el mensaje de salida.

La clase MbMessage proporciona los constructores de copia y los métodos para obtener el elemento raíz del mensaje. La clase MbElement proporciona la interfaz con los elementos de sintaxis.

Por ejemplo, si tiene un mensaje ensamblado de entrada con mensajes incorporados, puede tener el código siguiente en el método evaluate de su nodo definido por el usuario:
  1. Para crear una copia nueva del mensaje ensamblado y sus mensajes incorporados:
        MbMessage newMsg = new MbMessage(assembly.getMessage());
        MbMessageAssembly newAssembly = new MbMessageAssembly(assembly, newMsg);
  2. Para navegar al elemento de sintaxis pertinente del mensaje XML:
        MbElement rootElement = newAssembly.getMessage().getRootElement();
        MbElement switchElement = 
    			rootElement.getFirstElementByPath("/XML/data/action");
  3. Para cambiar el valor de un elemento existente:
      String elementValue = (String)switchElement.getValue();
        if(elementValue.equals("add"))
          switchElement.setValue("change");
        else if(elementValue.equals("change"))
          switchElement.setValue("delete");
        else if(elementValue.equals("delete"))
          switchElement.setValue("hold");
        else
          switchElement.setValue("failure");
  4. Para añadir un código nuevo como hijo del código de conmutación:
        MbElement tag = switchElement.createElementAsLastChild(MbElement.TYPE_NAME,
                                                               "PreviousValue",
                                                               elementValue);
  5. Para añadir un atributo a este nuevo código:
        tag.createElementAsFirstChild(MbElement.TYPE_NAME_VALUE,
                                      "NewValue",
                                      switchElement.getValue());
    
        MbOutputTerminal out = getOutputTerminal("out");
Como parte de la transformación, es posible que necesite crear un nuevo cuerpo de mensaje. Para crear un nuevo cuerpo de mensaje, utilice uno de los métodos siguientes, que asignan específicamente un analizador a una carpeta de árbol de mensaje:
createElementAfter(String) 
createElementAsFirstChild(String) 
createElementAsLastChild(String) 
createElementBefore(String) 
createElementAsLastChildFromBitstream(byte[], String, String, String, String, int, int, int) 
No utilice los siguientes métodos, que no asocian un analizador propietario con la carpeta:
createElementAfter(int)
createElementAfter(int, String, Object) 
createElementAsFirstChild(int) 
createElementAsFirstChild(int, String, Object) 
createElementAsLastChild(int) 
createElementAsLastChild(int, String, Object) 
createElementBefore(int) 
createElementBefore(int, String, Object) 

Propagación del mensaje

Antes de propagar un mensaje, decida qué datos de flujo de mensajes desea propagar, y si los va a propagar a un terminal de nodo o a un nodo Label.

Por ejemplo:
  1. Para propagar el mensaje al terminal de salida "out":
    MbOutputTerminal out = getOutputTerminal("out");
            out.propagate(newAssembly);
  2. Para propagar el mensaje a un nodo Label:
    MbRoute label1 = getRoute ("label1");
    Label1.propagate(newAssembly);

Llame a la función clearMessage() en el bloque try/catch final para borrar la memoria que está asignada para el árbol de mensaje.

Declaración del nombre de nodo

El nombre del nodo debe ser el mismo que el que se utiliza en el entorno de trabajo. Todos los nombres de nodo deben terminar por "Node". Declare el nombre utilizando el método siguiente:

public static String getNodeName()
{
   return "BasicNode";
}
Si no se declara este método, la infraestructura de API Java crea un nombre de nodo predeterminado utilizando las normas siguientes:
  • El nombre de clase se añade el nombre de paquete.
  • Los puntos se eliminan y la primera letra de cada parte del nombre de paquete y clase se escriben en mayúsculas.
Por ejemplo, por omisión se asigna a la clase siguiente el nombre de nodo "ComIbmPluginsamplesBasicNode":
package com.ibm.pluginsamples;
public class BasicNode extends MbNode implements MbNodeInterface
{
   ...

Declaración de atributos

Declare los atributos de nodo del mismo modo que las propiedades de bean Java. Debe escribir métodos getter y setter para los atributos. La infraestructura de API deduce los nombres de atributo utilizando las normas de introspección de bean de Java. Por ejemplo, si declara los dos métodos siguientes:

private String attributeVariable;

public String getFirstAttribute()
{
  return attributeVariable;
}

publc void setFirstAttribute(String value)
{
  attributeVariable = value;
}

el intermediario deduce que este nodo tiene un atributo denominado firstAttribute. Este nombre se deriva de los nombres de los métodos get o set, no de los nombres de variables de miembros de clase internos. Dado que los atributos sólo se pueden exponer como series de caracteres, los tipos numéricos se deben convertir a series de caracteres, o se deben convertir a partir de series de caracteres, en los métodos get o set. Por ejemplo, el método siguiente define un atributo denominado timeInSeconds:

int seconds;

public String getTimeInSeconds()
{
  return Integer.toString(seconds);
}

public void setTimeInSeconds(String value)
{
  seconds = Integer.parseInt(value);
}

Implementación de la funcionalidad de nodo

El intermediario llama al método evaluate, definido en MbNodeInterface, para procesar el mensaje. Toda la función de proceso para el nodo se incluye en este método.

El método evaluate tiene dos parámetros que se pasan al intermediario:
  1. MbMessageAssembly, que contiene los objetos siguientes a los que se accede utilizando los métodos apropiados:
    • El mensaje de entrada
    • El entorno local
    • El entorno global
    • La lista de excepciones
  2. El terminal de entrada en el que ha llegado el mensaje.
Por ejemplo, el siguiente extracto de código muestra cómo se puede escribir el método evaluate:
public void evaluate(MbMessageAssembly assembly, MbInputTerminal inTerm) throws MbException
  {
    // añadir aquí código de proceso de mensajes

    getOutputTerminal("out").propagate(assembly);
  }

Los datos de flujo de mensajes, que consta del mensaje, entorno, entorno local y lista de excepciones, se reciben en el terminal de entrada del nodo.

Supresión de una instancia del nodo

Se suprime una instancia del nodo cuando se realiza una de las acciones siguientes:
  • Se concluye el intermediario.
  • Se elimina el nodo o el flujo de mensajes que contiene el nodo y se vuelve a desplegar la configuración.
Si desea que el nodo realice alguna operación de limpieza, por ejemplo, cerrar sockets, incluya una implementación del método onDelete:
public void onDelete()
{
  // realizar limpieza de nodo si es necesario
}

El intermediario llama a este método inmediatamente antes de suprimir el nodo.

Avisos | Marcas registradas | Descargas | Biblioteca | Soporte | Su opinión

Copyright IBM Corporation 1999, 2009Copyright IBM Corporation 1999, 2009.
Última actualización : 2009-02-16 13:56:18

as09970_