Trabajar con mensajes de entrada grandes para propagar varios mensajes de salida

La representación de árbol de un mensaje suele ser más grande que la corriente de bits de entrada. La manipulación de un árbol de mensajes de gran tamaño puede requerir mucho almacenamiento, pero puede codificar métodos Java™ que ayuden a reducir la carga de almacenamiento en el nodo de integración.

Acerca de esta tarea

Cuando se analiza una corriente de bits de entrada y se crea un árbol lógico, la representación de árbol de un mensaje suele ser más grande, y en algunos casos mucho más grande, que la corriente de bits correspondiente.

Entre los motivos de esta expansión se incluyen los siguientes factores:

La adición de punteros que enlazan los objetos entre sí
La conversión de datos de tipo carácter a Unicode, que puede duplicar el tamaño original
La inclusión de los nombres de campo que pueden ser implícitos en la corriente de bits
La presencia de datos de control asociados al funcionamiento del nodo de integración

La manipulación de un árbol de mensajes grande puede requerir mucho almacenamiento. Si diseña un flujo de mensajes que maneja mensajes grandes que se componen de estructuras de repetición, puede codificar métodos Java que ayuden a reducir la carga de almacenamiento en el nodo de integración. Estos métodos permiten acceder al mensaje de forma tanto aleatoria como secuencial, pero presuponen que no necesita acceder a todo el mensaje a la vez.

Estos métodos Java hacen que el nodo de integración complete un análisis limitado del mensaje y que se mantenga en el almacenamiento a la vez, sólo esa parte del árbol de mensajes que refleja un único registro. Si el proceso requiere que retenga información de registro a registro (por ejemplo, para calcular un precio total a partir de una estructura repetitiva de artículos en un orden), puede declarar, inicializar y mantener variables Java, o puede guardar valores en otra parte del árbol de mensajes; por ejemplo, en el entorno local.

Esta técnica reduce la memoria que utiliza el nodo de integración a la necesaria para contener las secuencias de bits de entrada y de salida completas, más la memoria necesaria para los árboles de mensajes de un solo registro. Esta técnica también proporciona un ahorro de memoria incluso cuando se encuentra un pequeño número de resolicitudes en el mensaje. El nodo de integración utiliza el análisis parcial y la posibilidad de analizar partes especificadas del árbol de mensajes, a y desde la parte correspondiente de la corriente de bits.

Para utilizar estas técnicas en el nodo JavaCompute (o nodo Java definido por el usuario), realice cualquiera de los pasos siguientes.

Copie el objeto MbMessage de entrada utilizando el constructor de copia. Esta acción crea una copia modificable del mensaje de entrada que no se analiza y que, por consiguiente, utiliza una cantidad mínima de memoria.
Evite inspeccionar el mensaje de entrada, esto evita la necesidad de analizar el mensaje.
Utilice un bucle y una variable MbElement para recorrer el mensaje registro a registro. Para cada registro, utilice los procesos siguientes:
- Utilice transformaciones normales para construir un subárbol de salida correspondiente en un MbMessage de salida.
- Utilice el método MbElement.delete() para suprimir el árbol de mensajes del registro de entrada actual cuando haya completado la manipulación del registro.
- Utilice el código siguiente para propagar el mensaje de salida para el registro actual.
```
MbOutputTerminal.propagate(MbMessageAssembly, true)
```
  Este proceso permite recuperar y reutilizar recursos de árbol de mensajes y analizadores para la siguiente iteración del mensaje de salida.

Puede variar estas técnicas para adaptarlas al proceso necesario para los mensajes.

El siguiente código Java de ejemplo muestra cómo analizar un mensaje de entrada grande con muchos registros repetitivos, donde cada registro se propaga como un mensaje de salida individual.

Los mensajes XMLNSC de entrada están el formato siguiente, donde hay muchos elementos Record repetitivos.

<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>

El ejemplo siguiente muestra el código Java que se puede utilizar para analizar este mensaje grande, un registro cada vez, y propagar cada registro.

//Make a modifiable MbMessage based on the input message passed in on the inAssembly.
MbMessage clonedInMessage = new MbMessage(inAssembly.getMessage());
//Now partially parse the cloned input message one record at a time.
MbElement inputRootElement = clonedInMessage.getRootElement();
MbElement inputPropertiesElement = inputRootElement.getFirstElementByPath("Properties");
MbElement inputMQMDElement = inputRootElement.getFirstElementByPath("MQMD");
MbElement inputXMLNSCElement = inputRootElement.getFirstElementByPath("XMLNSC");

MbElement inputXMLNSCRootTagElement = inputXMLNSCElement.getFirstChild(); //Move to the TestCase tag
MbElement currentInputRecord = inputXMLNSCRootTagElement.getFirstChild(); //Move to the Record tag

while(currentInputRecord != null)
{
  // Create a new output message for the record that we are going to be propagate.
  MbMessage outputMessage = new MbMessage();
  MbMessageAssembly outAssembly = new MbMessageAssembly(inAssembly, outputMessage);

  //Create new parsers folders in the output message.
  MbElement outputRootElement = outputMessage.getRootElement();
  MbElement outputPropertiesElement = outputRootElement.createElementAsLastChild(inputPropertiesElement.getParserClassName());
  MbElement outputMQMDElement = outputRootElement.createElementAsLastChild(inputMQMDElement.getParserClassName());
  MbElement outputXMLNSCElement = outputRootElement.createElementAsLastChild(inputXMLNSCElement.getParserClassName());       
  //Create the root tag in the output XMLNSC folder that will be used for this output record.
  MbElement outputXMLNSCRootTag = outputXMLNSCElement.createElementAsLastChild(MbElement.TYPE_NAME, "TestCase", null);
  //Create the record tag for this output message instance.
  MbElement currentOutputRecord = outputXMLNSCRootTag.createElementAsLastChild(MbElement.TYPE_NAME, "Record", null);

  //Copy the Properties Folder, MQMD header, and the current record.
  outputPropertiesElement.copyElementTree(inputPropertiesElement);
  outputMQMDElement.copyElementTree(inputMQMDElement);
  currentOutputRecord.copyElementTree(currentInputRecord);   

  //Propagate this message, requesting that the output message assembly be cleared after propagation.
  out.propagate(outAssembly, true);
  //Note: You do not need to call clearMessage on outputMessage because it was cleared after the propagation.

  //Take a reference to the current record so that it can be deleted.
  MbElement previousInputRecord = currentInputRecord;
  //Now move to the next input record ready for processing.
  currentInputRecord = currentInputRecord.getNextSibling();
  //Now that we have moved to the next sibling, delete the input record that has already been processed.
  previousInputRecord.delete();

}

Este código Java genera un mensaje para cada subárbol de registro repetitivo en el mensaje XMLNSC de entrada:

<Record>
  <Field1>A</Field1>
  <Field2>B</Field2>
  <Field3>C</Field3>
  <Field4>D</Field4>
  <Field5>E</Field5>
</Record>