org.axonframework.commandhandling.model

Class GenericJpaRepository<T>

java.lang.Object

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

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

org.axonframework.commandhandling.model.GenericJpaRepository<T>

Type Parameters:

T - The type of aggregate the repository provides access to

All Implemented Interfaces:

Repository<T>

public class GenericJpaRepository<T>
extends LockingRepository<T,AnnotatedAggregate<T>>

Generic repository implementation that stores JPA annotated aggregates. These aggregates must have the proper JPA Annotations.

Optionally, the repository may be configured with a locking scheme. The repository will always force optimistic locking in the backing data store. The optional lock in the repository is in addition to this optimistic lock. Note that locks on this repository will not be shared with other repository instances.

When this repository is requested to persist changes to an aggregate, it will also flush the EntityManager, to enforce checking of database constraints and optimistic locks.

Since:

0.7

Author:

Allard Buijze

Constructor Summary

Constructors

Constructor and Description
GenericJpaRepository(EntityManagerProvider entityManagerProvider, AggregateModel<T> aggregateModel, EventBus eventBus) Initialize a repository for storing aggregates whose structure is defined by given aggregateModel.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, AggregateModel<T> aggregateModel, EventBus eventBus, LockFactory lockFactory) Initialize a repository for storing aggregates described by the given aggregateModel with an additional LockFactory.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, AggregateModel<T> aggregateModel, EventBus eventBus, LockFactory lockFactory, Function<String,?> identifierConverter) Initialize a repository for storing aggregates described by the given AggregateModel, with an additional LockFactory and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus) Initialize a repository for storing aggregates of the given aggregateType.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus, Function<String,?> identifierConverter) Initialize a repository for storing aggregates of the given aggregateType.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus, LockFactory lockFactory) Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus, LockFactory lockFactory, Function<String,?> identifierConverter) Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus, LockFactory lockFactory, ParameterResolverFactory parameterResolverFactory) Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus, LockFactory lockFactory, ParameterResolverFactory parameterResolverFactory, Function<String,?> identifierConverter) Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.
GenericJpaRepository(EntityManagerProvider entityManagerProvider, Class<T> aggregateType, EventBus eventBus, ParameterResolverFactory parameterResolverFactory) Initialize a repository for storing aggregates of the given aggregateType.

Method Summary

Modifier and Type	Method and Description
protected AnnotatedAggregate<T>	doCreateNewForLock(Callable<T> factoryMethod) Creates a new aggregate instance using the given factoryMethod.
protected void	doDeleteWithLock(AnnotatedAggregate<T> aggregate) Perform the actual deleting of the aggregate.
protected AnnotatedAggregate<T>	doLoadWithLock(String aggregateIdentifier, Long expectedVersion) Loads the aggregate with the given aggregateIdentifier.
protected void	doSaveWithLock(AnnotatedAggregate<T> aggregate) Perform the actual saving of the aggregate.
void	setForceFlushOnSave(boolean forceFlushOnSave) Indicates whether the EntityManager's state should be flushed each time an aggregate is saved.

Methods inherited from class org.axonframework.commandhandling.model.LockingRepository

doCreateNew, doDelete, doLoad, doSave, prepareForCommit

Methods inherited from class org.axonframework.commandhandling.model.AbstractRepository

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

Methods inherited from class java.lang.Object

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

Constructor Detail

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus)

Initialize a repository for storing aggregates of the given aggregateType. No additional locking will be used.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this EventStore

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            AggregateModel<T> aggregateModel,
                            EventBus eventBus)

Initialize a repository for storing aggregates whose structure is defined by given aggregateModel. No additional locking will be used.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this EventStore

aggregateModel - the model describing the structure of the aggregate

eventBus - the event bus to which new events are published

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus,
                            Function<String,?> identifierConverter)

Initialize a repository for storing aggregates of the given aggregateType. No additional locking will be used and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this EventStore

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

identifierConverter - the function that converts the String based identifier to the Identifier object used in the Entity

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus,
                            ParameterResolverFactory parameterResolverFactory)

Initialize a repository for storing aggregates of the given aggregateType. No additional locking will be used.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this EventStore

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

parameterResolverFactory - the component to resolve parameter values of annotated message handlers with

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus,
                            LockFactory lockFactory)

Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this repository

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

lockFactory - the additional locking strategy for this repository

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            AggregateModel<T> aggregateModel,
                            EventBus eventBus,
                            LockFactory lockFactory)

Initialize a repository for storing aggregates described by the given aggregateModel with an additional LockFactory.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this repository

aggregateModel - the model describing the structure of the aggregate

eventBus - the event bus to which new events are published

lockFactory - the additional locking strategy for this repository

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus,
                            LockFactory lockFactory,
                            Function<String,?> identifierConverter)

Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this repository

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

lockFactory - the additional locking strategy for this repository

identifierConverter - the function that converts the String based identifier to the Identifier object used in the Entity

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            AggregateModel<T> aggregateModel,
                            EventBus eventBus,
                            LockFactory lockFactory,
                            Function<String,?> identifierConverter)

Initialize a repository for storing aggregates described by the given AggregateModel, with an additional LockFactory and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this repository

aggregateModel - the model describing the structure of the aggregate

eventBus - the event bus to which new events are published

lockFactory - the additional locking strategy for this repository

identifierConverter - the function that converts the String based identifier to the Identifier object used in the Entity

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus,
                            LockFactory lockFactory,
                            ParameterResolverFactory parameterResolverFactory)

Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this repository

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

lockFactory - the additional locking strategy for this repository

parameterResolverFactory - the component to resolve parameter values of annotated message handlers with

GenericJpaRepository

public GenericJpaRepository(EntityManagerProvider entityManagerProvider,
                            Class<T> aggregateType,
                            EventBus eventBus,
                            LockFactory lockFactory,
                            ParameterResolverFactory parameterResolverFactory,
                            Function<String,?> identifierConverter)

Initialize a repository for storing aggregates of the given aggregateType with an additional LockFactory and allowing for a custom identifierConverter to convert a String based identifier to an Identifier Object.

Parameters:

entityManagerProvider - The EntityManagerProvider providing the EntityManager instance for this repository

aggregateType - the aggregate type this repository manages

eventBus - the event bus to which new events are published

lockFactory - the additional locking strategy for this repository

parameterResolverFactory - the component to resolve parameter values of annotated message handlers with

identifierConverter - the function that converts the String based identifier to the Identifier object used in the Entity

Method Detail

doLoadWithLock

protected AnnotatedAggregate<T> doLoadWithLock(String aggregateIdentifier,
                                               Long expectedVersion)

Description copied from class: LockingRepository

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

Specified by:

doLoadWithLock in class LockingRepository<T,AnnotatedAggregate<T>>

Parameters:

aggregateIdentifier - the identifier of the aggregate to load

expectedVersion - The expected version of the aggregate to load

Returns:

a fully initialized aggregate

doCreateNewForLock

protected AnnotatedAggregate<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,AnnotatedAggregate<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(AnnotatedAggregate<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,AnnotatedAggregate<T>>

Parameters:

aggregate - the aggregate to store

doDeleteWithLock

protected void doDeleteWithLock(AnnotatedAggregate<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,AnnotatedAggregate<T>>

Parameters:

aggregate - the aggregate to delete

setForceFlushOnSave

public void setForceFlushOnSave(boolean forceFlushOnSave)

Indicates whether the EntityManager's state should be flushed each time an aggregate is saved. Defaults to true.

Flushing the EntityManager will force JPA to send state changes to the database. Any key violations and failing optimistic locks will be identified in an early stage.

Parameters:

forceFlushOnSave - whether or not to flush the EntityManager after each save. Defaults to true.

See Also:

EntityManager.flush()