Mastering Spring’s Event System: Decoupling, Asynchronous Handling, and Generic Events

1. Introduction

ApplicationContext events are handled via ApplicationEvent and ApplicationListener. Adding a bean that implements ApplicationListener causes it to be notified whenever an ApplicationEvent is published, following the Observer pattern.

Since Spring 4.2 the event infrastructure supports annotation‑based listeners and publishing any arbitrary object as an event, which Spring wraps internally.

Benefits of Spring’s event mechanism include decoupling, asynchronous processing, improved execution efficiency, and flexibility through custom events and listeners.

2. Standard Spring Events

ContextRefreshedEvent : Published when the ApplicationContext is initialized or refreshed.

ContextStartedEvent : Published when start() is called on a ConfigurableApplicationContext, signalling Lifecycle beans to start.

ContextStoppedEvent : Published when stop() is called, signalling Lifecycle beans to stop.

ContextClosedEvent : Published on close() or JVM shutdown, destroying all singleton beans.

RequestHandledEvent : Web‑specific event indicating an HTTP request has been processed (DispatcherServlet).

ServletRequestHandledEvent : Subclass of RequestHandledEvent adding servlet‑specific context information.

3. Generic Events

Define a generic event class such as DomainObjectEvent<T> and listeners that accept a specific type, e.g., DomainObjectEvent<Person> . Without additional handling, type erasure causes listeners to receive all events.

Solution 1 – Subclass the generic event for each domain type (e.g., PersonCreatedEvent extends DomainObjectEvent<Person> ) so the generic type is retained at runtime.

Solution 2 – Implement ResolvableTypeProvider in the generic event class to expose the actual generic type, avoiding the need for many subclasses.

<code>@EventListener
public void personCreated(DomainObjectEvent<Person> event) {
    System.out.println("Person created: " + event.getSource());
}
</code>

Testing with a GenericApplicationContext shows that publishing new PersonCreatedEvent(new Person()) triggers only the Person listener, and similarly for Order events.

The same approach works for any object used as an event, not just subclasses of ApplicationEvent .

These techniques enable flexible, decoupled, and efficient event handling in Spring applications.