Defining snapshot strategies in Java (Eventuate Local only)

A snapshot strategy is given the opportunity to create a snapshot when an aggregate is updated by calling AggregateRepository.update(). It is a class that must implement the SnapshotStrategy interface. When using the Spring framework, snapshot strategies are registered by defining them as Spring Beans.

AccountSnapshotStrategy is an example of a snapshot strategy for an Account class:

public class AccountSnapshotStrategy implements SnapshotStrategy {

  @Override
  public Class<?> getAggregateClass() {
    return Account.class;
  }

  @Override
  public Optional<Snapshot> possiblySnapshot(Aggregate aggregate, Optional<Int128> snapshotVersion, List<EventWithId> oldEvents, List<Event> newEvents) {
    Account account = (Account) aggregate;
    return Optional.of(new AccountSnapshot(account.getBalance()));
  }

  @Override
  public Aggregate recreateAggregate(Class<?> clasz, Snapshot snapshot) {
    AccountSnapshot accountSnapshot = (AccountSnapshot) snapshot;
    Account aggregate = new Account();
    List<Event> events = aggregate.process(new CreateAccountCommand(accountSnapshot.getBalance()));
    Aggregates.applyEventsToMutableAggregate(aggregate, events);
    return aggregate;
  }
}

AccountSnapshotStrategy creates a snapshot every time it is invoked. Another strategy would be to create a snapshot every N events or every N seconds based on the current time and the event timestamps.

An AccountSnapshot stores the current balance of the account.

public class AccountSnapshot implements Snapshot {
  private BigDecimal balance;

  public AccountSnapshot() {
  }

  public AccountSnapshot(BigDecimal balance) {
    this.balance = balance;
  }

  public BigDecimal getBalance() {
    return balance;
  }
}

Stay in touch
Copyright © 2016 Eventuate, Inc • All rights reserved.