Puede mejorar el rendimiento del flujo de mensajes con Java™ utilizando algunas técnicas de optimización.
El nodo JavaCompute le
permite incluir cualquier proceso
Java válido y es común para
volver a utilizar clases
Java existentes para funciones
específicas. Sin embargo, este código afecta al rendimiento del flujo
de mensajes, para asegurarse de que cualquier código utilizado de
este modo sea eficaz.

Siempre que sea posible,
utilice las funciones y los nodos suministrados de
IBM®WebSphere Message Broker para realizar el
proceso en un mensaje, en lugar de volver a crear la función que ya se
ha
proporcionado.
Por ejemplo, no utilice un analizador XML
personalizado dentro del nodo
JavaCompute. El analizador
XMLNSC que se proporciona con
WebSphere Message Broker es un analizador de alto
rendimiento que también ofrece la validación para un esquema, y el
árbol de mensajes que se genera se puede utilizar en todo el flujo de
mensajes. Este no es el caso con un analizador personalizado con sus
propias
estructuras de datos. 
Evite iniciar procesos nuevos en el nodo
JavaCompute para realizar
un trabajo específico. Esto es costoso en términos de rendimiento y produce costes
de CPU adicionales y una carga mayor en el sistema, porque muchos
procesos de corta duración se inician y finalizan cuando el
trabajo se ha completado. Una de las ventajas del tiempo de ejecución
de WebSphere Message Broker es que los
procesos tienen una larga duración y se minimiza la inicialización. Esto reduce los costes de proceso totales, porque no se inician procesos nuevos cada vez que se invoca el flujo de mensajes. 
Para obtener información sobre las herramientas que puede utilizar para evaluar el estado actual de una aplicación Java en ejecución, consulte developerWorks IBM Monitoring and Diagnostic Tools for Java - Health Center Version 2.1.
Evitar crear y navegar por árboles sin referencias intermedias. Por ejemplo, el código siguiente navega de forma repetida desde root para crear el árbol:
MbMessage newEnv = new MbMessage(inAssembly.getMessage());
newEnv.getRootElement().createElementAsFirstChild(MbElement.TYPE_NAME, "Destination", null);
newEnv.getRootElement().getFirstChild().createElementAsFirstChild(MbElement.TYPE_NAME, "MQDestinationList", null);
newEnv.getRootElement().getFirstChild().getFirstChild().createElementAsFirstChild(MbElement.TYPE_NAME,"DestinationData", null);
Sin embargo, resulta más eficaz almacenar las referencias tal como se muestra en el ejemplo siguiente:
MbMessage newEnv = new MbMessage(inAssembly.getMessage());
MbElement destination = newEnv.getRootElement().createElementAsFirstChild(MbElement.TYPE_NAME,"Destination", null);
MbElement mqDestinationList = destination.createElementAsFirstChild(MbElement.TYPE_NAME, "MQDestinationList",
null);
mqDestinationList.createElementAsFirstChild(MbElement.TYPE_NAME,"DestinationData", null);
El operador + tiene un impacto negativo en el rendimiento debido a que implica la creación de un objeto String nuevo para cada concatenación; por ejemplo:
keyforCache = hostSystem + CommonFunctions.separator
+ sourceQueueValue + CommonFunctions.separator
+ smiKey + CommonFunctions.separator
+ newElement;
Para mejorar el rendimiento, utilice la clase StringBuffer y el método append para concatenar los objetos java.lang.String, en lugar del operador +, tal como se muestra en el ejemplo siguiente:
StringBuffer keyforCacheBuf = new StringBuffer();
keyforCacheBuf.append(hostSystem);
keyforCacheBuf.append(CommonFunctions.separator);
keyforCacheBuf.append(sourceQueueValue);
keyforCacheBuf.append(CommonFunctions.separator);
keyforCacheBuf.append(smiKey);
keyforCacheBuf.append(CommonFunctions.separator);
keyforCacheBuf.append(newElement);
keyforCache = keyforCacheBuf.toString();
Si desea procesar un BLOB (cortándolo en fragmentos o insertando caracteres, por ejemplo), es eficaz utilizar un nodo JavaCompute con sus potentes prestaciones de proceso. Si está utilizando un nodo JavaCompute, utilice ByteArrays y ByteArrayOutputStream para procesar el BLOB.
Evitar invocar manualmente la recogida de basura, porque se suspende el proceso en la JVM, lo que inhibe significativamente la productividad de mensajes. En un ejemplo, un flujo de mensajes de transformación basada en Java que estaba procesando a una velocidad de 1300 mensajes por segundo sin recogida de basura manual se redujo a 100 mensajes por segundo cuando una llamada de recogida de basura manual se añadió a cada mensaje que se estaba procesando.
