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>

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, 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, 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.

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	prepareForCommit(LockAwareAggregate<T,EventSourcedAggregate<T>> aggregate) Register handlers with the current Unit of Work that save or delete the given aggregate when the Unit of Work is committed.

Methods inherited from class org.axonframework.eventsourcing.EventSourcingRepository

getAggregateFactory, reportIllegalState, validateOnLoad

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

doCreateNew, doDelete, doLoad, doSave

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

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

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,
                                      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,
                                      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 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 LockingRepository#LockingRepository(Class)

Method Detail

prepareForCommit

protected void prepareForCommit(LockAwareAggregate<T,EventSourcedAggregate<T>> aggregate)

Description copied from class: AbstractRepository

Register handlers with the current Unit of Work that save or delete the given aggregate when the Unit of Work is committed.

Overrides:

prepareForCommit in class LockingRepository<T,EventSourcedAggregate<T>>

Parameters:

aggregate - The Aggregate to save or delete when the Unit of Work is committed

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