org.axonframework.modelling.command

Class LockingRepository.Builder<T>

java.lang.Object

org.axonframework.modelling.command.AbstractRepository.Builder<T>

org.axonframework.modelling.command.LockingRepository.Builder<T>

Type Parameters:

T - a generic specifying the Aggregate type contained in this Repository implementation

Direct Known Subclasses:

EventSourcingRepository.Builder, GenericJpaRepository.Builder

Enclosing class:

LockingRepository<T,A extends Aggregate<T>>

protected abstract static class LockingRepository.Builder<T>
extends AbstractRepository.Builder<T>

Abstract Builder class to instantiate LockingRepository implementations.

The LockFactory is defaulted to a pessimistic locking strategy, implemented in the PessimisticLockFactory. The SpanFactory is defaulted to a NoOpSpanFactory. A goal of this Builder goal 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.

Field Summary

Fields inherited from class org.axonframework.modelling.command.AbstractRepository.Builder

aggregateType, subtypes

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Builder(Class<T> aggregateType) Creates a builder for a Repository for given aggregateType.

Method Summary

Modifier and Type	Method and Description
LockingRepository.Builder<T>	aggregateModel(AggregateModel<T> aggregateModel) Sets the AggregateModel of generic type T, describing the structure of the aggregate this Repository will store.
LockingRepository.Builder<T>	handlerDefinition(HandlerDefinition handlerDefinition) Sets the HandlerDefinition used to create concrete handlers for the given aggregateType.
LockingRepository.Builder<T>	lockFactory(LockFactory lockFactory) Sets the LockFactory used to lock an aggregate.
LockingRepository.Builder<T>	parameterResolverFactory(ParameterResolverFactory parameterResolverFactory) Sets the ParameterResolverFactory used to resolve parameters for annotated handlers contained in the Aggregate.
LockingRepository.Builder<T>	spanFactory(SpanFactory spanFactory) Sets the SpanFactory implementation to use for providing tracing capabilities.
LockingRepository.Builder<T>	subtype(Class<? extends T> subtype) Sets a subtype of the aggregate type represented by this Repository.
LockingRepository.Builder<T>	subtypes(Set<Class<? extends T>> subtypes) Sets the subtypes of the aggregate type represented by this Repository.

Methods inherited from class org.axonframework.modelling.command.AbstractRepository.Builder

buildAggregateModel, validate

Methods inherited from class java.lang.Object

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

Constructor Detail

Builder

protected Builder(Class<T> aggregateType)

Creates a builder for a Repository for given aggregateType.

Parameters:

aggregateType - the aggregateType specifying the type of aggregate this Repository will store

Method Detail

parameterResolverFactory

public LockingRepository.Builder<T> parameterResolverFactory(@Nonnull
                                                             ParameterResolverFactory parameterResolverFactory)

Description copied from class: AbstractRepository.Builder

Sets the ParameterResolverFactory used to resolve parameters for annotated handlers contained in the Aggregate. Only used if the aggregateType approach is selected to create an AggregateModel.

Overrides:

parameterResolverFactory in class AbstractRepository.Builder<T>

Parameters:

parameterResolverFactory - a ParameterResolverFactory used to resolve parameters for annotated handlers contained in the Aggregate

Returns:

the current Builder instance, for fluent interfacing

handlerDefinition

public LockingRepository.Builder<T> handlerDefinition(@Nonnull
                                                      HandlerDefinition handlerDefinition)

Description copied from class: AbstractRepository.Builder

Sets the HandlerDefinition used to create concrete handlers for the given aggregateType. Only used if the aggregateType approach is selected to create an AggregateModel.

Overrides:

handlerDefinition in class AbstractRepository.Builder<T>

Parameters:

handlerDefinition - a HandlerDefinition used to create concrete handlers for the given aggregateType.

Returns:

the current Builder instance, for fluent interfacing

aggregateModel

public LockingRepository.Builder<T> aggregateModel(@Nonnull
                                                   AggregateModel<T> aggregateModel)

Description copied from class: AbstractRepository.Builder

Sets the AggregateModel of generic type T, describing the structure of the aggregate this Repository will store.

Overrides:

aggregateModel in class AbstractRepository.Builder<T>

Parameters:

aggregateModel - the AggregateModel of generic type T of the aggregate this Repository will store

Returns:

the current Builder instance, for fluent interfacing

subtypes

public LockingRepository.Builder<T> subtypes(@Nonnull
                                             Set<Class<? extends T>> subtypes)

Description copied from class: AbstractRepository.Builder

Sets the subtypes of the aggregate type represented by this Repository. Defining subtypes indicates this Repository supports polymorphic aggregate structure.

Only used if the aggregate model is not explicitly set. Defaults to an empty Set.

Overrides:

subtypes in class AbstractRepository.Builder<T>

Parameters:

subtypes - The subtypes of the aggregate type represented by this Repository.

Returns:

The current Builder instance, for fluent interfacing.

subtype

public LockingRepository.Builder<T> subtype(@Nonnull
                                            Class<? extends T> subtype)

Description copied from class: AbstractRepository.Builder

Sets a subtype of the aggregate type represented by this Repository. Defining a subtype indicates this Repository supports a polymorphic aggregate structure.

Only used if the aggregate model is not explicitly set.

Overrides:

subtype in class AbstractRepository.Builder<T>

Parameters:

subtype - A subtypes of the aggregate type represented by this Repository.

Returns:

The current Builder instance, for fluent interfacing.

spanFactory

public LockingRepository.Builder<T> spanFactory(SpanFactory spanFactory)

Description copied from class: AbstractRepository.Builder

Sets the SpanFactory implementation to use for providing tracing capabilities. Defaults to a NoOpSpanFactory by default, which provides no tracing capabilities.

Overrides:

spanFactory in class AbstractRepository.Builder<T>

Parameters:

spanFactory - The SpanFactory implementation

Returns:

The current Builder instance, for fluent interfacing.

lockFactory

public LockingRepository.Builder<T> lockFactory(LockFactory lockFactory)

Sets the LockFactory used to lock an aggregate. Defaults to a pessimistic locking strategy, implemented in the PessimisticLockFactory.

Parameters:

lockFactory - a LockFactory used to lock an aggregate

Returns:

the current Builder instance, for fluent interfacing