Examples of net.engio.mbassy.bus.common.IMessageBus

net.engio.mbassy.bus.common.IMessageBus
A message bus offers facilities for publishing messages to the message handlers of registered listeners. A message publication starts when an object is send to the bus using one of the its publication methods. Messages can be published synchronously or asynchronously and may be of any type that is a valid sub type of the type parameter T. Message handlers can be invoked synchronously or asynchronously depending on their configuration. Thus, there are two notions of synchronicity / asynchronicity. One on the caller side, e.g. the invocation of the message publishing methods. The second on the handler side, e.g. whether the handler is invoked in the same or a different thread.
Each message publication is isolated from all other running publications such that it does not interfere with them. Hence, the bus generally expects message handlers to be stateless as it may invoke them concurrently if multiple messages get published asynchronously. If handlers are stateful and not thread-safe they can be marked to be invoked in a synchronized fashion using @Synchronized annotation
A listener is any object that defines at least one message handler and that has been subscribed to at least one message bus. A message handler can be any method that accepts exactly one parameter (the message) and is marked as a message handler using the @Handler annotation.
By default, the bus uses weak references to all listeners such that registered listeners do not need to be explicitly unregistered to be eligible for garbage collection. Dead (garbage collected) listeners are removed on-the-fly as messages get dispatched. This can be changed using the @Listener annotation.
Generally message handlers will be invoked in inverse sequence of subscription but any client using this bus should not rely on this assumption. The basic contract of the bus is that it will deliver a specific message exactly once to each of the respective message handlers.
Messages are dispatched to all listeners that accept the type or supertype of the dispatched message. Additionally a message handler may define filters to narrow the set of messages that it accepts.
Subscribed message handlers are available to all pending message publications that have not yet started processing. Any message listener may only be subscribed once -> subsequent subscriptions of an already subscribed message listener will be silently ignored)
Removing a listener (unsubscribing) means removing all subscribed message handlers of that listener. This remove operation immediately takes effect and on all running dispatch processes -> A removed listener (a listener is considered removed after the remove(Object) call returned) will under no circumstances receive any message publications. Any running message publication that has not yet delivered the message to the removed listener will not see the listener after the remove operation completed.
NOTE: Generic type parameters of messages will not be taken into account, e.g. a List will get dispatched to all message handlers that take an instance of List as their parameter @Author bennidiDate: 2/8/12

    public void testSynchronizedWithSynchronousInvocation(){
        List<SynchronizedWithSynchronousDelivery> handlers = new LinkedList<SynchronizedWithSynchronousDelivery>();
        IBusConfiguration config = SyncAsync();
        config.getFeature(Feature.AsynchronousMessageDispatch.class)
                .setNumberOfMessageDispatchers(6);
        IMessageBus bus = createBus(config);
        for(int i = 0; i < numberOfListeners; i++){
            SynchronizedWithSynchronousDelivery handler = new SynchronizedWithSynchronousDelivery();
            handlers.add(handler);
            bus.subscribe(handler);
        }


        MessagePublication publication = null;
        for(int i = 0; i < numberOfMessages; i++){
           publication =  bus.post(new Object()).asynchronously();
        }
        // wait for last publication
        while (!publication.isFinished()){
            pause(100);
        }

View Full Code Here

    public void testSynchronizedWithAsSynchronousInvocation(){
        List<SynchronizedWithAsynchronousDelivery> handlers = new LinkedList<SynchronizedWithAsynchronousDelivery>();
        IBusConfiguration config = SyncAsync();
        config.getFeature(Feature.AsynchronousMessageDispatch.class)
                .setNumberOfMessageDispatchers(6);
        IMessageBus bus = createBus(config);
        for(int i = 0; i < numberOfListeners; i++){
            SynchronizedWithAsynchronousDelivery handler = new SynchronizedWithAsynchronousDelivery();
            handlers.add(handler);
            bus.subscribe(handler);
        }


        for(int i = 0; i < numberOfMessages; i++){
            track(bus.post(new Object()).asynchronously());
        }


        pause(10000);


        for(SynchronizedWithAsynchronousDelivery handler : handlers){

View Full Code Here

public class AsyncFIFOBusTest extends MessageBusTest {


    @Test
    public void testSingleThreadedSyncFIFO(){
        // create a fifo bus with 1000 concurrently subscribed listeners
        IMessageBus fifoBUs = BusFactory.AsynchronousSequentialFIFO();


        List<SyncListener> listeners = new LinkedList<SyncListener>();
        for(int i = 0; i < 1000 ; i++){
            SyncListener listener = new SyncListener();
            listeners.add(listener);
            fifoBUs.subscribe(listener);
        }


        // prepare set of messages in increasing order
        int[] messages = new int[1000];
        for(int i = 0; i < messages.length ; i++){
             messages[i] = i;
        }
        // publish in ascending order
        for(Integer message : messages)
            fifoBUs.post(message).asynchronously();


        while(fifoBUs.hasPendingMessages())
            pause(1000);


        for(SyncListener listener : listeners){
            assertEquals(messages.length, listener.receivedSync.size());
            for(int i=0; i < messages.length; i++){

View Full Code Here


    // NOTE: Can fail due to timing issues.
    @Test
    public void testSingleThreadedSyncAsyncFIFO(){
        // create a fifo bus with 1000 concurrently subscribed listeners
        IMessageBus fifoBUs = BusFactory.AsynchronousSequentialFIFO();


        List<SyncAsyncListener> listeners = new LinkedList<SyncAsyncListener>();
        for(int i = 0; i < 1000 ; i++){
            SyncAsyncListener listener = new SyncAsyncListener();
            listeners.add(listener);
            fifoBUs.subscribe(listener);
        }


        // prepare set of messages in increasing order
        int[] messages = new int[1000];
        for(int i = 0; i < messages.length ; i++){
            messages[i] = i;
        }
        // publish in ascending order
        for(Integer message : messages)
            fifoBUs.post(message).asynchronously();


        while(fifoBUs.hasPendingMessages())
            pause(2000);


        for(SyncAsyncListener listener : listeners){
            assertEquals(messages.length, listener.receivedSync.size());
            assertEquals(listener.receivedSync.size(), listener.receivedAsync.size());

View Full Code Here


    }


    @Test
    public void testDispatch1(){
        IMessageBus bus = createBus(SyncAsync());
        EventListener2 listener2 = new EventListener2();
        bus.subscribe(listener2);
        bus.post("jfndf").now();
        assertTrue(listener2Called);
        assertFalse(listener1Called);


        EventListener1 listener1 = new EventListener1();
        bus.subscribe(listener1);
        bus.post("jfndf").now();
        assertTrue(listener1Called);
    }

View Full Code Here

TOP

Related Classes of net.engio.mbassy.bus.common.IMessageBus

net.engio.mbassy.AsyncFIFOBusTest

net.engio.mbassy.MethodDispatchTest

net.engio.mbassy.SynchronizedHandlerTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.