Enterprise Java

Java EE6 Events: A lightweight alternative to JMS

The feature I’m going to talk about today is the event mechanism that is in java EE 6. The general idea is to fire an event and let an event listener pick it up.

I have created this example that is totally useless, but it simplicity helps me to focus on the important stuff. I’m going to fire a LogEvent from my backing action, that will log to the java.util.Logger.

The first thing I need is to create a POJO that contains my log message and my LogLevel.

public class LogMessage implements Serializable {
    private final String message;
    private final Level level;
    LogMessage(String message, Level level) {
        this.message = message;
        this.level = level;
    public String getMessage() {
        return message;
    public Level getLevel() {
        return level;

Now that I have my data wrapper, I need something to fire the event and something to pick it up. The first thing I create is my method where I fire the event.

Due to CDI I can inject an event.

@Inject Event<LogMessage> event;

So we just need to fire it.

event.fire(new LogMessage("Log it baby!", Level.INFO));

Now the event is fired, if no one is registerd to pick it up, it disappears into oblivion, thus we create a listener. The listeners needs a method that has one parameter, the generic type that is given to the previous event. LogMessage.

public class LogListener {
    private static final Logger LOGGER = Logger.getAnonymousLogger();
    public void process(@Observes LogMessage message){
        LOGGER.log(message.getLevel(), message.getMessage());

The @Observes annotation listens to all events with a LogMessage. When the event is fired, this method will be triggered.

This is a very nice way to create a loosely coupled application, you can separate heavy operations or encapsulate less essential operations in these event listeners.

All of this all happens synchronously. When we want to replace the log statement with a slow database call to a logging table, we could make our operation heavier than it should be.

What I’m looking for is to create an asynchronous call. As long as we support EJB, we can transform our Listener to an EJB by adding the @Stateless annotation on top of it. Now it’s a statless enterprise bean. This changes nothing to our sync/async problem, but EJB 3.1 support async operations. So if we also add the @Asynchronous annotation on top of it. It will asynchronously execute our logging statement.

public class LogListener {
    private static final Logger LOGGER = Logger.getAnonymousLogger();
    public void process(@Observes LogMessage message){
        LOGGER.log(message.getLevel(), message.getMessage());

If we would want to combine the database logging and the console logging, we can just create multiple methods that listen to the same event.

This is a great way to create a lightweight application with a very flexible components. The alternative solution to this problem is to use JMS, but you don’t want a heavyweight configuration for this kind of loosely coupling.

Reference: Java EE6 Events, a lightweight alternative to JMS from our JCG partner Jelle Victoor at the Styled Ideas Blog.

Related Articles :

Want to know how to develop your skillset to become a Java Rockstar?

Join our newsletter to start rocking!

To get you started we give you our best selling eBooks for FREE!


1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design


and many more ....


Receive Java & Developer job alerts in your Area

I have read and agree to the terms & conditions


Ilias Tsagklis

Ilias is a software developer turned online entrepreneur. He is co-founder and Executive Editor at Java Code Geeks.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

1 Comment
Newest Most Voted
Inline Feedbacks
View all comments
Tunde Michael
8 years ago

I was expecting a comparison of the two technologies, JMS & CDI Event mechanism, but you didnt compare or justify why you think CDI Event mechanism is a better or lightweight alternative to JMS. I am a huge fan of JMS and would really like you to clarify these few things: 1. Can another EJB module (or a separate application entirely) in the same server or server cluster listen to a CDI event? 2. Can CDI events be made persistent? 3. If the the listening application is down for maintenance after having registered for an event, will it get the… Read more »

Back to top button