Spring Boot provides a robust framework for implementing event-driven communicaiton, enabling loose coupling between application components. This mechanism is built on Spring's ApplicationEvent system. The following example demonstrates a complete implementation for defining, publishing, and listening to custom events.

1. Defining a Custom Event

Create a class that extends ApplicationEvent. This class serves as the data carrier for the event.

import org.springframework.context.ApplicationEvent;

public class NotificationEvent extends ApplicationEvent {
    private final String notificationText;

    public NotificationEvent(Object source, String notificationText) {
        super(source);
        this.notificationText = notificationText;
    }

    public String getNotificationText() {
        return notificationText;
    }
}

2. Publishing the Event

An event publisher is responsible for creating and broadcasting events. Inject ApplicationEventPublisher to perform this task.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class NotificationPublisher {

    @Autowired
    private ApplicationEventPublisher eventPublisher;

    public void broadcastNotification(String text) {
        System.out.println("Publishing event...");
        NotificationEvent event = new NotificationEvent(this, text);
        eventPublisher.publishEvent(event);
    }
}

3. Creating an Event Listener

A listener component processes events when they are published. Use the @EventListener annotation to designate a method as a listenre.

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class NotificationListener {

    @EventListener
    public void processNotification(NotificationEvent event) {
        System.out.println("Event received: " + event.getNotificationText());
    }
}

4. Triggering Event Publication from a Controller

A REST controller can be used to trigger the event flow, typically in response to an HTTP request.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class EventController {

    @Autowired
    private NotificationPublisher notificationPublisher;

    @GetMapping("/notify")
    public String triggerEvent(@RequestParam String message) {
        notificationPublisher.broadcastNotification(message);
        return "Notification event published successfully.";
    }
}

When the /api/notify endpoint is called with a message parameter, the NotificationPublisher creates and publishes a NotificationEvent. The NotificationListener automatically detects this event and executes its processNotification method. This pattern alows for clean separation of concerns, where the publisher does not need direct knowledge of the listeners. Multiple listeners can be defined for a single event type, and they will all be invoked synchronous by default.