org.axonframework.commandhandling.model.inspection

Class AnnotatedAggregate<T>

java.lang.Object

org.axonframework.messaging.Scope

org.axonframework.commandhandling.model.AggregateLifecycle

org.axonframework.commandhandling.model.inspection.AnnotatedAggregate<T>

Type Parameters:

T - The type of the aggregate root object

All Implemented Interfaces:

Aggregate<T>, ApplyMore

Direct Known Subclasses:

EventSourcedAggregate

public class AnnotatedAggregate<T>
extends AggregateLifecycle
implements Aggregate<T>, ApplyMore

Implementation of the Aggregate interface that allows for an aggregate root to be a POJO with annotations on its Command and Event Handler methods.

This wrapper ensures that aggregate members can use the AggregateLifecycle.apply(Object) method in a static context, as long as access to the instance is done via the execute(Consumer) or invoke(Function) methods.

See Also:

AggregateLifecycle.apply(Object), AggregateLifecycle.markDeleted()

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AnnotatedAggregate(AggregateModel<T> inspector, EventBus eventBus) Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.
protected	AnnotatedAggregate(AggregateModel<T> inspector, EventBus eventBus, RepositoryProvider repositoryProvider) Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.
protected	AnnotatedAggregate(T aggregateRoot, AggregateModel<T> model, EventBus eventBus) Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.
protected	AnnotatedAggregate(T aggregateRoot, AggregateModel<T> model, EventBus eventBus, RepositoryProvider repositoryProvider) Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.

Method Summary

Modifier and Type	Method and Description
ApplyMore	andThen(Runnable runnable) Execute the given runnable after applying the previous event.
ApplyMore	andThenApply(Supplier<?> payloadOrMessageSupplier) Apply a subsequent event to the aggregate after applying another event.
protected void	applyMessageOrPayload(Object payloadOrMessage) Apply a new event message to the aggregate and then publish this message to external systems.
protected <P> EventMessage<P>	createMessage(P payload, MetaData metaData) Creates an EventMessage with given payload and metaData.
protected <P> ApplyMore	doApply(P payload, MetaData metaData) Apply a DomainEventMessage with given payload and metadata (metadata from interceptors will be combined with the provided metadata).
protected <R> Aggregate<R>	doCreateNew(Class<R> aggregateType, Callable<R> factoryMethod) Creates a new aggregate instance.
protected void	doMarkDeleted() Marks this aggregate as deleted.
void	execute(Consumer<T> invocation) Execute a method on the underlying aggregate or one of its instances.
T	getAggregateRoot() Get the annotated aggregate instance.
protected boolean	getIsLive() Indicates whether this Aggregate instance is 'live'.
Object	handle(Message<?> message) Handle the given message on the aggregate root or one of its child entities.
Object	identifier() Retrieve a Object denoting the identifier of this Aggregate.
static <T> AnnotatedAggregate<T>	initialize(Callable<T> aggregateFactory, AggregateModel<T> aggregateModel, EventBus eventBus) Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel.
static <T> AnnotatedAggregate<T>	initialize(Callable<T> aggregateFactory, AggregateModel<T> aggregateModel, EventBus eventBus, boolean generateSequences) Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel.
static <T> AnnotatedAggregate<T>	initialize(Callable<T> aggregateFactory, AggregateModel<T> aggregateModel, EventBus eventBus, RepositoryProvider repositoryProvider) Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel.
static <T> AnnotatedAggregate<T>	initialize(Callable<T> aggregateFactory, AggregateModel<T> aggregateModel, EventBus eventBus, RepositoryProvider repositoryProvider, boolean generateSequences) Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel.
static <T> AnnotatedAggregate<T>	initialize(T aggregateRoot, AggregateModel<T> aggregateModel, EventBus eventBus) Initialize an aggregate with the given aggregateRoot which is described in the given aggregateModel.
static <T> AnnotatedAggregate<T>	initialize(T aggregateRoot, AggregateModel<T> aggregateModel, EventBus eventBus, RepositoryProvider repositoryProvider) Initialize an aggregate with the given aggregateRoot which is described in the given aggregateModel.
void	initSequence() Enable sequences on this Aggregate, causing it to emit DomainEventMessages, starting at sequence 0.
void	initSequence(long lastKnownSequenceNumber) Enable sequences on this Aggregate, causing it to emit DomainEventMessages based on the given lastKnownSequenceNumber.
<R> R	invoke(Function<T,R> invocation) Invoke a method on the underlying aggregate root or one of its instances.
boolean	isDeleted() Check if this aggregate has been deleted.
Long	lastSequence() Returns the last sequence of any event published, or null if no events have been published yet.
protected void	publish(EventMessage<?> msg) Publish an event to the aggregate root and its entities first and external event handlers (using the given event bus) later.
protected void	publishOnEventBus(EventMessage<?> msg) Publish an event to external event handlers using the given event bus.
protected void	registerRoot(Callable<T> aggregateFactory) Registers the aggregate root created by the given aggregateFactory with this aggregate.
Class<? extends T>	rootType() Get the class type of the wrapped aggregate root that the Aggregate defers to for command handling.
String	type() Retrieve a String denoting the type of this Aggregate.
Long	version() Gets the version of the aggregate.

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

apply, apply, createNew, describeScope, execute, getInstance, getVersion, isLive, markDeleted, registerWithUnitOfWork

Methods inherited from class org.axonframework.messaging.Scope

describeCurrentScope, endScope, executeWithResult, getCurrentScope, startScope

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.axonframework.commandhandling.model.Aggregate

identifierAsString

Constructor Detail

AnnotatedAggregate

protected AnnotatedAggregate(T aggregateRoot,
                             AggregateModel<T> model,
                             EventBus eventBus)

Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.

Parameters:

aggregateRoot - The aggregate root instance

model - The model describing the aggregate structure

eventBus - The Event Bus to publish generated events on

AnnotatedAggregate

protected AnnotatedAggregate(T aggregateRoot,
                             AggregateModel<T> model,
                             EventBus eventBus,
                             RepositoryProvider repositoryProvider)

Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.

Parameters:

aggregateRoot - The aggregate root instance

model - The model describing the aggregate structure

eventBus - The Event Bus to publish generated events on

repositoryProvider - Provides repositories for specific aggregate types

AnnotatedAggregate

protected AnnotatedAggregate(AggregateModel<T> inspector,
                             EventBus eventBus)

Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.

Parameters:

inspector - The AggregateModel that describes the aggregate

eventBus - The Event Bus to publish generated events on

AnnotatedAggregate

protected AnnotatedAggregate(AggregateModel<T> inspector,
                             EventBus eventBus,
                             RepositoryProvider repositoryProvider)

Initialize an Aggregate instance for the given aggregateRoot, described by the given aggregateModel that will publish events to the given eventBus.

Parameters:

inspector - The AggregateModel that describes the aggregate

eventBus - The Event Bus to publish generated events on

repositoryProvider - Provides repositories for specific aggregate types

Method Detail

initialize

public static <T> AnnotatedAggregate<T> initialize(Callable<T> aggregateFactory,
                                                   AggregateModel<T> aggregateModel,
                                                   EventBus eventBus)
                                            throws Exception

Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel. The given eventBus is used to publish events generated by the aggregate.

Type Parameters:

T - The type of the Aggregate root

Parameters:

aggregateFactory - The factory to create the aggregate root instance with

aggregateModel - The model describing the aggregate structure

eventBus - The EventBus to publish events on

Returns:

An Aggregate instance, fully initialized

Throws:

Exception - when an error occurs creating the aggregate root instance

initialize

public static <T> AnnotatedAggregate<T> initialize(Callable<T> aggregateFactory,
                                                   AggregateModel<T> aggregateModel,
                                                   EventBus eventBus,
                                                   RepositoryProvider repositoryProvider)
                                            throws Exception

Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel. The given eventBus is used to publish events generated by the aggregate.

Type Parameters:

T - The type of the Aggregate root

Parameters:

aggregateFactory - The factory to create the aggregate root instance with

aggregateModel - The model describing the aggregate structure

eventBus - The EventBus to publish events on

repositoryProvider - Provides repositories for specific aggregate types

Returns:

An Aggregate instance, fully initialized

Throws:

Exception - when an error occurs creating the aggregate root instance

initialize

public static <T> AnnotatedAggregate<T> initialize(Callable<T> aggregateFactory,
                                                   AggregateModel<T> aggregateModel,
                                                   EventBus eventBus,
                                                   boolean generateSequences)
                                            throws Exception

Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel. The given eventBus is used to publish events generated by the aggregate.

Type Parameters:

T - The type of the Aggregate root

Parameters:

aggregateFactory - The factory to create the aggregate root instance with

aggregateModel - The model describing the aggregate structure

eventBus - The EventBus to publish events on

generateSequences - Whether to generate sequence numbers on events published from this aggregate

Returns:

An Aggregate instance, fully initialized

Throws:

Exception - when an error occurs creating the aggregate root instance

initialize

public static <T> AnnotatedAggregate<T> initialize(Callable<T> aggregateFactory,
                                                   AggregateModel<T> aggregateModel,
                                                   EventBus eventBus,
                                                   RepositoryProvider repositoryProvider,
                                                   boolean generateSequences)
                                            throws Exception

Initialize an aggregate created by the given aggregateFactory which is described in the given aggregateModel. The given eventBus is used to publish events generated by the aggregate.

Type Parameters:

T - The type of the Aggregate root

Parameters:

aggregateFactory - The factory to create the aggregate root instance with

aggregateModel - The model describing the aggregate structure

eventBus - The EventBus to publish events on

repositoryProvider - Provides repositories for specific aggregate types

generateSequences - Whether to generate sequence numbers on events published from this aggregate

Returns:

An Aggregate instance, fully initialized

Throws:

Exception - when an error occurs creating the aggregate root instance

initialize

public static <T> AnnotatedAggregate<T> initialize(T aggregateRoot,
                                                   AggregateModel<T> aggregateModel,
                                                   EventBus eventBus)

Initialize an aggregate with the given aggregateRoot which is described in the given aggregateModel. The given eventBus is used to publish events generated by the aggregate.

Type Parameters:

T - The type of the Aggregate root

Parameters:

aggregateRoot - The aggregate root instance

aggregateModel - The model describing the aggregate structure

eventBus - The EventBus to publish events on

Returns:

An Aggregate instance, fully initialized

initialize

public static <T> AnnotatedAggregate<T> initialize(T aggregateRoot,
                                                   AggregateModel<T> aggregateModel,
                                                   EventBus eventBus,
                                                   RepositoryProvider repositoryProvider)

Initialize an aggregate with the given aggregateRoot which is described in the given aggregateModel. The given eventBus is used to publish events generated by the aggregate.

Type Parameters:

T - The type of the Aggregate root

Parameters:

aggregateRoot - The aggregate root instance

aggregateModel - The model describing the aggregate structure

eventBus - The EventBus to publish events on

repositoryProvider - Provides repositories for specific aggregate types

Returns:

An Aggregate instance, fully initialized

initSequence

public void initSequence()

Enable sequences on this Aggregate, causing it to emit DomainEventMessages, starting at sequence 0. Each Event applied will increase the sequence, allowing to trace each event back to the Aggregate instance that published it, in the order published.

initSequence

public void initSequence(long lastKnownSequenceNumber)

Enable sequences on this Aggregate, causing it to emit DomainEventMessages based on the given lastKnownSequenceNumber. Each Event applied will increase the sequence, allowing to trace each event back to the Aggregate instance that published it, in the order published.

Parameters:

lastKnownSequenceNumber - The sequence number to pass into the next event published

registerRoot

protected void registerRoot(Callable<T> aggregateFactory)
                     throws Exception

Registers the aggregate root created by the given aggregateFactory with this aggregate. Applies any delayed events that have not been applied to the aggregate yet.

This is method is commonly called while an aggregate is being initialized.

Parameters:

aggregateFactory - the factory to create the aggregate root

Throws:

Exception - if the aggregate factory fails to create the aggregate root

type

public String type()

Description copied from class: AggregateLifecycle

Retrieve a String denoting the type of this Aggregate.

Specified by:

type in interface Aggregate<T>

Specified by:

type in class AggregateLifecycle

Returns:

a String denoting the type of this Aggregate

identifier

public Object identifier()

Description copied from class: AggregateLifecycle

Retrieve a Object denoting the identifier of this Aggregate.

Specified by:

identifier in interface Aggregate<T>

Specified by:

identifier in class AggregateLifecycle

Returns:

a Object denoting the identifier of this Aggregate

version

public Long version()

Description copied from class: AggregateLifecycle

Gets the version of the aggregate.

Specified by:

version in interface Aggregate<T>

Specified by:

version in class AggregateLifecycle

Returns:

the current version of the aggregate

lastSequence

public Long lastSequence()

Returns the last sequence of any event published, or null if no events have been published yet. If sequences aren't enabled for this Aggregate, the this method will also return null;

Returns:

the last sequence of any event published, or null if no events have been published yet

getIsLive

protected boolean getIsLive()

Description copied from class: AggregateLifecycle

Indicates whether this Aggregate instance is 'live'. This means events currently applied represent events that are currently happening, as opposed to events representing historic decisions.

Specified by:

getIsLive in class AggregateLifecycle

Returns:

true if the aggregate is 'live', false if the aggregate is initializing state based on historic events

doCreateNew

protected <R> Aggregate<R> doCreateNew(Class<R> aggregateType,
                                       Callable<R> factoryMethod)
                                throws Exception

Description copied from class: AggregateLifecycle

Creates a new aggregate instance. In order for new aggregate to be created, a Repository should be available to the current aggregate. Repository of an aggregate to be created is exposed to the current aggregate via RepositoryProvider.

Specified by:

doCreateNew in class AggregateLifecycle

Type Parameters:

R - type of new aggregate to be created

Parameters:

aggregateType - type of new aggregate to be created

factoryMethod - factory method which creates new aggregate

Returns:

a new aggregate instance

Throws:

Exception - thrown if something goes wrong during instantiation of new aggregate

invoke

public <R> R invoke(Function<T,R> invocation)

Description copied from interface: Aggregate

Invoke a method on the underlying aggregate root or one of its instances. Use this over Aggregate.execute(Consumer) to obtain an invocation result, for instance in order to query the aggregate.

Note that the use of this method is not recommended as aggregates are not meant to be queried. Relying on this method is commonly a sign of design smell.

Specified by:

invoke in interface Aggregate<T>

Type Parameters:

R - The type of the result produced by the given invocation

Parameters:

invocation - The function that performs the actual invocation

Returns:

The invocation result

execute

public void execute(Consumer<T> invocation)

Description copied from interface: Aggregate

Execute a method on the underlying aggregate or one of its instances.

Note that the use of this method is not recommended as the wrapped aggregate instance is not meant to be exposed. Relying on this method is commonly a sign of design smell.

Specified by:

execute in interface Aggregate<T>

Parameters:

invocation - The function that performs the invocation

isDeleted

public boolean isDeleted()

Description copied from interface: Aggregate

Check if this aggregate has been deleted. This is checked by aggregate repositories when an aggregate is loaded. In case the repository is asked to load a deleted aggregate the repository will refuse by throwing an AggregateDeletedException.

Specified by:

isDeleted in interface Aggregate<T>

Returns:

true in case the aggregate was deleted, false otherwise

rootType

public Class<? extends T> rootType()

Description copied from interface: Aggregate

Get the class type of the wrapped aggregate root that the Aggregate defers to for command handling.

Specified by:

rootType in interface Aggregate<T>

Returns:

The aggregate root type

doMarkDeleted

protected void doMarkDeleted()

Description copied from class: AggregateLifecycle

Marks this aggregate as deleted. Implementations may react differently to aggregates marked for deletion. Typically, Event Sourced Repositories will ignore the marking and expect deletion to be provided as part of Event information.

Specified by:

doMarkDeleted in class AggregateLifecycle

publish

protected void publish(EventMessage<?> msg)

Publish an event to the aggregate root and its entities first and external event handlers (using the given event bus) later.

Parameters:

msg - the event message to publish

publishOnEventBus

protected void publishOnEventBus(EventMessage<?> msg)

Publish an event to external event handlers using the given event bus.

Parameters:

msg - the event message to publish

handle

public Object handle(Message<?> message)
              throws Exception

Description copied from interface: Aggregate

Handle the given message on the aggregate root or one of its child entities.

Specified by:

handle in interface Aggregate<T>

Parameters:

message - The message to be handled by the aggregate

Returns:

The result of message handling. Might returns null if for example handling a CommandMessage yields no results

Throws:

Exception - in case one is triggered during message processing

doApply

protected <P> ApplyMore doApply(P payload,
                                MetaData metaData)

Description copied from class: AggregateLifecycle

Apply a DomainEventMessage with given payload and metadata (metadata from interceptors will be combined with the provided metadata). The event should be applied to the aggregate immediately and scheduled for publication to other event handlers.

The event should be applied on all entities part of this aggregate. If the event is applied from an event handler of the aggregate and additional events need to be applied that depends on state changes brought about by the first event the returned ApplyMore instance should allow for additional events to be applied after this event.

Specified by:

doApply in class AggregateLifecycle

Parameters:

payload - the payload of the event to apply

metaData - any meta-data that must be registered with the Event

Returns:

a gizmo to apply additional events after the given event has been processed by the entire aggregate

See Also:

ApplyMore

createMessage

protected <P> EventMessage<P> createMessage(P payload,
                                            MetaData metaData)

Creates an EventMessage with given payload and metaData.

Type Parameters:

P - the payload type

Parameters:

payload - payload of the resulting message

metaData - metadata of the resulting message

Returns:

the resulting message

getAggregateRoot

public T getAggregateRoot()

Get the annotated aggregate instance. Note that this method should probably never be used in normal use. If you need to operate on the aggregate use invoke(Function) or execute(Consumer) instead.

Returns:

the aggregate instance

andThenApply

public ApplyMore andThenApply(Supplier<?> payloadOrMessageSupplier)

Description copied from interface: ApplyMore

Apply a subsequent event to the aggregate after applying another event. When the given payloadOrMessageSupplier is asked to provide the subsequent event the initial event has been fully processed by the aggregate.

If the given supplier passes an object that is an instance of a Message the event is applied with the metadata from the message. If the supplied event is not a Message instance it will be applied as an event without additional metadata.

Specified by:

andThenApply in interface ApplyMore

Parameters:

payloadOrMessageSupplier - The next event message or the payload of the next event

Returns:

an instance of ApplyMore to apply any subsequent events

andThen

public ApplyMore andThen(Runnable runnable)

Description copied from interface: ApplyMore

Execute the given runnable after applying the previous event. This runnable is guaranteed to be invoked when the previous event has been fully applied to the aggregate.

The given runnable must not directly alter any state of the aggregate. Instead, it should only decide if more events should be applied based on the state of the aggregate after the previous event

Specified by:

andThen in interface ApplyMore

Parameters:

runnable - the code to execute when the previous event was applied

Returns:

an instance of ApplyMore to apply any subsequent events

applyMessageOrPayload

protected void applyMessageOrPayload(Object payloadOrMessage)

Apply a new event message to the aggregate and then publish this message to external systems. If the given payloadOrMessage is an instance of a Message an event message is applied with the payload and metadata of the given message, otherwise an event message is applied with given payload and empty metadata.

Parameters:

payloadOrMessage - defines the payload and optionally metadata to apply to the aggregate