Receptor de sucesos JMS

JMSObjectGridEventListener se ha diseñado para soportar la invalidación de la memoria caché cercada del cliente y un mecanismo de réplica de igual a igual. Se trata de una implementación JMS (Java Message Service) de la interfaz ObjectGridEventListener.

El mecanismo de invalidación del cliente se puede utilizar en un entorno distribuido de eXtreme Scale para asegurarse de que los datos de la memoria caché cercana del cliente estén sincronizados con los servidores y otros clientes. Sin esta función, la memoria caché cercana del cliente podría albergar datos obsoletos. Sin embargo, incluso con este mecanismo de invalidación de cliente basado en JMS, debe tener en cuenta la ventana de temporización para actualizar una memoria caché cercana debido al retardo para el tiempo de ejecución en la publicación de actualizaciones.

El mecanismo de réplica de igual a igual se puede utilizar en entornos distribuidos y también locales de eXtreme Scale. Se trata de un proceso de réplica de núcleo a núcleo y permite a las actualizaciones de datos fluir entre los ObjectGrids locales y los ObjectGrids distribuidos. Por ejemplo, con este mecanismo puede mover las actualizaciones de datos de una cuadrícula distribuida a un ObjectGrid local, o de una cuadrícula a otra en un distinto dominio de sistema.

JMSObjectGridEventListener requiere que el usuario configure la información de JMS y JNDI (Java Naming and Directory Interface) para poder obtener los recursos JMS necesarios. De forma adicional, las propiedades relacionadas con la réplica se deben definir de forma correcta. En un entorno JEE, JNDI debe estar disponibles en los contenedores web y también en los contenedores EJB (Enterprise JavaBean). En este caso, la propiedad JNDI es opcional, a menos que desee obtener recursos JMS externos.

Este receptor de sucesos tiene propiedades que puede configurar mediante XML o con enfoques programáticos, que se pueden utilizar sólo para la invalidación de cliente, sólo para la réplica de igual a igual, o ambos. La mayoría de propiedades son opcionales para personalizar el comportamiento para conseguir la funcionalidad necesaria.

Si desea más información, consulte API JMSObjectGridEventListener.

Si desea más información, consulta la API JMSObjectGridEventListener.

Ampliación del plug-in JMSObjectGridEventListener

El plug-in JMSObjectGridEventListener permite a las instancias de ObjectGrid iguales recibir actualizaciones cuando los datos de la cuadricula se han modificado o desalojado. También permite notificar a los clientes cuando se actualizan o desalojan entradas de una cuadrícula de eXtreme Scale. Este tema describe cómo ampliar el plug-in JMSObjectGridEventListener para permitir notificar a las aplicaciones cuando se recibe un mensaje JMS. Esto es más práctico cuando se utiliza el valor CLIENT_SERVER_MODEL para la invalidación de clientes.

Cuando se ejecuta en el rol de receptor, la ejecución de eXtreme Scale llama automáticamente al método JMSObjectGridEventListener.onMessage alterado temporalmente cuando la instancia de JMSObjectGridEventListener recibe actualizaciones de mensaje JMS de la cuadrícula. Estos mensajes recortan una colección de objetos LogSequence. Los objetos LogSequence se pasan en el método onMessage y la aplicación utiliza el LogSequence para identificar qué entradas de memoria caché se han insertado, suprimido, actualizado o invalidado.

Para utilizar el punto de ampliación onMessage, las aplicaciones realizan los siguientes pasos.

  1. Cree una nueva clase, ampliando la clase JMSObjectGridEventListener, alterando temporalmente el método onMessage.
  2. Configure el JMSObjectGridEventListener ampliado del mismo modo que el ObjectGridEventListener para ObjectGrid.

El JMSObjectGridEventListener ampliado es una clase hija de JMSObjectGridEventListener y sólo puede alterar temporalmente dos métodos: los métodos initialize (opcional) y onMessage. Si una clase hija de la clase JMSObjectGridEventListener debe utilizar cualquier artefacto de ObjectGrid como, por ejemplo, ObjectGrid o Session en el método onMessage, puede obtener estos artefactos en el método initialize y almacenarlos en la memoria caché como variables de instancia. Además, en el método onMessage, los artefactos de ObjectGrid almacenados en la memoria caché se pueden utilizar para procesar una colección pasada de LogSequences.

Nota: El método initialize alterado temporalmente debe invocar el método super.initialize para poder inicializar un JMSObjectGridEventListener padre de forma apropiada.

A continuación, aparece un ejemplo de una clase JMSObjectGridEventListener ampliada.

package com.ibm.websphere.samples.objectgrid.jms.price;

import java.util.*;
import com.ibm.websphere.objectgrid.*;
import com.ibm.websphere.objectgrid.plugins.LogElement;
import com.ibm.websphere.objectgrid.plugins.LogSequence;
import com.ibm.websphere.objectgrid.plugins.builtins.JMSObjectGridEventListener;

public class ExtendedJMSObjectGridEventListener extends JMSObjectGridEventListener{
	protected static boolean debug = true;
	
    /**
     * Esta es la cuadrícula asociada al receptor.
     */
    	ObjectGrid grid;

    /**
     * Esta es la sesión asociada a este receptor.
     */
    	Session session;
    
    String objectGridType;
    
    public List receivedLogSequenceList = new ArrayList();

 
	/* (no Javadoc)
	 * @see com.ibm.websphere.objectgrid.plugins.builtins.JMSObjectGridEventListener
				#initialize(com.ibm.websphere.objectgrid.Session)
	 */
public void initialize(Session session) {
		// Nota: si debe utilizar algún artefacto de ObjectGrid, este clase necesita obtener el ObjectGrid
		//	 de la instancia pasada de Session y obtener el ObjectMap de la instancia de la sesión
		// para cualquier operación de correlación de ObjectGrid transaccional.
		
		super.initialize(session);  // debe invocar el método initialize de super.
		this.session = session; // almacene en la memoria caché la instancia de la sesión, en caso
		//			que necesite utilizarla para realizar la operación de correlación.
		this.grid = session.getObjectGrid(); // obtenga el ObjectGrid, en caso de
		//			necesitar obtener la información de ObjectGrid.
		
		if (grid.getObjectGridType() == ObjectGrid.CLIENT)
			objectGridType = "CLIENT";
		else if (grid.getObjectGridType() == ObjectGrid.SERVER)
			objectGridType = "Server";

		if (debug)
			System.out.println("ExtendedJMSObjectGridEventListener[" +
					objectGridType + "].initialize() : grid = "	+ this.grid);
	}
	
	/* (no Javadoc)
	 * @see com.ibm.websphere.objectgrid.plugins.builtins.JMSObjectGridEventListener
				#onMessage(java.util.Collection)
	 */
	protected void onMessage(Collection logSequences) {
			System.out.println("ExtendedJMSObjectGridEventListener[" +
				objectGridType + "].onMessage(): ");
		
		Iterator iter = logSequences.iterator();
		
		while (iter.hasNext()) {
            LogSequence seq = (LogSequence) iter.next();
            
    		StringBuffer buffer = new StringBuffer();
    		String mapName = seq.getMapName();
    		int size = seq.size();
    		buffer.append("\nLogSequence[mapName=" + mapName + ", size=" + size + ",
					objectGridType=" + objectGridType
    				+ "]: ");

    		Iterator logElementIter = seq.getAllChanges();
    		for (int i = seq.size() - 1; i >= 0; --i) {
    			LogElement le = (LogElement) logElementIter.next();
    			buffer.append(le.getType() + " -> key=" + le.getCacheEntry().getKey() + ", ");
    		}
    		buffer.append("\n");

    		receivedLogSequenceList.add(buffer.toString());

    if (debug) {
    			System.out.println("ExtendedJMSObjectGridEventListener["
						+ objectGridType + "].onMessage(): " + buffer.toString());
    		}
		}    
	}
	
	public String dumpReceivedLogSequenceList() {
		String result = "";
		int size = receivedLogSequenceList.size();
		result = result + "\nExtendedJMSObjectGridEventListener[" + objectGridType
				+ "]: receivedLogSequenceList size = " + size + "\n";
for (int i = 0; i < size; i++) {
			result = result + receivedLogSequenceList.get(i) + "\n";
		}
		return result;
	}

	public String toString() {
		return "ExtendedJMSObjectGridEventListener["
				+ objectGridType + " - " + this.grid + "]";
	}
}

Configuración

La clase JMSObjectGridEventListener ampliada se debe configurar del mismo modo para la invalidación de cliente y, también, para el mecanismo de réplica de igual a igual. Lo que aparece a continuación es el ejemplo de configuración de XML.

<objectGrid name="PRICEGRID">
<bean id="ObjectGridEventListener" 
				className="com.ibm.websphere.samples.objectgrid.jms.
						price.ExtendedJMSObjectGridEventListener">
<property name="invalidationModel" type="java.lang.String" value=
"CLIENT_SERVER_MODEL" description="" />
				<property name="invalidationStrategy" type="java.lang.String"
					value="INVALIDATE" description="" />
				<property name="jms_topicConnectionFactoryJndiName" type="java.lang.String"
					value="jms/TCF" description="" />
				<property name="jms_topicJndiName" type="java.lang.String"
					value="GRID.PRICEGRID" description="" />
				<property name="jms_topicName" type="java.lang.String"
					value="GRID.PRICEGRID" description="" />
<property name="jms_userid" type="java.lang.String" value="" description="" />
<property name="jms_password" type="java.lang.String" value="" description="" />
			</bean>
			<backingMap name="PRICE" pluginCollectionRef="PRICE"></backingMap>
      	</objectGrid>
Nota: El className del bean ObjectGridEventListener se ha configurado con la clase JMSObjectGridEventListener ampliada con las mismas propiedades que el JMSObjectGridEventListener genérico.