AbstractRepository (Axon Framework 3.1.1 API)

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>

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`.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected AggregateModel<T>`	`aggregateModel()` Returns the aggregate model stored by this repository.
`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.
`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(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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractRepository

AbstractRepository

AbstractRepository

Method Detail

newInstance

doCreateNew

load

managedAggregates

load

validateOnLoad

prepareForCommit

reportIllegalState

aggregateModel

getAggregateType

doSave

doLoad

doDelete

postSave

postDelete