Java Microservices - Event Sourcing

---

---

Introduction

In traditional systems, application state is stored as the current value of entities. For example, if a user updates their address, the database reflects only the latest address.

But in microservices, sometimes it's necessary to store a full history of changes - not just the final state.

Event Sourcing is a powerful design pattern that solves this by storing changes to application state as a sequence of events. Instead of only saving the current state, you store all events that led to it.

What is Event Sourcing?

Definition

Event Sourcing is a pattern in which every change to the state of an application is captured in an event object, and those events are persisted. The current state is then rebuilt by replaying the sequence of past events.

Example

Instead of storing:

{ "accountBalance": 1000 }

You store events like:

[
   { "type": "AccountCreated", "amount": 0 },
   { "type": "DepositMade", "amount": 1000 }
]

Replaying these events leads to the current balance.

Key Concepts of Event Sourcing

Benefits of Event Sourcing

Use Cases in Microservices

Spring Boot Example: Simple Event Sourcing for Account

We will build a simple Account microservice that −

• Accepts commands like CreateAccount, DepositMoney

• Persists events to an in-memory list (simulating event store)

• Applies events to rebuild account balance

Technologies

• Java 17+

• Spring Boot 3.x

Model: Domain Event Base Class

public interface DomainEvent {
   LocalDateTime occurredAt();
}

Account Events

public class AccountCreatedEvent implements DomainEvent {
   private final String accountId;
   private final LocalDateTime occurredAt = LocalDateTime.now();

   public AccountCreatedEvent(String accountId) {
      this.accountId = accountId;
   }

   public String getAccountId() { return accountId; }
   public LocalDateTime occurredAt() { return occurredAt; }
}

public class MoneyDepositedEvent implements DomainEvent {
   private final String accountId;
   private final double amount;
   private final LocalDateTime occurredAt = LocalDateTime.now();

   public MoneyDepositedEvent(String accountId, double amount) {
      this.accountId = accountId;
      this.amount = amount;
   }

   public String getAccountId() { return accountId; }
   public double getAmount() { return amount; }
   public LocalDateTime occurredAt() { return occurredAt; }
}

Event Store (In-Memory)

@Service
public class EventStore {
   private final List<DomainEvent> events = new ArrayList<>();

   public void save(DomainEvent event) {
      events.add(event);
   }
 
   public List<DomainEvent> getEventsForAccount(String accountId) {
      return events.stream()
         .filter(e -> {
         if (e instanceof AccountCreatedEvent ac) {
            return ac.getAccountId().equals(accountId);
         } else if (e instanceof MoneyDepositedEvent md) {
            return md.getAccountId().equals(accountId);
         }
         return false;
      })
      .toList();
   }
}

Aggregate: Account

public class Account {
   private final String accountId;
   private double balance = 0;

   public Account(String accountId) {
      this.accountId = accountId;
   }

   public void apply(DomainEvent event) {
      if (event instanceof AccountCreatedEvent) {
         // no-op
      } else if (event instanceof MoneyDepositedEvent e) {
         this.balance += e.getAmount();
      }
   }

   public double getBalance() {
      return balance;
   }
}

Command Controller

@RestController
@RequestMapping("/accounts")
public class AccountController {

   @Autowired
   private EventStore store;

   @PostMapping("/{id}/create")
   public ResponseEntity<String> createAccount(@PathVariable String id) {
      AccountCreatedEvent event = new AccountCreatedEvent(id);
      store.save(event);
      return ResponseEntity.ok("Account created: " + id);
   }

   @PostMapping("/{id}/deposit")
   public ResponseEntity<String> deposit(@PathVariable String id, @RequestParam double amount) {
      MoneyDepositedEvent event = new MoneyDepositedEvent(id, amount);
      store.save(event);
      return ResponseEntity.ok("Deposited " + amount);
   }

   @GetMapping("/{id}")
   public ResponseEntity<String> getBalance(@PathVariable String id) {
      List<DomainEvent> events = store.getEventsForAccount(id);
      Account account = new Account(id);
      events.forEach(account::apply);
      return+ ResponseEntity.ok("Balance: " + account.getBalance());
   }
}

Combining with CQRS

Event Sourcing works beautifully with CQRS −

• Command model modifies state via events

• Query model uses projections of those events

• Can use different databases for read/write

This enables high scalability and responsiveness for read-heavy systems.

Tools and Frameworks

Summary

Conclusion

Event Sourcing is a powerful pattern that provides traceability, scalability, and flexibility. When combined with microservices and messaging tools like Kafka, it enables robust, event-driven architectures.

While it introduces complexity, especially around modeling and querying, the long-term benefits−especially in systems requiring audit, replay, and high scalability-are significant.

Start small with in-memory event logs or lightweight projections, and grow into full-fledged event-sourced systems as your microservices mature.