org.axonframework.eventsourcing

Class EventSourcingRepository<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>

Type Parameters:

T - The type of aggregate this repository stores

All Implemented Interfaces:

Repository<T>

Direct Known Subclasses:

CachingEventSourcingRepository

public class EventSourcingRepository<T>
extends LockingRepository<T,EventSourcedAggregate<T>>

Abstract repository implementation that allows easy implementation of an Event Sourcing mechanism. It will automatically publish new events to the given EventBus and delegate event storage to the provided EventStore.

Since:

0.1

Author:

Allard Buijze

See Also:

EventStore

Constructor Summary

Constructors

Constructor and Description
EventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore) Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances.
EventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, LockFactory lockFactory, ParameterResolverFactory parameterResolverFactory, SnapshotTriggerDefinition snapshotTriggerDefinition) Initialize a repository with the given locking strategy and parameter resolver factory.
EventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, LockFactory lockFactory, SnapshotTriggerDefinition snapshotTriggerDefinition) Initialize a repository with the given locking strategy.
EventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, ParameterResolverFactory parameterResolverFactory, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances.
EventSourcingRepository(AggregateFactory<T> aggregateFactory, EventStore eventStore, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances and triggering snapshots using the given snapshotTriggerDefinition
EventSourcingRepository(AggregateModel<T> aggregateModel, AggregateFactory<T> aggregateFactory, EventStore eventStore) Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances.
EventSourcingRepository(AggregateModel<T> aggregateModel, AggregateFactory<T> aggregateFactory, EventStore eventStore, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances and triggering snapshots using the given snapshotTriggerDefinition
EventSourcingRepository(Class<T> aggregateType, EventStore eventStore) Initializes a repository with the default locking strategy, using a GenericAggregateFactory to create new aggregate instances of given aggregateType.
EventSourcingRepository(Class<T> aggregateType, EventStore eventStore, SnapshotTriggerDefinition snapshotTriggerDefinition) Initializes a repository with the default locking strategy, using a GenericAggregateFactory to create new aggregate instances of given aggregateType.

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.
AggregateFactory<T>	getAggregateFactory() Returns the factory used by this repository.
protected void	reportIllegalState(LockAwareAggregate<T,EventSourcedAggregate<T>> aggregate) Invoked when an the given aggregate instance has been detected that has been part of a rolled back Unit of Work.
protected void	validateOnLoad(Aggregate<T> aggregate, Long expectedVersion) Checks the aggregate for concurrent changes.

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

doCreateNew, doDelete, doLoad, doSave, prepareForCommit

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

EventSourcingRepository

public EventSourcingRepository(Class<T> aggregateType,
                               EventStore eventStore)

Initializes a repository with the default locking strategy, using a GenericAggregateFactory to create new aggregate instances of given aggregateType.

Parameters:

aggregateType - The type of aggregate stored in this repository

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

See Also:

LockingRepository.LockingRepository(Class)

EventSourcingRepository

public EventSourcingRepository(Class<T> aggregateType,
                               EventStore eventStore,
                               SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with the default locking strategy, using a GenericAggregateFactory to create new aggregate instances of given aggregateType.

Parameters:

aggregateType - The type of aggregate stored in this repository

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

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

See Also:

LockingRepository.LockingRepository(Class)

EventSourcingRepository

public EventSourcingRepository(AggregateFactory<T> aggregateFactory,
                               EventStore eventStore)

Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances.

Parameters:

aggregateFactory - The factory for new aggregate instances

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

See Also:

LockingRepository.LockingRepository(Class)

EventSourcingRepository

public EventSourcingRepository(AggregateModel<T> aggregateModel,
                               AggregateFactory<T> aggregateFactory,
                               EventStore eventStore)

Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances.

Parameters:

aggregateModel - The meta model describing the aggregate's structure

aggregateFactory - The factory for new aggregate instances

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

See Also:

LockingRepository.LockingRepository(Class)

EventSourcingRepository

public EventSourcingRepository(AggregateFactory<T> aggregateFactory,
                               EventStore eventStore,
                               SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances and triggering snapshots using the given snapshotTriggerDefinition

Parameters:

aggregateFactory - The factory for new aggregate instances

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

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

See Also:

LockingRepository.LockingRepository(Class)

EventSourcingRepository

public EventSourcingRepository(AggregateModel<T> aggregateModel,
                               AggregateFactory<T> aggregateFactory,
                               EventStore eventStore,
                               SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances and triggering snapshots using the given snapshotTriggerDefinition

Parameters:

aggregateModel - The meta model describing the aggregate's structure

aggregateFactory - The factory for new aggregate instances

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

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

See Also:

LockingRepository.LockingRepository(Class)

EventSourcingRepository

public EventSourcingRepository(AggregateFactory<T> aggregateFactory,
                               EventStore eventStore,
                               ParameterResolverFactory parameterResolverFactory,
                               SnapshotTriggerDefinition snapshotTriggerDefinition)

Initializes a repository with the default locking strategy, using the given aggregateFactory to create new aggregate instances.

Parameters:

aggregateFactory - The factory for new aggregate instances

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

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)

EventSourcingRepository

public EventSourcingRepository(AggregateFactory<T> aggregateFactory,
                               EventStore eventStore,
                               LockFactory lockFactory,
                               SnapshotTriggerDefinition snapshotTriggerDefinition)

Initialize a repository with the given locking strategy.

Parameters:

aggregateFactory - The factory for new aggregate instances

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

lockFactory - the locking strategy to apply to this repository

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

EventSourcingRepository

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

Initialize a repository with the given locking strategy and parameter resolver factory.

Parameters:

aggregateFactory - The factory for new aggregate instances

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

lockFactory - The locking strategy to apply to this repository

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

snapshotTriggerDefinition - The definition describing when to trigger a snapshot

Method Detail

doLoadWithLock

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

Perform the actual loading of an aggregate. The necessary locks have been obtained.

Specified by:

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

Parameters:

aggregateIdentifier - the identifier of the aggregate to load

expectedVersion - The expected version of the loaded aggregate

Returns:

the fully initialized aggregate

Throws:

AggregateDeletedException - in case an aggregate existed in the past, but has been deleted

AggregateNotFoundException - when an aggregate with the given identifier does not exist

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 AbstractRepository<T,LockAwareAggregate<T,EventSourcedAggregate<T>>>

Parameters:

aggregate - The loaded aggregate

expectedVersion - The expected version of the aggregate

reportIllegalState

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

Description copied from class: AbstractRepository

Invoked when an the given aggregate instance has been detected that has been part of a rolled back Unit of Work. This typically means that the state of the Aggregate instance has been compromised and cannot be guaranteed to be correct.

This implementation throws an exception, effectively causing the unit of work to be rolled back. Subclasses that can guarantee correct storage, even when specific instances are compromised, may override this method to suppress this exception.

When this method is invoked, the AbstractRepository.doSave(Aggregate), AbstractRepository.doDelete(Aggregate), AbstractRepository.postSave(Aggregate) and AbstractRepository.postDelete(Aggregate) are not invoked. Implementations may choose to invoke these methods.

Overrides:

reportIllegalState in class AbstractRepository<T,LockAwareAggregate<T,EventSourcedAggregate<T>>>

Parameters:

aggregate - The aggregate instance with illegal state

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.

Specified by:

doCreateNewForLock in class LockingRepository<T,EventSourcedAggregate<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.

Specified by:

doSaveWithLock in class LockingRepository<T,EventSourcedAggregate<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.

Specified by:

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

Parameters:

aggregate - the aggregate to delete

getAggregateFactory

public AggregateFactory<T> getAggregateFactory()

Returns the factory used by this repository.

Returns:

the factory used by this repository