org.axonframework.eventsourcing

Class AggregateSnapshotter

java.lang.Object

org.axonframework.eventsourcing.AbstractSnapshotter

org.axonframework.eventsourcing.AggregateSnapshotter

All Implemented Interfaces:

Snapshotter

Direct Known Subclasses:

SpringAggregateSnapshotter

public class AggregateSnapshotter
extends AbstractSnapshotter

Implementation of a snapshotter that uses the actual aggregate and its state to create a snapshot event. The motivation is that an aggregate always contains all relevant state. Therefore, storing the aggregate itself inside an event should capture all necessary information.

Since:

0.6

Author:

Allard Buijze

Constructor Summary

Constructors

Constructor and Description
AggregateSnapshotter(EventStore eventStore, AggregateFactory<?>... aggregateFactories) Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath.
AggregateSnapshotter(EventStore eventStore, List<AggregateFactory<?>> aggregateFactories) Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath.
AggregateSnapshotter(EventStore eventStore, List<AggregateFactory<?>> aggregateFactories, ParameterResolverFactory parameterResolverFactory) Initializes a snapshotter using the given parameterResolverFactory.
AggregateSnapshotter(EventStore eventStore, List<AggregateFactory<?>> aggregateFactories, ParameterResolverFactory parameterResolverFactory, Executor executor, TransactionManager transactionManager) Initializes a snapshotter that stores snapshots using the given executor.
AggregateSnapshotter(EventStore eventStore, List<AggregateFactory<?>> aggregateFactories, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition, Executor executor, TransactionManager transactionManager, RepositoryProvider repositoryProvider) Initializes a snapshotter that stores snapshots using the given executor.
AggregateSnapshotter(EventStore eventStore, List<AggregateFactory<?>> aggregateFactories, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition, RepositoryProvider repositoryProvider) Initializes a snapshotter using the given parameterResolverFactory.
AggregateSnapshotter(EventStore eventStore, List<AggregateFactory<?>> aggregateFactories, RepositoryProvider repositoryProvider) Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath.
AggregateSnapshotter(EventStore eventStore, RepositoryProvider repositoryProvider, AggregateFactory<?>... aggregateFactories) Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath.

Method Summary

Modifier and Type	Method and Description
protected DomainEventMessage	createSnapshot(Class<?> aggregateType, String aggregateIdentifier, DomainEventStream eventStream) Creates a snapshot event for an aggregate of which passed events are available in the given eventStream.
protected AggregateFactory<?>	getAggregateFactory(Class<?> aggregateType) Returns the AggregateFactory registered for the given aggregateType, or null if no such AggregateFactory is known.
protected void	registerAggregateFactory(AggregateFactory<?> aggregateFactory) Registers the given aggregateFactory with this snapshotter.

Methods inherited from class org.axonframework.eventsourcing.AbstractSnapshotter

createSnapshotterTask, getEventStore, getExecutor, scheduleSnapshot

Methods inherited from class java.lang.Object

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

Constructor Detail

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            AggregateFactory<?>... aggregateFactories)

Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath. The given aggregateFactories are used to instantiate the relevant Aggregate Root instances, which represent the snapshots.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

See Also:

ClasspathParameterResolverFactory

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            RepositoryProvider repositoryProvider,
                            AggregateFactory<?>... aggregateFactories)

Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath. The given aggregateFactories are used to instantiate the relevant Aggregate Root instances, which represent the snapshots.

Parameters:

eventStore - The Event Store to store snapshots in

repositoryProvider - Provides repositories for specific aggregate types

aggregateFactories - The factories for the aggregates supported by this snapshotter.

See Also:

ClasspathParameterResolverFactory

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            List<AggregateFactory<?>> aggregateFactories)

Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath. The given aggregateFactories are used to instantiate the relevant Aggregate Root instances, which represent the snapshots.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

See Also:

ClasspathParameterResolverFactory

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            List<AggregateFactory<?>> aggregateFactories,
                            RepositoryProvider repositoryProvider)

Initializes a snapshotter using the ParameterResolverFactory instances available on the classpath. The given aggregateFactories are used to instantiate the relevant Aggregate Root instances, which represent the snapshots.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

repositoryProvider - Provides repositories for specific aggregate types

See Also:

ClasspathParameterResolverFactory

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            List<AggregateFactory<?>> aggregateFactories,
                            ParameterResolverFactory parameterResolverFactory)

Initializes a snapshotter using the given parameterResolverFactory. The given aggregateFactories are used to instantiate the relevant Aggregate Root instances, which represent the snapshots. Snapshots are stores in the given eventStore.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

parameterResolverFactory - The ParameterResolverFactory instance to resolve parameter values for annotated handlers with

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            List<AggregateFactory<?>> aggregateFactories,
                            ParameterResolverFactory parameterResolverFactory,
                            HandlerDefinition handlerDefinition,
                            RepositoryProvider repositoryProvider)

Initializes a snapshotter using the given parameterResolverFactory. The given aggregateFactories are used to instantiate the relevant Aggregate Root instances, which represent the snapshots. Snapshots are stores in the given eventStore.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

parameterResolverFactory - The ParameterResolverFactory instance to resolve parameter values for annotated handlers with

handlerDefinition - The handler definition used to create concrete handlers

repositoryProvider - Provides repositories for specific aggregate types

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            List<AggregateFactory<?>> aggregateFactories,
                            ParameterResolverFactory parameterResolverFactory,
                            Executor executor,
                            TransactionManager transactionManager)

Initializes a snapshotter that stores snapshots using the given executor.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

parameterResolverFactory - The ParameterResolverFactory instance to resolve parameter values for annotated handlers with

executor - The executor to process the actual snapshot creation with

transactionManager - The transaction manager to handle the transactions around the snapshot creation process with

AggregateSnapshotter

public AggregateSnapshotter(EventStore eventStore,
                            List<AggregateFactory<?>> aggregateFactories,
                            ParameterResolverFactory parameterResolverFactory,
                            HandlerDefinition handlerDefinition,
                            Executor executor,
                            TransactionManager transactionManager,
                            RepositoryProvider repositoryProvider)

Initializes a snapshotter that stores snapshots using the given executor.

Parameters:

eventStore - The Event Store to store snapshots in

aggregateFactories - The factories for the aggregates supported by this snapshotter.

parameterResolverFactory - The ParameterResolverFactory instance to resolve parameter values for annotated handlers with

handlerDefinition - The handler definition used to create concrete handlers

executor - The executor to process the actual snapshot creation with

transactionManager - The transaction manager to handle the transactions around the snapshot creation process with

repositoryProvider - Provides repositories for specific aggregate types

Method Detail

createSnapshot

protected DomainEventMessage createSnapshot(Class<?> aggregateType,
                                            String aggregateIdentifier,
                                            DomainEventStream eventStream)

Description copied from class: AbstractSnapshotter

Creates a snapshot event for an aggregate of which passed events are available in the given eventStream. May return null to indicate a snapshot event is not necessary or appropriate for the given event stream.

Specified by:

createSnapshot in class AbstractSnapshotter

Parameters:

aggregateType - The aggregate's type identifier

aggregateIdentifier - The identifier of the aggregate to create a snapshot for

eventStream - The event stream containing the aggregate's past events

Returns:

the snapshot event for the given events, or null if none should be stored.

getAggregateFactory

protected AggregateFactory<?> getAggregateFactory(Class<?> aggregateType)

Returns the AggregateFactory registered for the given aggregateType, or null if no such AggregateFactory is known.

Sublasses may override this method to enhance how AggregateFactories are retrieved. They may choose to registerAggregateFactory(AggregateFactory) if it hasn't been found using this implementation.

Parameters:

aggregateType - The type to get the AggregateFactory for

Returns:

the appropriate AggregateFactory, or null if not found

registerAggregateFactory

protected void registerAggregateFactory(AggregateFactory<?> aggregateFactory)

Registers the given aggregateFactory with this snapshotter. If a factory for this type was already registered, it is overwritten with this one.

Parameters:

aggregateFactory - the AggregateFactory to register