Use a notificação do objeto para determinar o resultado de um pedido que seu aplicativo fez no objeto.
O CMP pode notificar aplicativos sempre que comandos são concluídos ou sempre que ocorrem alterações nos objetos administrados. Ao usar o padrão de design OBSERVER, o aplicativo CMP pode definir um manipulador para um objeto fornecido pelo usuário que possui um método específico que será chamado se um objeto for modificado ou excluído, ou sempre que uma resposta para uma ação enviada anteriormente for retornada do broker.
O código fornecido pelo usuário deve implementar a interface AdministeredObjectListener. Esta interface define métodos que são invocados pelo CMP quando ocorre um evento em um objeto administrado no qual o listener é registrado. Os seguintes métodos são definidos:
O formato das cadeias transmitidas para os dois parâmetros finais é uma representação interna do objeto administrado. É possível tornar esta representação um tipo de objeto administrado usando o método getManagedSubcomponentFromStringRepresentation().
Considere as seguintes informações adicionais:
processDelete(…) é chamado se o objeto com o qual o listener é registrado é removido completamente do intermediário. Fornecido para processDelete(…) é um parâmetro - um identificador para o objeto administrado que foi excluído; quando este método é retornado, o identificador do objeto administrado não pode mais ser válido. Quase ao mesmo tempo que um processDelete(…) ocorre, é enviado um evento processModify(…) para os listeners do pai do objeto excluído, para anunciar uma alteração na lista de subcomponentes do pai.
Para registrar um listener, cada objeto administrado possui um método registerListener() que é usado para informar ao CMP para chamar o código fornecido sempre que um evento ocorre nesse objeto. É possível registrar o mesmo AdministeredObjectListener para notificações a partir de múltiplos objetos administrados. Também é possível registrar múltiplos AdministeredObjectListeners no mesmo 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) {
// o encadeamento pode fazer algo mais aqui em vez de
try {
Thread.sleep(10000);
} catch (InterruptedException ex) {
// ignorar
}
}
}
}
public void processActionResponse(AdministeredObject obj,
CompletionCodeType cc,
List bipMessages,
Properties refProperties) {
// Evento ignorado neste exemplo
}
public void processDelete(AdministeredObject deletedObject) {
// Evento ignorado neste exemplo
}
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();
}
}
}
O método listenForChanges() tenta registrar uma instância da classe MonitorBroker para notificações das alterações do broker. Se bem-sucedido, o encadeamento principal pausa indefinidamente para impedir que o aplicativo seja finalizado quando o método for retornado. Quando o listener é registrado, sempre que o broker é alterado (por exemplo, se um grupo de execução for incluído), o método processModify() é chamado. Este método exibe detalhes de cada notificação na tela.
É necessário registrar listeners separados para cada objeto administrado no qual você deseja receber notificações. É possível usar a mesma instância do listener para múltiplos objetos administrados.
O primeiro método remove o registro de um único listener de um único objeto administrado; os outros dois métodos removem o registro de todos os listeners conectados a essa instância BrokerProxy. Além disso, o método final mostra que todos os listeners são removidos implicitamente quando a conexão com o intermediário é interrompida.
Você também pode implementar a interface AdvancedAdministeredObjectListener que, quando registrada, gera informações adicionais para aplicativos.