WebSphere Message Broker, Versão 8.0.0.5 Sistemas operacionais: AIX, HP-Itanium, Linux, Solaris, Windows, z/OS

Consulte as informações sobre a versão mais recente do produto em IBM Integration Bus, Versão 9.0

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 WebSphere Message Broker Toolkit, você deve criar um novo projeto Java:
  1. Clique em Arquivo > Novo > Projeto. Selecione Java e clique em Avançar.
  2. No campo Nome do Projeto, insira um nome de projeto e clique em Avançar.
  3. Na área de janela Configurações Java, selecione a guia Bibliotecas e clique em Incluir JARs Externos.
  4. Selecione install_dir\classes\jplugin2.jar.
  5. Siga os prompts nas outras guias para definir quaisquer outras definições de construção.
  6. 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 broker é registrada com o broker 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 broker para cada mensagem que é transmitida pelo fluxo.

O nome de classe deve terminar com a palavra "Node". Por exemplo, se você tiver designado o nome como Basic no WebSphere Message Broker Toolkit, o nome de classe deverá ser BasicNode.

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 WebSphere Message Broker Toolkit:
  1. Clique em Arquivo > Novo > Outro, selecione Classe e, em seguida, clique em Avançar.
  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.

Para propagar o mesmo objeto MbMessage diversas vezes, chame o método finalizeMessage() no objeto MBMessage, de forma que todas as mudanças feitas na mensagem sejam refletidas no fluxo de bits que é gerado no recebimento de dados do nó Java; por exemplo:
MbMessage newMsg = new MbMessage(assembly.getMessage());
MbMessageAssembly newAssembly = new MbMessageAssembly(assembly, newMsg);
...
newMsg.finalizeMessage(MbMessage.FINALIZE_NONE);
out.propagate(newAssembly;
...
newMsg.finalizeMessage(MbMessage.FINALIZE_NONE);
out.propagate(newAssembly);

Declarando o Nome do Nó

O nome do nó deve ser o mesmo utilizado no WebSphere Message Broker Toolkit. 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;
}

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

O broker 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 broker 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 broker:
  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 broker.
  • Você remove o nó ou o fluxo de mensagens que contém o nó e reimplementa a configuração.
Se desejar que o nó execute alguma operação de limpeza, por exemplo, fechando soquetes, inclua uma implementação do método onDelete:
public void onDelete()
{
  // executar limpeza do nó se necessário
}

Esse método é chamado pelo broker imediatamente antes de ele excluir o nó.

Avisos | Marcas Registradas | Downloads | Biblioteca | Suporte | Feedback

Copyright IBM Corporation 1999, 2014Copyright IBM Corporation 1999, 2014.

        
        Última atualização:
        
        Última atualização: 2015-02-28 18:30:26


Tópico de TarefaTópico de Tarefa | Versão 8.0.0.5 | as09970_