Guava - EventBus (Event Bus) - Programmer Sought

Guava atguava-librariesWe provide the event bus EventBus library, which is an implementation of the event publishing subscription mode, which allows us to decouple our module and domain boundaries with the weak reference nature of events in domain-driven design (DDD).

No more nonsense, go straight to the Guava EventBus theme. First of all, Guava provides us with two events bus, the synchronous event EventBus and the asynchronous implementation of AsyncEventBus. They are not singletons. The official reason is not to think about how we use them. Of course, if we want to be a singleton, we can easily package it, and a singleton pattern guarantees that only one instance is created.

Let's take EventBus as an example. AsyncEventBus is used in the same way.

subscription

First of all, EventBus provides us with a register method to subscribe to events. Guava's implementation here is very friendly. We don't need to implement any extra interfaces or base classes. We only need to mark the subscription method.@SubscribeAnd guaranteeOnly one input parameterThe method can be done. So for some simple events, we can even go straight

new Object() {

    @Subscribe
    public void lister(Integer integer) {
        System.out.printf("%d from int%n", integer);
    }
}

Events published by Guava do not handle thread-safe by default, but we can mark @AllowConcurrentEvents to keep them thread safe.

release

For event sources, events can be published via the post method. The release of events for Guava is determined by the method parameter type of the subscription method in the above example. In other words, the type of post incoming and its base class type can receive this event. For example, the following example:

final EventBus eventBus = new EventBus();
eventBus.register(new Object() {

    @Subscribe
    public void lister(Integer integer) {
        System.out.printf("%s from int%n", integer);
    }

    @Subscribe
    public void lister(Number integer) {
        System.out.printf("%s from Number%n", integer);
    }

    @Subscribe
    public void lister(Long integer) {
        System.out.printf("%s from long%n", integer);
    }
});

eventBus.post(1);
eventBus.post(1L);

Here are Integer, Long, and their base class Number. When we send an integer data, either the Integer and Number methods are received, and the Long type is accepted by the Long type and the Number type.

So bloggers recommend that it is necessary to encapsulate a specific type of event for each type of event.

DeadEvent

DeadEvent is temporarily unclear how to translate more desirable. It describes the death event, that is, there is no subscriber concern, no processing, and is represented by the method of the DeadEvent type parameter. For example, in the above example, we post an Object type, as follows:

final EventBus eventBus = new EventBus();
eventBus.register(new Object() {

    @Subscribe
    public void lister(DeadEvent event) {
        System.out.printf("%s=%s from dead events%n", event.getSource().getClass(), event.getEvent());
    }
});

eventBus.post(new Object());