Event-driven architecture pattern in Spring Boot

Introduction

Event-driven architecture helps your app react to things happening, like messages or actions, without waiting. It makes your app more flexible and faster.

When you want different parts of your app to work independently and communicate by sending messages.

When your app needs to handle many tasks at the same time without slowing down.

When you want to build apps that can easily grow or change without breaking everything.

When you want to respond quickly to user actions or system events, like new orders or notifications.

Syntax

Spring Boot

1. Define an event class (a simple Java class).
2. Create an event publisher using ApplicationEventPublisher.
3. Create an event listener using @EventListener annotation.
4. Publish events from your service or controller.

Example:

public class MyEvent {
    private final String message;
    public MyEvent(String message) { this.message = message; }
    public String getMessage() { return message; }
}

@Component
public class MyEventPublisher {
    private final ApplicationEventPublisher publisher;
    public MyEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    public void publish(String message) {
        publisher.publishEvent(new MyEvent(message));
    }
}

@Component
public class MyEventListener {
    @EventListener
    public void handleMyEvent(MyEvent event) {
        System.out.println("Received event: " + event.getMessage());
    }
}

Use @EventListener on methods to listen for events.

Events are simple Java objects carrying data.

Examples

This defines a simple event carrying a username.

Spring Boot

public class UserCreatedEvent {
    private final String username;
    public UserCreatedEvent(String username) { this.username = username; }
    public String getUsername() { return username; }
}

This listens for UserCreatedEvent and prints the username.

Spring Boot

@Component
public class UserEventListener {
    @EventListener
    public void onUserCreated(UserCreatedEvent event) {
        System.out.println("User created: " + event.getUsername());
    }
}

This publishes the event after creating a user.

Spring Boot

@Component
public class UserService {
    private final ApplicationEventPublisher publisher;
    public UserService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    public void createUser(String username) {
        // logic to create user
        publisher.publishEvent(new UserCreatedEvent(username));
    }
}

Sample Program

This Spring Boot app creates a user and publishes an event. The listener prints a message when it receives the event.

Spring Boot

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(DemoApplication.class, args);
        var userService = context.getBean(UserService.class);
        userService.createUser("alice");
    }
}

class UserCreatedEvent {
    private final String username;
    public UserCreatedEvent(String username) { this.username = username; }
    public String getUsername() { return username; }
}

@Component
class UserService {
    private final ApplicationEventPublisher publisher;
    public UserService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    public void createUser(String username) {
        System.out.println("Creating user: " + username);
        publisher.publishEvent(new UserCreatedEvent(username));
    }
}

@Component
class UserEventListener {
    @EventListener
    public void onUserCreated(UserCreatedEvent event) {
        System.out.println("User created event received for: " + event.getUsername());
    }
}

Important Notes

Events help separate concerns: one part sends info, another reacts.

Listeners run in the same thread by default; use async if needed.

Spring Boot makes event handling easy with annotations.

Summary

Event-driven architecture lets parts of your app talk by sending and listening to events.

Spring Boot uses simple Java classes and annotations to handle events.

This pattern helps build apps that are flexible and easy to maintain.

Practice

1. What is the main purpose of the event-driven architecture pattern in Spring Boot?

easy

A. To store data in a relational database

B. To allow different parts of the application to communicate by sending and receiving events

C. To create user interfaces with HTML and CSS

D. To handle HTTP requests directly without any middleware

Solution

1. Step 1: Understand event-driven architecture basics

   This pattern lets components send and listen to events to communicate asynchronously.

2. Step 2: Identify Spring Boot usage

   Spring Boot uses Java classes and annotations to implement this pattern for flexible communication.

3. Final Answer:

   To allow different parts of the application to communicate by sending and receiving events -> Option B

4. Quick Check:

   Event-driven communication = To allow different parts of the application to communicate by sending and receiving events [OK]

Hint: Event-driven means parts talk by sending/listening events [OK]

Common Mistakes:

• Confusing event-driven with database storage
• Thinking it handles UI design
• Assuming it processes HTTP requests directly

2. Which annotation is used in Spring Boot to mark a method as an event listener?

easy

A. @EventHandler

B. @Listener

C. @HandleEvent

D. @EventListener

Solution

1. Step 1: Recall Spring Boot event listener annotation

   Spring Boot uses @EventListener to mark methods that listen for events.

2. Step 2: Check other options

   @EventHandler, @Listener, and @HandleEvent are not valid Spring Boot annotations for event listening.

3. Final Answer:

   @EventListener -> Option D

4. Quick Check:

   @EventListener marks event methods [OK]

Hint: Remember: @EventListener listens to events in Spring Boot [OK]

Common Mistakes:

• Using @EventHandler which is not a Spring Boot annotation
• Confusing with @Listener or @HandleEvent which don't exist
• Misspelling the annotation name

3. Given this Spring Boot event publishing code snippet, what will be printed?

public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) { super(source); }
}

@Component
public class Publisher {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void publish() {
        publisher.publishEvent(new MyEvent(this));
    }
}

@Component
public class Listener {
    @EventListener
    public void onMyEvent(MyEvent event) {
        System.out.println("Event received");
    }
}

medium

A. Event received

B. No output

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand event publishing

   The Publisher publishes a MyEvent instance using ApplicationEventPublisher.

2. Step 2: Understand event listening

   The Listener class has a method annotated with @EventListener that listens for MyEvent and prints "Event received".

3. Final Answer:

   Event received -> Option A

4. Quick Check:

   Publishing triggers listener print = Event received [OK]

Hint: Publishing event triggers listener print statement [OK]

Common Mistakes:

• Thinking no output because listener is missing
• Assuming compilation error due to event class
• Expecting runtime exception without error

4. What is wrong with this Spring Boot event listener code?

@Component
public class MyListener {
    @EventListener
    public void handleEvent(String event) {
        System.out.println("Event: " + event);
    }
}

medium

A. EventListener methods cannot accept String as event parameter

B. Missing @Component annotation

C. Method must return a value

D. EventListener annotation is misspelled

Solution

1. Step 1: Check event parameter type

   Spring events can be any object, including String, but using String as event parameter is discouraged because it may cause ambiguity and unintended triggers.

2. Step 2: Understand best practice

   Using custom event classes extending ApplicationEvent or plain objects is preferred for clarity and to avoid conflicts.

3. Final Answer:

   EventListener methods cannot accept String as event parameter -> Option A

4. Quick Check:

   String event param is invalid for event listener [OK]

Hint: EventListener needs custom event class, not String [OK]

Common Mistakes:

• Thinking @Component is missing
• Believing method must return a value
• Assuming annotation is misspelled

5. You want to build a Spring Boot app where multiple components react to a user registration event asynchronously. Which approach best fits the event-driven architecture pattern?

hard

A. Send HTTP requests manually between components

B. Call all components directly from the registration method without events

C. Create a UserRegisteredEvent class, publish it with ApplicationEventPublisher, and have multiple @EventListener methods handle it

D. Use a database trigger to notify components

Solution

1. Step 1: Identify event-driven pattern usage

   Creating a custom event class and publishing it allows decoupled communication between components.

2. Step 2: Understand asynchronous handling

   Multiple @EventListener methods can react independently and asynchronously to the event.

3. Step 3: Evaluate other options

   Direct calls, database triggers, or manual HTTP requests do not follow Spring Boot event-driven best practices.

4. Final Answer:

   Create a UserRegisteredEvent class, publish it with ApplicationEventPublisher, and have multiple @EventListener methods handle it -> Option C

5. Quick Check:

   Custom event + publisher + listeners = Create a UserRegisteredEvent class, publish it with ApplicationEventPublisher, and have multiple @EventListener methods handle it [OK]

Hint: Use custom event class and @EventListener for async reactions [OK]

Common Mistakes:

• Calling components directly, losing decoupling
• Relying on database triggers for app events
• Manually sending HTTP requests between components