org.axonframework.eventsourcing

Class CachingEventSourcingRepository<T>

java.lang.Object

org.axonframework.commandhandling.model.AbstractRepository<T,LockAwareAggregate<T,A>>

org.axonframework.commandhandling.model.LockingRepository<T,EventSourcedAggregate<T>>

org.axonframework.eventsourcing.EventSourcingRepository<T>

org.axonframework.eventsourcing.CachingEventSourcingRepository<T>

Type Parameters:

T - The type of aggregate this repository stores

All Implemented Interfaces:

Repository<T>, ScopeAware

public class CachingEventSourcingRepository<T>
extends EventSourcingRepository<T>

Implementation of the event sourcing repository that uses a cache to improve loading performance. The cache removes the need to read all events from disk, at the cost of memory usage.

Note that an entry of a cached aggregate is immediately invalidated when an error occurs while saving that aggregate. This is done to prevent the cache from returning aggregates that may not have fully persisted to disk.

Since:

0.3

Author:

Allard Buijze

Constructor Summary

Constructors

Constructor and Description
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, Cache cache) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, Cache cache, RepositoryProvider repositoryProvider) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, Cache cache, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, Cache cache, SnapshotTriggerDefinition snapshotTriggerDefinition, RepositoryProvider repositoryProvider) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, LockFactory lockFactory, Cache cache, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition, SnapshotTriggerDefinition snapshotTriggerDefinition, RepositoryProvider repositoryProvider) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, LockFactory lockFactory, Cache cache, ParameterResolverFactory parameterResolverFactory, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, LockFactory lockFactory, Cache cache, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.
CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, LockFactory lockFactory, Cache cache, SnapshotTriggerDefinition snapshotTriggerDefinition, RepositoryProvider repositoryProvider) Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Method Summary

Modifier and Type	Method and Description
protected EventSourcedAggregate<T>	doCreateNewForLock(Callable<T> factoryMethod) Creates a new aggregate instance using the given factoryMethod.
protected void	doDeleteWithLock(EventSourcedAggregate<T> aggregate) Perform the actual deleting of the aggregate.
protected EventSourcedAggregate<T>	doLoadWithLock(String aggregateIdentifier, Long expectedVersion) Perform the actual loading of an aggregate.
protected void	doSaveWithLock(EventSourcedAggregate<T> aggregate) Perform the actual saving of the aggregate.
protected void	validateOnLoad(Aggregate<T> aggregate, Long expectedVersion) Checks the aggregate for concurrent changes.

Methods inherited from class org.axonframework.eventsourcing.EventSourcingRepository

getAggregateFactory, readEvents, reportIllegalState

Methods inherited from class org.axonframework.commandhandling.model.LockingRepository

doCreateNew, doDelete, doLoad, doSave, prepareForCommit

Methods inherited from class org.axonframework.commandhandling.model.AbstractRepository

aggregateModel, canResolve, getAggregateType, load, load, managedAggregates, newInstance, postDelete, postSave, send

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      Cache cache)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy. It stores Aggregates in the given cache.

A repository initialized using this constructor does not create snapshots for aggregates.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

cache - The cache in which entries will be stored

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      Cache cache,
                                      RepositoryProvider repositoryProvider)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy. It stores Aggregates in the given cache.

A repository initialized using this constructor does not create snapshots for aggregates.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

cache - The cache in which entries will be stored

repositoryProvider - Provides repositories for specific aggregate types

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      Cache cache,
                                      SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

cache - The cache in which entries will be stored

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      Cache cache,
                                      SnapshotTriggerDefinition snapshotTriggerDefinition,
                                      RepositoryProvider repositoryProvider)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

cache - The cache in which entries will be stored

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

repositoryProvider - Provides repositories for specific aggregate types

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      LockFactory lockFactory,
                                      Cache cache,
                                      SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Note that an optimistic locking strategy is not compatible with caching.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

lockFactory - The lock factory restricting concurrent access to aggregate instances

cache - The cache in which entries will be stored

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      LockFactory lockFactory,
                                      Cache cache,
                                      SnapshotTriggerDefinition snapshotTriggerDefinition,
                                      RepositoryProvider repositoryProvider)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Note that an optimistic locking strategy is not compatible with caching.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

lockFactory - The lock factory restricting concurrent access to aggregate instances

cache - The cache in which entries will be stored

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

repositoryProvider - Provides repositories for specific aggregate types

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      LockFactory lockFactory,
                                      Cache cache,
                                      ParameterResolverFactory parameterResolverFactory,
                                      SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Note that an optimistic locking strategy is not compatible with caching.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

lockFactory - The lock factory restricting concurrent access to aggregate instances

cache - The cache in which entries will be stored

parameterResolverFactory - The parameter resolver factory used to resolve parameters of annotated handlers

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

See Also:

LockingRepository.LockingRepository(Class)

CachingEventSourcingRepository

public CachingEventSourcingRepository(AggregateFactory<T> aggregateFactory,
                                      EventStore eventStore,
                                      LockFactory lockFactory,
                                      Cache cache,
                                      ParameterResolverFactory parameterResolverFactory,
                                      HandlerDefinition handlerDefinition,
                                      SnapshotTriggerDefinition snapshotTriggerDefinition,
                                      RepositoryProvider repositoryProvider)

Initializes a repository with a the given aggregateFactory and a pessimistic locking strategy.

Note that an optimistic locking strategy is not compatible with caching.

Parameters:

aggregateFactory - The factory for new aggregate instances

eventStore - The event store that holds the event streams for this repository

lockFactory - The lock factory restricting concurrent access to aggregate instances

cache - The cache in which entries will be stored

parameterResolverFactory - The parameter resolver factory used to resolve parameters of annotated handlers

handlerDefinition - The handler definition used to create concrete handlers

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

repositoryProvider - Provides repositories for specific aggregate types

See Also:

LockingRepository.LockingRepository(Class)

Method Detail

validateOnLoad

protected void validateOnLoad(Aggregate<T> aggregate,
                              Long expectedVersion)

Description copied from class: AbstractRepository

Checks the aggregate for concurrent changes. Throws a ConflictingModificationException when conflicting changes have been detected.

This implementation throws a ConflictingAggregateVersionException if the expected version is not null and the version number of the aggregate does not match the expected version

Overrides:

validateOnLoad in class EventSourcingRepository<T>

Parameters:

aggregate - The loaded aggregate

expectedVersion - The expected version of the aggregate

doCreateNewForLock

protected EventSourcedAggregate<T> doCreateNewForLock(Callable<T> factoryMethod)
                                               throws Exception

Description copied from class: LockingRepository

Creates a new aggregate instance using the given factoryMethod. Implementations should assume that this method is only called if a UnitOfWork is currently active.

Overrides:

doCreateNewForLock in class EventSourcingRepository<T>

Parameters:

factoryMethod - The method to create the aggregate's root instance

Returns:

an Aggregate instance describing the aggregate's state

Throws:

Exception - when the factoryMethod throws an exception

doSaveWithLock

protected void doSaveWithLock(EventSourcedAggregate<T> aggregate)

Description copied from class: LockingRepository

Perform the actual saving of the aggregate. All necessary locks have been verified.

Overrides:

doSaveWithLock in class EventSourcingRepository<T>

Parameters:

aggregate - the aggregate to store

doDeleteWithLock

protected void doDeleteWithLock(EventSourcedAggregate<T> aggregate)

Description copied from class: LockingRepository

Perform the actual deleting of the aggregate. All necessary locks have been verified.

Overrides:

doDeleteWithLock in class EventSourcingRepository<T>

Parameters:

aggregate - the aggregate to delete

doLoadWithLock

protected EventSourcedAggregate<T> doLoadWithLock(String aggregateIdentifier,
                                                  Long expectedVersion)

Perform the actual loading of an aggregate. The necessary locks have been obtained. If the aggregate is available in the cache, it is returned from there. Otherwise the underlying persistence logic is called to retrieve the aggregate.

Overrides:

doLoadWithLock in class EventSourcingRepository<T>

Parameters:

aggregateIdentifier - the identifier of the aggregate to load

expectedVersion - The expected version of the aggregate

Returns:

the fully initialized aggregate