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

Trabalhando com Mensagens de Entrada Grandes para Propagar Várias Mensagens de Saída

A representação em árvore de uma mensagem normalmente é maior que o fluxo de bits de entrada. A manipulação de uma grande árvore de mensagens pode requerer muito armazenamento, mas é possível codificar métodos Java™ que ajudam a reduzir a carga de armazenamento no broker.

Quando um fluxo de bits de entrada é analisado e uma árvore lógica é criada, a representação em árvore de uma mensagem é geralmente maior e, em alguns casos, muito maior, que o fluxo de bits correspondente.
As razões para essa expansão incluem os seguintes fatores:
  • A inclusão de ponteiros que vinculam os objetos em conjunto
  • Conversão de dados de caracteres em Unicode, o que pode duplicar o tamanho
  • A inclusão de nomes de campos que podem ter sido implícitos no fluxo de bits
  • A presença de dados de controle associados à operação do broker

A manipulação de uma árvore de mensagens grande pode exigir muito armazenamento. Se você projetar um fluxo de mensagens que manipule mensagens grandes compostas de estruturas de repetição, poderá codificar métodos Java que ajudam a reduzir a carga de armazenamento no broker. Esses métodos suportam o acesso aleatório e sequencial à mensagem, mas supõem que você não necessite de acesso à mensagem completa de uma vez.

Esses métodos Java fazem com que o broker conclua a análise limitada da mensagem e mantenha o armazenamento ao mesmo tempo, somente da parte da árvore de mensagens que reflete um único registro. Se o seu processamento exigir que você retenha informações de registro a registro (por exemplo, para calcular um preço total de uma estrutura de repetição de itens em uma ordem), será possível declarar, inicializar e manter variáveis Java ou será possível salvar valores em outra parte da árvore de mensagens; por exemplo, no ambiente local.

Essa técnica reduz a memória que é utilizada pelo broker para a memória necessária para manter os fluxos de bits de entrada e saída integrais, mais a memória necessária para as árvores de mensagens de apenas um registro. Essa técnica também fornece economia de memória, mesmo quando um pequeno número de repetições é encontrado na mensagem. O intermediário utiliza a análise parcial e a capacidade de analisar partes específicas da árvore de mensagens na parte correspondente do fluxo de bits.

Para usar essas técnicas em seu nó JavaCompute (ou no nó Java definido pelo usuário), execute algumas das etapas a seguir.
  • Copie o MbMessage de entrada usando o construtor de cópias. Essa ação cria uma cópia modificável da mensagem de entrada que não é analisada e, portanto, utiliza uma quantidade mínima de memória.
  • Evite qualquer inspeção da mensagem de entrada, que evita a necessidade de analisar a mensagem.
  • Use um loop e uma variável MbElement para percorrer a mensagem, um registro de cada vez. Para cada registro, utilize os seguintes processos:
    • Use conversões normais para construir uma subárvore de saída correspondente em um MbMessage de saída.
    • Use o método MbElement.delete() para excluir a árvore de mensagens de registro de entrada quando você concluiu a manipulação de registro.
    • Use o código a seguir para propagar a mensagem de saída para o registro atual.
      MbOutputTerminal.propagate(MbMessageAssembly, true)
      Esse processo permite que recursos e analisadores da árvore de mensagens sejam recuperados e reutilizados para a próxima iteração de mensagem de saída.

Você pode variar estas técnicas para adequar o processamento necessário para suas mensagens.

O código Java de exemplo a seguir demonstra como analisar uma grande mensagem de entrada com vários registros de repetição, em que cada registro é propagado como uma mensagem de saída individual.

As mensagens XMLNSC de entrada estão no formato a seguir, em que há vários elementos Record de repetição.
<TestCase>
  <Record><Field1>A</Field1><Field2>B</Field2><Field3>C</Field3><Field4>D</Field4><Field5>EA</Field5></Record>
  <Record><Field1>A</Field1><Field2>B</Field2><Field3>C</Field3><Field4>D</Field4><Field5>EA</Field5></Record>
  <Record><Field1>A</Field1><Field2>B</Field2><Field3>C</Field3><Field4>D</Field4><Field5>EA</Field5></Record>
  <Record><Field1>A</Field1><Field2>B</Field2><Field3>C</Field3><Field4>D</Field4><Field5>EA</Field5></Record>
  ....
</TestCase>
O exemplo a seguir mostra o código Java que pode ser usado para analisar essa grande mensagem, um registro por vez e propagar cada registro.
//Torne um MbMessage modificável com base na mensagem de entrada passada no inAssembly.
MbMessage clonedInMessage = new MbMessage(inAssembly.getMessage());
//Agora, analise parcialmente a mensagem de entrada clonada, um registro por vez.
MbElement inputRootElement = clonedInMessage.getRootElement();
MbElement inputPropertiesElement = inputRootElement.getFirstElementByPath("Properties");
MbElement inputMQMDElement = inputRootElement.getFirstElementByPath("MQMD");
MbElement inputXMLNSCElement = inputRootElement.getFirstElementByPath("XMLNSC");

MbElement inputXMLNSCRootTagElement = inputXMLNSCElement.getFirstChild(); //Mover para a tag TestCase
MbElement currentInputRecord = inputXMLNSCRootTagElement.getFirstChild(); //Mover para a tag Record

while(currentInputRecord != null)
{
  // Crie uma nova mensagem de saída para o registro que vamos propagar.
  MbMessage outputMessage = new MbMessage();
  MbMessageAssembly outAssembly = new MbMessageAssembly(inAssembly, outputMessage);

  //Crie novas pastas de analisadores na mensagem de saída.
  MbElement outputRootElement = outputMessage.getRootElement();
  MbElement outputPropertiesElement = outputRootElement.createElementAsLastChild(inputPropertiesElement.getParserClassName());
  MbElement outputMQMDElement = outputRootElement.createElementAsLastChild(inputMQMDElement.getParserClassName());
  MbElement outputXMLNSCElement = outputRootElement.createElementAsLastChild(inputXMLNSCElement.getParserClassName());       
  //Crie a tag raiz na pasta XMLNSC de saída que será usada para este registro de saída.
  MbElement outputXMLNSCRootTag = outputXMLNSCElement.createElementAsLastChild(MbElement.TYPE_NAME, "TestCase", null);
  //Crie a tag de registro para essa instância de mensagem de saída.
  MbElement currentOutputRecord = outputXMLNSCRootTag.createElementAsLastChild(MbElement.TYPE_NAME, "Record", null);

  //Copie a Pasta de Propriedades, o cabeçalho MQMD e o registro atual.
  outputPropertiesElement.copyElementTree(inputPropertiesElement);
  outputMQMDElement.copyElementTree(inputMQMDElement);
  currentOutputRecord.copyElementTree(currentInputRecord);   

  //Propague esta mensagem, solicitando que o conjunto da mensagem de saída seja limpo após a propagação.
  out.propagate(outAssembly, true);
  //Nota: Não é necessário chamar clearMessage em outputMessage porque ele foi limpo após a propagação.

  //Tome uma referência para o registro atual para que ele possa ser excluído.
  MbElement previousInputRecord = currentInputRecord;
  //Agora, mova para o próximo registro de entrada pronto para processamento.
  currentInputRecord = currentInputRecord.getNextSibling();
  //Agora que movemos para o próximo irmão, exclua o registro de entrada que já foi processado.
  previousInputRecord.delete();

}
Esse código Java produz uma mensagem para cada subárvore de Registro de repetição na mensagem XMLNSC de entrada:
<Record>
  <Field1>A</Field1>
  <Field2>B</Field2>
  <Field3>C</Field3>
  <Field4>D</Field4>
  <Field5>E</Field5>
</Record>
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:53


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