Java EE 7: EJB publishing CDI Events that are pushed over WebSocket to browser client
In this article, I show how I have created a simple and fairly meaningless Java EE 7 application that uses a number of smart Java EE features:
- a stateless session bean has a scheduled method (that is triggered every 3 seconds)
- the stateless session bean publishes custom CDI events
- a class annotated as WebSocket EndPoint manages WebSocket channels with WS clients (in this case simple HTML browser applications) – echoing messages between the clients
- the WebSocket Endpoint also observes the CDI event and pushes the event payload to each of the WebSocket clients
Using NetBeans 7.3.1 and GlassFish 4.0 – as well as a number of blog-articles and sample applications – this turned out to be very simple to put together.
This next figure visualizes what I did:
The implementation steps
The important steps to come to a running applications are:
- create new Java EE 7 project in NetBeans
- create class TimeEvent that will be used to publish as CDI event
- create class EventProducer – a stateless EJB session bean that is scheduled to trigger every 3 seconds; it publishes a TimeEvent whenever it is triggered
- create class SocketMediator – an annotated POJO that has the ServerEndpoint annotation (to handle incoming WebSocket messages) as well as a method that observes the TimeEvent and pushes the payload of the event to every WebSocket session maintained by the POJO
1. Create new Java EE 7 project in NetBeans
Using the wizard, creating a new project is straightforward.
2. Create class TimeEvent that will be used to publish as CDI event
This class itself is simple; it has not interface to implement nor annotations to contain.
The container – and therefore our code – can discern between different types of events. Using an Event Qualifier – such as WBTimeEvent shown below – we can guide our observer methods in the specific events and conditions they listen for.
3. Create class EventProducer – a stateless EJB session bean that is scheduled to trigger every 3 seconds; it publishes a TimeEvent whenever it is triggered
This class is more interesting. The class is instantiated by the Java EE container. It is triggered by the container according to the schedule (every three seconds) to execute the produceRegularEvent method. This method creates a new instance of the TimeEvent. Then it uses the injected Event object (annotated with the Event Qualifier) – that will contain a TimeEvent as payload – to actually publish a CDI event:
4. create class SocketMediator
This class is arguably the most interesting one of the lot. It exposes a WebSocket endpoint – at the path socketmediator. That means that messages sent to ws://host:port/appname/socketmediator will end up in the onMessage() method in this class.
Whenever a client opens a connect to the websocket at mediatorendpoint, the session for that client is retained in the peers collection. This collection is used whenever a message is to be pushed to every client.
When a message arrives on the WebSocket – onMessage method – its content is forwarded to each of the connected clients , except the sender of the message. This sender receives a message that advises about the message having been received and processed.
The onTimeEvent method observes the TimeEvent (with WBTimeEvent qualifier). Whenever that event occurs, this method will be invoked by the container. In the method, the payload is taken from the event and sent in a WebSocket message to each of the registered clients.
The HTML required to get this to work is simple:
6. Run the application
The application can easily be run from NetBeans, deployed directly onto the GlassFish 4.0 Server.
As soon as the browser has started, the web socket connection is established and the web socket messages based on the time events start arriving in the browser. When the link Click is clicked, a message is pushed over the web socket channel to the server where it is forwarded to each of the connected clients.
Download the NetBeans/Maven Project with the sources for this article: JavaEE7_WebSocketEJBTimerCDIEvents.
Blog article – Integrating WebSockets and JMS with CDI Events in Java EE 7 by Bruno Borges – https://blogs.oracle.com/brunoborges/entry/integrating_websockets_and_jms_with
Blog article – Getting Started with JSF 2.0 and CDI part 3 – Events – http://www.andygibson.net/blog/2010/01/11/getting-started-with-jsf-2-0-and-cdi-part-3/
Tutorial for NetBeans – Using the WebSocket API in a Web Application – https://netbeans.org/kb/docs/javaee/maven-websocketapi.html
- Stand-alone Java Client for jWebSocket Server – communicating from Java Client to Web Clients and vice versa over WebSockets
- Implementing a Java Server Side component for jWebSocket Server for WebSocket interaction with Web Clients
- Push-based synchronized slideshow web application – implemented using WebSockets and jWebSocket server – the open source Java WebSocket server
- Push-based synchronized slideshow web application – implemented using WebSockets and Kaazing WebSocket Gateway
- Publishing to CometD Bayeux Channel from inside the Oracle Database – PL/SQL based push to CometD Web Client
- Giving Java 8 a spin using NetBeans 7.4 RC
- ADF 12c: Using WebSockets to implement client to client push (in a scalable manner)
- JDeveloper 12c & ADF 12c: Launch of the next generation
- Live match report using JMS, BAM, ADF Push and Data Visualization
- Java EE 7: Creating a background download manager using Java Batch in GlassFish 4.0
- Getting started with Java EE 7 – Hands on in 10 minutes
- Fanning Out Events on the Oracle SOA Suite 11g Event Delivery Network
- ADF interaction with business service – an ongoing discussion
- JavaOne 2012: What’s new in Servlet3.1: An Overview
- JavaOne 2012: Strategy and Technical Keynote