org.axonframework.eventhandling.saga.repository

Class AnnotatedSagaRepository<T>

java.lang.Object

org.axonframework.eventhandling.saga.repository.LockingSagaRepository<T>

org.axonframework.eventhandling.saga.repository.AnnotatedSagaRepository<T>

All Implemented Interfaces:

SagaRepository<T>

public class AnnotatedSagaRepository<T>
extends LockingSagaRepository<T>

Abstract implementation for saga repositories. This (partial) implementation will take care of the uniqueness of saga instances in the JVM. That means it will prevent multiple instances of the same conceptual Saga (i.e. with same identifier) to exist within the JVM.

Since:

0.7

Author:

Allard Buijze

Constructor Summary

Constructors

Constructor and Description
AnnotatedSagaRepository(Class<T> sagaType, SagaStore<? super T> sagaStore) Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore.
AnnotatedSagaRepository(Class<T> sagaType, SagaStore<? super T> sagaStore, ResourceInjector resourceInjector) Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore.
AnnotatedSagaRepository(Class<T> sagaType, SagaStore<? super T> sagaStore, ResourceInjector resourceInjector, ParameterResolverFactory parameterResolverFactory) Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore.
AnnotatedSagaRepository(Class<T> sagaType, SagaStore<? super T> sagaStore, ResourceInjector resourceInjector, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition) Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore.
AnnotatedSagaRepository(Class<T> sagaType, SagaStore<? super T> sagaStore, SagaModel<T> sagaModel, ResourceInjector resourceInjector, LockFactory lockFactory) Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore.

Method Summary

Modifier and Type	Method and Description
protected void	commit(AnnotatedSaga<T> saga) Commits the given modified saga to the underlying saga store.
protected void	deleteSaga(AnnotatedSaga<T> saga) Remove the given saga as well as all known association values pointing to it from the repository.
AnnotatedSaga<T>	doCreateInstance(String sagaIdentifier, Supplier<T> sagaFactory) Creates a new Saga instance.
AnnotatedSaga<T>	doLoad(String sagaIdentifier) Loads a known Saga instance by its unique identifier.
protected AnnotatedSaga<T>	doLoadSaga(String sagaIdentifier) Loads the saga with given sagaIdentifier from the underlying saga store and returns it as a AnnotatedSaga.
Set<String>	find(AssociationValue associationValue) Find saga instances of the given type that have been associated with the given associationValue.
protected void	storeSaga(AnnotatedSaga<T> saga) Stores a newly created Saga instance.
protected Set<String>	unsavedSagaResource(UnitOfWork<?> unitOfWork) Returns a set of identifiers of sagas that may have changed in the context of the given unitOfWork and have not been saved yet.
protected void	updateSaga(AnnotatedSaga<T> saga) Update a stored Saga, by replacing it with the given saga instance.

Methods inherited from class org.axonframework.eventhandling.saga.repository.LockingSagaRepository

createInstance, load

Methods inherited from class java.lang.Object

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

Constructor Detail

AnnotatedSagaRepository

public AnnotatedSagaRepository(Class<T> sagaType,
                               SagaStore<? super T> sagaStore)

Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore. The repository will use a AnnotationSagaMetaModelFactory and NoResourceInjector to initialize Saga instances after a target instance is created or loaded from the store. This repository uses a PessimisticLockFactory when a Saga is loaded.

Parameters:

sagaType - the saga target type

sagaStore - the saga store for saving and loading of sagas

AnnotatedSagaRepository

public AnnotatedSagaRepository(Class<T> sagaType,
                               SagaStore<? super T> sagaStore,
                               ResourceInjector resourceInjector)

Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore. The repository will use given resourceInjector and AnnotationSagaMetaModelFactory to initialize Saga instances after a target instance is created or loaded from the store. This repository uses a PessimisticLockFactory when a Saga is loaded.

Parameters:

sagaType - the saga target type

sagaStore - the saga store for saving and loading of sagas

resourceInjector - the resource injector used to initialize Sagas that delegate to the target

AnnotatedSagaRepository

public AnnotatedSagaRepository(Class<T> sagaType,
                               SagaStore<? super T> sagaStore,
                               ResourceInjector resourceInjector,
                               ParameterResolverFactory parameterResolverFactory)

Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore. The repository will use given resourceInjector and AnnotationSagaMetaModelFactory to initialize Saga instances after a target instance is created or loaded from the store. This repository uses a PessimisticLockFactory when a Saga is loaded.

Parameters:

sagaType - the saga target type

sagaStore - the saga store for saving and loading of sagas

resourceInjector - the resource injector used to initialize Sagas that delegate to the target

parameterResolverFactory - The ParameterResolverFactory instance to resolve parameter values for annotated handlers with

AnnotatedSagaRepository

public AnnotatedSagaRepository(Class<T> sagaType,
                               SagaStore<? super T> sagaStore,
                               ResourceInjector resourceInjector,
                               ParameterResolverFactory parameterResolverFactory,
                               HandlerDefinition handlerDefinition)

Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore. The repository will use given resourceInjector and AnnotationSagaMetaModelFactory to initialize Saga instances after a target instance is created or loaded from the store. This repository uses a PessimisticLockFactory when a Saga is loaded.

Parameters:

sagaType - the saga target type

sagaStore - the saga store for saving and loading of sagas

resourceInjector - the resource injector used to initialize Sagas that delegate to the target

parameterResolverFactory - The ParameterResolverFactory instance to resolve parameter values for annotated handlers with

handlerDefinition - The handler definition used to create concrete handlers

AnnotatedSagaRepository

public AnnotatedSagaRepository(Class<T> sagaType,
                               SagaStore<? super T> sagaStore,
                               SagaModel<T> sagaModel,
                               ResourceInjector resourceInjector,
                               LockFactory lockFactory)

Initializes an AnnotatedSagaRepository for given sagaType that stores sagas in the given sagaStore. The repository will use the given sagaModel and resourceInjector to initialize Saga instances after a target instance is created or loaded from the store.

Parameters:

sagaType - the saga target type

sagaStore - the saga store for saving and loading of sagas

sagaModel - the saga model used to initialize Sagas that delegate to the target

resourceInjector - the resource injector used to initialize Sagas that delegate to the target

lockFactory - lock factory used when a saga is loaded

Method Detail

doLoad

public AnnotatedSaga<T> doLoad(String sagaIdentifier)

Description copied from class: LockingSagaRepository

Loads a known Saga instance by its unique identifier. Due to the concurrent nature of Sagas, it is not unlikely for a Saga to have ceased to exist after it has been found based on associations. Therefore, a repository should return null in case a Saga doesn't exists, as opposed to throwing an exception.

Specified by:

doLoad in class LockingSagaRepository<T>

Parameters:

sagaIdentifier - The unique identifier of the Saga to load

Returns:

The Saga instance, or null if no such saga exists

doCreateInstance

public AnnotatedSaga<T> doCreateInstance(String sagaIdentifier,
                                         Supplier<T> sagaFactory)

Description copied from class: LockingSagaRepository

Creates a new Saga instance. The returned Saga will delegate event handling to the instance supplied by the given factoryMethod.

Specified by:

doCreateInstance in class LockingSagaRepository<T>

Parameters:

sagaIdentifier - the identifier to use for the new saga instance

sagaFactory - Used to create a new Saga delegate

Returns:

a new Saga instance wrapping an instance of type T

unsavedSagaResource

protected Set<String> unsavedSagaResource(UnitOfWork<?> unitOfWork)

Returns a set of identifiers of sagas that may have changed in the context of the given unitOfWork and have not been saved yet.

Parameters:

unitOfWork - the unit of work to inspect for unsaved sagas

Returns:

set of saga identifiers of unsaved sagas

commit

protected void commit(AnnotatedSaga<T> saga)

Commits the given modified saga to the underlying saga store. If the saga is not active anymore it will be deleted. Otherwise the stored saga and its associations will be updated.

Parameters:

saga - the saga to commit to the store

find

public Set<String> find(AssociationValue associationValue)

Description copied from interface: SagaRepository

Find saga instances of the given type that have been associated with the given associationValue.

Parameters:

associationValue - The value that the returned Sagas must be associated with

Returns:

A Set containing the found Saga instances. If none are found, an empty Set is returned. Will never return null.

deleteSaga

protected void deleteSaga(AnnotatedSaga<T> saga)

Remove the given saga as well as all known association values pointing to it from the repository. If no such saga exists, nothing happens.

Parameters:

saga - The saga instance to remove from the repository

updateSaga

protected void updateSaga(AnnotatedSaga<T> saga)

Update a stored Saga, by replacing it with the given saga instance.

Parameters:

saga - The saga that has been modified and needs to be updated in the storage

storeSaga

protected void storeSaga(AnnotatedSaga<T> saga)

Stores a newly created Saga instance.

Parameters:

saga - The newly created Saga instance to store.

doLoadSaga

protected AnnotatedSaga<T> doLoadSaga(String sagaIdentifier)

Loads the saga with given sagaIdentifier from the underlying saga store and returns it as a AnnotatedSaga. Resources of the saga will be injected using the ResourceInjector configured with the repository.

Parameters:

sagaIdentifier - the identifier of the saga to load

Returns:

AnnotatedSaga instance with the loaded saga