All Classes and Interfaces
Class
Description
Abstract AggregateFactory implementation that is aware of snapshot events.
ParameterResolverFactory that will supply a parameter resolver when a matching parameter annotation is paired
with a suitable type of parameter.
Deprecated.
Abstract implementation of the Cache interface which makes it easier to implement Adapters.
Abstract implementation of the
ChildEntityDefinition to provide reusable functionality for collections of
ChildEntityDefinitions.Abstract implementation of a CommandGateway, which handles the dispatch interceptors and retrying on failure.
Abstract Builder class to instantiate
AbstractCommandGateway implementations.Abstract implementation of the
DeadlineManager to be implemented by concrete solutions for the
DeadlineManager.Abstract base class of a serialized domain event.
Base class for the Event Bus.
Abstract Builder class to instantiate
AbstractEventBus implementations.Abstract base class of a serialized event.
Abstract implementation of an EventGateway, which handles the dispatch interceptors.
Abstract Builder class to instantiate
AbstractEventGateway implementations.Abstract implementation of an
EventProcessor.Abstract Builder class to instantiate a
AbstractEventProcessor.Abstract
EventStorageEngine implementation that takes care of event serialization and upcasting.Abstract Builder class to instantiate an
AbstractEventStorageEngine.Abstract implementation of an
EventStore that uses a EventStorageEngine to store and load events.Abstract Builder class to instantiate an
AbstractEventStore.Abstract implementation of an
EventTableFactory that provides Jdbc "create table" statements compatible with
most databases.Abstract base class for Messages.
Abstract implementation of the PropertyAccessStrategy that uses a no-arg, public method to access the property
value.
Abstract implementations for conditions that match against the availability of beans of a specific type with a
given qualifier.
Abstract implementation of the
Repository that takes care of the dispatching of events when an aggregate is
persisted.Abstract Builder class to instantiate
AbstractRepository implementations.Abstract implementation of a
ResourceInjector for sagas that injects field and method resources.Abstract implementation of the
ResponseType which contains
match functions for the majority of the Type options available.An abstract base class for
RetrySchedulers.A builder class for the
RetryScheduler implementations.Abstract implementation of the
RoutingStrategy interface that includes a fallback RoutingStrategy
which prescribes what happens when routing cannot be resolved by this implementation.Deprecated.
since moving to jakarta, as the generic
serializedSaga was not handled well.Abstract implementation of the SagaManager interface that provides basic functionality required by most SagaManager
implementations.
Abstract Builder class to instantiate
AbstractSagaManager implementations.Abstract base class of a serialized domain event.
Abstract base class of a serialized snapshot event storing the state of an aggregate.
Primary key definition of the AbstractEventEntry class.
Abstract implementation of the
Snapshotter that uses a task executor to
creates snapshots.Abstract Builder class to instantiate
AbstractSnapshotter implementations.Abstract implementation of the
SnapshotTrigger that schedules snapshots on
the Unit of Work.Abstract base class of a JPA entry containing a serialized tracking token belonging to a given process.
Abstract implementation of the Unit of Work.
Abstract implementation for XStream based serializers.
Abstract Builder class to instantiate
AbstractXStreamSerializer.A command filter that accepts all
CommandMessages.Deprecated.
in through use of the AxonServer java
connector
References a new
EventTrackerStatus which work just has started on.Interface that describes an aggregate.
Annotation that informs Axon's auto configurer for Spring that a given
Component is an aggregate instance.Command handler that registers a set of
CommandHandler based on annotations of an aggregate.Builder class to instantiate a
AggregateAnnotationCommandHandler.Exception indicating that an aggregate has been blacklisted by the DisruptorCommandBus.
Specialization of the Module Configuration for modules that define an Aggregate Configuration.
Axon Configuration API extension that allows the definition of an Aggregate.
Enumeration containing the possible creation policies for aggregates.
Special case of the
AggregateNotFoundException that indicates that historic
information of an aggregate was found, but the aggregate has been deleted.Exception indicating that the entity of an aggregate could not be found.
Interface describing objects capable of creating instances of aggregates to be initialized with an event stream.
Adds the aggregate identifier to the Span if the current message being handled is a
DomainEventMessage.Exception thrown when an invocation on a method of an aggregate gives rise to an exception.
Abstract base class of a component that models an aggregate's life cycle.
A Snapshotter trigger mechanism which based on the loading time of an Aggregate decides when to trigger the creation
of a snapshot.
Implementation of a
AbstractChildEntityDefinition that is used to detect Collections of entities (member type
assignable to Iterable) annotated with AggregateMember.Implementation of a
ChildEntityDefinition that is used to detect single entities annotated with AggregateMember.Implementation of a
AbstractChildEntityDefinition that is used to detect Maps with entities as values
annotated with AggregateMember.Interface of a factory for an
AggregateModel for any given type defining an aggregate.Specialized EntityModel that describes the capabilities and properties of an aggregate root of type
T.Thrown if an aggregate model is invalid.
Exception indicating that the an aggregate could not be found in the repository.
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.
Annotation placed on types that should be treated as the root of an aggregate.
Deprecated.
in favor of the
AggregateScopeDescriptorDescribes the scope of an Aggregate by means of its type and identifier.
Implementation of a snapshotter that uses the actual aggregate and its state to create a snapshot event.
Builder class to instantiate a
AggregateSnapshotter.Exception indicating that the changes in an aggregate (generated events) are ignored by the DisruptorCommandBus,
because it cannot guarantee that these changes have been applied to an aggregate instance with the correct state.
Exception indicating that concurrent access to a repository was detected.
A test fixture that allows the execution of given-when-then style test cases.
Annotation indication that a parameter on a Message Handler method should be injected with the
aggregate type of a
DomainEventMessage.An extension of the AbstractAnnotatedParameterResolverFactory that accepts parameters of a
String type that
are annotated with the AggregateType annotation and assigns the aggregate type of the
DomainEventMessage.FieldFilter implementation that accepts all Fields.
Annotation marking a Handler (or class) as being capable of handling replays, or not, depending on the value passed.
A
CommandMessageFilter implementation that matches whenever both supplied CommandMessageFilter
instances match.Implementation of the
Aggregate interface that allows for an aggregate root to be a POJO with annotations on
its Command and Event Handler methods.AggregateMetaModelFactory implementation that uses annotations on the target aggregate's members to build up the
meta-model of the aggregate.
Implementation of a
ChildEntity that uses annotations on a target entity to resolve event and command
handlers.Annotated command handler interceptor on aggregate.
Container for message handler attributes, constructed through inspecting an
AnnotatedElement.Inspector for a message handling target of type
T that uses annotations on the target to inspect the
capabilities of the target.Implementation of a
MessageHandlingMember that is used to invoke message handler methods on the target type.The default HandlerDefinition implementation in Axon.
Implementation of the
interface that allows for a POJO instance with annotated message handlers to act
as a Saga.Implementation of the SagaManager that uses annotations on the Sagas to describe the lifecycle management.
Builder class to instantiate a
AnnotatedSagaManager.SagaRepository implementation extending from the LockingSagaRepository dealing with annotated Sagas.Builder class to instantiate a
AnnotatedSagaRepository.Adapter that turns any
@CommandHandler annotated bean into a MessageHandler
implementation.Deprecated.
Replaced by the
MessageHandlerLookup and MessageHandlerConfigurer.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.
Builder class to instantiate a
AnnotationCommandTargetResolver.Deprecated.
Use Spring Boot autoconfiguration or register the individual beans explicitly.
Deprecated.
Use Spring Boot autoconfiguration or register the individual beans explicitly.
Adapter that turns any bean with
EventHandler annotated methods into an EventMessageHandler.Adapter that turns any
@QueryHandler annotated bean into a MessageHandler
implementation.Deprecated.
Replaced by the
MessageHandlerLookup and MessageHandlerConfigurer.Revision Resolver implementation that checks for the presence of an
@Revision annotation.RoutingStrategy that expects an
RoutingKey (meta-)annotation on the command message's payload.Builder class to instantiate a
AnnotationRoutingStrategy.Default implementation of a
SagaMetaModelFactory.Utility class for locating annotations and attribute values on elements.
Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.appendEvents(List, Serializer)Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.storeSnapshot(DomainEventMessage, Serializer).Component that forward events received from a
SubscribableMessageSource as Spring ApplicationEvent to
the ApplicationContext.Deprecated.
Use Spring Boot autoconfiguration or register the individual beans explicitly.
Interface that describes a mechanism that enables the application of an additional event after another event is
applied.
Represents an artifact with its group ID, artifact ID, and version.
Represents an upgrade suggestion for a specific artifact version by the AxonIQ Update Checker API.
Utility class (inspired by Springs Assert class) for doing assertions on parameters and object state.
Used to derive the value of an association property as designated by the association property name.
A combination of key and value by which a Saga can be found.
JPA wrapper around an Association Value.
In-memory storage for AssociationValue to Saga mappings.
Interface describing a container of
Association Values for a single Saga instance.Default implementation of the AssociationValues interface.
Specialization of the SimpleCommandBus that processed Commands asynchronously from the calling thread.
Builder class to instantiate a
AsynchronousCommandBus.Implementation of a
EventProcessingStrategy that creates event processing tasks for asynchronous execution.Deprecated.
in favor of the
SimpleResourceInjectorHolder for package-based class scanning for Avro schema extraction.
Configures the base packages used by autoconfiguration when scanning for classes containing Avro Schema.
Serializer providing support for Apache Avro, using
Single Object Encoded binary
encoding.
Builder to set up Avro Serializer using some defaults.
Autoconfigures required beans for the Avro serializer.
Serialization strategy for Avro Serializer.
Configuration class used by the strategy to receive configuration from the
AvroSerializer.Builder during
instantiation of AvroSerializer.Builder for the configuration.
Utilities for Avro manipulations.
Error indication that an Assertion failed during a test case.
Deprecated.
Replaced by the
SpringConfigurer and SpringAxonConfiguration.Exception indicating that a configuration error has been made in the Axon configuration.
Auto configuration class for the deadline manager and event scheduler using db-scheduler.
Base exception for all Axon Framework related exceptions.
Module related to AxonIQ console, for now it's just logging information about AxonIQ console when it's not suppressed
and the console-framework-client is not available.
Auto configuration class for the deadline manager and event scheduler using JobRunr.
Exception indicating an error has been cause that cannot be resolved without intervention.
An Axon-specific
Predicate, used to check the non-transiency of a failure comparing it against concrete classes.Autoconfiguration class for Spring Boot Actuator monitoring tools around Axon Server.
Configures Axon Server as implementation for the CommandBus, QueryBus and EventStore.
Axon
CommandBus implementation that connects to Axon Server to submit and receive commands and command
responses.Builder class to instantiate an
AxonServerCommandBus.Exception thrown if there is a problem dispatching a command on Axon Server.
Configuration class provided configurable fields and defaults for anything Axon Server related.
Configuration class for Flow Control of specific message types.
ConnectionDetails implementation carrying the connection details for an Axon Server instance.
The component which manages all the connections which an Axon client can establish with an Axon Server instance.
Builder class to instantiate an
AxonServerConnectionManager.Constructs an Axon Server container for testing.
ConnectionDetailsFactory implementation that recognizes Spring Boot Docker Compose-managed Docker containers running
Axon Server and creates an AxonServerConnectionDetails bean with the details to connect to AxonServer within that
container.
Deprecated.
In favor of
AxonServerContainer following the merger of Standard and Enterprise edition into a
single version.Implementation of the
EventScheduler that uses Axon Server to schedule the events.Builder class to instantiate an
AxonServerEventScheduler.Axon EventStore implementation that connects to the AxonIQ AxonServer Server to store and retrieve Events.
Builder class to instantiate a
AxonServerEventStore.A factory towards
AxonServerEventStores.Contract defining
AxonServerEventStore.Builder based configuration when constructing an
AxonServerEventStore.Builder class to instantiate an
AxonServerEventStoreFactory.Generic exception indicating an error related to AxonServer.
An
AbstractHealthIndicator implementation exposing the health of the connections made through the AxonServerConnectionManager.Exception indicating a non-transient problem that was reported by the remote end of a connection.
Exception indicating a non-transient problem that was reported during query handling by the remote end of a connection.
Axon
QueryBus implementation that connects to Axon Server to submit and receive queries and query responses.Builder class to instantiate an
AxonServerQueryBus.An AxonServer Exception which is thrown on a Query Dispatching exception.
Wrapper around standard Axon Framework
Registration.Exception indicating a problem that was reported by the remote end of a connection.
An AxonServer Exception which is thrown on a Query Handling exception.
Deprecated.
In favor of
AxonServerContainer following the merger of Standard and Enterprise edition into a
single version.A
SimpleStatusAggregator implementation determining the overall health of an Axon Framework application using
Axon Server.A
SubscriptionQueryResult that emits initial response and update when subscription query response message is
received.ConnectionDetailsFactory class that recognizes TestContainer instances running Axon Server.
Event published after initialization of Axon through the Spring event mechanism.
Thread factory that created threads in a given group.
Configures the timeout settings for message handlers.
Exception indicated that an Axon-specific task has timed out.
Configures common tracing components for Axon Framework.
Exception indicating an error occurred that might be resolved by retrying the operation that caused the exception.
Utility class to detect Axon Framework versions from the classpath.
AbstractEventStorageEngine implementation that fetches events in batches from the backing database.Abstract Builder class to instantiate a
BatchingEventStorageEngine.Unit of Work implementation that is able to process a batch of Messages instead of just a single Message.
Helper class to simplify the creation of bean definitions for components configured in Axon Configuration.
BeanPropertyAccessStrategy implementation that uses JavaBean style property access.
Interceptor that applies JSR303 bean validation on incoming
Messages.Deprecated.
in favor of using
BeanValidationInterceptor which moved
to jakarta.Wrapper for command handler Callbacks that detects blacklisted aggregates and starts a cleanup process when an
aggregate is blacklisted.
Interface for a stream that can be polled for information using (optionally blocking) pull operations.
Utility class containing reusable functionality for implementing the Builder Pattern in (infrastructure) components.
Content type converter between single-object-encoded bytes and Avro generic record.
ContentTypeConverter that converts byte arrays into InputStream.
ContentTypeConverter implementation for Jackson 3 that converts byte[] containing UTF8 encoded
JSON string to a Jackson JsonNode.
ContentTypeConverter implementation for Jackson 2 that converts byte[] containing UTF8 encoded
JSON string to a Jackson JsonNode.
ContentTypeConverter that converts byte arrays into Strings.
Abstraction for a Caching mechanism.
Interface describing callback methods, which are invoked when changes are made in the underlying cache.
Adapter implementation for the EntryListener, allowing for overriding only specific callback methods.
Implementation of the event sourcing repository that uses a cache to improve loading performance.
Saga Repository implementation that adds caching behavior to the repository it wraps.
Builder class to instantiate a
CachingSagaStore.A Supplier that caches its result, useful if the supplier operation is expensive and expected to always yield the
same result.
Interface towards a mechanism that replicates the behavior of a Command Handling component.
Exception indicating that a conversion is required between to upcasters, but there is no converter capable of doing
the conversion.
Calculates capacity by tracking, within the configured time window, the average message processing time
and multiplying that by the amount of messages processed.
Calculates capacity by tracking, within the configured time window, the average message processing time
and multiplying that by the amount of messages processed.
Contract describing the cause for
dead lettering a Message.A converter that delegates to a chain of other ContentTypeConverters to convert from a source to a target for which
there is not necessarily a single converter available.
A
MessageHandlerInterceptorMemberChain implementation that constructs a chain of instances of itself based on
a given iterator of MessageHandlingMembers.Converter implementation that will combine converters to form chains of converters to be able to convert
from one type to another, for which there is no suitable single converter.
Interface describing en entity that is a child of another entity.
Interface describing the definition of a Child Entity.
Implementation of a
CommandMessageHandlingMember that forwards commands to a child entity.Classpath Avro schema loader.
HandlerDefinition instance that locates other HandlerDefinition instances on the class path.
HandlerEnhancerDefinition instance that locates other HandlerEnhancerDefinition instances on the class path.
ParameterResolverFactory instance that locates other ParameterResolverFactory instances on the class path.
Resolves certain parameters from the classpath.
Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.cleanGaps(TrackingToken)Utility methods for operations on collections.
The mechanism that dispatches Command objects to their appropriate CommandHandler.
Interface describing the component that remotely connects multiple CommandBus instances.
Exception thrown when the CommandBusConnector has a communication failure
Span factory that creates spans for the
CommandBus.Interface describing a callback that is invoked when command handler execution has finished.
This class retains a list of callbacks for CommandCallbackConnectors to use.
Wrapper for a Command callback.
Exception indicating that an error has occurred while trying to dispatch a command to another (potentially remote)
segment of the CommandBus.
Indicates that an exception has occurred while handling a command.
Interface towards the Command Handling components of an application.
Factory that creates
CommandGateway implementations from custom interface definitions.Builder class to instantiate a
CommandGatewayFactory.Interface towards the mechanism that handles a method call on a gateway interface method.
Marker annotation to mark any method on an object as being a CommandHandler.
Annotation used to mark methods on Aggregate members which can intercept commands.
Deprecated.
in favor of the more generic
MessageInterceptingMemberComponent of the DisruptorCommandBus that invokes the command handler.
Deprecated.
Replaced by the
MessageHandlerLookup and MessageHandlerConfigurer.DataHolder for the DisruptorCommandBus.
A
UsagePropertyProvider implementation that reads the usage properties from the command line system
properties.Provides the load factor value of the client for the specific command.
Represents a Message carrying a command as its payload.
Interface describing a filter that can be applied to commands to describe the type of commands supported by a node in
a cluster.
MessageHandler specialization for handlers of Command Messages.
Interface describing a message handler capable of handling a specific command.
A
CommandMessageFilter implementation which filters CommandMessages by the CommandMessage.getCommandName().Calculate the priority of
CommandMessage based on its content.Message that represents a result from handling a
CommandMessage.Interface describing a mechanism used to find a suitable member of a cluster capable of handling given command
message.
Converter between Axon Framework
CommandMessages and Axon Server gRPC Command messages.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.
Helper class for validation of dispatched commands.
XStream HierarchicalStreamDriver implementation that uses a CompactWriter to write XML without newlines and
indentation, while writing it using the (default) XPPReader.
Exception indicating that
QueryUpdateEmitter is completed, thus cannot be used to emit messages and report
errors.A Component used in the Axon Configurer.
DomainEventStream implementation that concatenates multiple streams, taking into account that some sequence
numbers may appear in more than one stream.
Annotation indication that a parameter on an
EventHandler method should be
injected with a value that informs whether the event is the last event of a processed batch of events.Parameter resolver factory for boolean event handler parameters annotated with
ConcludesBatch.Exception indicating that concurrent access to a repository was detected.
Conditional that only matches when for the specified bean class in the BeanFactory there is an
instance which has the given qualifier set on it.Conditional that only matches when for the specified bean class in the BeanFactory there is an
instance which has the given qualifier set on it.A special implementation of a Token that is used to store configuration specific to the underlying storage of each
TokenStore instance.Interface describing the Global Configuration for Axon components.
ParameterResolverFactory implementation that resolves parameters from available components in the Configuration
instance it was configured with.
ResourceInjector implementation that injects resources defined in the Axon Configuration.
Implementation of the
ScopeAwareProvider which will retrieve a List of ScopeAware components
in a lazy manner.Entry point of the Axon Configuration API.
Deprecated.
Replaced by the
SpringConfigurer, which itself is a Configurer implementation.Interface describing a configurer for a module in the Axon Configuration API.
Descries a conflict between expected and actual version of an aggregate.
Interface describing a factory for exceptions that indicate an unresolved conflict in an aggregate instance.
Exception indicating that the (actual) version of a loaded aggregate did not match the given expected version number.
Root of a hierarchy of exceptions indicating the detection of conflicting concurrent modifications.
ParameterResolverFactory that add support for the ConflictResolver parameter type in annotated handlers.
Interface describing an object that is capable of detecting conflicts between changes to be applied to an aggregate,
and unseen changes made to the aggregate.
Utility class providing common Predicates used to detect conflicts between the actual state of an event sourced
aggregate and the expected state of the aggregate.
Interface describing functionality for connection managers.
Interface towards a mechanism that provides access to a JDBC Connection.
Deprecated.
in through use of the AxonServer java
connector
Factory for creating wrappers around a Connection, allowing one to override the behavior of the
Connection.close() method.Interface defining an operation to close the wrapped connection
Implementation of ConnectionCloseHandler that does nothing on close or commit.
Component used by command routers to find members capable of handling a given command.
Member implementation used by a
ConsistentHash registry.Represents a listener that is notified when a ConsistentHash instance of the component it is registered with has
changed.
EntityManagerProvider implementation that expects the container to inject the default container managed
EntityManager
instance.
Deprecated.
in favor of using
ContainerManagedEntityManagerProvider
which moved to jakarta.Interface describing a mechanism that converts the data type of IntermediateRepresentations of SerializedObjects for
Upcasters.
Deprecated.
in through use of the AxonServer java
connector
ConflictExceptionSupplier that is provided with more details of a version conflict.
Abstract implementation of a
SingleEntryMultiUpcaster and an EventUpcaster that eases the common
process of upcasting one intermediate event representation to several other representations by applying a flat
mapping function to the input stream of intermediate representations.Abstract implementation of an
Upcaster that eases the common process of upcasting one intermediate
representation to several other representations by applying a simple flat mapping function to the input stream of
intermediate representations.Abstract implementation of an
Upcaster that eases the common process of upcasting one intermediate
representation to another representation by applying a simple mapping function to the input stream of intermediate
representations.Abstract implementation of an event
Upcaster that eases the common process of upcasting one intermediate
event representation to another representation by applying a simple mapping function to the input stream of
intermediate representations.Interface describing methods that can be executed after the first "given" state has been supplied.
Interface describing a mechanism that can convert data from one to another type.
Implementation of a QueryResponseMessage that is aware of the requested response type and performs a just-in-time
conversion to ensure the response is formatted as requested.
Message interceptor that registers
CorrelationDataProviders with the Unit of Work.Object defining the data from a Message that should be attached as correlation data to messages generated as result
of the processing of that message.
Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.createHeadToken()Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.createTailToken()Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.createTokenAt(Instant)Annotation used to specify the creation policy for a command handler.
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.Interface specifying a message handler containing a creation policy definition.
Default entry point to gain access to the current UnitOfWork.
ParameterResolverFactory that add support for the UnitOfWork parameter type in annotated handlers.
ConnectionProvider implementation that obtains a connection from a given DataSource.
Some utility methods regarding Date and Time.
Pojo that contains the needed information for a
Task handling a deadline, will be
serialized and deserialized using the configured Serializer on the
Scheduler.Pojo for the data needed by the db-scheduler Scheduler.
Implementation of
DeadlineManager that delegates scheduling and triggering to a db scheduler
Scheduler.Builder class to instantiate a
DbSchedulerDeadlineManager.Default supplier for an
DbSchedulerDeadlineManager.TaskInstanceId implementation representing a scheduled Deadline task.
EventScheduler implementation that delegates scheduling and triggering to a db-scheduler Scheduler.
Builder class to instantiate a
DbSchedulerEventScheduler.Default supplier for an
DbSchedulerEventScheduler.Pojo that contains the needed information for a
Task handling a deadline.Pojo for the data needed by the db-scheduler Scheduler.
ScheduleToken implementation representing a scheduled DbScheduler Job.
Interface describing a dead lettered
Message implementation of generic type M.Default DeadLetter JPA entity implementation of dead letters.
Represents an
EventMessage when stored into the database.Implementation of an
EventHandlerInvoker utilizing a SequencedDeadLetterQueue to enqueue
events for which handling failed.Builder class to instantiate a
DeadLetteringEventHandlerInvoker.A functional interface describing how to convert a
ResultSet in JdbcDeadLetter implementation of type
DConverter that can convert a
EventMessage to a DeadLetterEventEntry and vice versa.Deprecated.
in favor of using
DeadLetterJpaConverter which
moved to jakarta.A
ParameterResolverFactory constructing a ParameterResolver resolving the DeadLetter that is
being processed.Exception signaling a
SequencedDeadLetterQueue is overflowing.A
ConfigurerModule implementation dedicated towards registering a SequencedDeadLetterQueue provider
with the EventProcessingConfigurer.Schema description for an
EventMessage holding
DeadLetter entry table in JDBC.Instantiate a builder to construct a
DeadLetterSchema.A contract towards all
PreparedStatements a JdbcSequencedDeadLetterQueue
requires to function.A functional interface to create a JDBC-specific
DeadLetter entry
table and its indices.Functional interface describing a
Consumer of a DeadlineMessage.Pojo that contains the information about a
Job, will be serialized and deserialized using
the configured Serializer on the JobRunrDeadlineManager.Exception which occurs during deadline message processing.
Annotation used to mark handlers which are capable of handling a
DeadlineMessage.Interface describing a message handler capable of handling a specific deadline.
Quartz job which depicts handling of a scheduled deadline message.
This binder is used to map deadline message and deadline scopes to the job data and vice versa.
Contract for deadline managers.
Exception indicating a problem in the Deadline manager mechanism, more precisely the
DbSchedulerDeadlineManager wasn't properly supplied.Span factory that creates spans for the
DeadlineManager.Helps validation of deadline mechanism provided by
StubDeadlineManager.Represents a Message for a Deadline, specified by its deadline name and optionally containing a deadline payload.
Implementation of a
HandlerEnhancerDefinition that is used for DeadlineHandler annotated methods.Exception indicating that a deadlock has been detected while a thread was attempting to acquire a lock.
Utility class providing a number of reasonable
EnqueueDecisions.A
BaseMatcher implementation that first matches based on Object.equals(Object).Default implementation of the CallbackBehavior interface.
Default implementation of the
CommandBusSpanFactory.Builder class to instantiate a
DefaultCommandBusSpanFactory.Default implementation of the CommandGateway interface.
Builder class to instantiate a
DefaultCommandGateway.Entry point of the Axon Configuration API.
ConflictDescription implementation that takes the necessary information in the Constructor.Implementation of a
ConflictResolver that fetches any unseen changes from the EventStore.Default implementation of the
DeadLetterJdbcConverter, converting ResultSets into
JdbcDeadLetter instances.Builder class to instantiate a
DefaultDeadLetterJdbcConverter.Default implementation of the
DeadLetterStatementFactory used by the JdbcSequencedDeadLetterQueue
Constructs PreparedStatements that are compatible with most databases.Builder class to instantiate a
DefaultDeadLetterStatementFactory.Default implementation of the
DeadlineManagerSpanFactory.Builder class to instantiate a
DefaultDeadlineManagerSpanFactory.Default implementation of the
EventBusSpanFactory.Builder class to instantiate a
DefaultEventBusSpanFactory.Default implementation of the EventGateway interface.
A Builder class for
DefaultEventGateways.An
EventMessageConverter that will convert an Axon event message into a Spring message by:
Copying axon event payload into Spring message payload
Copying axon event metadata into Spring message headers
Adding axon event message specific attributes - that are not part of axon metadata - to the Spring message Headers.Default implementation of the
EventProcessorSpanFactory.Builder class to instantiate a
DefaultEventProcessorSpanFactory.Deprecated.
in through use of the AxonServer java
connector
Default IdentifierFactory implementation that uses generates random
java.util.UUID based identifiers.Default implementation of
InstructionAckSource.Mechanism that takes care of interceptor and handler execution.
Factory for the default parameter resolvers.
Default implementation of the
PersistentStreamMessageSourceFactory that creates
PersistentStreamMessageSource instances.Default implementation of the
QueryBusSpanFactory.Builder class to instantiate a
DefaultQueryBusSpanFactory.Implementation of the QueryGateway interface that allows the registration of dispatchInterceptors.
Builder class to instantiate a
DefaultQueryGateway.Default implementation of the
QueryUpdateEmitterSpanFactory.Builder class to instantiate a
DefaultQueryUpdateEmitterSpanFactory.Default implementation of the
RepositorySpanFactory.Builder class to instantiate a
DefaultRepositorySpanFactory.Default implementation of the
SagaManagerSpanFactory.Builder class to instantiate a
DefaultSagaManagerSpanFactory.Provides functionality for incompatibility checks and saves the results in a in memory cache.
Default implementation of the
SnapshotterSpanFactory.Builder class to instantiate a
DefaultSnapshotterSpanFactory.Default implementation of
SubscriptionQueryResult.Implementation of the UnitOfWork that processes a single message.
Default implementation of the
UsagePropertyProvider interface.Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.storeSnapshot(DomainEventMessage, Serializer)A
CommandMessageFilter that denies all CommandMessages.A
CommandMessageFilter implementation which denies CommandMessages based on their CommandMessage.getCommandName().Utility class for creating a description.
Deprecated.
in through use of the AxonServer java
connector
Represents a vulnerability in an AxonIQ Artifact in use.
Represents the severity of a vulnerability in an AxonIQ artifact.
Utility class for generating hashes for values using several algorithms.
Event processing strategy that directly initiates event processing.
Simple executor implementation that runs a given Runnable immediately in the calling thread.
Property implementation that accesses public field to obtain a value of a property for a given instance.
Implementation of PropertyAccessStrategy that scans class hierarchy to get public field named "property"
Annotation marking a Handler (or class) as not being able to handle replays
Composite of
MessageDispatchInterceptors that apply all interceptors in the order of registration.Base class for dispatch messages which may be used in the
CommandBusConnector upon dispatching a command
to other nodes.Deprecated.
in through use of the AxonServer java
connector
Asynchronous CommandBus implementation with very high performance characteristics.
Builder class to instantiate a
DisruptorCommandBus.Specialized UnitOfWork instance for the
DisruptorCommandBus.A contract towards being a distributed message bus implementation.
Implementation of a
CommandBus that is aware of multiple instances of a CommandBus working together to spread
load.Builder class to instantiate a
DistributedCommandBus.Defines the properties for the Distributed Command Bus, when automatically configured in the Application Context.
The JGroups specific configuration for the Distributed Command Bus.
Converter that converts Dom4j Document instances to a byte array.
Interface describing the properties of serialized Domain Event Messages.
Default implementation of a tracked domain event entry.
Represents a Message that wraps a DomainEvent and an Event representing an important change in the Domain.
Contract describing a component which is aware of
DomainEventMessage their sequences and is capable of
providing the last known sequence number for a given Aggregate identifier.The DomainEventStream represents a stream of historical events published by an Aggregate.
An
EnqueueDecision stating a dead letter should not be enqueued.Enumeration describing a set of reasonable
DuplicateCommandHandlerResolver implementations.Functional interface towards resolving the occurrence of a duplicate command handler being subscribed.
Exception indicating a duplicate Command Handler was subscribed whilst this behavior is purposefully guarded against.
Enumeration describing a set of reasonable
DuplicateQueryHandlerResolver implementations.Functional interface towards resolving the occurrence of a duplicate query handler being subscribed.
Exception indicating a duplicate Query Handler was subscribed whilst this behavior is purposefully guarded against.
Cache implementation that delegates all calls to an EhCache instance.
Deprecated.
since ehcache 2 is nearing eol, we added
EhCache3Adapter instead, which uses ehcache 3.Implementation of an
EventStore that stores and fetches events using an EventStorageEngine.Deprecated.
in favor of using
EmbeddedEventStore which moved to jakarta.Builder class to instantiate an
EmbeddedEventStore.Builder class to instantiate an
EmbeddedEventStore.Matches any empty collection.
Indicates that the annotated
SagaEventHandler method indicates the end of a Saga instance's lifecycle.A
HandlerEnhancerDefinition inspecting the existence of the EndSaga annotation on MessageHandlingMembers.A
WrappedMessageHandlingMember implementation dedicated towards MessageHandlingMembers annotated
with EndSaga.A contract towards describing a decision among a
dead letter containing a message of type
M concerning whether to add it to a SequencedDeadLetterQueue.Provides components with an EntityManager to access the persistence mechanism.
Deprecated.
in favor of using
EntityManagerProvider which moved to jakarta.Interface of an entity model that describes the properties and capabilities of an entity of type
T.A
UsagePropertyProvider implementation that reads the usage properties from the environment variables.A functional interface to supply environment variables.
Matcher that will match an Object if all the fields on that Object contain values equal to the same field in the
expected instance.
A predicate that matches against
DomainEventData instances that have a revision 'equal' to the
revision of the class is has serialized data for.Matcher testing for object equality as per
Object.equals(Object o)Converts an Axon Server Error to the relevant Axon framework exception.
Describes the context of an error.
Interface of the error handler that will be invoked if event processing fails.
Client-side buffer of messages received from the server.
Specification of the mechanism on which the Event Listeners can subscribe for events and event publishers can publish
their events.
Span factory that creates spans for the
EventBus.Deprecated.
in through use of the AxonServer java
connector
A consumer that allows implementations to throw exceptions.
Snapshotter trigger mechanism that counts the number of events to decide when to create a snapshot.
Interface describing the properties of serialized Event Messages.
Interface towards the Event Handling components of an application.
Annotation to be placed on methods that can handle events.
Interface for an event message handler that defers handling to one or more other handlers.
Deprecated.
Replaced by the
MessageHandlerLookup and MessageHandlerConfigurer.Strategy towards reading/writing an Axon EventMessage from/to a Quartz
JobDataMap.Message Dispatch Interceptor that logs published events to a SLF4J logger.
Represents a Message wrapping an Event, which is represented by its payload.
Interface describing a mechanism that converts Spring Messages from an Axon Event Messages and vice versa.
Converter responsible for converting to and from known
EventMessage implementations that should be supported
by a SequencedDeadLetterQueue capable of storing
EventMessages.Deprecated.
in favor of using
EventMessageDeadLetterJpaConverter
which moved to jakarta.Interface to be implemented by classes that can handle events.
Abstract implementation of a
SingleEntryMultiUpcaster and an EventUpcaster that eases the common
process of upcasting one intermediate event representation to several other representations by applying a flat
mapping function to the input stream of intermediate representations.Auto configuration for
EventProcessingModule.Defines a contract for accessor methods regarding event processing configuration.
Defines a contract for configuring event processing.
Contract defining
DeadLetteringEventHandlerInvoker.Builder based configuration when constructing a
DeadLetteringEventHandlerInvoker.Contract which defines how to build an event processor.
Contract defining
PooledStreamingEventProcessor.Builder based configuration when constructing a
PooledStreamingEventProcessor.Contract which define how to build
SubscribableMessageSourceDefinitionException thrown when an
EventProcessor failed to handle a batch of events.Event processing module configuration.
Interface describing a strategy for the processing of a batch of events.
An Event Processor processes event messages from an event queue or event bus.
Service that listens to
PlatformOutboundInstructions to control EventProcessors when for example
requested by Axon Server.Module Configuration implementation that defines the components needed to control and monitor the
EventProcessors with AxonServer.A
MessageMonitor implementation dedicated to EventMessages.A
MessageMonitor implementation dedicated to EventMessages.Builder class to instantiate a
EventProcessorLatencyMonitor.Properties describing the settings for Event Processors.
The processing modes of an
EventProcessor.Span factory that creates spans for the
EventProcessor implementations.Scheduler that keeps track of (Event processing) tasks that need to be executed sequentially.
Callback that allows the SequenceManager to receive a notification when this scheduler finishes processing
events.
Exception indication that an error occurred while publishing an event to an AMQP Broker
Component of the DisruptorCommandBus that stores and publishes events generated by the command's execution.
Interface towards a mechanism capable of scheduling the publication of events.
Exception indicating a problem in the Event Scheduling mechanism, more precisely the
DbSchedulerEventScheduler was not supplied properly.Helper class for validating events scheduled in a given event scheduler.
Schema of an event entry to be stored using Jdbc.
Builder for an
EventSchema that gets initialized with default values.Implementation of an
Aggregate that is sourced from events that have
been published by the aggregate.Annotation that marks a method in an Aggregate (either the root, or an entity) as a handler for Events generated by
that aggregate.
Abstract repository implementation that allows easy implementation of an Event Sourcing mechanism.
Builder class to instantiate a
EventSourcingRepository.Provides a mechanism to append as well as retrieve events from an underlying storage like a database.
Provides a mechanism to open streams from events in the the underlying event storage.
Deprecated.
in through use of the AxonServer java
connector
Indicates that the given events stream could not be stored or read due to an underlying exception.
Utility class for dealing with event streams.
Interface describing a factory for JDBC to create the Domain and Snapshot Event tables.
Interface describing the status of a
Segment of a TrackingEventProcessor.Represent a listener that is notified whenever the
Map of EventTrackerStatus' in the TrackingEventProcessor this component is registered to has changed.A
SingleEventUpcaster implementation which allows for type upcasting only.Builder class to instantiate an
EventTypeUpcaster.Interface that is used for upcasters of event data.
Upcaster chain used to upcast
event representations.Utility class for dealing with events.
Helper class for validating events published on a given EventBus.
Matcher testing for exact classes.
A matcher that will match if all the given
matchers against the event in a list at their respective
index.Annotation marking a Handler as an interceptor for other handlers that is only interested in handling
exception results.
Utility class used to serializer
Throwables into ErrorMessages.Exception utility methods.
Exception thrown to indicate that execution of a task has failed.
Class of objects that contain the result of an executed task.
A Functional Interface towards a
BiFunction which ingests both an AxonServerConfiguration and a
BlockingQueue of Runnable, and outputs an ExecutorService.A RetryScheduler that uses a backoff strategy, retrying commands at increasing intervals when they fail because of
an exception that is not explicitly non-transient.
Builder class to instantiate an
ExponentialBackOffIntervalRetryScheduler.Implementation of
DuplicateCommandHandlerResolver that throws a DuplicateCommandHandlerSubscriptionException
when a duplicate registration is detected.Implementation of
DuplicateQueryHandlerResolver that throws a DuplicateQueryHandlerSubscriptionException
when a duplicate registration is detected.A
CommandCallback implementation wrapping another, that concisely logs failed commands.Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.fetchTrackedEvents(TrackingToken, int)The FieldFilter indicates whether any given Field should be accepted for processing or not.
DomainEventStream implementation that filters a stream.
Implementation of EventStorageEngine that delegates to another implementation, while filtering
events as they are appended.
Quartz Job that publishes an event on an Event Bus.
ParameterResolver implementation that injects a fixed value.
RevisionResolver implementation that returns a fixed value as revision, regardless of the type of serialized object
involved.
Interface describing the operations available on a test fixture in the configuration stage.
Interface describing action to perform on a Saga Test Fixture during the configuration phase.
Exception indicating that an error occurred that prevented successful execution of a test fixture.
Interface towards an object that contains the results of a Fixture execution.
Default implementation of FixtureExecutionResult.
ParameterResolverFactory implementation for use in test cases that prevent that all declared resources on message
handlers need to be configured.
Deprecated.
in through use of the AxonServer java
connector
Interface describing a message handler capable of forwarding a specific command.
Interface describing the required functionality to forward a message.
Only forward messages of type
T if the routing key of the message matches that of the entity.Forward no messages
T regardless of their set up.Forward all messages
T regardless of their set up.SequencingPolicy that does not enforce any sequencing requirements on event processing.
Command Handler Callback that allows the dispatching thread to wait for the result of the callback, using the Future
mechanism.
Implementation of a
TrackingToken that uses the global insertion sequence number of the event to determine
tracking order and additionally stores a set of possible gaps that have been detected while tracking the event
store.Deprecated.
in favor of the
GapAwareTrackingTokenDedicated
CollectionConverter implementation to de-/serializer the GapAwareTrackingToken and
org.axonframework.eventsourcing.eventstore.GapAwareTrackingToken.Aggregate factory that uses a convention to create instances of aggregates.
Implementation of the CommandMessage that takes all properties as constructor parameters.
Generic implementation of
CommandResultMessage.Generic implementation of the
dead letter allowing any type of Message to be dead
lettered.A
DeadLetterTableFactory implementation compatible with most databases.Generic implementation of the
DeadlineMessage.Generic implementation of a serialized domain event entry.
Generic implementation of a
DomainEventMessage.Deprecated.
this class is available for backward compatibility with instances that were serialized with Axon 2.
Generic implementation of the EventMessage interface.
Generic repository implementation that stores JPA annotated aggregates.
Deprecated.
in favor of using
GenericJpaRepository which moved to jakarta.Builder class to instantiate a
GenericJpaRepository for aggregate type T.Builder class to instantiate a
GenericJpaRepository for aggregate type T.Deprecated.
this class is available for backward compatibility with instances that were serialized with Axon 2.
Generic implementation of a
Message that contains the payload and metadata as unserialized values.Generic implementation of the QueryMessage.
QueryResponseMessage implementation that takes all properties as constructor parameters.
Content type converter between Avro generic record and single-object-encoded bytes.
Generic implementation of the
ResetContext.Generic implementation of
ResultMessage.Generic SagaSqlSchema implementation, for use in most databases.
Generic implementation of the
StreamingQueryMessage.Generic implementation of the
SubscriptionQueryMessage.Generic
SubscriptionQueryUpdateMessage which holds incremental update of an subscription query.Generic implementation of a token entry.
Jdbc token entry table factory compatible with most databases.
Generic implementation of a
DomainEventMessage that is also a TrackedEventMessage.Generic implementation of a
TrackedEventMessage.Implementation of an
Upcaster that is formed of a chain of other upcasters which are combined to upcast a
stream of intermediate objects.Interface to an object that publishes events on behalf of an aggregate.
Registry for application metrics with convenient ways to register Axon components.
Registry for application metrics with convenient ways to register Axon components.
Tracking token based on the global sequence number of an event.
Deprecated.
in favor of the
GlobalSequenceTrackingTokenWrapper that allows clients to access a gRPC
Command as a CommandMessage.DomainEventData implementation that retrieves its raw data from a protobuf
Event message.Wrapper that allows clients to access a gRPC
QueryRequest as a QueryMessage.Wrapper that allows clients to access a gRPC
QueryResponse as a QueryResponseMessage.Wrapper that allows clients to access a gRPC
SubscriptionQuery message as a
SubscriptionQueryMessage.Deprecated.
in through use of the AxonServer java
connector
Converts GRPC Exceptions to
RuntimeExceptions.Deprecated.
in through use of the AxonServer java
connector
Exception thrown when a message exceeds the maximum allowed size.
Interceptor around a gRPC request that checks whether the message size is within the limits of the server.
Exception created to log a warning when a message size exceeds a certain threshold.
Wrapper around standard Axon Framework serializer that can deserialize Metadata from AxonServer events.
Utility class for converting gRPC MetaData entries into a Java Map and vice versa.
Mapping that translates a
MetaData into a map of GRPC MetaDataValue.Mapping that translates an object into a GRPC
SerializedObject.Contract towards serializing an object of type
A.Mapping that translates a
Message into a GRPC SerializedObject.Wrapper that allows clients to access a gRPC
SerializedObject message as a SerializedObject.Container for message handler attributes.
Comparator used by
AnnotatedHandlerInspector to sort MessageHandlingMember entity members.Interface that describes an object capable of inspecting a method to determine if the method is suitable for message
handling.
Spring
those configured in a Spring Application Context) and complements those
found using a service loader on the Bean Class Loader.
FactoryBean that creates a HandlerDefinition using configured HandlerDefinition and
invalid @link
{@link HandlerEnhancerDefinition) beans (e.g.
Interface describing objects that are capable of enhancing a
MessageHandler, giving it additional
functionality.Base exception for exceptions raised by Handler methods.
Handler registry - gives possibility of registering handlers for specific cases and contexts.
Factory that creates spans for the spans representing handlers.
Configuration for the timeout settings of message handlers.
Inspects message handler and wraps it in a
TimeoutWrappedMessageHandlingMember if the handler should have a
timeout.Uses reflection to know if a handler handles a certain type of messages.
Meta-annotation indicating the meta-annotated annotation is used for
MessageHandlingMembers.Default headers to include when publishing a message on a broker.
Utility class holding additional
Status instances.Deprecated.
in through use of the AxonServer java
connector
Deprecated.
in through use of the AxonServer java
connector
Deprecated.
in through use of the AxonServer java
connector
Deprecated.
in through use of the AxonServer java
connector
Combines multiple
UsagePropertyProvider instances into a single provider.Jdbc table factory for HSQL databases.
Specialization of the GenericSagaSqlSchema for use in the HSQL database.
Abstract Factory class that provides access to an IdentifierFactory implementation.
Exception indicating that a required identifier is missing in the processed message.
Validates the structure of an object passed as Aggregate Identifier.
An
EnqueueDecision stating a dead letter should be ignored.FieldFilter implementation that rejects a given Field
Indicates situations when access to the Payload of a Message is not allowed.
Adapter class that publishes Events from a Spring Messaging Message Channel on the Event Bus.
Exception indicating that an aggregate was not compatible with the requirements of the
GenericAggregateFactory.Infrastructure autoconfiguration class for Axon Framework application.
Implementation of an
IntermediateEventRepresentation that contains the original serialized payload and
metadata before these have been upcast.Thread-safe event storage engine that stores events and snapshots in memory.
SagaRepository implementation that stores all Saga instances in memory.
In-memory implementation of the
SequencedDeadLetterQueue.Builder class to instantiate an
InMemorySequencedDeadLetterQueue.Implementation of a
TokenStore that stores tracking tokens in memory.Converter that converts an InputStream to a byte array.
Converter that converts an input stream to a Dom4J document.
Converter that converts an input stream to a XOM document.
A
ResponseType implementation that will match with query handlers which return a single instance of the
expected response type.Responsible for sending instruction acknowledgements.
Deprecated.
in through use of the AxonServer java connector
Interceptor autoconfiguration class for Axon Framework application.
The interceptor chain manages the flow of a message through a chain of interceptors and ultimately to the message
handler.
Parameter resolver factory that adds support for resolving current
InterceptorChain.Interface describing the intermediate representation of an event during upcasting.
RetryScheduler implementation that retries commands at regular intervals when they fail because of an exception that
is not explicitly non-transient.
Builder class to instantiate a
IntervalRetryScheduler.Utility methods for IO operations.
DomainEventStream implementation that gets its messages from an Iterator.
Serializer implementation that uses Jackson 3 to serialize objects into a JSON format.
Builder class to instantiate a
Jackson3Serializer.Non-generic interface for a consumer that accepts a
JsonMapper.Builder
for customizing Jackson3Serializer.Serializer implementation that uses Jackson 2 to serialize objects into a JSON format.
Builder class to instantiate a
JacksonSerializer.Deprecated.
in favor of the
XStreamSerializer and
JacksonSerializer, as direct Java serialization is relatively error
prone.Builder class to instantiate a
JavaSerializer.Cache adapter implementation that allows providers implementing the JCache abstraction to be used.
Autoconfiguration class for Axon's JDBC specific infrastructure components.
A
DeadLetter that was saved to a JDBC-backed database and reconstructed from it.An
EventStorageEngine implementation that uses JDBC to store and
fetch events.Builder class to instantiate a
JdbcEventStorageEngine.Class which holds the default
PreparedStatement builder methods for use in the JdbcEventStorageEngine.Exception indicating an error occurred while interacting with a JDBC resource.
A
SagaStore implementation that uses JDBC to store and find Saga instances.Builder class to instantiate a
JdbcSagaStore.A JDBC-based implementation of the
SequencedDeadLetterQueue, used for storing dead letters containing
event messages durably.Builder class to instantiate an
JdbcSequencedDeadLetterQueue.SQLErrorCodesResolver is an implementation of PersistenceExceptionResolver used to resolve sql error codes to see if
it is an duplicate key constraint violation.
A
TokenStore implementation that uses JDBC to save and load TrackingToken instances.Builder class to instantiate a
JdbcTokenStore.Utility class for safely executing Jdbc queries.
Describes a function that creates a new
PreparedStatement ready to be executed.Describes a function that converts a
ResultSet into a result of type R.Implementation of
DeadlineManager that delegates scheduling and triggering to a Jobrunr
JobScheduler.Builder class to instantiate a
JobRunrDeadlineManager.EventScheduler implementation that delegates scheduling and triggering to a JobRunr JobScheduler.
Builder class to instantiate a
JobRunrEventScheduler.ScheduleToken implementation representing a scheduled JobRunr Job.
Autoconfiguration class for Axon's JPA specific infrastructure components.
A
DeadLetter that was saved to the database and reconstructed from it.Deprecated.
in favor of using
JpaDeadLetter which moved to
jakarta.EventStorageEngine implementation that uses JPA to store and fetch events.
Deprecated.
in favor of using
JpaEventStorageEngine which
moved to jakarta.Builder class to instantiate a
JpaEventStorageEngine.Builder class to instantiate a
JpaEventStorageEngine.Autoconfiguration class for Axon's JPA specific event store components.
Deprecated.
in favor of using
JpaAutoConfiguration which moved to jakarta.Deprecated.
in favor of using
JpaEventStoreAutoConfiguration which moved to jakarta.JPA implementation of the
SagaStore.Deprecated.
in favor of using
JpaSagaStore which moved to
jakarta.Builder class to instantiate a
JpaSagaStore.Builder class to instantiate a
JpaSagaStore.JPA-backed implementation of the
SequencedDeadLetterQueue, used for storing dead letters containing
Eventmessages durably as a DeadLetterEntry.Deprecated.
in favor of using
JpaSequencedDeadLetterQueue
which moved to jakarta.Builder class to instantiate an
JpaSequencedDeadLetterQueue.Builder class to instantiate an
JpaSequencedDeadLetterQueue.Implementation of a token store that uses JPA to save and load tokens.
Deprecated.
in favor of using
JpaTokenStore which moved to
jakarta.Builder class to instantiate a
JpaTokenStore.Builder class to instantiate a
JpaTokenStore.ContentTypeConverter implementation for Jackson 3 that converts a JsonNode object into a byte[].
ContentTypeConverter implementation for Jackson 2 that converts a JsonNode object into a byte[].
A
ContentTypeConverter implementation for Jackson 3 that converts a JsonNode object
into an ObjectNode.A
ContentTypeConverter implementation for Jackson 2 that converts a JsonNode object
into an ObjectNode.Exception indicating that a
Message has been refused due to a structural
validation failure.Deprecated.
in favor of using
JSR303ViolationException which moved
to jakarta.Utility class to retrieve the current Kotlin version at runtime.
Utility to create labels for use with JobRunr.
Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.lastSequenceNumberFor(String)Represents a serialized object that can be deserializedObjects upon request.
EventJobDataBinder implementation that adds support for Event publication Jobs scheduled in Axon 2.
Interface for components that can be started and shut down as part of the Application lifecycle.
Functional interface for lifecycle activities that may run asynchronously
Interface towards the registry that holds all lifecycle handlers for components.
Functional interface towards a lifecycle handler used during start up or shutdown of an application.
Utility class used to resolve
LifecycleHandlers to be registered to the Configuration.Exception indicating a failure occurred during a lifecycle handler method invocation.
Interface describing the configuration of start and shutdown handlers within Axon's configuration.
Interface of an error handler that is invoked when an exception is triggered as result of an
EventMessageHandler handling an event.Abstract implementation for matchers that use event-specific matchers to match against a list of items.
Utility methods for operations on lists.
A matcher that will match if all the given
matchers match against at least one item in a given List.A matcher that will match if all the given
matchers match against at least one item in a given List.Interface of a lock acquired to gain (exclusive) access to a shared resource, with a mechanism to release it again.
Exception indicating that a lock could not be obtained.
Aggregate implementation that provides access to the lock held by the aggregate while a command is handled.
Interface to the lock factory.
Implementation of the Repository interface that takes provides a locking mechanism to prevent concurrent
modifications of persisted aggregates.
Abstract Builder class to instantiate
LockingRepository implementations.Abstract implementation of a saga repository that locks access to a saga while the saga is being operated on.
Abstract Builder class to instantiate
LockingSagaRepository implementations.CommandCallback implementation that simply logs the results of a command.
Implementation of the DuplicateCommandHandlerResolver that allows registrations to be overridden by new handlers, but
logs this (on WARN level) to a given logger.
Implementation of the
DuplicateQueryHandlerResolver that allows registrations to be overridden by new handlers,
but logs this (on WARN level) to a given logger.Implementation of a
ListenerInvocationErrorHandler that logs exceptions as errors but otherwise does nothing
to prevent event handling from continuing.MessageDispatchInterceptor and MessageHandlerInterceptor implementation that logs dispatched and
incoming messages, and their result, to a SLF4J logger.Implementation of the QueryInvocationErrorHandler that logs all errors to a given
Logger.Builder class to instantiate a
LoggingQueryInvocationErrorHandler.Implementation of a
SpanFactory that requires no java agent or APM system, only logging.An
UpdateCheckerReporter implementation that logs the results of the update check.Loads and stores a unique machine ID in the user's home directory.
Customizer to add more customizations to a managed channel to Axon Server.
Matcher that will match an Object if that object is a
Map of which all
keys-values pairs are equal to pairs of the expected instance.FieldFilter that delegates to an arbitrary number of other filters.
Exception indicating that an error occurred that prevented successful execution of a matcher.
Utility class containing static methods to obtain instances of (List) Matchers.
RevisionResolver that uses Maven meta data to retrieve the application version.
Artifact version resolver that uses Maven meta data to retrieve the jar version.
Functional interface returning the maximum amount of segments a
Coordinator may claim, based on the given
processingGroup.Member of a cluster of connected command endpoints.
PrivilegedAction that makes the given method accessible for reflection.
Special Wrapped Token implementation that keeps track of two separate tokens, of which the streams have been merged
into a single one.
Representation of a Message, containing a Payload and MetaData.
A
MessageDispatchInterceptor that adds the {$code authorities} from the authorized principle.A
MessageHandlerInterceptor that verifies authorization based on Secured annotations on the payload
of Messages.Counts the number of ingested, successful, failed and processed messages
Counts the number of ingested, successful, failed and processed messages
Abstract implementation of a
Message that delegates to an existing message.Interceptor that allows messages to be intercepted and modified before they are dispatched.
Interface marking components capable of registering Dispatch Interceptors.
Annotation indicating that a member method should be able to respond to
Messages.Interface for a component that processes Messages.
An implementation of a
ConfigurerModule that will register a list of beans as handlers for a specific type of
message.Enumeration defining the auto configurable message handler types.
Annotation marking an handler method as an interceptor handler.
Workflow interface that allows for customized message handler invocation chains.
HandlerEnhancerDefinition that marks methods (meta-)annotated with MessageHandlerInterceptor
as interceptors.Interface to interact with a MessageHandlingMember instance through a chain of interceptors, which were used to build
up this chain.
Interface marking components capable of registering Handler Interceptors.
MessageHandlerInvocationException is a runtime exception that wraps an exception thrown by an invoked message
handler.
A
BeanDefinitionRegistryPostProcessor implementation that detects beans with Axon Message handlers and
registers an MessageHandlerConfigurer to have these handlers registered in the Axon
Configuration.The
MessageHandlerRegistrar manages the lifecycle of a message handling component, by defining a MessageHandlerRegistrar.start() and MessageHandlerRegistrar.shutdown() method and keeping hold of the message handler's Registration.Sets the timeout settings of a message handler.
Interface describing a handler for specific messages targeting entities of a specific type.
Annotation indication that a parameter on a Message Handler method should be injected with the identifier of a
Message.
An extension of the AbstractAnnotatedParameterResolverFactory that accepts parameters of a
String type that
are annotated with the MessageIdentifier annotation and assigns the identifier of the Message.Adds the message identifier to the Span.
Marker interface for
MessageHandlingMember instances that need to be treated as interceptors, rather
than regular members.Specifies a mechanism to monitor message processing.
An interface to let the message processor inform the message monitor of the result
of processing the message
Interface describing a factory for a Message Monitor.
CorrelationDataProvider that provides the
identifier of a Message to
other messages that are created as result of processing the first message.Maintains the context around the processing of a single Message.
A
MessageMonitor which creates Timer instances for the overall, success, failure and ignored time an
ingested Message takes.A
MessageMonitor which introduces a Timer for the overall timer of all Messages being
ingested, as well as a success, failure and ignored Timer.Builder class to instantiate a
MessageTimerMonitor.Builder class to instantiate a
MessageTimerMonitor.Adds the message type (simple class name) to the Span.
Deprecated.
this class is available for backward compatibility with instances that were serialized with Axon 2.
Represents MetaData that is passed along with a payload in a Message.
Used to derive the value of an association property by looking it up the event message's
MetaData.CommandTargetResolver implementation that uses MetaData entries to extract the identifier and optionally the version
of the aggregate that the command targets.
This
TextMapGetter implementation is able to extract the parent OpenTelemetry span context from a
Message.This
TextMapSetter implementation is able to insert the current OpenTelemetry span context into a
Message.ValueDeserializer implementation for Jackson 3 that deserializes MetaData instances.
JsonDeserializer implementation for Jackson 2 that deserializes MetaData instances.
RoutingStrategy implementation that uses the value in the
MetaData of a CommandMessage assigned to a given key.Builder class to instantiate a
AnnotationRoutingStrategy.A
SequencingPolicy implementation that extracts the sequence identifier from the EventMessage's
MetaData, based on a given metaDataKey.Builder class to instantiate a
MetaDataSequencingPolicy.Adds the metadata of the message to the span as attributes.
Annotation that indicates the parameter needs to be resolved to the value of the Message MetaData stored under the
given
key.Property implementation that invokes a method to obtain a value of a property for a given instance.
Implementation of a
HandlerEnhancerDefinition that is used for CommandHandler annotated methods.Implementation of
HandlerEnhancerDefinition used for CommandHandlerInterceptor annotated methods.Implementation of
HandlerEnhancerDefinition used for CreationPolicy annotated methods.Definition of handlers that can handle
QueryMessages.Auto configuration to set up Metrics for the infrastructure components.
Implementation of the
ConfigurerModule which uses the GlobalMetricRegistry
to register several Metrics Modules to the given Configurer.Implementation of the
ConfigurerModule which uses the
GlobalMetricRegistry to register several Metrics Modules to the given
Configurer.Properties describing the settings for Metrics.
Auto configuration specific properties around Metrics.
Auto configuration to set up Micrometer Metrics for the infrastructure components.
Interface describing a module for the Axon Configuration API.
Deprecated.
this class is available for backward compatibility with instances that were serialized with Axon 3.
Wrapper for a callback that notifies a Message Monitor of the message execution result.
CorrelationDataProvider that combines the data of multiple other correlation providers.
Implementation of
EventHandlerInvoker with capabilities to invoke several different invokers.HandlerDefinition instance that delegates to multiple other instances, in the order provided.
HandlerEnhancerDefinition instance that delegates to multiple other instances, in the order provided.
Delegates messages and callbacks to the given list of message monitors
ParameterResolverFactory instance that delegates to multiple other instances, in the order provided.
A
ResponseType implementation that will match with query handlers which return a multiple instances of the
expected response type.A
TrackingToken implementation combining several TrackingTokens into one.Implementation of a
SpanFactory that delegates calls to multiple other factories.Implementation which allows for tracking processors to process messages from an arbitrary number of sources.
Deprecated.
In favor of
MultiStreamableMessageSource.Builder class to instantiate a
MultiStreamableMessageSource.Deprecated.
In favor of
MultiStreamableMessageSource.Builder.Jdbc event entry table factory for MySql databases.
A
CommandMessageFilter implementation that negates the result of another CommandMessageFilter
instance.Deprecated.
Various components have dedicated tracing SpanFactory interfaces since 4.9.0.
Creates a builder that will create a
NestingSpanFactory.Default implementation of
CreationPolicyAggregateFactory that invokes the default, no-arguments constructor
of the aggregate class A.Deprecated.
Use Spring Boot autoconfiguration or register the individual beans explicitly.
Condition that checks if a bean with given class already exists in the Spring context.
Cache implementation that does absolutely nothing.
Implementation of a
ConflictResolver that does nothing.Exception indicating that no suitable command handler could be found for the given command.
Exception indicating a query for a single result was executed, but no handlers were found that could provide an
answer.
Indicates that the
JpaSequencedDeadLetterQueue could not resolve a converter based on the
DeadLetterEntry or EventMessage that needed to be converted.This will implement
MessageHandlerInterceptorMemberChain with no more interceptors.FieldFilter implementation that only accepts non-static Fields.
A predicate for checking non-transiency of a failure comparing it against configured concrete classes.
FieldFilter implementation that only accepts non-transient Fields.
Callback that does absolutely nothing when invoked.
Event upcaster that does nothing.
No-op implementation of a
Lock.A message monitor that returns a NoOp message callback
A NoOp MessageMonitor callback
SpanFactory implementation that creates a NoOpSpanFactory.NoOpSpan.The
Span implementation that does nothing.ResourceInjector that does not inject anything.
A
ScopeDescriptor describing no active scope.Implementation of
SnapshotTriggerDefinition that doesn't trigger snapshots at all.An
AxonException describing that there is no such dead letter present in a
SequencedDeadLetterQueue.TransactionManager implementation that does nothing.
LockFactory implementation that does nothing.
Matcher that matches against a
null or void value.A
ContentTypeConverter implementation for Jackson 3 that converts an ObjectNode object
into a JsonNode.A
ContentTypeConverter implementation for Jackson 2 that converts an ObjectNode object
into a JsonNode.Miscellaneous object utility methods.
Condition implementation to check for a bean instance of a specific class *and* a specific qualifier on it,
matching if no such bean can be found.Condition implementation to check for a bean instance of a specific class *and* a specific qualifier on it.Automatically configured the
OpenTelemetrySpanFactory as the method of providing tracing in Axon Framework.Span implementation that uses OpenTelemetry's Span to provide tracing
capabilities to an application.Creates
Span implementations that are compatible with OpenTelemetry java agent instrumentation.Builder class to instantiate a
OpenTelemetrySpanFactory.A
ResponseType implementation that will match with query handlers which return a single instance of the
expected response type, but returns that as an Optional containing the result.Oracle 11 doesn't support the data type BIGINT, so NUMBER(19) is used as a substitute instead.
Oracle 11 does not support AUTO_INCREMENT.
Jdbc token entry table factory for Oracle databases.
Utility class with some specific hacks required to get certain features to work with Oracle v11.
A
CommandMessageFilter implementation that matches whenever either of the supplied CommandMessageFilter instances match.Adapter class that sends Events from an event bus to a Spring Messaging Message Channel.
Enables iterating through a JDBC query using paging.
Describes a function that creates a new
PreparedStatement that pages results through the given
offset and maxSize, ready to be executed.Enables iterating through a JPA query using paging while lazily mapping the results when necessary.
Deprecated.
in favor of using
PagingJpaQueryIterable which moved to jakarta.Interface for a mechanism that resolves handler method parameter values from a given
Message.Interface for objects capable of creating Parameter Resolver instances for annotated handler methods.
Used to derive the value of an association property by looking it up the event message's payload.
Matcher that matches any message (e.g.
Implementation of a
ParameterResolver that resolves the Message payload as parameter in a handler method.Matches a list of Messages if the list of their payloads matches the given matcher..
A
MessageMonitor implementation which creates a new MessageMonitor for every Message payload type
ingested by it.Deprecated.
As of release 4.4, replaced by using
s on the monitor implementations.
invalid reference
TagAdds the
payload type as an attribute to the Span.The PersistenceExceptionResolver is used to find out if an exception is caused by duplicate keys.
A connection instance receiving the events for a persistent stream to pass on in batches of events to an event
consumer.
A
SubscribableMessageSource that receives event from a persistent stream from Axon Server.Definition of a
PersistentStreamMessageSource.Functional interface for creating instances of a
PersistentStreamMessageSource.Post-processor to create Spring beans for persistent streams defined in the application context.
Functional interface towards constructing a
ScheduledExecutorService for a PersistentStreamMessageSource.A provider of
SequencingPolicies for a given Configuration.Implementation of a
LockFactory that uses a pessimistic locking strategy.Builder class for the
PessimisticLockFactory.Utility class containing constants which can be used as input for the
StartHandler and ShutdownHandler annotations, or components implementing the Lifecycle interface.A
StreamingEventProcessor implementation which pools its resources to enhance processing speed.Builder class to instantiate a
PooledStreamingEventProcessor.Jdbc table factory for Postgresql databases.
SQL schema supporting PostgreSQL databases.
Jdbc token entry table factory for Postgres databases.
Matcher implementation that delegates the matching to a Predicate.
Indicates the relative priority of the annotated component.
Comparator that compares objects based on the value on an
@Priority
annotation.A wrapper class of
Callables that adheres to a priority by implementing PriorityTask.This
ExecutorService wraps an existing one, creating a PriorityTask for every Runnable that
is submitted that's an instance of one.A wrapper class of
Runnables that adheres to a priority by implementing PriorityTask.Represents a task such as
Runnable or Comparable that adheres to a priority by implementing
Comparable.Responsible for creating
Scheduler implementations relevant to the Axon Server connector.Hint for the Configuration API that the annotated Event Handler object should be assigned to an Event Processor with
the specified name.
Utility class contain helper methods to extract information from
ProcessingInstructions.Exception indicating that an action was retried a maximum times, without a good result.
Processing utilities.
Singleton ErrorHandler implementation that does not do anything.
An
AxonServerConnectionDetails implementation based on a given AxonServerConfiguration bean.Interface describing a mechanism that can read a predefined property from a given instance.
Exception indicating that a predefined property is not accessible.
Abstract Strategy that provides access to all PropertyAccessStrategy implementations.
A
UsagePropertyProvider that reads the AxonIQ Data Collection properties from a file located at
~/.axoniq/update-checker.properties.A
SequencingPolicy implementation that extracts the sequence identifier from the event message payload based
on a given property or property extractor.Builder class to instantiate a
PropertySequencingPolicy.Deprecated.
in through use of the AxonServer java
connector
A
ResponseType implementation that will match with query
handlers that return a Publisher stream of the expected response type.Implementation of
DeadlineManager that delegates scheduling and triggering to a Quartz Scheduler.Builder class to instantiate a
QuartzDeadlineManager.EventScheduler implementation that delegates scheduling and triggering to a Quartz Scheduler.
Builder class to instantiate a
QuartzEventScheduler.Spring FactoryBean that creates a QuartzEventScheduler instance using resources found in the Spring Application
Context.
ScheduleToken implementation representing a scheduled Quartz Job.
The mechanism that dispatches Query objects to their appropriate QueryHandlers.
Span factory that creates spans for the
QueryBus.Exception indicating that the execution of a Query Handler has resulted in an exception.
Interface towards the Query Handling components of an application.
Marker annotation to mark any method on an object as being a QueryHandler.
Describes a class capable of subscribing to the query bus.
Deprecated.
Replaced by the
MessageHandlerLookup and MessageHandlerConfigurer.Interface indicating that a MessageHandlingMember is capable of handling specific query messages.
Interface describing a mechanism for the QueryMessage components to report errors.
Message type that carries a Query: a request for information.
Calculate the priority of
QueryMessage based on its content.Message that contains the results of a Query.
Single result row from a Query to the AxonServer.
Iterator to process the results of a query.
Converter between Axon Framework
QueryMessage and QueryResponseMessage and Axon Server gRPC Query and QueryResponse messages.Encapsulates the identifying fields of a Query Handler when one is subscribed to the
QueryBus.Component which informs subscription queries about updates, errors and when there are no more updates.
Span factory that creates spans for the
QueryUpdateEmitter.Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.fetchDomainEvents(String, long, int)Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.fetchTrackedEvents(TrackingToken, int)Contract which defines how to build a PreparedStatement for use on
JdbcEventStorageEngine.fetchTrackedEvents(TrackingToken, int)Contract which defines how to build a PreparedStatement for use on
invalid input: '@author Lucas Campos
@since 4.3'CommandBus implementation that does not perform any actions on subscriptions or dispatched commands, but records
them instead.
A wrapper around a
ListenerInvocationErrorHandler that in itself also implements
ListenerInvocationErrorHandler.Utility class for working with Java Reflection API.
Annotation intended for types and methods to trigger the registration of entities found in the given
RegisterDefaultEntities.packages() with the DefaultEntityRegistrar.Interface that provides a mechanism to cancel a registration.
Description of an Exception received from a remote source.
Exception indicating that an error has occurred while remotely handling a message.
Exception indicating that a non transient error has occurred while remotely handling a message.
References an
EventTrackerStatus which no active work is occurring on.An implementation of the
HandlerEnhancerDefinition that is used for
AllowReplay annotated message handling methods.Annotation indication that a parameter on a Message Handler method should be injected with the
resetContext
present in a ReplayToken.An implementation of the
ParameterResolverFactory which resolves the parameter annotated with
ReplayContext.An implementation of the
ParameterResolverFactory which resolves the
ReplayStatus parameter.Type that can be used as parameter of Event Handler methods that indicates whether a message is delivered as part of
a replay, or in regular operations.
Token keeping track of the position before a reset was triggered.
Base class for reply messages which may be used in the
CommandBusConnector for replying on received
commands from other nodes.The reporter generates extensive human-readable reports of what the expected outcome of a test was, and what the
actual results were.
The
Repository provides an abstraction of the storage of aggregates.Helper class for the validation of Saga Repository content.
Deprecated.
Replaced by the
SpringAggregateLookup and SpringAggregateConfigurer.Provides a repository for given aggregate type.
Span factory that creates spans for the
Repository.Represents a Message initiating the reset of an Event Handling Component.
Annotation that can be placed on a method that is to be invoked when a reset is being prepared.
Exception indicating that a reset is not supported by a component.
Interface describing a mechanism to inject resources into Saga instances.
Specifies the expected response type required when performing a query through the
QueryBus/QueryGateway.Utility class containing static methods to obtain instances of
ResponseType.Deprecated.
in through use of the AxonServer java
connector
Meta-Annotation used to demarcate
MessageHandlerInterceptor annotated methods as interceptors that should
only act on the result of a handler invocation.Message that represents a result of handling some form of request message.
ParameterResolverFactory that provides support for Parameters where the result of Handler execution is expected to
be injected.
Interface describing the operations available on the "validate result" (a.k.a.
Implementation of the ResultValidator.
Callback implementation that will invoke a retry scheduler if a command results in a runtime exception.
Interface towards a mechanism that decides whether to schedule a command for execution when a previous attempts
resulted in an exception.
Annotation that attaches revision information to a Serializable object.
Interface towards a mechanism that resolves the revision of a given payload type.
A
SnapshotFilter implementation which based on a configurable allowed revision will only SnapshotFilter.allow(DomainEventData) DomainEventData containing that revision.Builder class to instantiate a
RevisionSnapshotFilter.The RollbackConfiguration defines if a Unit of Work should be rolled back when an exception is raised during the
processing of a Message.
Enum containing common rollback configurations for the Unit of Work.
Field or method level annotation that marks a field or method providing the routing key that a command
targets.
Interface describing a mechanism that generates a routing key for a given command.
Interface describing an implementation of a Saga.
Annotation that informs Axon's auto configurer for Spring that a given
Component is a saga instance.Represents a set of components needed to configure a Saga.
Provides mechanisms to configure the components used to manage and store Saga.
Exception triggered when a new saga instance could not be instantiated.
Enumeration containing the possible Creation Policies for Sagas.
Java Persistence Entity allowing sagas to be stored in a relational database.
Method-level annotation indicating that the annotated method is an event handler method for the saga instance.
Exception triggered by a saga while it is processing an event or processing a task.
Describes the conditions under which a Saga should be created, and which AssociationValue it should be initialized
with.
Exception triggered during initialization of a Saga.
Abstract base class of a component that models a saga's life cycle.
Span factory that creates spans for the
AbstractSagaManager.Interface of a factory for a
SagaModel for any given saga type.Utility class that inspects annotation on a Saga instance and returns the relevant configuration for its Event
Handlers.
A data holder containing information of
SagaEventHandler annotated methods.Interface of a model that describes a Saga of type
T.Interface towards the storage mechanism of Saga instances.
SagaSchema allows specification of custom storage locations for the saga repositories.
Builder for an
SagaSchema that gets initialized with default values.Deprecated.
in favor of the
SagaScopeDescriptorDescribes the scope of a Saga by means of its type and identifier.
Interface describing the SQL statements that the JdbcSagaRepository needs to execute against the underlying
database.
Exception indicating that an error has occurred while storing a Saga.
Provides a mechanism to find, load update and delete sagas of type
T from an underlying storage like a
database.Interface describing a Saga entry fetched from a SagaStore.
Fixture for testing Annotated Sagas based on events and time passing.
Holds the data regarding deadline schedule.
Interface describing an event to be scheduled at a given date and time.
Schedules tasks to be executed in future.
Token that identifies a single scheduled Event.
Exception indicating a problem in the Event Scheduling mechanism.
Provides functionality for incompatibility checks.
Describes functionality off processes which can be 'in scope', like an Aggregate or Saga.
Interface describing components which are
Scope aware.Contract towards a mechanism to provide a
Stream of components which are ScopeAware.Denotes the description of a
Scope.Factory for a
ScopeDescriptor ParameterResolver.MessageHandlerDefinition that verifies authorization based on
Secured annotations on the message handler.A representation of a segment and corresponding mask with various capabilities.
Contract describing a component that can process
dead letters that it has enqueued.Interface describing the required functionality for a dead letter queue.
EventStorageEngine implementation that combines the streams of two event storage engines.
A matcher that will match if all the given
matchers each match against an item that the previous
matcher matched against.Annotation indicating that a parameter on an Event Handler method should be injected with the SequenceNumber of
a DomainEventMessage.
An extension of the AbstractAnnotatedParameterResolverFactory that accepts parameters of a
Long type
annotated with the SequenceNumber annotation and assigns the sequenceNumber of the DomainEventMessage.ParameterResolver that resolves SequenceNumber parameters
Interface to a policy definition for concurrent processing, for example event handling.
Concurrency policy that requires sequential processing of events raised by the same aggregate.
SequencingPolicy that requires sequential handling of all events delivered to an event handler.
Indicates that an exception occurred while serializing or deserializing an object.
A message containing serialized payload data and metadata.
Represents the serialized form of a
MetaData instance.Interface describing the structure of a serialized object.
Holder that keeps references to serialized representations of a payload and meta data of a specific message.
Specialization of the SerializedObject for Sagas represented as byte array.
Describes the type of a serialized object.
Interface describing a serialization mechanism.
A group of properties that allows easy configuration of the serializers used for different types of objects that
Axon needs to serialize.
Enumerates different possible standard serializers, available in Axon.
RevisionResolver implementation that returns the (String representation of the) serialVersionUID of a class.
Configurer module which is auto-loadable by the
DefaultConfigurer that sets sensible
default to use when the AxonServer connector is available on the classpath.Exception that is triggered when an error occurs that is related to the registration or deregistration of a member to
the distributed command bus service registry.
An
EnqueueDecision stating a dead letter should be enqueued.Annotation indicating that a member method should be a part of the shutdown cycle of an Axon application.
Exception indicating a process tried to register an activity whilst the application is shutting down.
A latch implementation to be used in shutdown scenarios.
Implementation of the CommandBus that dispatches commands to the handlers subscribed to that specific command's name.
Builder class to instantiate a
SimpleCommandBus.CorrelationDataProvider implementation defines correlation headers by the header names.
Implementation of
DeadlineManager which uses Java's ScheduledExecutorService as scheduling and
triggering mechanism.Builder class to instantiate a
SimpleDeadlineManager.Simple implementation of the EntityManagerProvider that returns the EntityManager instance provided at construction
time.
Deprecated.
in favor of using
SimpleEntityManagerProvider which moved to
jakarta.Implementation of the
EventBus that dispatches events in the thread the publishes them.Builder class to instantiate a
SimpleEventBus.Implementation of an
EventHandlerInvoker that forwards events to a list of registered EventMessageHandler.Builder class to instantiate a
SimpleEventHandlerInvoker.An
EventScheduler implementation that uses Java's ScheduledExecutorService as scheduling and triggering
mechanism.Builder class to instantiate a
SimpleEventScheduler.Spring FactoryBean that creates a SimpleEventScheduler instance using resources found in the Spring Application
Context.
Simple implementation of the
HandlerAttributes which is given the attributes in the constructor.An endpoint in the network for a command handling service.
Implementation of the QueryBus that dispatches queries to the handlers within the JVM.
Builder class to instantiate a
SimpleQueryBus.Implementation of
QueryUpdateEmitter that uses Project Reactor to implement Update Handlers.Builder class to instantiate a
SimpleQueryUpdateEmitter.A resource injector that checks for @Inject annotated fields and setter methods to inject resources.
A
ParameterResolverFactory implementation for simple resource injections.ScheduleToken for tasks event scheduled using the SimpleEventScheduler.
SerializedObject implementation that takes all properties as constructor parameters.
SerializedType implementation that takes its properties as constructor parameters.
Abstract implementation of an
Upcaster that eases the common process of upcasting one intermediate
representation to several other representations by applying a simple flat mapping function to the input stream of
intermediate representations.Abstract implementation of an
Upcaster that eases the common process of upcasting one intermediate
representation to another representation by applying a simple mapping function to the input stream of intermediate
representations.Abstract implementation of an event
Upcaster that eases the common process of upcasting one intermediate
event representation to another representation by applying a simple mapping function to the input stream of
intermediate representations.Abstraction interface to bridge old
FluxSink and Sinks.Many API with a common
API.A reservoir of measurements constrained by a sliding window that stores only the measurements made
in the last
N seconds (or other time unit).Default implementation of an event entry containing a serialized snapshot of an aggregate.
Functional interface defining an
SnapshotFilter.allow(DomainEventData) method to take snapshot data into account when
loading an aggregate.Interface describing instances that are capable of creating snapshot events for aggregates.
Span factory that creates spans for the
Snapshotter.Interface describing a mechanism that keeps track of an Aggregate's activity in order to trigger a snapshot.
Interface describing the mechanism for triggering Snapshots.
Annotation indication that a parameter on a Message Handler method should be
injected with the aggregate identifier of a DomainEventMessage.
Represents a part of the application logic that will be traced.
The
SpanFactory is responsible for making spans in a way the chosen tracing provider is
compatible with.Represents the scope of a
Span.Utilities for creating spans which are relevant for all implementations of tracing.
Avro schema loader loading schemas embedded into Java classes generated by Avro Java Maven generator, which include
the original schema in a static field.
Avro serializer strategy responsible for operations on
SpecificRecordBase.A
ConfigurerModule implementation that will configure an Aggregate with the Axon Configuration.A
BeanDefinitionRegistryPostProcessor implementation that scans for Aggregate types and registers a
configurer for each Aggregate found.Snapshotter implementation that uses the AggregateRoot as state for the snapshot.
Builder class to instantiate a
SpringAggregateSnapshotter.Implementation of the
AggregateSnapshotter that eases the configuration when
used within a Spring Application Context.Deprecated.
Replaced by the
SpringConfigurer and SpringAxonConfiguration.Implementation of an
SpringAxonAutoConfigurer.ImportSelector that enables the import of the SpringAxonAutoConfigurer after
all @Configuration beans have been processed.Factory Bean implementation that creates an Axon
Configuration for a Configurer.ParameterResolverFactory implementation that resolves parameters using Spring dependency resolution.
ParameterResolverFactory implementation that resolves parameters in the Spring Application Context.
A
Configurer implementation that considers the Spring Application context as a
source for components.Deprecated.
Replaced by the
HandlerDefinitionFactoryBean.Deprecated.
Use Spring Boot autoconfiguration or register the individual beans explicitly.
ConnectionProvider implementation that is aware of Transaction Managers and provides the connection attached to an
active transaction manager, instead of asking a Data Source directly.
Deprecated.
Replaced by the
HandlerDefinitionFactoryBean.Deprecated.
Replaced by the
HandlerDefinitionFactoryBean.Spring factory bean that creates a ParameterResolverFactory instance that is capable of resolving parameter values as
Spring Beans, in addition to the default behavior defined by Axon.
An
AggregateFactory implementation that uses Spring prototype beans to create new uninitialized instances of
Aggregates.Deprecated.
Instead of using a factory bean, consider retrieving the Repository directly from the Axon Configuration.
ResourceInjector implementation that injects Saga instances with resources available from the Spring Application
context the injector is registered in.
A
ConfigurerModule implementation that configures a Saga based on configuration found in the Application
Context.A
BeanDefinitionRegistryPostProcessor implementation that scans for Saga types and registers a configurer for each Saga found.TransactionManager implementation that uses a
PlatformTransactionManager as
underlying transaction manager.Utility class for Spring specific helper functions.
SQLErrorCodesResolver is an implementation of PersistenceExceptionResolver used to resolve sql error codes to see if
it is an duplicate key constraint violation.
Deprecated.
in favor of using
SQLErrorCodesResolver which moved
to jakarta.SQLStateResolver is an implementation of PersistenceExceptionResolver used to resolve sql state values to see if it
violates a unique key constraint.
Annotation indicating that a member method should be a part of the start cycle of an Axon application.
Indicates that the annotated
SagaEventHandler method can trigger the
creation of a new Saga instance.Interface for a source of
messages that processors can track.An
EventProcessor which processes an event stream in segments.Supplier of
PlatformInboundInstruction that represent the status of a StreamingEventProcessor.A special type of
QueryMessage used for initiating streaming queries.Utility class for working with Streams.
ContentTypeConverter that converts String into byte arrays.
Utility methods for when dealing with
Strings.Stub implementation of an AggregateLifecycle that registers all applied events for verification later.
Implementation of
StubAggregateLifecycle that can be used as an RegisterExtension
annotated method or field in a test class.Deprecated.
in favor of
StubAggregateLifecycleExtension to be used in
combination with Junit 5Stub implementation of
DeadlineManager.EventScheduler implementation that uses it's own concept of "Current Time" for the purpose of testing.
ScheduleToken returned by the StubEventScheduler.
Interface for a source of
messages to which message processors can subscribe.Definition for a
SubscribableMessageSource.Event processor implementation that
subscribes to the EventBus for
events.Builder class to instantiate a
SubscribingEventProcessor.Converter between Axon Framework
SubscriptionQueryMessage, the initial QueryResponseMessage and the
subsequent SubscriptionQueryUpdateMessage's and Axon Server gRPC SubscriptionQuery and SubscriptionQueryResponse.Deprecated.
since 3.4.0 Reactor version, Sinks API does not use FluxSink.OverflowStrategy
Message type that carries a Subscription Query: a request for information.
Result of the subscription query.
Message which holds incremental update of an subscription query.
Tags configuration labeling Axon Node represented by key-value pairs.
Spring Configuration properties for
TagsConfiguration.Utility class for micrometer tag management.
Field or method level annotation that marks a field or method providing the identifier of the aggregate that a
command targets.
Field or method level annotation that marks a field or method providing the expected version of the aggregate that a
command targets.
Interface towards a mechanism that is capable of resolving the context name to which a
Message should be
routed.Configuration properties for a task timeout.
This class detects whether the usage reporter is being used in a unit test environment, such as a JUnit test or
another testing framework.
Interface describing the operations available on a test fixture in the execution stage.
Class or method level annotation that indicates the calling thread should not wait longer than the provided timeout
for the results of a command.
Configuration properties for time limits of processing transactions and handlers in Axon Framework.
Annotation indication that a parameter on an Event Handler method should be injected with the Timestamp of an Event
Message.
Writer interface for writing a formatted timestamp to a
PreparedStatement during updates of the database.Deprecated.
in through use of the AxonServer java
connector
Implementation of a token entry compatible with JPA that stores its serialized token as a byte array.
Primary key for token entries used by JPA
Schema of an token entry to be stored using Jdbc.
Builder for an
TokenSchema that gets initialized with default values.Describes a component capable of storing and retrieving event tracking tokens.
Properties describing the settings for the default
Token Store.Interface describing a factory for JDBC to create the table containing tracking token entries.
Object representing a topology change at Axon Server.
The handler subscription of a
TopologyChange.The enumeration referencing the possible
TopologyChange types.A functional interface representing a listener that is notified when a
TopologyChange occurs to a specific
context.Enhances message handlers with the provided
SpanFactory, wrapping handling of the message in a Span
that is reported to the monitoring tooling.Builder class to instantiate a
TracingHandlerEnhancerDefinition.Properties describing the settings for tracing.
Defines which
SpanAttributesProviders are enabled.Configuration properties for the behavior of creating tracing spans for the
CommandBus.Configuration properties for the behavior of creating tracing spans for the
DeadlineManager.Configuration properties for the behavior of creating tracing spans for the
EventProcessor implementations.Configuration properties for the behavior of creating tracing spans for the
QueryBus.Configuration properties for the behavior of creating tracing spans for the
Repository.Configuration properties for the behavior of creating tracing spans for the
AbstractSagaManager.Configuration properties for the behavior of creating tracing spans for the
Snapshotter.Specialization of the DomainEventData class that includes the Token representing the position of this event in
a stream.
Interface describing the properties of serialized Event Messages containing a
TrackingToken.Represents an
EventMessage containing a TrackingToken.Implementation of the
EventTrackerStatus, providing simply modification methods to switch from one
EventTrackerStatus value object to another.EventProcessor implementation that tracks events from a
StreamableMessageSource.Builder class to instantiate a
TrackingEventProcessor.Enum representing the possible states of the Processor
Configuration object for the
TrackingEventProcessor.Describes a stream of
TrackedEventMessages.Tag interface identifying a token that is used to identify the position of an event in an event stream.
Implementation of a
ParameterResolverFactory that resolves the TrackingToken of an event message
if that message is a TrackedEventMessage.Interface of an object that represents a started transaction that can be committed or rolled back.
Interface towards a mechanism that manages transactions
Deprecated.
Use Spring Boot autoconfiguration or register the individual beans explicitly.
Interceptor that uses a
TransactionManager to start a new transaction before a Message is handled.Wrapper for exceptions that occurred while calling an @BeforeTransaction or @AfterTransaction annotated method.
Utility class for doing reflection on types.
Exception indicating that a processor tried to claim a Token (either by retrieving or updating it) that has already
been claimed by another process.
Exception indicating that the TokenStore was unable to initialize a Token for a tracking processor and Segment.
Exception indicating that a TokenStore implementation was unable determine its identifier based on the underlying
storage.
Exception indicating that a message has been rejected due to a lack of authorization.
PropertyAccessStrategy implementation that finds properties defined according to the Uniform Access Principle
(see Wikipedia).
This class represents a Unit of Work that monitors the processing of a
Message.Enum indicating possible phases of the Unit of Work.
Wrapper for a ConnectionProvider that checks if a connection is already attached to the Unit of Work, favoring that
connection over creating a new one.
Message handler interceptor that sets a timeout on the processing of the current
UnitOfWork.Class representing a serialized object of which there is no class available in the current class loader.
Set of simple
RoutingStrategy implementations.Thrown when an @...Handler annotated method was found that does not conform to the rules that apply to those
methods.
Implementation of an
IntermediateEventRepresentation that contains upcast functions for the payload and
metadata of a previous representation.Interface for Upcasters.
The UpdateChecker reports Anonymous usage data to AxonIQ periodically.
A
ConfigurerModule that registers the UpdateChecker component.Client for checking for updates and sending anonymous usage data to the AxonIQ servers.
Interface for reporting the response of the update checker to the user.
Represents an UpdateChecker request, including machine and instance identifiers, operating system details, JVM
information, Kotlin version, and a list of library versions.
Represents the response from the UpdateChecker API, containing information about version upgrades and vulnerabilities
found in the artifacts used by the application.
Result of registering an Update Handler.
Convenience implementation of a StreamObserver that provides access to the request stream, which allows cancellation
of the call, flow control, etc.
Provides properties related to the Anonymous Usage Collection feature.
Structure that holds an Aggregate Identifier and an expected version of an aggregate.
Cache implementation that keeps values in the cache until the garbage collector has removed them.
Interface to an object that publishes events on behalf of an aggregate.
Interface providing an API to methods in the "when" state of the fixture execution.
Represents a
CommandCallback that was wrapped with another.Abstract implementation of a
MessageHandlingMember that delegates to a wrapped MessageHandlingMember.Interface marking a token that wraps another token.
Wrapper around an
EventTrackerStatus, delegating all calls to a delegate.Exception representing that a wrong dead letter was provided to the queue.
Converter that converts XOM Document instances to a String.
Autoconfigures an
XStream instance in absence of an existing XStream bean.Utility class exposing an operation that searches the
ApplicationContext for auto-configuration base
packages.Serializer that uses XStream to serialize and deserialize arbitrary objects.
Builder class to instantiate a
XStreamSerializer.
MessageHandlerLookupandMessageHandlerConfigurer, eliminating the need of an abstract implementation used for command and query registration.