All Classes and Interfaces

Class	Description
AbstractChildEntityDefinition	Abstract implementation of the ChildEntityDefinition to provide reusable functionality for collections of ChildEntityDefinitions.
AbstractRepository<T,A extends Aggregate<T>>	Abstract implementation of the Repository that takes care of the dispatching of events when an aggregate is persisted.
AbstractRepository.Builder<T>	Abstract Builder class to instantiate AbstractRepository implementations.
AbstractResourceInjector	Abstract implementation of a ResourceInjector for sagas that injects field and method resources.
AbstractSagaEntry<T>	Deprecated. since moving to jakarta, as the generic serializedSaga was not handled well.
AbstractSagaManager<T>	Abstract implementation of the SagaManager interface that provides basic functionality required by most SagaManager implementations.
AbstractSagaManager.Builder<T>	Abstract Builder class to instantiate AbstractSagaManager implementations.
Aggregate<T>	Interface that describes an aggregate.
AggregateAnnotationCommandHandler<T>	Command handler that registers a set of CommandHandler based on annotations of an aggregate.
AggregateAnnotationCommandHandler.Builder<T>	Builder class to instantiate a AggregateAnnotationCommandHandler.
AggregateCreationPolicy	Enumeration containing the possible creation policies for aggregates.
AggregateEntityNotFoundException	Exception indicating that the entity of an aggregate could not be found.
AggregateIdentifier	Field or Method annotation that identifies the member containing the identifier of the Aggregate.
AggregateInvocationException	Exception thrown when an invocation on a method of an aggregate gives rise to an exception.
AggregateLifecycle	Abstract base class of a component that models an aggregate's life cycle.
AggregateMember	Marker annotation for a Field or Method that references one or more Entities capable of handling Commands or Events.
AggregateMemberAnnotatedChildEntityCollectionDefinition	Implementation of a AbstractChildEntityDefinition that is used to detect Collections of entities (member type assignable to Iterable) annotated with AggregateMember.
AggregateMemberAnnotatedChildEntityDefinition	Implementation of a ChildEntityDefinition that is used to detect single entities annotated with AggregateMember.
AggregateMemberAnnotatedChildEntityMapDefinition	Implementation of a AbstractChildEntityDefinition that is used to detect Maps with entities as values annotated with AggregateMember.
AggregateMetaModelFactory	Interface of a factory for an AggregateModel for any given type defining an aggregate.
AggregateModel<T>	Specialized EntityModel that describes the capabilities and properties of an aggregate root of type T.
AggregateModellingException	Thrown if an aggregate model is invalid.
AggregateNotFoundException	Exception indicating that the an aggregate could not be found in the repository.
AggregateRolledBackException	Exception indicating that an aggregate has been part of a Unit of Work that was rolled back and that the validity of its state cannot be guaranteed.
AggregateRoot	Annotation placed on types that should be treated as the root of an aggregate.
AggregateScopeDescriptor	Describes the scope of an Aggregate by means of its type and identifier.
AggregateStreamCreationException	Exception indicating that concurrent access to a repository was detected.
AggregateTypeUtils	Utility class providing static methods to retrieve the type as a String for a given aggregate Class.
AggregateVersion	Field or Method annotation that indicates the member contains the value that represents the version of the Aggregate, used for optimistic locking, as well as state validation for commands.
AnnotatedAggregate<T>	Implementation of the Aggregate interface that allows for an aggregate root to be a POJO with annotations on its Command and Event Handler methods.
AnnotatedAggregateMetaModelFactory	AggregateMetaModelFactory implementation that uses annotations on the target aggregate's members to build up the meta-model of the aggregate.
AnnotatedChildEntity<P,C>	Implementation of a ChildEntity that uses annotations on a target entity to resolve event and command handlers.
AnnotatedCommandHandlerInterceptor<T>	Annotated command handler interceptor on aggregate.
AnnotatedSaga<T>	Implementation of the interface that allows for a POJO instance with annotated message handlers to act as a Saga.
AnnotatedSagaManager<T>	Implementation of the SagaManager that uses annotations on the Sagas to describe the lifecycle management.
AnnotatedSagaManager.Builder<T>	Builder class to instantiate a AnnotatedSagaManager.
AnnotatedSagaRepository<T>	SagaRepository implementation extending from the LockingSagaRepository dealing with annotated Sagas.
AnnotatedSagaRepository.Builder<T>	Builder class to instantiate a AnnotatedSagaRepository.
AnnotationCommandTargetResolver	CommandTargetResolver that uses annotations on the command to identify the methods that provide the Aggregate Identifier of the targeted Aggregate and optionally the expected version of the aggregate.
AnnotationCommandTargetResolver.Builder	Builder class to instantiate a AnnotationCommandTargetResolver.
AnnotationSagaMetaModelFactory	Default implementation of a SagaMetaModelFactory.
ApplyMore	Interface that describes a mechanism that enables the application of an additional event after another event is applied.
AssociationResolver	Used to derive the value of an association property as designated by the association property name.
AssociationValue	A combination of key and value by which a Saga can be found.
AssociationValueEntry	JPA wrapper around an Association Value.
AssociationValueMap	In-memory storage for AssociationValue to Saga mappings.
AssociationValues	Interface describing a container of Association Values for a single Saga instance.
AssociationValuesImpl	Default implementation of the AssociationValues interface.
CachingSagaStore<T>	Saga Repository implementation that adds caching behavior to the repository it wraps.
CachingSagaStore.Builder<T>	Builder class to instantiate a CachingSagaStore.
ChildEntity<T>	Interface describing en entity that is a child of another entity.
ChildEntityDefinition	Interface describing the definition of a Child Entity.
ChildForwardingCommandMessageHandlingMember<P,C>	Implementation of a CommandMessageHandlingMember that forwards commands to a child entity.
CommandHandlerInterceptor	Annotation used to mark methods on Aggregate members which can intercept commands.
CommandHandlerInterceptorHandlingMember<T>	Deprecated. in favor of the more generic MessageInterceptingMember
CommandTargetResolver	Interface towards a mechanism that is capable of extracting an Aggregate Identifier and Version form a command that identifies the aggregate instance the command should be invoked on.
ConcurrencyException	Exception indicating that concurrent access to a repository was detected.
ConflictingAggregateVersionException	Exception indicating that the (actual) version of a loaded aggregate did not match the given expected version number.
ConflictingModificationException	Root of a hierarchy of exceptions indicating the detection of conflicting concurrent modifications.
CreationPolicy	Annotation used to specify the creation policy for a command handler.
CreationPolicyAggregateFactory<A>	Interface to describe a way to create Aggregate instances based on an identifier when an instance has to be created in order to be used in Command handlers annotated with CreationPolicy.
CreationPolicyMember<T>	Interface specifying a message handler containing a creation policy definition.
DefaultRepositorySpanFactory	Default implementation of the RepositorySpanFactory.
DefaultRepositorySpanFactory.Builder	Builder class to instantiate a DefaultRepositorySpanFactory.
DefaultSagaManagerSpanFactory	Default implementation of the SagaManagerSpanFactory.
DefaultSagaManagerSpanFactory.Builder	Builder class to instantiate a DefaultSagaManagerSpanFactory.
EndSaga	Indicates that the annotated SagaEventHandler method indicates the end of a Saga instance's lifecycle.
EndSagaMessageHandlerDefinition	A HandlerEnhancerDefinition inspecting the existence of the EndSaga annotation on MessageHandlingMembers.
EndSagaMessageHandlerDefinition.EndSageMessageHandlingMember<T>	A WrappedMessageHandlingMember implementation dedicated towards MessageHandlingMembers annotated with EndSaga.
EntityId	Field or Method annotation that marks the member containing the identifier of an Entity.
EntityModel<T>	Interface of an entity model that describes the properties and capabilities of an entity of type T.
ForwardingCommandMessageHandlingMember<T>	Interface describing a message handler capable of forwarding a specific command.
ForwardingMode<T extends org.axonframework.messaging.Message<?>>	Interface describing the required functionality to forward a message.
ForwardMatchingInstances<T extends org.axonframework.messaging.Message<?>>	Only forward messages of type T if the routing key of the message matches that of the entity.
ForwardNone<T extends org.axonframework.messaging.Message<?>>	Forward no messages T regardless of their set up.
ForwardToAll<T extends org.axonframework.messaging.Message<?>>	Forward all messages T regardless of their set up.
GenericJpaRepository<T>	Generic repository implementation that stores JPA annotated aggregates.
GenericJpaRepository<T>	Deprecated. in favor of using GenericJpaRepository which moved to jakarta.
GenericJpaRepository.Builder<T>	Builder class to instantiate a GenericJpaRepository for aggregate type T.
GenericJpaRepository.Builder<T>	Builder class to instantiate a GenericJpaRepository for aggregate type T.
GenericSagaSqlSchema	Generic SagaSqlSchema implementation, for use in most databases.
HsqlSagaSqlSchema	Specialization of the GenericSagaSqlSchema for use in the HSQL database.
IdentifierMissingException	Exception indicating that a required identifier is missing in the processed message.
InMemorySagaStore	SagaRepository implementation that stores all Saga instances in memory.
JdbcSagaStore	A SagaStore implementation that uses JDBC to store and find Saga instances.
JdbcSagaStore.Builder	Builder class to instantiate a JdbcSagaStore.
JpaSagaStore	JPA implementation of the SagaStore.
JpaSagaStore	Deprecated. in favor of using JpaSagaStore which moved to jakarta.
JpaSagaStore.Builder	Builder class to instantiate a JpaSagaStore.
JpaSagaStore.Builder	Builder class to instantiate a JpaSagaStore.
LockAwareAggregate<AR,A extends Aggregate<AR>>	Aggregate implementation that provides access to the lock held by the aggregate while a command is handled.
LockingRepository<T,A extends Aggregate<T>>	Implementation of the Repository interface that takes provides a locking mechanism to prevent concurrent modifications of persisted aggregates.
LockingRepository.Builder<T>	Abstract Builder class to instantiate LockingRepository implementations.
LockingSagaRepository<T>	Abstract implementation of a saga repository that locks access to a saga while the saga is being operated on.
LockingSagaRepository.Builder<T>	Abstract Builder class to instantiate LockingSagaRepository implementations.
MetaDataAssociationResolver	Used to derive the value of an association property by looking it up the event message's MetaData.
MetaDataCommandTargetResolver	CommandTargetResolver implementation that uses MetaData entries to extract the identifier and optionally the version of the aggregate that the command targets.
MethodCommandHandlerInterceptorDefinition	Implementation of HandlerEnhancerDefinition used for CommandHandlerInterceptor annotated methods.
MethodCreationPolicyDefinition	Implementation of HandlerEnhancerDefinition used for CreationPolicy annotated methods.
NoArgumentConstructorCreationPolicyAggregateFactory<A>	Default implementation of CreationPolicyAggregateFactory that invokes the default, no-arguments constructor of the aggregate class A.
NoResourceInjector	ResourceInjector that does not inject anything.
Oracle11SagaSqlSchema	Oracle 11 does not support AUTO_INCREMENT.
PayloadAssociationResolver	Used to derive the value of an association property by looking it up the event message's payload.
PostgresSagaSqlSchema	SQL schema supporting PostgreSQL databases.
Repository<T>	The Repository provides an abstraction of the storage of aggregates.
RepositoryProvider	Provides a repository for given aggregate type.
RepositorySpanFactory	Span factory that creates spans for the Repository.
ResourceInjector	Interface describing a mechanism to inject resources into Saga instances.
Saga<T>	Interface describing an implementation of a Saga.
SagaCreationException	Exception triggered when a new saga instance could not be instantiated.
SagaCreationPolicy	Enumeration containing the possible Creation Policies for Sagas.
SagaEntry<T>	Java Persistence Entity allowing sagas to be stored in a relational database.
SagaEventHandler	Method-level annotation indicating that the annotated method is an event handler method for the saga instance.
SagaExecutionException	Exception triggered by a saga while it is processing an event or processing a task.
SagaInitializationPolicy	Describes the conditions under which a Saga should be created, and which AssociationValue it should be initialized with.
SagaInstantiationException	Exception triggered during initialization of a Saga.
SagaLifecycle	Abstract base class of a component that models a saga's life cycle.
SagaManagerSpanFactory	Span factory that creates spans for the AbstractSagaManager.
SagaMetaModelFactory	Interface of a factory for a SagaModel for any given saga type.
SagaMethodMessageHandlerDefinition	Utility class that inspects annotation on a Saga instance and returns the relevant configuration for its Event Handlers.
SagaMethodMessageHandlingMember<T>	A data holder containing information of SagaEventHandler annotated methods.
SagaModel<T>	Interface of a model that describes a Saga of type T.
SagaRepository<T>	Interface towards the storage mechanism of Saga instances.
SagaSchema	SagaSchema allows specification of custom storage locations for the saga repositories.
SagaSchema.Builder	Builder for an SagaSchema that gets initialized with default values.
SagaScopeDescriptor	Describes the scope of a Saga by means of its type and identifier.
SagaSqlSchema	Interface describing the SQL statements that the JdbcSagaRepository needs to execute against the underlying database.
SagaStorageException	Exception indicating that an error has occurred while storing a Saga.
SagaStore<T>	Provides a mechanism to find, load update and delete sagas of type T from an underlying storage like a database.
SagaStore.Entry<T>	Interface describing a Saga entry fetched from a SagaStore.
SerializedSaga	Specialization of the SerializedObject for Sagas represented as byte array.
SimpleResourceInjector	A resource injector that checks for @Inject annotated fields and setter methods to inject resources.
StartSaga	Indicates that the annotated SagaEventHandler method can trigger the creation of a new Saga instance.
TargetAggregateIdentifier	Field or method level annotation that marks a field or method providing the identifier of the aggregate that a command targets.
TargetAggregateVersion	Field or method level annotation that marks a field or method providing the expected version of the aggregate that a command targets.
VersionedAggregateIdentifier	Structure that holds an Aggregate Identifier and an expected version of an aggregate.