org.axonframework.modelling.command

Class AbstractRepository.Builder<T>

java.lang.Object

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

Type Parameters:

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

Direct Known Subclasses:

LockingRepository.Builder

Enclosing class:

AbstractRepository<T,A extends Aggregate<T>>

public abstract static class AbstractRepository.Builder<T>
extends Object

Abstract Builder class to instantiate AbstractRepository implementations.

This Builder's main goal is to build 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.

The SpanFactory defaults to a NoOpSpanFactory.

Field Summary

Fields

Modifier and Type	Field and Description
protected Class<T>	aggregateType
protected Set<Class<? extends T>>	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
AbstractRepository.Builder<T>	aggregateModel(AggregateModel<T> aggregateModel) Sets the AggregateModel of generic type T, describing the structure of the aggregate this Repository will store.
protected AggregateModel<T>	buildAggregateModel() Instantiate the AggregateModel of generic type T describing the structure of the Aggregate this Repository will store.
AbstractRepository.Builder<T>	handlerDefinition(HandlerDefinition handlerDefinition) Sets the HandlerDefinition used to create concrete handlers for the given aggregateType.
AbstractRepository.Builder<T>	parameterResolverFactory(ParameterResolverFactory parameterResolverFactory) Sets the ParameterResolverFactory used to resolve parameters for annotated handlers contained in the Aggregate.
AbstractRepository.Builder<T>	spanFactory(RepositorySpanFactory spanFactory) Sets the RepositorySpanFactory implementation to use for providing tracing capabilities.
AbstractRepository.Builder<T>	spanFactory(SpanFactory spanFactory) Deprecated. Use spanFactory(RepositorySpanFactory) instead, as it provides more configuration options
AbstractRepository.Builder<T>	subtype(Class<? extends T> subtype) Sets a subtype of the aggregate type represented by this Repository.
AbstractRepository.Builder<T>	subtypes(Set<Class<? extends T>> subtypes) Sets the subtypes of the aggregate type represented by this Repository.
protected void	validate() Validates whether the fields contained in this Builder are set accordingly.

Methods inherited from class java.lang.Object

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

Field Detail

aggregateType

protected final Class<T> aggregateType

subtypes

protected Set<Class<? extends T>> subtypes

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 AbstractRepository.Builder<T> parameterResolverFactory(@Nonnull
                                                              ParameterResolverFactory parameterResolverFactory)

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.

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 AbstractRepository.Builder<T> handlerDefinition(@Nonnull
                                                       HandlerDefinition handlerDefinition)

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

Parameters:

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

Returns:

the current Builder instance, for fluent interfacing

aggregateModel

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

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

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 AbstractRepository.Builder<T> subtypes(@Nonnull
                                              Set<Class<? extends T>> subtypes)

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.

Parameters:

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

Returns:

The current Builder instance, for fluent interfacing.

subtype

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

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.

Parameters:

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

Returns:

The current Builder instance, for fluent interfacing.

spanFactory

@Deprecated
public AbstractRepository.Builder<T> spanFactory(SpanFactory spanFactory)

Deprecated. Use spanFactory(RepositorySpanFactory) instead, as it provides more configuration options

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

Parameters:

spanFactory - The SpanFactory implementation

Returns:

The current Builder instance, for fluent interfacing.

spanFactory

public AbstractRepository.Builder<T> spanFactory(RepositorySpanFactory spanFactory)

Sets the RepositorySpanFactory implementation to use for providing tracing capabilities. Defaults to a DefaultRepositorySpanFactory backed by a NoOpSpanFactory, which provides no tracing capabilities.

Parameters:

spanFactory - The SpanFactory implementation

Returns:

The current Builder instance, for fluent interfacing.

buildAggregateModel

protected AggregateModel<T> buildAggregateModel()

Instantiate the AggregateModel of generic type T describing the structure of the Aggregate this Repository will store.

Returns:

a AggregateModel of generic type T describing the Aggregate this Repository will store

validate

protected void validate()
                 throws AxonConfigurationException

Validates whether the fields contained in this Builder are set accordingly.

Throws:

AxonConfigurationException - if one field is asserted to be incorrect according to the Builder's specifications