org.axonframework.commandhandling.model

Class AbstractRepository<T,A extends Aggregate<T>>

java.lang.Object

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

Type Parameters:

T - The type of aggregate this repository stores

All Implemented Interfaces:

Repository<T>, ScopeAware

Direct Known Subclasses:

LockingRepository

public abstract class AbstractRepository<T,A extends Aggregate<T>>
extends Object
implements Repository<T>

Abstract implementation of the Repository that takes care of the dispatching of events when an aggregate is persisted. All uncommitted events on an aggregate are dispatched when the aggregate is saved.

Note that this repository implementation does not take care of any locking. The underlying persistence is expected to deal with concurrency. Alternatively, consider using the LockingRepository.

Since:

0.1

Author:

Allard Buijze

See Also:

LockingRepository

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractRepository(AggregateModel<T> aggregateModel) Initializes a repository that stores aggregate of the given aggregateType.
protected	AbstractRepository(Class<T> aggregateType) Initializes a repository that stores aggregate of the given aggregateType.
protected	AbstractRepository(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory) Initializes a repository that stores aggregate of the given aggregateType.
protected	AbstractRepository(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition) Initializes a repository that stores aggregate of the given aggregateType.

Method Summary

Modifier and Type	Method and Description
protected AggregateModel<T>	aggregateModel() Returns the aggregate model stored by this repository.
boolean	canResolve(ScopeDescriptor scopeDescription) Check whether this implementation can resolve a Scope object based on the provided scopeDescription.
protected abstract A	doCreateNew(Callable<T> factoryMethod) Creates a new aggregate instance using the given factoryMethod.
protected abstract void	doDelete(A aggregate) Removes the aggregate from the repository.
protected abstract A	doLoad(String aggregateIdentifier, Long expectedVersion) Loads and initialized the aggregate with the given aggregateIdentifier.
protected abstract void	doSave(A aggregate) Performs the actual saving of the aggregate.
protected Class<? extends T>	getAggregateType() Returns the aggregate type stored by this repository.
A	load(String aggregateIdentifier) Load the aggregate with the given unique identifier.
A	load(String aggregateIdentifier, Long expectedVersion) Load the aggregate with the given unique identifier.
protected Map<String,A>	managedAggregates(UnitOfWork<?> uow) Returns the map of aggregates currently managed by this repository under the given unit of work.
A	newInstance(Callable<T> factoryMethod) Creates a new managed instance for the aggregate, using the given factoryMethod to instantiate the aggregate's root.
protected void	postDelete(A aggregate) Perform action that needs to be done directly after deleting an aggregate and committing the aggregate's uncommitted events.
protected void	postSave(A aggregate) Perform action that needs to be done directly after updating an aggregate and committing the aggregate's uncommitted events.
protected void	prepareForCommit(A aggregate) Register handlers with the current Unit of Work that save or delete the given aggregate when the Unit of Work is committed.
protected void	reportIllegalState(A aggregate) Invoked when an the given aggregate instance has been detected that has been part of a rolled back Unit of Work.
void	send(Message<?> message, ScopeDescriptor scopeDescription) Send a Message to a Scope which is described by the given scopeDescription.
protected void	validateOnLoad(Aggregate<T> aggregate, Long expectedVersion) Checks the aggregate for concurrent changes.

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractRepository

protected AbstractRepository(Class<T> aggregateType)

Initializes a repository that stores aggregate of the given aggregateType. All aggregates in this repository must be instanceOf this aggregate type.

Parameters:

aggregateType - The type of aggregate stored in this repository

AbstractRepository

protected AbstractRepository(Class<T> aggregateType,
                             ParameterResolverFactory parameterResolverFactory)

Initializes a repository that stores aggregate of the given aggregateType. All aggregates in this repository must be instanceOf this aggregate type.

Parameters:

aggregateType - The type of aggregate stored in this repository

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

AbstractRepository

protected AbstractRepository(Class<T> aggregateType,
                             ParameterResolverFactory parameterResolverFactory,
                             HandlerDefinition handlerDefinition)

Initializes a repository that stores aggregate of the given aggregateType. All aggregates in this repository must be instanceOf this aggregate type.

Parameters:

aggregateType - The type of aggregate stored in this repository

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

handlerDefinition - The handler definition used to create concrete handlers

AbstractRepository

protected AbstractRepository(AggregateModel<T> aggregateModel)

Initializes a repository that stores aggregate of the given aggregateType. All aggregates in this repository must be instanceOf this aggregate type.

Parameters:

aggregateModel - The model describing the structure of the aggregate

Method Detail

newInstance

public A newInstance(Callable<T> factoryMethod)
              throws Exception

Description copied from interface: Repository

Creates a new managed instance for the aggregate, using the given factoryMethod to instantiate the aggregate's root.

Specified by:

newInstance in interface Repository<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

doCreateNew

protected abstract A doCreateNew(Callable<T> factoryMethod)
                          throws Exception

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

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

load

public A load(String aggregateIdentifier,
              Long expectedVersion)

Description copied from interface: Repository

Load the aggregate with the given unique identifier.

Specified by:

load in interface Repository<T>

Parameters:

aggregateIdentifier - The identifier of the aggregate to load

expectedVersion - The expected version of the loaded aggregate

Returns:

The aggregate root with the given identifier.

Throws:

AggregateNotFoundException - if aggregate with given id cannot be found

RuntimeException - any exception thrown by implementing classes

managedAggregates

protected Map<String,A> managedAggregates(UnitOfWork<?> uow)

Returns the map of aggregates currently managed by this repository under the given unit of work. Note that the repository keeps the managed aggregates in the root unit of work, to guarantee each Unit of Work works with the state left by the parent unit of work.

The returns map is mutable and reflects any changes made during processing.

Parameters:

uow - The unit of work to find the managed aggregates for

Returns:

a map with the aggregates managed by this repository in the given unit of work

load

public A load(String aggregateIdentifier)

Description copied from interface: Repository

Load the aggregate with the given unique identifier. No version checks are done when loading an aggregate, meaning that concurrent access will not be checked for.

Specified by:

load in interface Repository<T>

Parameters:

aggregateIdentifier - The identifier of the aggregate to load

Returns:

The aggregate root with the given identifier.

validateOnLoad

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

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

Parameters:

aggregate - The loaded aggregate

expectedVersion - The expected version of the aggregate

Throws:

ConflictingModificationException - when conflicting changes have been detected

ConflictingAggregateVersionException - the expected version is not null and the version number of the aggregate does not match the expected version

prepareForCommit

protected void prepareForCommit(A aggregate)

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

Parameters:

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

reportIllegalState

protected void reportIllegalState(A aggregate)

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 doSave(Aggregate), doDelete(Aggregate), postSave(Aggregate) and postDelete(Aggregate) are not invoked. Implementations may choose to invoke these methods.

Parameters:

aggregate - The aggregate instance with illegal state

aggregateModel

protected AggregateModel<T> aggregateModel()

Returns the aggregate model stored by this repository.

Returns:

the aggregate model stored by this repository

getAggregateType

protected Class<? extends T> getAggregateType()

Returns the aggregate type stored by this repository.

Returns:

the aggregate type stored by this repository

doSave

protected abstract void doSave(A aggregate)

Performs the actual saving of the aggregate.

Parameters:

aggregate - the aggregate to store

doLoad

protected abstract A doLoad(String aggregateIdentifier,
                            Long expectedVersion)

Loads and initialized the aggregate with the given aggregateIdentifier.

Parameters:

aggregateIdentifier - the identifier of the aggregate to load

expectedVersion - The expected version of the aggregate to load

Returns:

a fully initialized aggregate

Throws:

AggregateNotFoundException - if the aggregate with given identifier does not exist

doDelete

protected abstract void doDelete(A aggregate)

Removes the aggregate from the repository. Typically, the repository should ensure that any calls to doLoad(String, Long) throw a AggregateNotFoundException when loading a deleted aggregate.

Parameters:

aggregate - the aggregate to delete

postSave

protected void postSave(A aggregate)

Perform action that needs to be done directly after updating an aggregate and committing the aggregate's uncommitted events. No op by default.

Parameters:

aggregate - The aggregate instance being saved

postDelete

protected void postDelete(A aggregate)

Perform action that needs to be done directly after deleting an aggregate and committing the aggregate's uncommitted events. No op by default.

Parameters:

aggregate - The aggregate instance being saved

send

public void send(Message<?> message,
                 ScopeDescriptor scopeDescription)
          throws Exception

Description copied from interface: ScopeAware

Send a Message to a Scope which is described by the given scopeDescription.

Specified by:

send in interface ScopeAware

Parameters:

message - a Message to be send to a Scope

scopeDescription - a D extending ScopeDescriptor, describing the Scope to send the given message to

Throws:

Exception - if sending the message failed. Might occur if the message handling process throws an exception

canResolve

public boolean canResolve(ScopeDescriptor scopeDescription)

Description copied from interface: ScopeAware

Check whether this implementation can resolve a Scope object based on the provided scopeDescription. Will return true in case it should be able to resolve the Scope and false if it cannot.

Specified by:

canResolve in interface ScopeAware

Parameters:

scopeDescription - a ScopeDescriptor describing the Scope to be resolved

Returns:

true in case it should be able to resolve the Scope and false if it cannot