Utilice la notificación de objetos para determinar el resultado de una solicitud que su aplicación haya realizado sobre el objeto.
El CMP puede enviar una notificación a las aplicaciones cada vez que finalice un mandato o siempre que se produzcan cambios en objetos administrados. Utilizando el patrón de diseño OBSERVER, la aplicación de CMP puede definir un manejador para un objeto suministrado por el usuario que tenga un método específico al que se llame si un objeto se modifica o suprime, o siempre que se devuelve una respuesta a una acción sometida anteriormente desde el intermediario.
El código suministrado por el usuario ha de implementar la interfaz AdministeredObjectListener. Esta interfaz define métodos que invoca el CMP cuando se produce un suceso en un objeto administrado para el que está registrado el escucha. Están definidos los siguientes métodos:
El formato de las series de caracteres pasadas a los dos parámetros finales es una representación interna de los objetos administrados. Puede convertir esta representación en un tipo de objeto administrado usando el método getManagedSubcomponentFromStringRepresentation().
Considere la información adicional siguiente:
processDelete(…) se llama si el objeto con el que está registrado el escucha se elimina totalmente del intermediario . Para processDelete(…) se suministra un parámetro - un manejador para el objeto administrador que se ha suprimido; cuando el método vuelva, es posible que el manejador del objeto administrado ya no sea válido. Más o menos al mismo tiempo que se produce un suceso processDelete(…), se envía un suceso processModify(…) a los escuchas del padre del objeto suprimido para anunciar un cambio en la lista de subcomponentes del padre.
Para registrar un escucha, cada objeto administrado tiene un método registerListener() que se utiliza para indicar al CMP que llame al código suministrado siempre que se produzca un suceso en dicho objeto. Puede registrar el mismo AdministeredObjectListener para las notificaciones de múltiples objetos administrados. También puede registrar varios AdministeredObjectListeners para el mismo objeto administrado.
import com.ibm.broker.config.proxy.*;
import com.ibm.broker.config.proxy.CompletionCodeType;
import java.util.List;
import java.util.ListIterator;
import java.util.Properties;
public class MonitorBroker implements AdministeredObjectListener {
public static void main(String[] args) {
BrokerProxy b = null;
try {
BrokerConnectionParameters bcp =
new MQBrokerConnectionParameters(
"localhost",
1414,
"");
b = BrokerProxy.getInstance(bcp);
} catch (ConfigManagerProxyException cmpex) {
System.out.println("Error connecting: "+cmpex);
}
if (b != null) {
System.out.println("Connected to broker");
listenForChanges(b);
b.disconnect();
}
}
private static void listenForChanges(AdministeredObject obj)
{
if (obj != null) {
obj.registerListener(new MonitorBroker());
while(true) {
// la hebra podría hacer algo distinto aquí
try {
Thread.sleep(10000);
} catch (InterruptedException ex) {
// ignorar
}
}
}
}
public void processActionResponse(AdministeredObject obj,
CompletionCodeType cc,
List bipMessages,
Properties refProperties) {
// Suceso ignorado en este ejemplo
}
public void processDelete(AdministeredObject deletedObject) {
// Suceso ignorado en este ejemplo
}
public void processModify(AdministeredObject affectedObject,
List changedAttributes,
List newChildren,
List removedChildren) {
try {
System.out.println(affectedObject+" has changed:");
ListIterator e = changedAttributes.listIterator();
while (e.hasNext()) {
String changedAttribute = (String) e.next();
System.out.println("Changed: "+changedAttribute);
}
ListIterator e2 = newChildren.listIterator();
while (e2.hasNext()) {
String newChildStr = (String) e2.next();
AdministeredObject newChild =
affectedObject.getManagedSubcomponentFromStringRepresentation(newChildStr);
System.out.println("New child: "+newChild);
}
ListIterator e3 = removedChildren.listIterator();
while (e3.hasNext()) {
String remChildStr = (String) e3.next();
AdministeredObject removedChild =
affectedObject.getManagedSubcomponentFromStringRepresentation(remChildStr);
System.out.println("Removed child: "+removedChild);
}
} catch (ConfigManagerProxyPropertyNotInitializedException ex) {
ex.printStackTrace();
}
}
}
El método listenForChanges() intenta registrar una instancia de la clase MonitorBroker para las notificaciones de cambios de intermediario. Si la operación es satisfactoria, la hebra principal queda en pausa indefinidamente para impedir que la aplicación finalice cuando el método vuelva. Cuando el escucha está registrado, siempre que el intermediario cambia (por ejemplo si se añade un grupo de ejecución) se llama al método processModify(). Este método muestra detalles de cada notificación en la pantalla.
Debe registrar escuchas distintos para cada objeto administrado en el que desee recibir notificaciones. Puede utilizar la misma instancia de escucha para diversos objetos administrados.
El primer método anula el registro de un solo escucha de un solo objeto administrado; los dos otros métodos anulan el registro de todos los escuchas conectados a esta instancia de BrokerProxy. Además, el método final muestra que se eliminan implícitamente todas las escuchas cuando se detiene la conexión con el intermediario.
También se puede implementar la interfaz AdvancedAdministeredObjectListener que, cuando está registrada, produce más información para las aplicaciones.