Package 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 Details

    • clock

      public static Clock clock

  • Constructor Details

    • 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 Details

    • 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.