Event traceability and CQRS are suitable for complex business systems. 1. Event traceability provides complete audit and time travel capabilities by saving event sequence reconstruction status, but increases query complexity; 2. CQRS separates read and write models to improve scalability and performance, but introduces final consistency; 3. In Java, Axon Framework can be implemented in combination with Spring Boot, using @Aggregate to process commands, @EventSourcingHandler updates status, and @EventHandler builds read models; 4. Applicable to scenarios that require high auditability and uneven read and write load, and is not suitable for simple CRUD systems; 5. Pay attention to event immutability, version control, final consistency processing and debugging complexity. This architecture is of great value in high demand systems.

Event Sourcing and command query separation of responsibilities (CQRS) are two important models in modern distributed systems that deal with complex business logic and improve system scalability. In the Java ecosystem, combined with tools such as Spring Boot and Axon Framework, these two modes can be efficiently implemented. The following is an analysis from several aspects of concepts, application scenarios, implementation methods and precautions.

What are Event Sourcing and CQRS?

1. Event Sourcing

In traditional systems, we usually only save the current status of the entity (such as the user balance is 100 yuan). The core idea of event tracing is: not to directly save the state, but to save the sequence of events that lead to state changes .

For example, the balance change in a user account is not directly updated with the balance field, but records:

• MoneyDeposited(amount=50)
• MoneyWithdrawn(amount=20)

The state is reconstructed by replaying these events.

advantage:

• Complete audit log
• Easy to debug and backtrack
• Support time travel (reconstructs status at any time point)

shortcoming:

• Query performance may decline (replay event required)
• Complex event version management
• High threshold for beginners

2. CQRS (Command Query Responsibility Segregation)

CQRS separates the system's read and write operations:

• Command : Modify data, write model (Write Model)
• Query : read data, corresponding to read model (Read Model)

This is not just hierarchy, but allows different data models, databases and even technology stacks to handle read and write.

Typical structure:

 Client → Command → Command Handler → Events → Event Store
                     ↓
               Event Handlers → Update Read Model (eg, SQL, Elasticsearch)
                     ↓
Client ← Query ← Read Model

advantage:

• Read and write models can be optimized independently
• Easy to scale (such as reading more and writing less scenarios can scale out the query service in a query service)
• A clearer division of responsibilities

shortcoming:

• System complexity increases
• There is a delay between read and write (final consistency)

How to implement it in Java? Using Axon Framework

Axon is the most popular framework in Java to implement Event Sourcing and CQRS, and integrates well with Spring.

Add dependencies (Maven)

 <dependency>
    <groupId>org.axonframework</groupId>
    <artifactId>axon-spring-boot-starter</artifactId>
    <version>4.6.0</version>
</dependency>

Example: Bank Account Transfer

1. Define events

 public class MoneyDepositedEvent {
    public final String accountId;
    public final double amount;

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

public class MoneyWithdrawnEvent {
    public final String accountId;
    public final double amount;

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

2. Aggregate - Write a model

 @Aggregate
public class BankAccount {

    @AggregateIdentifier
    private String accountId;
    private double balance;

    public BankAccount() {} // Required by Axon

    // Command Handler
    @CommandHandler
    public BankAccount(CreateAccountCommand command) {
        // Publish the account creation event AggregateLifecycle.apply(new AccountCreatedEvent(command.accountId));
    }

    @CommandHandler
    public void handle(DepositMoneyCommand command) {
        if (command.amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        AggregateLifecycle.apply(new MoneyDepositedEvent(command.accountId, command.amount));
    }

    @CommandHandler
    public void handle(WithdrawMoneyCommand command) {
        if (command.amount > balance) {
            throw new IllegalStateException("Insufficial funds");
        }
        AggregateLifecycle.apply(new MoneyWithdrawnEvent(command.accountId, command.amount));
    }

    // Event Sourcing Handler - Used to update the status @EventSourcingHandler
    public void on(MoneyDepositedEvent event) {
        this.balance = event.amount;
    }

    @EventSourcingHandler
    public void on(MoneyWithdrawnEvent event) {
        this.balance -= event.amount;
    }
}

3. Event processing (update reading model)

 @Component
public class AccountProjection {

    private final AccountRepository accountRepository;

    public AccountProjection(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }

    @EventHandler
    public void on(MoneyDepositedEvent event) {
        AccountView account = accountRepository.findById(event.accountId)
            .orElse(new AccountView(event.accountId, 0.0));
        account.balance = event.amount;
        accountRepository.save(account);
    }

    @EventHandler
    public void on(MoneyWithdrawnEvent event) {
        AccountView account = accountRepository.findById(event.accountId)
            .orElseThrow();
        account.balance -= event.amount;
        accountRepository.save(account);
    }
}

4. Read model entity (for query)

 @Entity
public class AccountView {
    @Id
    private String id;
    private double balance;

    // constructors, getters, setters
}

5. Query the interface

 @RestController
public class AccountQueryController {

    @Autowired
    private AccountRepository accountRepository;

    @GetMapping("/accounts/{id}")
    public AccountView getAccount(@PathVariable String id) {
        return accountRepository.findById(id).orElse(null);
    }
}

When to use Event Sourcing CQRS?

• The business logic is complex and requires audit tracking (such as finance, order system)
• Read and write loads vary greatly and need independent expansion
• The system needs to support "undo", "replay", and "time travel"
• In the microservice architecture, the communication between services through event

?? Not recommended for use with simple CRUD systems, it will be over-designed.

Things to note

• Event immutable : Once published, it cannot be modified, and only compensation events can be added.
• Event version control : When the event structure changes, serialization compatibility or migration must be supported.
• Read model consistency : CQRS is the final consistency, and the front-end needs to deal with the situation where "the operation is successful but the query is not updated".
• Debugging difficulty increases : tools are required to support event stream viewing, replaying, etc.

Summarize

In Java, Event Sourcing and CQRS can be implemented more easily through the Axon Framework:

• Use @Aggregate to manage writing models
• Update the aggregation status with @EventSourcingHandler
• Use @EventHandler to build a reading model
• Complete separation of commands and queries

Although complexity is introduced, this architecture is very valuable in systems that require high auditability and scalability.

Basically all that is, the key is to understand that "state is the result of events" and that "reading and writing can take different paths."

The above is the detailed content of Event Sourcing and CQRS Patterns in Java. For more information, please follow other related articles on the PHP Chinese website!