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.