org.axonframework.modelling.command

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

java.lang.Object

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

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

Type Parameters:

T - The type that this aggregate stores

All Implemented Interfaces:

ScopeAware, Repository<T>

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

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	LockingRepository.Builder<T> Abstract Builder class to instantiate LockingRepository implementations.

Constructor Summary

Constructors

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

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 LockAwareAggregate<T,A>	doLoadOrCreate(String aggregateIdentifier, Callable<T> factoryMethod) Loads an aggregate from the reporsitory.
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.modelling.command.AbstractRepository

aggregateModel, canResolve, getAggregateType, load, load, loadOrCreate, 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(LockingRepository.Builder<T> builder)

Instantiate a LockingRepository based on the fields contained in the LockingRepository.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 this criteria is not met.

Additionally will assert that the LockFactory is not null, resulting in an AxonConfigurationException if this is the case.

Parameters:

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

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

doLoadOrCreate

protected LockAwareAggregate<T,A> doLoadOrCreate(String aggregateIdentifier,
                                                 Callable<T> factoryMethod)
                                          throws Exception

Description copied from class: AbstractRepository

Loads an aggregate from the reporsitory. If the aggregate does not exists, it is created using the factoryMethod.

Overrides:

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

Parameters:

aggregateIdentifier - the identifier of the aggregate

factoryMethod - the method that creates a new instance

Returns:

the aggregate

Throws:

Exception - when loading or creating the aggregate failed

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