Spring Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:


1. Overview

In this article, we'll be discussing how to use events in Spring.

Events are one of the more overlooked functionalities in the framework but also one of the more useful. And – like many other things in Spring – event publishing is one of the capabilities provided by ApplicationContext.

There are a few simple guidelines to follow:

  • the event should extend ApplicationEvent
  • the publisher should inject an ApplicationEventPublisher object
  • the listener should implement the ApplicationListener interface

Further reading:

Spring Application Context Events

Learn about the built-in events for the Spring application context

How To Do @Async in Spring

How to enable and use @Async in Spring - from the very simple config and basic usage to the more complex executors and exception handling strategies.

Spring Expression Language Guide

This article explores Spring Expression Language (SpEL), a powerful expression language that supports querying and manipulating object graphs at runtime.

2. A Custom Event

Spring allows to create and publish custom events which – by default – are synchronous. This has a few advantages – such as, for example, the listener being able to participate in the publisher’s transaction context.

2.1. A Simple Application Event

Let’s create a simple event class – just a placeholder to store the event data. In this case, the event class holds a String message:

public class CustomSpringEvent extends ApplicationEvent {
    private String message;

    public CustomSpringEvent(Object source, String message) {
        this.message = message;
    public String getMessage() {
        return message;

2.2. A Publisher

Now let’s create a publisher of that event. The publisher constructs the event object and publishes it to anyone who's listening.

To publish the event, the publisher can simply inject the ApplicationEventPublisher and use the publishEvent() API:

public class CustomSpringEventPublisher {
    private ApplicationEventPublisher applicationEventPublisher;

    public void doStuffAndPublishAnEvent(final String message) {
        System.out.println("Publishing custom event. ");
        CustomSpringEvent customSpringEvent = new CustomSpringEvent(this, message);

Alternatively, the publisher class can implement the ApplicationEventPublisherAware interface – this will also inject the event publisher on the application start-up. Usually, it's simpler to just inject the publisher with @Autowire.

2.3. A Listener

Finally, let's create the listener.

The only requirement for the listener is to be a bean and implement ApplicationListener interface:

public class CustomSpringEventListener implements ApplicationListener<CustomSpringEvent> {
    public void onApplicationEvent(CustomSpringEvent event) {
        System.out.println("Received spring custom event - " + event.getMessage());

Notice how our custom listener is parametrized with the generic type of custom event – which makes the onApplicationEvent() method type safe. This also avoids having to check if the object is an instance of a specific event class and casting it.

And, as already discussed – by default spring events are synchronous – the doStuffAndPublishAnEvent() method blocks until all listeners finish processing the event.

3. Creating Asynchronous Events

In some cases, publishing events synchronously isn't really what we're looking for – we may need async handling of our events.

You can turn that on in the configuration by creating an ApplicationEventMulticaster bean with an executor; for our purposes here SimpleAsyncTaskExecutor works well:

public class AsynchronousSpringEventsConfig {
    @Bean(name = "applicationEventMulticaster")
    public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
        SimpleApplicationEventMulticaster eventMulticaster =
          new SimpleApplicationEventMulticaster();
        eventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
        return eventMulticaster;

The event, the publisher and the listener implementations remain the same as before – but now, the listener will asynchronously deal with the event in a separate thread.

4. Existing Framework Events

Spring itself publishes a variety of events out of the box. For example, the ApplicationContext will fire various framework events. E.g. ContextRefreshedEvent, ContextStartedEvent, RequestHandledEvent etc.

These events provide application developers an option to hook into the lifecycle of the application and the context and add in their own custom logic where needed.

Here's a quick example of a listener listening for context refreshes:

public class ContextRefreshedListener 
  implements ApplicationListener<ContextRefreshedEvent> {
    public void onApplicationEvent(ContextRefreshedEvent cse) {
        System.out.println("Handling context re-freshed event. ");

To learn more about existing framework events, have a look at our next tutorial here.

5. Annotation-Driven Event Listener

Starting with Spring 4.2, an event listener is not required to be a bean implementing the ApplicationListener interface – it can be registered on any public method of a managed bean via the @EventListener annotation:

public class AnnotationDrivenContextStartedListener {
    // @Async
    public void handleContextStart(ContextStartedEvent cse) {
        System.out.println("Handling context started event.");

As before, the method signature declares the event type it consumes. As before, this listener is invoked synchronously. But now making it asynchronous is as simple as adding an @Async annotation (do not forget to enable Async support in the application).

6. Generics Support

It is also possible to dispatch events with generics information in the event type.

6.1. A Generic Application Event

Let's create a generic event type. In our example, the event class holds any content and a success status indicator:

public class GenericSpringEvent<T> {
    private T what;
    protected boolean success;

    public GenericSpringEvent(T what, boolean success) {
        this.what = what;
        this.success = success;
    // ... standard getters

Notice the difference between GenericSpringEvent and CustomSpringEvent. We now have the flexibility to publish any arbitrary event and it's not required to extend from ApplicationEvent anymore.

6.2. A Listener

Now let’s create a listener of that event. We could define the listener by implementing the ApplicationListener interface like before:

public class GenericSpringEventListener 
  implements ApplicationListener<GenericSpringEvent<String>> {
    public void onApplicationEvent(@NonNull GenericSpringEvent<String> event) {
        System.out.println("Received spring generic event - " + event.getWhat());

But unfortunately, this definition requires us to inherit GenericSpringEvent from the ApplicationEvent class. So for this tutorial, let's make use of an annotation-driven event listener discussed previously.

It is also possible to make the event listener conditional by defining a boolean SpEL expression on the @EventListener annotation. In this case, the event handler will only be invoked for a successful GenericSpringEvent of String:

public class AnnotationDrivenEventListener {
    @EventListener(condition = "#event.success")
    public void handleSuccessful(GenericSpringEvent<String> event) {
        System.out.println("Handling generic event (conditional).");

The Spring Expression Language (SpEL) is a powerful expression language that's covered in details in another tutorial.

6.3. A Publisher

The event publisher is similar to the one described above. But due to type erasure, we need to publish an event that resolves the generics parameter we would filter on. For example, class GenericStringSpringEvent extends GenericSpringEvent<String>.

And there's an alternative way of publishing events. If we return a non-null value from a method annotated with @EventListener as the result, Spring Framework will send that result as a new event for us. Moreover, we can publish multiple new events by returning them in a collection as the result of event processing.

7. Transaction Bound Events

This paragraph is about using the @TransactionalEventListener annotation. To learn more about transaction management check out the Transactions with Spring and JPA tutorial.

Since Spring 4.2, the framework provides a new @TransactionalEventListener annotation, which is an extension of @EventListener, that allows binding the listener of an event to a phase of the transaction. Binding is possible to the following transaction phases:

  • AFTER_COMMIT (default) is used to fire the event if the transaction has completed successfully
  • AFTER_ROLLBACK – if the transaction has rolled back
  • AFTER_COMPLETION – if the transaction has completed (an alias for AFTER_COMMIT and AFTER_ROLLBACK)
  • BEFORE_COMMIT is used to fire the event right before transaction commit

Here's a quick example of transactional event listener:

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void handleCustom(CustomSpringEvent event) {
    System.out.println("Handling event inside a transaction BEFORE COMMIT.");

This listener will be invoked only if there's a transaction in which the event producer is running and it's about to be committed.

And, if no transaction is running the event isn’t sent at all unless we override this by setting fallbackExecution attribute to true.

8. Conclusion

In this quick tutorial, we went over the basics of dealing with events in Spring – creating a simple custom event, publishing it, and then handling it in a listener.

We also had a brief look at how to enable asynchronous processing of events in the configuration.

Then we learned about improvements introduced in Spring 4.2, such as annotation-driven listeners, better generics support, and events binding to transaction phases.

As always, the code presented in this article is available over on Github. This is a Maven-based project, so it should be easy to import and run as it is.

Spring bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Newest Most Voted
Inline Feedbacks
View all comments
5 years ago

Might be silly question… If we are using synchronous event and I published event from a transactional service… Then event handler will also take part in same transaction right?

Eugen Paraschiv
5 years ago
Reply to  Naresh

Hey Naresh – not a silly question at all. When the async method is called – no, the transactional context will not be propagated – it will be executed outside of the transaction. Hope that clarifies things. Cheers,

Koushik Chatterjee
Koushik Chatterjee
4 years ago

Hi Eugen, so is there any way so that I can run some of the event async and some sync way by using annotation based configuration. assume (i have multiple event publisher, for same or multiple event)

Eugen Paraschiv
4 years ago

That’s definitely a good question. I don’t think that’s supported, but I haven’t checked lately. Now, there is of course another way to go here – you can make use of the @Async annotation to make sure the events that should be handled in an async way, are.
Hope it helps. Cheers,

Aleksandar Milicevic
Aleksandar Milicevic
4 years ago

Hi Eugen,
Can I inject spring bean to custom spring event?

Eugen Paraschiv
4 years ago

Hey Aleksandar – so, if you mean injecting a bean into the actual event – no, that’s not something I’d recommend. That would mean that the actual event needs to be a Spring bean, which makes events heavyweight and ads conceptual load to your system. If you really need to pass a bean reference, that’s fine – you can certainly do that when you instantiate your event (again, if you really need to). But most of the time, you shouldn’t need to do that.
Hope that helps. Cheers,

Comments are closed on this article!