All Classes and Interfaces
Class
Description
ParameterResolverFactory that will supply a parameter resolver when a matching parameter annotation is paired
with a suitable type of parameter.
Abstract implementation of the Cache interface which makes it easier to implement Adapters.
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 base class for Messages.
Abstract implementation of the PropertyAccessStrategy that uses a no-arg, public method to access the property
value.
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.Abstract base class of a serialized domain event.
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.References a new
EventTrackerStatus which work just has started on.Adds the aggregate identifier to the Span if the current message being handled is a
DomainEventMessage.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.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.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.
Adapter that turns any
@CommandHandler annotated bean into a MessageHandler
implementation.Adapter that turns any bean with
EventHandler annotated methods into an EventMessageHandler.Adapter that turns any
@QueryHandler annotated bean into a MessageHandler
implementation.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.Utility class for locating annotations and attribute values on elements.
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.
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.Serializer providing support for Apache Avro, using
Single Object Encoded binary
encoding.
Builder to set up Avro Serializer using some defaults.
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.
Exception indicating that a configuration error has been made in the Axon configuration.
Base exception for all Axon Framework related exceptions.
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.Thread factory that created threads in a given group.
Exception indicated that an Axon-specific task has timed out.
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.
Unit of Work implementation that is able to process a batch of Messages instead of just a single Message.
BeanPropertyAccessStrategy implementation that uses JavaBean style property access.
Interceptor that applies JSR303 bean validation on incoming
Messages.Deprecated.
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.
A Supplier that caches its result, useful if the supplier operation is expensive and expected to always yield the
same result.
Exception indicating that a conversion is required between to upcasters, but there is no converter capable of doing
the conversion.
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.
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.
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.
A
UsagePropertyProvider implementation that reads the usage properties from the command line system
properties.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().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.
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.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.A special implementation of a Token that is used to store configuration specific to the underlying storage of each
TokenStore instance.Interface towards a mechanism that provides access to a JDBC Connection.
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.
Interface describing a mechanism that converts the data type of IntermediateRepresentations of SerializedObjects for
Upcasters.
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 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.
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.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.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.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.Default implementation of the
CommandBusSpanFactory.Builder class to instantiate a
DefaultCommandBusSpanFactory.Default implementation of the CommandGateway interface.
Builder class to instantiate a
DefaultCommandGateway.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.Default implementation of the
EventProcessorSpanFactory.Builder class to instantiate a
DefaultEventProcessorSpanFactory.Default IdentifierFactory implementation that uses generates random
java.util.UUID based identifiers.Mechanism that takes care of interceptor and handler execution.
Factory for the default parameter resolvers.
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.Provides functionality for incompatibility checks and saves the results in a in memory cache.
Default implementation of
SubscriptionQueryResult.Implementation of the UnitOfWork that processes a single message.
Default implementation of the
UsagePropertyProvider interface.A
CommandMessageFilter that denies all CommandMessages.A
CommandMessageFilter implementation which denies CommandMessages based on their CommandMessage.getCommandName().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
Base class for dispatch messages which may be used in the
CommandBusConnector upon dispatching a command
to other nodes.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.Converter that converts Dom4j Document instances to a byte array.
Interface describing the properties of serialized Domain Event Messages.
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.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.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.A
UsagePropertyProvider implementation that reads the usage properties from the environment variables.A functional interface to supply environment variables.
Describes the context of an error.
Interface of the error handler that will be invoked if event processing fails.
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.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.
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.
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.Exception thrown when an
EventProcessor failed to handle a batch of events.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.
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
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.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.
Annotation marking a Handler as an interceptor for other handlers that is only interested in handling
exception results.
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 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.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.
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.Dedicated
CollectionConverter implementation to de-/serializer the GapAwareTrackingToken and
org.axonframework.eventsourcing.eventstore.GapAwareTrackingToken.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.Generic implementation of the EventMessage interface.
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 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.Tracking token based on the global sequence number of an event.
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.
Interface describing objects that are capable of enhancing a
MessageHandler, giving it additional
functionality.Base exception for exceptions raised by Handler methods.
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.
Combines multiple
UsagePropertyProvider instances into a single provider.Abstract Factory class that provides access to an IdentifierFactory implementation.
Validates the structure of an object passed as Aggregate Identifier.
An
EnqueueDecision stating a dead letter should be ignored.Indicates situations when access to the Payload of a Message is not allowed.
Implementation of an
IntermediateEventRepresentation that contains the original serialized payload and
metadata before these have been upcast.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.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.
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.
A
DeadLetter that was saved to a JDBC-backed database and reconstructed from it.Exception indicating an error occurred while interacting with a JDBC resource.
A JDBC-based implementation of the
SequencedDeadLetterQueue, used for storing dead letters containing
event messages durably.Builder class to instantiate an
JdbcSequencedDeadLetterQueue.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.
A
DeadLetter that was saved to the database and reconstructed from it.Deprecated.
in favor of using
JpaDeadLetter which moved to
jakarta.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.
Represents a serialized object that can be deserializedObjects upon request.
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.
Exception indicating a failure occurred during a lifecycle handler method invocation.
Interface of an error handler that is invoked when an exception is triggered as result of an
EventMessageHandler handling an event.Utility methods for operations on lists.
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.
Interface to the lock factory.
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.
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.
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.
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.
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
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.
Adds the message type (simple class name) to the Span.
Represents MetaData that is passed along with a payload in 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.Definition of handlers that can handle
QueryMessages.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.
Builder class to instantiate a
MultiStreamableMessageSource.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.Cache implementation that does absolutely 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.A predicate for checking non-transiency of a failure comparing it against configured concrete classes.
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.A
ScopeDescriptor describing no active scope.An
AxonException describing that there is no such dead letter present in a
SequencedDeadLetterQueue.TransactionManager implementation that does nothing.
LockFactory implementation that does nothing.
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.
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.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.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.
Implementation of a
ParameterResolver that resolves the Message payload as parameter in a handler method.Adds the
payload type as an attribute to the Span.The PersistenceExceptionResolver is used to find out if an exception is caused by duplicate keys.
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 token entry table factory for Postgres databases.
Indicates the relative priority of the annotated component.
Comparator that compares objects based on the value on an
@Priority
annotation.Exception indicating that an action was retried a maximum times, without a good result.
Processing utilities.
Singleton ErrorHandler implementation that does not do anything.
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.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.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.
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.
Message that contains the results of a Query.
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.Utility class for working with Java Reflection API.
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.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.
Specifies the expected response type required when performing a query through the
QueryBus/QueryGateway.Utility class containing static methods to obtain instances of
ResponseType.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.
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.
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.
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.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.
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.
Describes the type of a serialized object.
Interface describing a serialization mechanism.
RevisionResolver implementation that returns the (String representation of the) serialVersionUID of a class.
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.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
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.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 serializer strategy responsible for operations on
SpecificRecordBase.Annotation indicating that a member method should be a part of the start cycle of an Axon application.
Interface for a source of
messages that processors can track.An
EventProcessor which processes an event stream in segments.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.Interface for a source of
messages to which message processors can subscribe.Event processor implementation that
subscribes to the EventBus for
events.Builder class to instantiate a
SubscribingEventProcessor.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.
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.
Class or method level annotation that indicates the calling thread should not wait longer than the provided timeout
for the results of a command.
Annotation indication that a parameter on an Event Handler method should be injected with the Timestamp of an Event
Message.
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.
Interface describing a factory for JDBC to create the table containing tracking token entries.
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.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
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.
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.
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.
Provides properties related to the Anonymous Usage Collection feature.
Cache implementation that keeps values in the cache until the garbage collector has removed them.
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.
Serializer that uses XStream to serialize and deserialize arbitrary objects.
Builder class to instantiate a
XStreamSerializer.
BeanValidationInterceptorwhich moved to jakarta.