Recently, I faced a complex problem in our financial application: tracking every state change for audit trails while maintaining high performance during peak loads. Traditional CRUD approaches fell short, leading me to explore event sourcing with Axon Framework and Spring Boot. This combination provides robust solutions for auditability, scalability, and temporal querying that I’ll demonstrate through practical examples.

Event sourcing fundamentally changes how we manage state. Instead of overwriting data, we capture every change as immutable events. These events become the source of truth. Combined with CQRS (Command Query Responsibility Segregation), we separate write operations from reads for optimized performance. Consider these core building blocks:

// Commands
public class CreateAccountCommand {
    private String accountId;
    private String accountHolder;
    private BigDecimal initialBalance;
    // Constructor and getters
}

// Events
public class AccountCreatedEvent {
    private String accountId;
    private String accountHolder;
    private BigDecimal initialBalance;
    private Instant timestamp;
    // Constructor and getters
}

Why store events rather than just current state? Because events provide a complete audit trail and enable time-travel debugging. When rebuilding state, we replay events sequentially. This might sound resource-intensive, but Axon’s snapshotting mechanism optimizes it by periodically storing aggregate state. How does Axon handle concurrent modifications? Through optimistic locking using event versioning.

To start, add these key dependencies to your Spring Boot project:

<dependency>
    <groupId>org.axonframework</groupId>
    <artifactId>axon-spring-boot-starter</artifactId>
    <version>4.8.0</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Aggregates are the heart of event sourcing. They process commands and emit events while enforcing business rules. Notice how the Account aggregate below uses past events to rebuild state:

@Aggregate
public class Account {
    @AggregateIdentifier
    private String accountId;
    private BigDecimal balance;
    
    @EventSourcingHandler
    public void on(AccountCreatedEvent event) {
        this.accountId = event.getAccountId();
        this.balance = event.getInitialBalance();
    }
    
    @CommandHandler
    public void handle(DepositMoneyCommand command) {
        if (command.getAmount().signum() <= 0) {
            throw new IllegalArgumentException("Invalid deposit amount");
        }
        apply(new MoneyDepositedEvent(accountId, command.getAmount(), balance.add(command.getAmount())));
    }
}

For projections, we update read models asynchronously. This separation allows scaling reads independently from writes. Here’s a JPA projection updating an account balance view:

@Service
public class AccountProjection {
    
    @EventHandler
    public void on(MoneyDepositedEvent event, @Timestamp Instant timestamp) {
        AccountView account = repository.findById(event.getAccountId());
        account.setBalance(event.getNewBalance());
        account.setLastUpdated(timestamp);
        repository.save(account);
    }
}

What about complex business processes spanning multiple aggregates? That’s where sagas shine. For a money transfer between accounts:

@Saga
public class TransferSaga {
    
    @StartSaga
    @SagaEventHandler(associationProperty = "transferId")
    public void handle(TransferInitiatedEvent event) {
        // Send debit command to source account
    }
    
    @SagaEventHandler(associationProperty = "transferId")
    public void handle(SourceAccountDebitedEvent event) {
        // Send credit command to target account
    }
}

Testing is straightforward with Axon’s test fixtures. We can verify command handling and event emission:

@Test
void testAccountCreation() {
    fixture.givenNoPriorActivity()
           .when(new CreateAccountCommand("acc1", "John Doe", BigDecimal.TEN))
           .expectSuccessfulHandlerExecution()
           .expectEvents(new AccountCreatedEvent("acc1", "John Doe", BigDecimal.TEN, Instant.now()));
}

In production, I configure event store persistence and monitoring:

axon:
  serializer:
    events: jackson
  eventhandling:
    processors:
      transactions:
        mode: tracking
        source: eventStore
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/events

From my experience, three practices are critical: First, design bounded contexts carefully – not everything needs event sourcing. Second, version events explicitly using @Revision. Third, implement idempotent handlers for reliable reprocessing. How do you handle schema changes? I use upcasters to transform old event formats during replay.

Event sourcing fundamentally changed how I approach data integrity. By treating state changes as immutable facts, we gain unprecedented audit capabilities and temporal querying. Have you considered how event replay could simplify debugging in your systems? If this approach resonates with you, share your experiences below. Found this useful? Like, comment, and share with colleagues facing similar architectural challenges.