HelloEventConsumer.java

/*
 * Copyright 2008 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.rioproject.examples.events.service;

import org.rioproject.associations.Association;
import org.rioproject.servicebean.ServiceBeanContext;
import org.rioproject.impl.event.BasicEventConsumer;
import org.rioproject.event.RemoteServiceEvent;
import org.rioproject.event.RemoteServiceEventListener;
import org.rioproject.examples.events.Hello;
import org.rioproject.examples.events.HelloEvent;
import org.rioproject.impl.watch.StopWatch;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.PreDestroy;

/**
 * The HelloEventConsumer example
 */
public class HelloEventConsumer {
    /**
     * An EventConsumer that receives notifications for EventProducer
     * instances that produce HelloEvents
     */
    private BasicEventConsumer consumer;
    /**
     * A local watch for measuring how long it took to send the event
     */
    private StopWatch watch = null;
    /**
     * The local event consumer
     */
    private RemoteServiceEventListener localConsumer;

    /**
     * Event notification count
     */
    private int notificationCount;

    /** The Logger for this example */
    static Logger logger = LoggerFactory.getLogger("org.rioproject.examples.events");

    /*
    * The ServiceBeanContext will be injected, allowing the bean to create
    * and add necessary event handling classes
    */
    public void setServiceBeanContext(ServiceBeanContext context) throws Exception {
        /**
         * Create the stop watch, and register the stop watch with the
         * WatchDataRegistry
         */
        watch = new StopWatch("Hello Consumer");
        context.getWatchRegistry().register(watch);
        localConsumer = new LocalEventConsumer();
        consumer = new BasicEventConsumer(HelloEvent.getEventDescriptor(),
                                          localConsumer);
        logger.info("Initialized HelloEvent Consumer");
    }

    public void setEventProducer(Association<Hello> hello) {
        consumer.register(hello.getServiceItem());
    }

    @PreDestroy
    public void cleanup() {
        if (consumer != null) {
            consumer.deregister(localConsumer);
            consumer.terminate();
        }
    }

    public int getNotificationCount() {
        return notificationCount;
    }

    /**
     * The LocalEventConsumer handles notification of remote events. Event
     * notifications of <code>RemoteServiceEvent</code> objects is done
     * within a JVM, i.e. remote invocation semantics are not implied by the use
     * of this interface.
     */
    class LocalEventConsumer implements RemoteServiceEventListener {
        public void notify(RemoteServiceEvent event) {
            if (event instanceof HelloEvent) {
                notificationCount++;
                HelloEvent helloEvent = (HelloEvent) event;
                /*
                * Instead of calling startTiming(), we use the time from the
                * event to set the start time. This will allow us to measure a
                * distributed response. Note: it is assumed the clocks are
                * roughly the same for this example.
                */
                watch.setStartTime(((HelloEvent) event).getWhen());
                watch.stopTiming();
                logger.info("Received HelloEvent seqno={}, message=[{}]",
                            event.getSequenceNumber(), helloEvent.getMessage());
            } else {
                logger.warn("Unwanted event received: {}", event);
            }
        }
    }
}