org.axonframework.eventsourcing

Class AggregateLoadTimeSnapshotTriggerDefinition

java.lang.Object

org.axonframework.eventsourcing.AggregateLoadTimeSnapshotTriggerDefinition

All Implemented Interfaces:

SnapshotTriggerDefinition

public class AggregateLoadTimeSnapshotTriggerDefinition
extends Object
implements SnapshotTriggerDefinition

A Snapshotter trigger mechanism which based on the loading time of an Aggregate decides when to trigger the creation of a snapshot. A snapshot is triggered when loading the aggregate exceeds the given loadTimeMillisThreshold in milliseconds.

This threshold can be exceeded in two distinct scenarios:

1. When initializing / event sourcing the aggregate in question.
2. When new events are being applied by the aggregate.

If the definable loadTimeMillisThreshold is met in situation one, the snapshot will be triggered regardless of the outcome of command handling. Thus also if command handling returns exceptionally. If the loadTimeMillisThreshold is only reached once the aggregate has been fully initialized, than the snapshot will only be triggered if handling resolves successfully.

Since:

4.4.4

Author:

Yvonne Ceelie

Field Summary

Fields

Modifier and Type	Field and Description
static Clock	clock

Constructor Summary

Constructors

Constructor and Description
AggregateLoadTimeSnapshotTriggerDefinition(Snapshotter snapshotter, long loadTimeMillisThreshold) Initialize a SnapshotTriggerDefinition to trigger snapshot creation using the given snapshotter when loading the aggregate instance takes longer than the given loadTimeMillisThreshold.

Method Summary

Modifier and Type	Method and Description
SnapshotTrigger	prepareTrigger(Class<?> aggregateType) Prepares a new trigger for an aggregate with the given aggregateIdentifier and aggregateType.
SnapshotTrigger	reconfigure(Class<?> aggregateType, SnapshotTrigger trigger) Reconfigure the necessary infrastructure components in the given trigger instance, which may have been lost in the (de)serialization process.

Methods inherited from class java.lang.Object

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

Field Detail

clock

public static Clock clock

Constructor Detail

AggregateLoadTimeSnapshotTriggerDefinition

public AggregateLoadTimeSnapshotTriggerDefinition(Snapshotter snapshotter,
                                                  long loadTimeMillisThreshold)

Initialize a SnapshotTriggerDefinition to trigger snapshot creation using the given snapshotter when loading the aggregate instance takes longer than the given loadTimeMillisThreshold.

Parameters:

snapshotter - the snapshotter to notify when a snapshot needs to be taken

loadTimeMillisThreshold - the maximum time that loading an aggregate may take

Method Detail

prepareTrigger

public SnapshotTrigger prepareTrigger(@Nonnull
                                      Class<?> aggregateType)

Description copied from interface: SnapshotTriggerDefinition

Prepares a new trigger for an aggregate with the given aggregateIdentifier and aggregateType. The trigger will be notified of each event applied on the aggregate, as well as the moment at which the aggregate state is fully initialized based on its historic events.

It is highly recommended that the instances returned by this method are Serializable. Any resources that the trigger needs that are not serializable, can be reattached by implementing the SnapshotTriggerDefinition.reconfigure(Class, SnapshotTrigger) method. This method is invoked when a SnapshotTrigger has been deserialized.

Specified by:

prepareTrigger in interface SnapshotTriggerDefinition

Parameters:

aggregateType - The type of aggregate for which to create a trigger

Returns:

the trigger instance for an aggregate

reconfigure

public SnapshotTrigger reconfigure(@Nonnull
                                   Class<?> aggregateType,
                                   @Nonnull
                                   SnapshotTrigger trigger)

Description copied from interface: SnapshotTriggerDefinition

Reconfigure the necessary infrastructure components in the given trigger instance, which may have been lost in the (de)serialization process.

Since implementations of the SnapshotTrigger often rely on a Snapshotter which cannot be serialized, it may be necessary to inject these resourcs after deserialization of a trigger.

Implementations returning a Serializable SnapshotTrigger (which is recommended), should implement this method if not all fields could be initialized base don serialized data.

Specified by:

reconfigure in interface SnapshotTriggerDefinition

Parameters:

aggregateType - The type of aggregate for which this trigger was created

trigger - The trigger instance formerly created using SnapshotTriggerDefinition.prepareTrigger(Class)

Returns:

a fully (re)configured trigger instance, may be the same trigger instance.