Passo a Passo de Amostras do WS-Notification

O exemplo da fonte de eventos, EventSource.java, é uma fonte de eventos simples que envia um único evento hardcode atribuído aos Serviços da Web. Ele demonstra as seguintes etapas que uma fonte de eventos deve seguir:

  1. Obtendo um depósito de informações do provedor do evento
  2. Criando um evento e preenchendo-o com os dados necessários
  3. Utilizando os Serviços da Web gerados nos stubs do lado cliente para enviar um evento

O código fonte do EventSource.java está disponível no diretório <sdk_install_dir>/samples/wsnt-was/src/com/wtci/samples/was/source do SDK.

Este exemplo utiliza classes de log Hyades, bem como classes geradas a partir dos arquivos wsdl. Utilize as seguintes instruções de importação para acessar os pacotes necessários:

import com.ibm.wtci.samples.waswsn10.emitter.NotificationConsumerService;
import com.ibm.wtci.samples.waswsn10.emitter.NotificationConsumerServiceLocator;
import com.ibm.wtci.samples.waswsn10.wsn.NotificationConsumer;
import com.ibm.wtci.samples.waswsn10.wsn.NotificationMessageHolderType;

import com.ibm.ws.webservices.engine.xmlsoap.SOAPElement;
import com.ibm.ws.webservices.engine.xmlsoap.SOAPFactory;

import org.eclipse.hyades.logging.events.cbe.CommonBaseEvent;
import org.eclipse.hyades.logging.events.cbe.EventFactory;
import org.eclipse.hyades.logging.events.cbe.EventFactoryFactory;
import org.eclipse.hyades.logging.events.cbe.Situation;
import org.eclipse.hyades.logging.events.cbe.util.EventFormatter;

import java.net.URL;

O método main do EventSource.java cria uma nova instância de EventSource utilizando o construtor padrão. Ele chama então o método sendEvent privado, que contém a lógica do programa principal. Depois que o método sendEvent retorna, o método main() imprime a mensagem "Notificação enviada" na saída padrão.

    /**
     * Método principal da fonte de eventos.
     *
     * @param args
     *            argumentos transmitidos a partir da linha de comandos
     */
    public static void main(String args[]) {
        EventSourceWsn10 source = new EventSourceWsn10();
        try {
            source.sendEvent();
            System.out.println("Notificação enviada");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Criando e Preenchendo o Evento

O método createEvent() de EventSource.java é um método do assistente utilizado para criar um evento e preenchê-lo com um conjunto mínimo de dados de propriedade. Esse método é chamado pelo método sendEvent para criar o evento que será enviado aos Serviços da Web.

    public static CommonBaseEvent[] createEvents() throws Exception {
        CommonBaseEvent[] events = null;

        String cbeFile = System.getProperty("cbe.file");
        if (cbeFile != null) {
            events = EventFormatter.eventsFromCanonicalXMLDoc(cbeFile);
        } else {
            // A primeira etapa é acessar o depósito de informações do provedor do evento
            EventFactory eventFactory =
                EventFactoryFactory.createEventFactory();

            // Criando um evento com um nome de extensão.
            Evento CommonBaseEvent =
                eventFactory.createCommonBaseEvent("EVENT");
            event.setCreationTimeAsLong(System.currentTimeMillis());

            // Definindo a descrição obrigatória da situação do evento.
            Situation situation = eventFactory.createSituation();
            situation.setCategoryName(Situation.REPORT_SITUATION_CATEGORY);
            situation.setReportSituation("INTERNA", "Bem-sucedida");
            event.setSituation(situation);

            // Definindo a identificação obrigatória do componente da
            // fonte de eventos
            event.setSourceComponentId("Fonte de Eventos",
                "source.EventSource",
                "createEvent()",
                "http://www.ibm.com/namespaces/autonomic/Tivoli/Samples",
                "Sample",
                "unknown",
                "hostname");

            // Definindo a versão do Evento de Base Comum
            event.setVersion("1.0.1");
            // Definindo os campos opcionais
            event.setSeverity((short) 10);
            event.setMsg("Tutorial da Infra-estrutura de Eventos Comuns");

            events = new CommonBaseEvent[] { event };
        }

        retornar eventos;
    }

O método createEvent executa as seguintes etapas:

  1. Utiliza o método createEventFactory() do EventFactoryFactory para criar um novo objeto EventFactory
  2. Utiliza o método createCommonBaseEvent(String) do depósito de informações do provedor do evento para criar um novo objeto de evento (uma instância de CommonBaseEvent). A cadeia especificada ("EVENT") é utilizada para definir a propriedade extensionName do evento e a hora atual do sistema é utilizada para definir a propriedade creationTime.
  3. Define o valor da propriedade situation do evento. Como situation é uma propriedade complexa, ela é representada por uma classe Java especializada. Portanto, a definição da propriedade situation requer várias etapas separadas:
    1. Criando um Novo Objeto Situation
    2. Utilizando métodos do definidor para preencher o objeto Situation com os dados de propriedade requeridos
    3. Definindo a propriedade situation do evento chamando o método Event.setSituation(), especificando o objeto Situation preenchido
  4. Ela define os valores de várias outras propriedades de eventos, algumas obrigatórias e outras opcionais. Essas propriedades incluem gravidade, msg, versão e sourceComponentId.
    Nota: Da mesma forma que situation, sourceComponentId também é uma propriedade complexa. Entretanto, suas propriedades filhas são todos atributos simples representados por cadeias, para que você possa utilizar o método do assistente setSourceComponentId() em vez de instanciar separadamente um objeto Java especializado.

    As outras propriedades definidas pelo exemplo (versão, gravidade e msg) são todas propriedades simples representadas por cadeias ou inteiros.

  5. Finalmente, o método createEvent() retorna o evento, que é agora preenchido com dados de propriedade.

Criando a Mensagem de Notificação

O próximo método do exemplo de fonte de eventos, createNotificationMessage(event), é um método do assistente utilizado para criar mensagem de notificação que encapsula o evento transmitido como parâmetro para o método. Esse método é chamado pelo método sendEvent para criar a mensagem de notificação que será enviada aos Serviços da Web.

    public static NotificationMessageHolderType[] createNotificationMessage(
            CommonBaseEvent events[]) throws Exception {
        NotificationMessageHolderType[] notificationArray =
            new NotificationMessageHolderType[events.length];
        for (int i = 0; i < events.length; i++) {

            //Criando uma instância de NotificationMessageHolderType
            notificationArray[i] = new NotificationMessageHolderType();

            //Criando um elemento Tópico com o nome 'Tópico'
            SOAPFactory soapFactory = new SOAPFactory();
            SOAPElement topicSE = (SOAPElement)
                soapFactory.createElement("Tópico");
            SOAPElement topicSEChild = (SOAPElement)
                topicSE.addChildElement("Tópico");
            topicSEChild.setAttribute("dialeto","nenhum");
            notificationArray[i].setTopic(topicSE);

            //Definindo o evento para ser a mensagem da notificação
            SOAPElement messageSE = (SOAPElement)
                soapFactory.createElement("Mensagem");
            messageSE.addNamespaceDeclaration("ns2",
                "http://www.ibm.com/AC/commonbaseevent1_0_1");
            messageSE.addAttribute("http://www.w3.org/2001/XMLSchema-instance",
                "tipo",
                "ns2:CommonBaseEvent");
            String cbeStr = EventFormatter.toCanonicalXMLString(events[i]);
            SOAPElement cbeSE = (SOAPElement)
                soapFactory.createElementFromXMLString(cbeStr);
            messageSE.addChildElement(cbeSE);
            notificationArray[i].setMessage(messageSE);

            //Definindo informações sobre o produtor do evento na
            //notificação
            SOAPElement producerSE = (SOAPElement)
                soapFactory.createElement("ProducerReference");
            SOAPElement producerSEChild = (SOAPElement)
                soapFactory.createElement("Endereço",
                "ns1",
                "http://schemas.xmlsoap.org/ws/2003/03/addressing");
            producerSEChild.addTextNode("protocol://your.event.source.address");
            producerSE.addChildElement(producerSEChild);
            notificationArray[i].setProducerReference(producerSE);
        }
        return notificationArray;
    }

O createNotificationMessage(evento) executa as seguintes etapas:

  1. Cria um objeto NotificationMessageHolderType que contém informações da notificação a ser enviada.
  2. O elemento Tópico da notificação é criado com o nome 'Tópico'. Um elemento filho aninhado é incluído para mostrar que tudo dentro do elemento Tópico será ignorado quando a notificação for recebida.
  3. A mensagem da notificação é definida para ser o evento transmitido para o método.
  4. As informações sobre o produtor do evento são definidas na notificação.
  5. A mensagem de notificação, criada e preenchida de acordo com as informações, é retornada ao responsável pela chamada.

Enviando Evento

O último método do exemplo da fonte de eventos, sendEvent(), contém a lógica do programa principal. Este método manipula toda a interação com o cliente NotificationConsumer, incluindo o envio do evento.

    private void sendEvent() throws Exception {
        //A primeira etapa é criar um evento
        CommonBaseEvent[] events = createEvents();

        //Criando a mensagem de notificação que encapsula o evento
        NotificationMessageHolderType[] notification =
            createNotificationMessage(events);

        //Obtendo o endereço do serviço da Web do NotificationConsumerService
        String endpoint = System.getProperty("service.address");
        if (endpoint == null) {
            // Se nenhum endereço foi especificado, supõe-se que o serviço da Web esteja
            // em execução no host local na porta 9080 que era
            endpoint = "http://localhost:9080/wsnt-was/services/NotificationConsumer10Soap";
        }

        //Criando um objeto URL para o endereço obtido
        java.net.URL serviceURL = new URL(endpoint);

        //Criando uma instância do NotificationConsumerServiceLocator
        NotificationConsumerService notifierSvc =
            new NotificationConsumerServiceLocator();
        NotificationConsumer notifier =
            notifierSvc.getNotificationConsumer10Soap(serviceURL);

        //Enviando a notificação
        notifier.notify(notification);

    }

O método sendEvent() executa as seguintes etapas:

  1. Chama o método do assistente createEvent() para criar e preencher um novo evento.
  2. Chama o método do assistente createNotificationMessage(event) para criar uma mensagem de notificação que encapsula o evento criado.
  3. Na propriedade do sistema, ele obtém o endereço dos Serviços da Web do NotificationConsumer, atendendo ao pedido de notificação.
  4. Ele instancia o NotificationConsumerServiceLocator, que é então utilizado para obter um objeto NotificationConsumer
  5. Envia o evento chamando o método notify() do NotificationConsumer. Isso gera uma mensagem SOAP que encapsula o evento


Tópicos Relacionados
Construindo as Amostras
Executando as Amostras


Conceitos Relacionados
Convertendo um Evento no Formato Evento de Base Comum para o Formato de Evento do Console Corporativo