org.axonframework.commandhandling.model

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

java.lang.Object

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

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

Type Parameters:

T - The type that this aggregate stores

All Implemented Interfaces:

Repository<T>, ScopeAware

Direct Known Subclasses:

EventSourcingRepository, GenericJpaRepository

public abstract class LockingRepository<T,A extends Aggregate<T>>
extends AbstractRepository<T,LockAwareAggregate<T,A>>

Implementation of the Repository interface that takes provides a locking mechanism to prevent concurrent modifications of persisted aggregates. Unless there is a locking mechanism present in the underlying persistence environment, it is recommended to use a LockingRepository (or one of its subclasses).

The LockingRepository can be initialized with a locking strategy. Pessimistic Locking is the default strategy. Pessimistic Locking requires an exclusive lock to be handed to a thread loading an aggregate before the aggregate is handed over. This means that, once an aggregate is loaded, it has full exclusive access to it, until it saves the aggregate.

Important: If an exception is thrown during the saving process, any locks held are released. The calling thread may reattempt saving the aggregate again. If the lock is available, the thread automatically takes back the lock. If, however, another thread has obtained the lock first, a ConcurrencyException is thrown.

Since:

0.3

Author:

Allard Buijze

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	LockingRepository(AggregateModel<T> aggregateModel) Initialize a repository with a pessimistic locking strategy, using the given aggregateModel, describing the structure of the aggregate.
protected	LockingRepository(AggregateModel<T> aggregateModel, LockFactory lockFactory) Initialize the repository with the given lockFactory and aggregateModel
protected	LockingRepository(Class<T> aggregateType) Initialize a repository with a pessimistic locking strategy.
protected	LockingRepository(Class<T> aggregateType, LockFactory lockFactory) Initialize the repository with the given lockFactory.
protected	LockingRepository(Class<T> aggregateType, LockFactory lockFactory, ParameterResolverFactory parameterResolverFactory) Initialize the repository with the given lockFactory and parameterResolverFactory.
protected	LockingRepository(Class<T> aggregateType, LockFactory lockFactory, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition) Initialize the repository with the given lockFactory, parameterResolverFactory and handlerDefinition.
protected	LockingRepository(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory) Initialize a repository with a pessimistic locking strategy and a parameter resolver factory.
protected	LockingRepository(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition) Initialize a repository with a pessimistic locking strategy and a parameter resolver factory.

Method Summary

Modifier and Type	Method and Description
protected LockAwareAggregate<T,A>	doCreateNew(Callable<T> factoryMethod) Creates a new aggregate instance using the given factoryMethod.
protected abstract A	doCreateNewForLock(Callable<T> factoryMethod) Creates a new aggregate instance using the given factoryMethod.
protected void	doDelete(LockAwareAggregate<T,A> aggregate) Verifies whether all locks are valid and delegates to doDeleteWithLock(Aggregate) to perform actual deleting.
protected abstract void	doDeleteWithLock(A aggregate) Perform the actual deleting of the aggregate.
protected LockAwareAggregate<T,A>	doLoad(String aggregateIdentifier, Long expectedVersion) Perform the actual loading of an aggregate.
protected abstract A	doLoadWithLock(String aggregateIdentifier, Long expectedVersion) Loads the aggregate with the given aggregateIdentifier.
protected void	doSave(LockAwareAggregate<T,A> aggregate) Verifies whether all locks are valid and delegates to doSaveWithLock(Aggregate) to perform actual storage.
protected abstract void	doSaveWithLock(A aggregate) Perform the actual saving of the aggregate.
protected void	prepareForCommit(LockAwareAggregate<T,A> 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.commandhandling.model.AbstractRepository

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

Methods inherited from class java.lang.Object

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

Constructor Detail

LockingRepository

protected LockingRepository(Class<T> aggregateType)

Initialize a repository with a pessimistic locking strategy.

Parameters:

aggregateType - The type of aggregate stored in this repository

LockingRepository

protected LockingRepository(AggregateModel<T> aggregateModel)

Initialize a repository with a pessimistic locking strategy, using the given aggregateModel, describing the structure of the aggregate.

Parameters:

aggregateModel - The model describing the structure of the aggregate

LockingRepository

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

Initialize a repository with a pessimistic locking strategy and a parameter resolver factory.

Parameters:

aggregateType - The type of aggregate stored in this repository

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

LockingRepository

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

Initialize a repository with a pessimistic locking strategy and a parameter resolver factory.

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

LockingRepository

protected LockingRepository(Class<T> aggregateType,
                            LockFactory lockFactory)

Initialize the repository with the given lockFactory.

Parameters:

aggregateType - The type of aggregate stored in this repository

lockFactory - the lock factory to use

LockingRepository

protected LockingRepository(AggregateModel<T> aggregateModel,
                            LockFactory lockFactory)

Initialize the repository with the given lockFactory and aggregateModel

Parameters:

aggregateModel - The model describing the structure of the aggregate

lockFactory - the lock factory to use

LockingRepository

protected LockingRepository(Class<T> aggregateType,
                            LockFactory lockFactory,
                            ParameterResolverFactory parameterResolverFactory)

Initialize the repository with the given lockFactory and parameterResolverFactory.

Parameters:

aggregateType - The type of aggregate stored in this repository

lockFactory - The lock factory to use

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

LockingRepository

protected LockingRepository(Class<T> aggregateType,
                            LockFactory lockFactory,
                            ParameterResolverFactory parameterResolverFactory,
                            HandlerDefinition handlerDefinition)

Initialize the repository with the given lockFactory, parameterResolverFactory and handlerDefinition.

Parameters:

aggregateType - The type of aggregate stored in this repository

lockFactory - The lock factory to use

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

handlerDefinition - The handler definition used to create concrete handlers

Method Detail

doCreateNew

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

Description copied from class: AbstractRepository

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:

doCreateNew in class AbstractRepository<T,LockAwareAggregate<T,A extends Aggregate<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

doCreateNewForLock

protected abstract A doCreateNewForLock(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

doLoad

protected LockAwareAggregate<T,A> doLoad(String aggregateIdentifier,
                                         Long expectedVersion)

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

Specified by:

doLoad in class AbstractRepository<T,LockAwareAggregate<T,A extends Aggregate<T>>>

Parameters:

aggregateIdentifier - the identifier of the aggregate to load

expectedVersion - The expected version of the aggregate

Returns:

the fully initialized aggregate

Throws:

AggregateNotFoundException - if aggregate with given id cannot be found

prepareForCommit

protected void prepareForCommit(LockAwareAggregate<T,A> 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 AbstractRepository<T,LockAwareAggregate<T,A extends Aggregate<T>>>

Parameters:

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

doSave

protected void doSave(LockAwareAggregate<T,A> aggregate)

Verifies whether all locks are valid and delegates to doSaveWithLock(Aggregate) to perform actual storage.

Specified by:

doSave in class AbstractRepository<T,LockAwareAggregate<T,A extends Aggregate<T>>>

Parameters:

aggregate - the aggregate to store

doDelete

protected final void doDelete(LockAwareAggregate<T,A> aggregate)

Verifies whether all locks are valid and delegates to doDeleteWithLock(Aggregate) to perform actual deleting.

Specified by:

doDelete in class AbstractRepository<T,LockAwareAggregate<T,A extends Aggregate<T>>>

Parameters:

aggregate - the aggregate to delete

doSaveWithLock

protected abstract void doSaveWithLock(A aggregate)

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

Parameters:

aggregate - the aggregate to store

doDeleteWithLock

protected abstract void doDeleteWithLock(A aggregate)

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

Parameters:

aggregate - the aggregate to delete

doLoadWithLock

protected abstract A doLoadWithLock(String aggregateIdentifier,
                                    Long expectedVersion)

Loads the aggregate with the given aggregateIdentifier. All necessary locks have been obtained.

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