Skip to end of metadata
Go to start of metadata

Any CDI managed component may produce and consume events. This allows beans to interact in a completely decoupled fashion. Beans consume events by registering for a particular event type and optional qualifiers. The Errai CDI extension simply extends this concept into the client tier. A GWT client application can simply register an Observer for a particular event type and thus receive events that are produced on the server-side. Likewise and using the same API, GWT clients can produce events that are consumed by a server-side observer.

Let's take a look at an example.

FraudClient.java

Two things are noteworthy in this example:

  1. Injection of an Event dispatcher proxy
  2. Creation of an Observer method for a particular event type

The event dispatcher is responsible for sending events created on the client-side to the server-side event subsystem (CDI container). This means any event that is fired through a dispatcher will eventually be consumed by a CDI managed bean, if there is an corresponding Observer registered for it on the server side.

In order to consume events that are created on the server-side you need to declare an client-side observer method for a particular event type. In case an event is fired on the server this method will be invoked with an event instance of type you declared.

To complete the example, let's look at the corresponding server-side CDI bean:

AccountService.java

Conversational events

A server can address a single client in response to an event annotating event types as @Conversational. Consider a service that responds to a subscription event.

SubscriptionService.java

And the Document class would be annotated like so:

Document.java

As such, when Document events are fired, they will be limited in scope to the initiating conversational contents – which are implicitly inferred by the caller. So only the client which fired the Subscription event will receive the fired Document event.

Client-Server Event Example

A key feature of the Errai CDI framework is the ability to federate the CDI eventing bus between the client and the server. This permits the observation of server produced events on the client, and vice-versa.

Example server code:

MyServerBean.java

Domain-model:

MyRequestEvent.java
MyResponseEvent.java

Client application logic:

MyClientBean.java
Labels:
None
Enter labels to add to this page:
Please wait 
Looking for a label? Just start typing.
  1. Dec 04, 2013

    I understand there is a way to do client side only events. Can you please add this to the documentation?