AnnotatedAggregate (Axon Framework 3.1.1 API)

java.lang.Object
- 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(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`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
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 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(CommandMessage<?> msg)` Handle the given `commandMessage` on the aggregate root or one of its child entities.
`Object`	`identifier()` Get the unique 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(T aggregateRoot, AggregateModel<T> aggregateModel, EventBus eventBus)` Initialize an aggregate with the given `aggregateRoot` which is described in the given `aggregateModel`.
`<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.
`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()` Get the String representation of the aggregate's type.
`Long`	`version()` Get the aggregate's version.

Methods inherited from class org.axonframework.commandhandling.model.AggregateLifecycle
apply, apply, execute, executeWithResult, getInstance, isLive, markDeleted, registerAsCurrent, registerWithUnitOfWork

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(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
- 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(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
  - 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 interface: Aggregate
    
    Get the String representation of the aggregate's type. This defaults to the simple name of the Aggregate.rootType() unless configured otherwise.
    
    Specified by:
    
    type in interface Aggregate<T>
    
    Returns:
    
    The aggregate's type
  - identifier
```
public Object identifier()
```
    Description copied from interface: Aggregate
    
    Get the unique identifier of this aggregate
    
    Specified by:
    
    identifier in interface Aggregate<T>
    
    Returns:
    
    The aggregate's identifier
  - version
```
public Long version()
```
    Description copied from interface: Aggregate
    
    Get the aggregate's version. For event sourced aggregates this is identical to the sequence number of the last applied event.
    
    Specified by:
    
    version in interface Aggregate<T>
    
    Returns:
    
    The aggregate's version
  - 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
  - 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(CommandMessage<?> msg)
              throws Exception
```
    Description copied from interface: Aggregate
    
    Handle the given commandMessage on the aggregate root or one of its child entities.
    
    Specified by:
    
    handle in interface Aggregate<T>
    
    Parameters:
    
    msg - The command to be handled by the aggregate
    
    Returns:
    
    The result of command handling. Returns null in case the command yields no result.
    
    Throws:
    
    Exception - in case one is triggered during command 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

Class AnnotatedAggregate<T>

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

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

Constructor Detail

AnnotatedAggregate

AnnotatedAggregate

Method Detail

initialize

initialize

registerRoot

type

identifier

version

getIsLive

invoke

execute

isDeleted

rootType

doMarkDeleted

publish

publishOnEventBus

handle

doApply

createMessage

getAggregateRoot

andThenApply

andThen

applyMessageOrPayload