Spring Modulith - Events

Aug 3, 2024 · 6 min read · spring spring-modulith events postgres liquibase ·

Share on:

Overview

Spring boot modulith implementation with spring events & persistence with postgres & replay of events.

Github: https://github.com/gitorko/project73

Spring Modulith

Modular Monolith is an architectural style where source code is structured on the concept of modules

Spring Modulith is a module of Spring that helps in organizing large applications into well-structured, manageable, and self-contained modules. It provides various features like module isolation, events, and monitoring to support a modular architecture.

Building a Modern Monolith application, with Spring Modulith lets you avoid the network jumps, serialization & de-serialization. Each service is isolated via package boundary. Eg: OrderService, NotificationService bean won't be injected in all the classes, instead they rely on spring event bus to communicate with each other.

You can structure your code based on domain, Order package deals only with processing the order, notification package deals only with sending notifications etc. We can split the core of the monolith into modules by identifying the domains of our application and defining bounded contexts. We can consider the domain or business modules of our application as direct sub-packages of the application’s main package.

Since the application becomes a monolith, you cant individually scale out individual services, so if a particular service needs more scale you can move only that module to a separate service (microservice architecture).

Spring events ensures loose coupling in an application, it allows inter-module interaction. Instead of injecting different beans and invoking them in the directly you now publish an event and all other places that need to process it will implement a listener.

Tightly coupled with single commit transaction boundary

1@Transactional 2public void complete(Order order) { 3 orderService.save(order); 4 inventoryService.update(order); 5 auditService.add(order); 6 rewardService.update(order); 7 notificationService.update(order); 8}

Loosely coupled but still single commit transaction boundary

1@Transactional 2public void complete(Order order) { 3 applicationEventPublisher.publishEvent(order); 4}

Service can be developed without all the implementations. Eg: Audit logging service is being developed and not ready, hence instead of being blocked on developing the core customer service class, just publish an event and when the service is ready add a listener to process that event.

Spring events are in-memory so if the server restarts all events published will be lost. With Spring Modulith library you can now persist such event and process them after a restart.

A module can access the content of any other module but can't access sub-packages of other modules.
A module also cant access content that is not public

By default @EventListener run on the same thread as the caller, to run it asynchronously use @Async

@ApplicationModuleListener by default comes with @Transactional, @Async & @TransactionalEventListener annotation enabled.

@Externalized will publish the events to queues like RabbitMQ/Kafka.

To process the events on restart enable this flag.

1spring: 2 modulith: 3 republish-outstanding-events-on-restart: true

Code

 1package com.demo.project73.common;  2  3import lombok.extern.slf4j.Slf4j;  4import org.springframework.boot.context.event.ApplicationReadyEvent;  5import org.springframework.context.event.EventListener;  6import org.springframework.stereotype.Service;  7  8@Service  9@Slf4j 10public class ApplicationEventListener { 11 /** 12 * ApplicationStartingEvent - fired at the start of a run but before any processing 13 * ApplicationEnvironmentPreparedEvent - fired when the Environment to be used in the context is available 14 * ApplicationContextInitializedEvent- fired when the ApplicationContext is ready 15 * ApplicationPreparedEvent - fired when ApplicationContext is prepared but not refreshed 16 * ContextRefreshedEvent - fired when an ApplicationContext is refreshed 17 * WebServerInitializedEvent - fired after the web server is ready 18 * ApplicationStartedEvent - fired after the context has been refreshed but before any application and command-line runners have been called 19 * ApplicationReadyEvent - fired to indicate that the application is ready to service 20 * ApplicationFailedEvent - fired if there is an exception and the application fails to start 21 */ 22 @EventListener(ApplicationReadyEvent.class) 23 public void onStart() { 24 log.info("Triggered when application ready!"); 25 } 26}

 1package com.demo.project73.audit.internal.listener;  2  3import com.demo.project73.common.OrderEvent;  4import lombok.extern.slf4j.Slf4j;  5import org.springframework.modulith.events.ApplicationModuleListener;  6import org.springframework.stereotype.Component;  7  8@Component  9@Slf4j 10public class AuditEventListener { 11 12 @ApplicationModuleListener 13 public void processOrderEvent(OrderEvent orderEvent) { 14 log.info("[Audit] Order Event Received: {}", orderEvent); 15 } 16 17}

 1package com.demo.project73.order.internal.service;  2  3import java.util.UUID;  4  5import com.demo.project73.common.CustomEvent;  6import com.demo.project73.common.PrimeReward;  7import com.demo.project73.common.SeasonReward;  8import com.demo.project73.order.internal.domain.Order;  9import com.demo.project73.common.OrderEvent; 10import lombok.RequiredArgsConstructor; 11import lombok.extern.slf4j.Slf4j; 12import org.springframework.context.ApplicationEventPublisher; 13import org.springframework.stereotype.Service; 14import org.springframework.transaction.annotation.Transactional; 15 16@Service 17@Slf4j 18@RequiredArgsConstructor 19public class OrderService { 20 21 final ApplicationEventPublisher applicationEventPublisher; 22 23 /** 24 * @ApplicationModuleListener need a transactional boundary else won't run. 25 */ 26 @Transactional 27 public Order placeOrder(Order order) { 28 for (String item : order.getItems()) { 29 OrderEvent orderEvent = OrderEvent.builder() 30 .orderId(order.getOrderId()) 31 .item(item) 32 .orderDate(order.getOrderDate()) 33 .build(); 34 log.info("Publishing Order: {}", orderEvent); 35 applicationEventPublisher.publishEvent(orderEvent); 36 } 37 38 PrimeReward coupon1 = PrimeReward.builder() 39 .id(UUID.randomUUID()) 40 .couponCode("coupon-code-" + UUID.randomUUID()) 41 .build(); 42 SeasonReward coupon2 = SeasonReward.builder() 43 .id(UUID.randomUUID()) 44 .couponCode("coupon-code-" + UUID.randomUUID()) 45 .build(); 46 CustomEvent<PrimeReward> customEvent1 = new CustomEvent(this, coupon1); 47 CustomEvent<SeasonReward> customEvent2 = new CustomEvent(this, coupon2); 48 log.info("Publishing CustomEvent: {}", customEvent1); 49 applicationEventPublisher.publishEvent(customEvent1); 50 log.info("Publishing CustomEvent: {}", customEvent2); 51 applicationEventPublisher.publishEvent(customEvent2); 52 return order; 53 } 54}

 1package com.demo.project73.reward.internal.listener;  2  3import com.demo.project73.common.CustomEvent;  4import com.demo.project73.common.PrimeReward;  5import com.demo.project73.common.SeasonReward;  6import lombok.SneakyThrows;  7import lombok.extern.slf4j.Slf4j;  8import org.springframework.context.event.EventListener;  9import org.springframework.scheduling.annotation.Async; 10import org.springframework.stereotype.Component; 11import org.springframework.transaction.event.TransactionPhase; 12import org.springframework.transaction.event.TransactionalEventListener; 13 14@Component 15@Slf4j 16public class RewardListener { 17 /** 18 * Processes the custom event 19 */ 20 @Async 21 @SneakyThrows 22 @EventListener 23 public void processEvent(CustomEvent myEvent) { 24 log.info("Processing CustomEvent {}", myEvent); 25 if (myEvent.getEntity() instanceof PrimeReward) { 26 log.info("PrimeReward Event: {}", ((PrimeReward) myEvent.getEntity()).getCouponCode()); 27 } 28 if (myEvent.getEntity() instanceof SeasonReward) { 29 log.info("SeasonReward Event: {}", ((SeasonReward) myEvent.getEntity()).getCouponCode()); 30 } 31 } 32 33 /** 34 * AFTER_COMMIT: The event will be handled when the transaction gets committed successfully. 35 * AFTER_COMPLETION: The event will be handled when the transaction commits or is rolled back. 36 * AFTER_ROLLBACK: The event will be handled after the transaction has rolled back. 37 * BEFORE_COMMIT: The event will be handled before the transaction commit. 38 */ 39 @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT) 40 void afterAuditEventProcessed(CustomEvent myEvent) { 41 log.info("After CustomEvent processed: {}", myEvent); 42 } 43}

Setup

 1# Project 73  2  3Spring Events  4  5[https://gitorko.github.io/spring-events/](https://gitorko.github.io/spring-events/)  6  7### Version  8  9Check version 10 11```bash 12$java --version 13openjdk 21.0.3 2024-04-16 LTS 14``` 15 16### Modulith Documentation 17 18```bash 19brew install graphviz 20``` 21 22### Postgres DB 23 24```bash 25docker run -p 5432:5432 --name pg-container -e POSTGRES_PASSWORD=password -d postgres:14 26docker ps 27docker exec -it pg-container psql -U postgres -W postgres 28CREATE USER test WITH PASSWORD 'test@123'; 29CREATE DATABASE "test-db" WITH OWNER "test" ENCODING UTF8 TEMPLATE template0; 30grant all PRIVILEGES ON DATABASE "test-db" to test; 31 32docker stop pg-container 33docker start pg-container 34``` 35 36### RabbitMQ 37 38Run the docker command to start a rabbitmq instance 39 40```bash 41docker run -d --hostname my-rabbit --name my-rabbit -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest -p 8085:15672 -p 5672:5672 rabbitmq:3-management 42``` 43 44Open the rabbitmq console 45 46[http://localhost:8085](http://localhost:8085) 47 48``` 49user:guest 50pwd: guest 51``` 52 53### Dev 54 55To run the code. 56 57```bash 58./gradlew clean build 59./gradlew bootRun 60```