Criando um Processamento de Mensagem ou Nó de Saída em Java

Um nó de processamento de mensagem é utilizado para processar uma mensagem e um nó de saída é utilizado para enviar uma mensagem para a saída como um fluxo de bits.

Antes de começar

O WebSphere Message Broker fornece a origem para dois nós de amostra definidos pelo usuário chamados SwitchNode e TransformNode. Você pode utilizar esses nós em seus estados atuais ou poderá modificá-los.

Ao codificar um nó de processamento de mensagens ou um nó de saída, os dois tipos fornecem basicamente as mesmas funções. Você pode desempenhar o processamento de mensagens em um nó de saída e, da mesma forma, pode propagar uma mensagem de saída para um fluxo de bits a partir de um nó do processamento de mensagens. Para simplificar, este tópico refere-se principalmente ao nó como um nó de processamento de mensagens, mas não discute a funcionalidade dos dois tipos de nó.

Um nó Java definido pelo usuário é distribuído como um arquivo .jar.

Criando um Novo Projeto Java

Antes de poder criar os nós Java no ambiente de trabalho, você deve criar um novo projeto Java:
  1. Alterne para a perspectiva Java.
  2. Clique em Arquivo > Novo > Projeto. Selecione Java no menu esquerdo e, em seguida, selecione Projeto Java no menu direito.
  3. Dê um nome ao projeto.

    O painel Configurações Java exibido.

  4. Selecione a guia Bibliotecas e clique em Incluir JARs Externos.
  5. Selecione install_dir\classes\jplugin2.jar.
  6. Siga os prompts nas outras guias para definir quaisquer outras definições de construção.
  7. Clique em Concluir.
Agora é possível desenvolver a origem de seu nó Java nesse projeto.

Declarando a Classe do Nó de Processamento de Mensagem

Qualquer classe que implemente MbNodeInterface e que esteja contida no caminho da LIL do intermediário é registrada com o intermediário como um nó de processamento de mensagem. Ao implementar MbNodeInterface, você também deve implementar um método evaluate para essa classe. O método evaluate é chamado pelo intermediário para cada mensagem que é transmitida pelo fluxo.

Por exemplo, para declarar a classe de nó de processamento de mensagem:
package com.ibm.jplugins;

import com.ibm.broker.plugin.*;

public class BasicNode extends MbNode implements MbNodeInterface
Declare a classe no ambiente de trabalho:
  1. Clique em Arquivo > Novo > Classe.
  2. Defina o pacote e os campos de nome de classe para valores adequados.
  3. Exclua o texto no campo de texto Superclasse e clique no botão Procurar.
  4. Selecione MbNode e clique em OK.
  5. Clique no botão Incluir próximo ao campo de texto Interfaces e selecione MbNodeInterface.
  6. Clique em Concluir.

Definindo o Construtor de Nó

Quando o nó é instanciado, o construtor da classe de nó do usuário é chamado. Crie os terminais do nó e inicialize quaisquer valores padrão para os atributos nesse construtor.

Um nó de processamento de mensagem tem um número de terminais de entrada e de terminais de saída associados a ele. Utilize os métodos createInputTerminal e createOutputTerminal para incluir terminais em um nó quando ele é instanciado.

Por exemplo, para criar um nó com um terminal de entrada e dois terminais de saída:

public MyNode() throws MbException
{
		// criar os terminais aqui
		createInputTerminal ("in");
		createOutputTerminal ("out");
		createOutputTerminal ("failure");
}

Acessando os Dados da Mensagem

Em muitos casos, o nó definido pelo usuário necessita acessar o conteúdo da mensagem recebida em seu terminal de entrada. A mensagem é representada como uma árvore de elementos de sintaxe. Utilize a função de utilitário fornecida para os métodos evaluatepara gerenciamento de mensagem, acesso ao buffer de mensagem, navegação de elemento da sintaxe e acesso ao elemento da sintaxe.

A classe MbElement fornece a interface para os elementos de sintaxe.

Por exemplo:

  1. Para navegar até o elemento de sintaxe relevante na mensagem XML:
        MbElement rootElement = assembly.getMessage().getRootElement();
        MbElement switchElement =
    rootElement.getLastChild().getFirstChild().getFirstChild();
  2. Para selecionar o terminal indicado pelo valor desse 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);

Transformando um Objeto Mensagem

A mensagem de entrada recebida é somente leitura, portanto, para que uma mensagem possa ser transformada, é preciso gravá-la para uma nova mensagem de saída. É possível copiar elementos da mensagem de entrada ou criar novos elementos na mensagem de saída.

A classe MbMessage fornece os construtores de cópia e os métodos para obter o elemento raiz da mensagem. A classe MbElement fornece a interface para os elementos de sintaxe.

Por exemplo, se houver um conjunto de mensagens de entrada com mensagens integradas, será possível ter o seguinte código no método evaluate do nó definido pelo usuário:
  1. Para criar uma nova cópia do conjunto de mensagens e suas mensagens incorporadas:
        MbMessage newMsg = new MbMessage(assembly.getMessage());
        MbMessageAssembly newAssembly = new MbMessageAssembly(assembly, newMsg);
  2. Para navegar até o elemento de sintaxe relevante na mensagem XML:
        MbElement rootElement = newAssembly.getMessage().getRootElement();
        MbElement switchElement =
    rootElement.getFirstElementByPath("/XML/data/action");
  3. Para alterar o valor de um 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 incluir uma nova tag como um filho da tag chave:
        MbElement tag = switchElement.createElementAsLastChild(MbElement.TYPE_NAME,
                                                               "PreviousValue",
                                                               elementValue);
  5. Para incluir um atributo na nova tag:
        tag.createElementAsFirstChild(MbElement.TYPE_NAME_VALUE,
                                      "NewValue",
                                      switchElement.getValue());
    
        MbOutputTerminal out = getOutputTerminal("out");
Como parte da transformação, pode ser necessário criar um novo corpo da mensagem. Para criar um novo corpo da mensagem, utilize um das seguintes métodos, que especificam um analisador a uma pasta da árvore de mensagens:
createElementAfter(String)
createElementAsFirstChild(String)
createElementAsLastChild(String)
createElementBefore(String)
createElementAsLastChildFromBitstream(byte[], String, String, String, String, int, int, int)
Não utilize os seguintes métodos porque eles não associam um analisador de propriedade à pasta:
createElementAfter(int)
createElementAfter(int, String, Object)
createElementAsFirstChild(int)
createElementAsFirstChild(int, String, Object)
createElementAsLastChild(int)
createElementAsLastChild(int, String, Object)
createElementBefore(int)
createElementBefore(int, String, Object)

Propagando a Mensagem

Antes de propagar a mensagem, decida sobre quais dados do fluxo de mensagens você deseja propagar e se propagar para um terminal do nó ou para um nó Label.

Por exemplo:
  1. Para propagar a mensagem para o terminal de saída "out":
    MbOutputTerminal out = getOutputTerminal("out");
            out.propagate(newAssembly);
  2. Para propagar a mensagem a um nó Label:
    MbRoute label1 = getRoute ("label1");
    Label1.propagate(newAssembly);

Chame a função clearMessage() no bloco finally de try/catch para limpar a memória que é alocada para a árvore de mensagens.

Declarando o Nome do Nó

O nome do nó deve ser o mesmo utilizado no ambiente de trabalho. Todos os nomes de nós devem terminar com "Node". Declare o nome utilizando o seguinte método:

public static String getNodeName()
{
   return "BasicNode";
}
Se esse método não é declarado, a estrutura de API Java cria um nome de nó padrão utilizando as seguintes regras:
  • O nome da classe é anexado ao nome do pacote.
  • Os pontos são removidos e a primeira letra de cada parte do pacote e do nome da classe é transformada em maiúsculas.
Por exemplo, por padrão o nome de nó "ComIbmPluginsamplesBasicNode" é atribuído à seguinte classe:
package com.ibm.pluginsamples;
public class BasicNode extends MbNode implements MbNodeInterface
{
   ...

Declarando Atributos

Declare atributos do nó da mesma forma que propriedades de Java Bean. Você deve gravar métodos getter e setter para os atributos. A estrutura da API infere os nomes dos atributos utilizando as regras de introspecção do Java Bean. Por exemplo, se você declarar os dois métodos seguintes:

private String attributeVariable;

public String getFirstAttribute()
{
  return attributeVariable;
}

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

O intermediário inferirá que esse nó tem um atributo chamado firstAttribute. Esse nome é derivado dos nomes dos métodos get ou set, não de nenhum nome de variável de membro de classe interna. Os atributos somente podem ser expostos como cadeias, portanto é preciso converter qualquer tipo numérico em cadeias e de cadeias nos métodos get ou set. Por exemplo, o método a seguir define um atributo chamado timeInSeconds:

int seconds;

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

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

Implementando a Funcionalidade do Nó

O método evaluate, definido em MbNodeInterface, é chamado pelo intermediário para processar a mensagem. Toda a função de processamento do nó é incluída nesse método.

O método evaluate tem dois parâmetros que são transmitidos pelo intermediário:
  1. O MbMessageAssembly, que contém os seguintes objetos que são acessados utilizando os métodos apropriados:
    • A mensagem de entrada
    • O LocalEnvironment
    • O Environment global
    • A ExceptionList
  2. O terminal de entrada no qual a mensagem chegou.
Por exemplo, a seguinte extração de código mostra como o método evaluate pode ser gravado:
public void evaluate(MbMessageAssembly assembly, MbInputTerminal inTerm) throws MbException
  {
    // add message processing code here

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

Os dados do fluxo de mensagens, que consiste em mensagem, Environment, LocalEnvironment e ExceptionList, são recebidos no terminal de entrada do nó.

Excluindo uma Instância do Nó

Uma instância do nó é excluída quando:
  • Você encerra o intermediário.
  • Você remove o nó ou o fluxo de mensagens que contém o nó e reimplementa a configuração.
Se você desejar que o nó desempenhe quaisquer operações de limpeza, por exemplo, fechar soquetes, inclua uma implementação do método onDelete:
public void onDelete()
{
  // executar limpeza do nó se necessário
}

Esse método é chamado pelo intermediário imediatamente antes de ele excluir o nó.

Referências relacionadas
Estrutura da Lista de Exceções
Nó Label
Avisos | Marcas Registradas | Downloads | Biblioteca | Suporte | Feedback

Copyright IBM Corporation 1999, 2009Copyright IBM Corporation 1999, 2009.
Última atualização : 2009-02-13 16:13:11

as09970_