Package org.axonframework.eventsourcing

Class EventSourcingRepository<T>

java.lang.Object

org.axonframework.modelling.command.AbstractRepository<T,LockAwareAggregate<T,EventSourcedAggregate<T>>>

org.axonframework.modelling.command.LockingRepository<T,EventSourcedAggregate<T>>

org.axonframework.eventsourcing.EventSourcingRepository<T>

Type Parameters:

T - The type of aggregate this repository stores

All Implemented Interfaces:

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

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	EventSourcingRepository.Builder<T>	Builder class to instantiate a EventSourcingRepository.

Field Summary

Fields inherited from class org.axonframework.modelling.command.AbstractRepository

spanFactory

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	EventSourcingRepository(EventSourcingRepository.Builder<T> builder)	Instantiate a EventSourcingRepository based on the fields contained in the EventSourcingRepository.Builder.

Method Summary

Modifier and Type	Method	Description
static <T> EventSourcingRepository.Builder<T>	builder(Class<T> aggregateType)	Instantiate a Builder to be able to create a EventSourcingRepository for aggregate type T.
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 DomainEventStream	readEvents(String aggregateIdentifier)	Reads the events for the given aggregateIdentifier from the eventStore. this method may be overridden to add pre or postprocessing to the loading of an event stream
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.modelling.command.LockingRepository

doCreateNew, doDelete, doLoad, doLoadOrCreate, doSave, prepareForCommit

Methods inherited from class org.axonframework.modelling.command.AbstractRepository

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

Methods inherited from class java.lang.Object

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

Constructor Details

EventSourcingRepository

protected EventSourcingRepository(EventSourcingRepository.Builder<T> builder)

Instantiate a EventSourcingRepository based on the fields contained in the EventSourcingRepository.Builder.

A goal of the provided Builder is to create an AggregateModel specifying generic T as the aggregate type to be stored. All aggregates in this repository must be instanceOf this aggregate type. To instantiate this AggregateModel, either an AggregateModel can be provided directly or an aggregateType of type Class can be used. The latter will internally resolve to an AggregateModel. Thus, either the AggregateModel or the aggregateType should be provided. An AxonConfigurationException is thrown if these criteria are not met. The same criteria holds for the AggregateFactory. Either the AggregateFactory can be set directly or it will be instantiated internally based on the aggregateType. Hence, one of both is a hard requirement, and will also result in an AxonConfigurationException if both are missing.

Additionally, the builder will assert that the LockFactory, EventStore and SnapshotTriggerDefinition are not null, resulting in an AxonConfigurationException if for any of these this is the case. The RepositorySpanFactory is defaulted to a DefaultRepositorySpanFactory backed by a NoOpSpanFactory.

Parameters:

builder - the EventSourcingRepository.Builder used to instantiate a EventSourcingRepository instance

Method Details

builder

public static <T>
EventSourcingRepository.Builder<T> builder(Class<T> aggregateType)

Instantiate a Builder to be able to create a EventSourcingRepository for aggregate type T. Can also be used to instantiate a CachingEventSourcingRepository for aggregate type T. This Builder will check whether a Cache is provided. If this holds, the EventSourcingRepository.Builder.build() function returns a CachingEventSourcingRepository instead of an EventSourcingRepository.

The LockFactory is defaulted to an PessimisticLockFactory and the SnapshotTriggerDefinition to a NoSnapshotTriggerDefinition implementation. A goal of this Builder goal is to create an AggregateModel specifying generic T as the aggregate type to be stored. All aggregates in this repository must be instanceOf this aggregate type. To instantiate this AggregateModel, either an AggregateModel can be provided directly or an aggregateType of type Class can be used. The latter will internally resolve to an AggregateModel. Thus, either the AggregateModel or the aggregateType should be provided. The same criteria holds for the AggregateFactory. Either the AggregateFactory can be set directly or it will be instantiated internally based on the aggregateType. Hence, one of both is a hard requirement.

Additionally, the EventStore is a hard requirement and as such should be provided.

Returns:

a Builder to be able to create a EventSourcingRepository

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

readEvents

protected DomainEventStream readEvents(String aggregateIdentifier)

Reads the events for the given aggregateIdentifier from the eventStore. this method may be overridden to add pre or postprocessing to the loading of an event stream

Parameters:

aggregateIdentifier - the identifier of the aggregate to load

Returns:

the domain event stream for the given aggregateIdentifier, with eventStreamFilter applied if one was configured

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