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.
Base implementation of a
Component and
ComponentDefinition.ComponentCreator to simplify definition and creation of
components through a ComponentDefinition.An entry holding the lifecycle
handler and its corresponding phase.Abstract implementation of the
ConsistencyMarker interface that implements the required comparisons with the
ConsistencyMarker.ORIGIN and
ConsistencyMarker.INFINITY consistency markers.Abstract
EntityChildMetamodel that implements common functionality for most implementations.Abstract implementation of the
EntityChildModelDefinition interface that makes concrete implementations
easier to maintain.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.
An abstract implementation of the
MessageStream interface that wraps a ResultStream.Repository implementation that ensures safe concurrent access to entities stored in it.
References a new
EventTrackerStatus which work just has started on.Event Storage Engine implementation that uses the aggregate-oriented APIs of Axon Server, allowing it to interact
with versions that do not have DCB support.
ConsistencyMarker implementation that keeps track of a position per aggregate identifier.Utility class for handling various operations related to the Aggregate-based Event Storage Engine.
An
EventStorageEngine implementation that uses JPA to store and fetch events from an aggregate-based event
storage solution.Configuration class of the
AggregateBasedJpaEventStorageEngine.A JPA entry dedicated for storing
EventMessages in the
AggregateBasedJpaEventStorageEngine.Adds the aggregate identifier to the Span if the current message being handled is a
DomainEventMessage.An implementation of
Position based on aggregate sequence numbers.Annotation indication that a parameter on a Message Handler method should be injected with the
of a
.
invalid reference
aggregate typeinvalid reference
org.axonframework.eventhandling.DomainEventMessageAn extension of the AbstractAnnotatedParameterResolverFactory that accepts parameters of a
String type that
are annotated with the AggregateType annotation and assigns the aggregate type from the
ProcessingContext if present.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.
Adapter that turns classes with
CommandHandler
annotated methods into a CommandHandlingComponent.Implementation of the
EntityIdResolver that converts the payload through the configured
MessageConverter then takes the expected representation of the message handler from the
AnnotatedEntityMetamodel.EntityIdResolverDefinition that converts the payload of incoming messages based on the
expected payload type of the message
handler in the model, and then looks for a TargetEntityId-annotated
member in the payload, through the AnnotationBasedEntityIdResolver.An
EntityMetamodel implementation that uses reflection to inspect the entity.Factory for creating
AnnotatedEntityMetamodel instances for a given entity type.Utility class that matches an entity instance to a message based on the routing key of a message and the routing key
of the entity.
Adapter that turns classes with
EventHandler annotated
methods into a EventHandlingComponent.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.The default HandlerDefinition implementation in Axon.
Adapter that turns classes with
QueryHandler annotated
methods into a QueryHandlingComponent.Implementation of the
EntityEvolvingComponent that applies state changes through
EventHandler(-meta)-annotated methods using the
AnnotatedHandlerInspector.Implementation of a
EntityIdResolver that inspects the payload of a Message for fields or methods
annotated with TargetEntityId.Definition for an
EntityIdResolver that uses annotation to resolve the entity identifier.Annotation-based
CriteriaResolver implementation which resolves EventCriteria based on the given
id for loading the entity.Defines how an
AnnotationBasedEventCriteriaResolver should be constructed for an EventSourcedEntity
annotated class.Reflection-based implementation of the
EventSourcedEntityFactory interface.Definition for an annotation-based
EventSourcedEntityFactory that constructs an
EventSourcedEntity-annotated class.Implementation of
TagResolver that processes EventTag and EventTags annotation on fields and
methods of event payload objects to create Tag instances.Exception thrown when tag resolution fails.
A
MessageTypeResolver implementation looking for a configurable annotation on the Class this resolver
is invoked for.An annotation specification unique to the
AnnotationMessageTypeResolver.RoutingStrategy that expects an
Command (meta-)annotation on the command message's payload.Utility class for locating annotation and attribute values on elements.
Interface describing the consistency boundary condition for
EventMessages when
appending them to an Event Store.Exception indicating that a transaction was rejected due to conflicts detected in the events to append.
An
ApplicationConfigurer combines the component registry with the notion of lifecycle.An
ApplicationContext is a container for components that are registered in the
ComponentRegistry of the
ApplicationConfigurer.Component that forward events received from a
SubscribableEventSource as Spring ApplicationEvent to
the ApplicationContext.Represents an artifact with its group ID, artifact ID, and version.
Represents an upgrade suggestion for a specific artifact version by the AxonIQ UpdateChecker API.
Utility class (inspired by Springs Assert class) for doing assertions on parameters and object state.
RetryScheduler implementation that schedules retries on a
ScheduledExecutorService based on a given
policy.Converter providing support for Apache Avro, using
Single Object Encoded binary
encoding.
Configuration for the AvroConverter.
Strategy for Avro Converter.
Configuration for the Avro converter strategy.
Holder for package-based class scanning for Avro schema extraction.
Configures the base packages used by autoconfiguration when scanning for classes containing Avro Schema.
Autoconfigures required beans for the Avro
Converter.Utilities for Avro manipulations.
Error indication that an Assertion failed during a test case.
Autoconfiguration class that defines the
AxonConfiguration and
ComponentRegistry implementations that supports beans to be accessed as
components.The configuration of any Axon Framework application.
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 caused 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.
Base Axon Server Autoconfiguration.
An implementation of the
CommandBusConnector that connects to an Axon Server instance to send and receive
commands.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.
A
ConfigurationEnhancer that is auto-loadable by the
ApplicationConfigurer, setting sensible defaults when using Axon Server.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.
Utility class for the
AxonServerContainer, used to initialize the cluster.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.
An
EventStorageEngine implementation using Axon Server through the axonserver-connector-java
project.A
ComponentFactory implementation that generates AxonServerEventStorageEngine instances.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.
AxonServerQueryBusConnector is an implementation of
QueryBusConnector that connects to AxonServer to enable
the dispatching and receiving of queries.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.
A
SimpleStatusAggregator implementation determining the overall health of an Axon Framework application using
Axon Server.ConnectionDetailsFactory class that recognizes TestContainer instances running Axon Server.
Event published after initialization of Axon through the Spring event mechanism.
Fixture for testing Axon Framework application.
Allow customizing the fixture setup.
Interface describing the operations available on a test phase for testing Axon-based applications using a
given-when-then pattern.
Interface describing the operations available in the Given phase of the test fixture execution.
Interface describing the initial setup phase of a test fixture.
Interface describing the operations available in the Then phase of the test fixture execution.
Operations available in the Then phase of the test fixture execution only if command was dispatched during
the When phase.
Operations available in the Then phase of the test fixture execution only if event was published during the
When phase.
Interface describing the operations available in the Then phase of the test fixture execution.
Interface describing the operations available in the Then phase of the test fixture execution.
Operations available in the Then phase of the test fixture execution only if no command or event was
dispatched during the When phase.
Interface describing the operations available in the When phase of the test fixture execution.
When-phase specific for executing a
command.When-phase specific for publishing an
event.When-phase after no action in the When-phase.
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.
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.
Base implementation for custom modules that contains the ComponentRegistry required to register components, enhancers
and (sub)modules.
Utility methods for working with Spring
BeanDefinitions.BeanPropertyAccessStrategy implementation that uses JavaBean style property access.
Interceptor that applies JSR303 bean validation on incoming
Messages.Utility class containing reusable functionality for implementing the Builder Pattern in (infrastructure) components.
A
ContentTypeConverter implementation that converts byte[] containing UTF8 encoded JSON string to a
JsonNode.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.
Interface towards a mechanism that replicates the behavior of a Command Handling component.
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.
Autoconfiguration that constructs a default
CBORMapper, typically to be used by a
JacksonConverter.A
ContentTypeConverter implementation 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.A
Converter implementation that will combine ContentTypeConverters to form
chains of converters to be able to convert from one type to another, for which there is no suitable single
converter.Exception indicating that multiple child entities of a parent entity are able to handle the same command.
Functional interface describing how to get the child entity (or entity collection), and apply the evolved child
entity (or entities in case of a collection) to the parent entity.
Exception indicating that there was no child entity available to handle a command.
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.
ConfigurationEnhancer that registers the ClasspathParameterResolverFactory as the default
ParameterResolverFactory.ParameterResolverFactory instance that locates other ParameterResolverFactory instances on the class path.
Resolves certain parameters from the classpath.
Utility for creating classes by name containing a class cache.
MessageStream implementation that invokes the given
closeHandler once the stream is closed.Utility methods for operations on collections.
Annotation used to mark an object as a command.
The mechanism that dispatches
commands to their appropriate
command handler.The
CommandBusConnector interface defines the contract for connecting multiple CommandBus instances.A functional interface representing a handler for incoming command messages.
A callback interface for handling the result of command processing.
Span factory that creates spans for the
CommandBus.Utility class to convert commands during
dispatching and handling of
subscribed command handlers in the
AxonServerCommandBusConnector.Component that dispatches commands to a
CommandGateway in a predefined
context.ParameterResolverFactory that ensures the CommandDispatcher is resolved in the context of the current
ProcessingContext.Configuration enhancer that registers the
CommandDispatcherParameterResolverFactory to the
ComponentRegistry of the Configuration.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.
Annotation to be placed on methods that can handle
commands, thus making them
CommandHandlers.Interface describing a handler of
commands.Interface describing a registry of
command handlers.Interface describing a group of
CommandHandlers belonging to a single component.Interface describing a message handler capable of handling a specific command.
A
Module and ModuleBuilder implementation providing operation to construct a command handling
application module.The command handler configuration phase of the command handling module.
The setup phase of the command handling module.
A
UsagePropertyProvider implementation that reads the usage properties from the command line system
properties.A
Message carrying a command as its payload.Calculate the priority of
CommandMessage based on its content.Interface describing the result from command handling.
A
ResultMessage that represents a result from handling a CommandMessage.Resolves the target child entity for a given command message.
Defines how a
CommandTargetResolver should be constructed for an EntityMember-annotated member of an
AnnotatedEntityMetamodel.Helper class for validation of dispatched commands.
Exception indicating that
QueryUpdateEmitter is completed, thus cannot be used to emit messages and report
errors.Describes a component defined in a
Configuration, that may depend on other component for its initialization
or during it's startup/shutdown operations.A tuple representing a
Component's uniqueness, consisting out of a type and name.Functional interface describing how to build a component of type
C using the Configuration during
construction.A functional interface describing how to decorate a component of type
C.Defines the structure of a
Component that is available in the Configuration of the application or one
of its Modules.Mandatory interface to be implemented by all implementations of
ComponentDefinition.Represents an intermediate step in the creation of a
ComponentDefinition.Contract towards describing the properties an (infrastructure) component might have.
Exception indicating that an error occurred in the component description process.
A factory of components of type generic
C.Represents a handler for a component's lifecycle.
The starting point when configuring any Axon Framework application.
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.Implementation of the
EntityMetamodel interface that enables the definition of command handlers and child
entities for a given entity type E.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.Utility class containing operations to convert Axon Framework's
SourcingCondition and
StreamingCondition into an Axon Server SourceEventsRequest and StreamEventsRequest
respectively.A special implementation of a Token that is used to store configuration specific to the underlying storage of each
TokenStore instance.Interface providing access to all configured
components in an Axon Framework application.An
ApplicationContext implementation that retrieves components from a given Configuration.Interface describing an enhancement of the
ComponentRegistry from the Axon Framework configuration API,
taking effect during build of the configurer.ConfigurationEnhancer that registers the ConfigurationParameterResolverFactory as additional
parameter resolver factory to the ComponentRegistry.A
ParameterResolverFactory implementation that resolves parameters from available components in the
Configuration instance it was configured with.A
TransactionalExecutor implementation for JDBC Connections.Interface describing functionality for connection managers.
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.
Interface representing a point in an Event Stream up to where certain state has been made up-to-date.
Utility class for constructing objects using reflection.
EntityManagerProvider implementation that expects the container to inject the default container managed
EntityManager
instance.
Interface describing a mechanism that converts an object from a specified
source type to
the defined target type.Interface describing operations for context-specific, immutable, resource management.
Object that is used as a key to retrieve and register resources of a given type in a
Context.A
MessageStream implementation that continuously fetches event messages
from a configurable data source.Exception indicating that a conversion is required between two formats, but there is no converter capable of doing
the conversion.
Interface describing a mechanism that can convert data from one to another type.
Autoconfiguration class dedicated to configuring the
Converter.A group of properties that allows easy configuration of the
Converters used for different types of objects that Axon needs to
convert.Enumerates different possible standard
Converters available in
Axon Framework.A
CommandGateway implementation that wraps the CommandResult of the delegate into a result that can
convert the payload of the result using a provided MessageConverter.A
MessageDispatchInterceptor and MessageHandlerInterceptor implementation using
CorrelationDataProviders to collect and set a collection of correlation data.Object defining the data from a
Message that should be attached as correlation data to Messages
generated as result of the processing of the given message.Autoconfiguration class dedicated to collection any
CorrelationDataProviders.A registry of
CorrelationDataProviders, acting as a collection of
registered
CorrelationDataProvider components.Functional interface describing a resolver of an
EventCriteria based on an identifier of type I.Defines how a
CriteriaResolver should be constructed for an EventSourcedEntity annotated class.ConnectionProvider implementation that obtains a connection from a given DataSource.
Some utility methods regarding Date and Time.
Exception indicating that a deadlock has been detected while a thread was attempting to acquire a lock.
Defines the structure of a decorator for
components in the Configuration of the
application or one of its Modules.Defines the behavior that all implementation of
DecoratorDefinition must provide.Represents an intermediate phase in the creation of a
DecoratorDefinition.A
BaseMatcher implementation that first matches based on Object.equals(Object).Default implementation of the
AxonApplication.Default implementation of the CallbackBehavior interface.
Default implementation of the
CommandBusSpanFactory.Builder class to instantiate a
DefaultCommandBusSpanFactory.Default implementation of the
CommandGateway interface.Default implementation of the
ComponentRegistry allowing for reuse of Component,
ComponentDecorator, ConfigurationEnhancer, and Module registration for the
ApplicationConfigurer and Module implementations alike.Default implementation of the
CorrelationDataProviderRegistry, maintaining a list of
CorrelationDataProviders.Default implementation of the
DispatchInterceptorRegistry, maintaining lists of CommandMessage,
EventMessage, and QueryMessage-specific
MessageDispatchInterceptors.Default implementation of the
EventBusSpanFactory.Builder class to instantiate a
DefaultEventBusSpanFactory.Default implementation of the
EventGateway interface using the EventSink to publish events.Default implementation of
EventHandlingComponentsConfigurer providing EventHandlingComponents`
builders management with decoration support.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.The default
EventStoreTransaction.Default implementation of the
HandlerInterceptorRegistry, maintaining lists of CommandMessage,
EventMessage, and QueryMessage-specific
MessageHandlerInterceptors.Default IdentifierFactory implementation that uses generates random
java.util.UUID based identifiers.Default implementation of
InstructionAckSource.Default implementation for a
MessageDispatchInterceptorChain.The
DefaultMessageMonitorRegistry is a default implementation of the MessageMonitorRegistry interface
responsible for managing and providing components of MessageMonitor for various message types such as
CommandMessage, EventMessage, and QueryMessage.Factory for the default parameter resolvers.
Default implementation of
ProcessorModuleFactory that assigns event handlers to processors using
ProcessorDefinitions.Default implementation of the
QueryBusSpanFactory.Builder class to instantiate a
DefaultQueryBusSpanFactory.Default implementation of the
QueryGateway interface.Default implementation of the
QueryUpdateEmitterSpanFactory.Builder class to instantiate a
DefaultQueryUpdateEmitterSpanFactory.Provides functionality for incompatibility checks and saves the results in a cache.
Default implementation of the
UsagePropertyProvider interface.An implementation of the
MessageStream that wraps a stream that will become available asynchronously.A utility class to run a task with a delay in a virtual thread.
A
CommandBusConnector implementation that wraps another CommandBusConnector and delegates all calls
to it.Abstract implementation of an
EventBus that delegates all calls to a given delegate.An
EventConverter implementation delegating conversion operations to a MessageConverter.Abstract implementation of an
EventHandlingComponent that delegates calls to a given delegate.A
MessageConverter implementation delegating conversion operations to a Converter.Abstract implementation of an MessageStream that delegates calls to a given delegate.
A
QueryBusConnector implementation that wraps another QueryBusConnector and delegates all calls to
it.Contract allowing components
to describe themselves with a given
ComponentDescriptor.Utility class for creating a description.
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.
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
A registry of
MessageDispatchInterceptors, acting as a collection of
registered
MessageDispatchInterceptors components.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.Configuration for the
DistributedCommandBus.Configuration enhancer for the
DistributedCommandBus, which upon detection of a CommandBusConnector
in the configuration will decorate the regular CommandBus with the provided
connector.Defines the properties for the Distributed Command Bus, when automatically configured in the Application Context.
The JGroups specific configuration for the Distributed Command Bus.
Implementation of a
QueryBus that is aware of multiple instances of a QueryBus working together to
spread the load.Configuration for the
DistributedQueryBus.Configuration enhancer for the
DistributedQueryBus, which upon detection of a QueryBusConnector in
the configuration will decorate the regular QueryBus with the provided
connector.Exception indicating a duplicate
CommandHandler was subscribed.Exception indicating that a duplicate registration of modules has been detected.
Exception indicating a duplicate
QueryHandler was subscribed.Cache implementation that delegates all calls to an EhCache instance.
Represents an empty append transaction.
An
ApplicationContext implementation that does not provide any components.Matches any empty collection.
Exception indicating that a creational command handler was invoked for an entity that already exists.
Interface describing a child
EntityMetamodel that can be handled in the context of its parent.Interface describing the definition of an
EntityChildMetamodel.Functional interface describing a handler of a
CommandMessage for that uses an entity to make a decision.A
CommandHandlingComponent that handles commands for an entity.Annotation that indicates that a method or constructor is a factory method for an event-sourced entity.
Functional interface describing how to evolve a given
entity of type e based on a given
EventMessage.Interface describing a group of
EntityEvolvers belonging to a single entity of type E,
forming an entity that can evolve its state based on the events it receives.Thrown when an
EntityIdResolver was unable to determine an id from
a given payload.Resolver for the id of an entity.
Definition describing how to create an
EntityIdResolver for a given entity type and identifier type.A
TransactionalExecutor implementation for EntityManagers.Provides components with an EntityManager to access the persistence mechanism.
Annotation placed on fields or methods of an entity that should be treated as a child entity.
The messaging metamodel of entity type
E, containing the information needed to handle commands and events.Builder for an
EntityMetamodel instance, allowing the registration of command handlers, an entity evolver,
and child entities.Functional interface used to build an
EntityMetamodel for a specific entity type, based on the provided
Configuration and EntityMetamodelBuilder.Exception thrown by the
is
EventSourcedEntityFactory when the entity returned by
invalid reference
EventSourcedEntityFactory#create(Object, EventMessage)null when calling it with a non-null
firstEventMessage during the EventSourcingRepository.load(Object, ProcessingContext) or
EventSourcingRepository.loadOrCreate(Object, ProcessingContext).Exception thrown by the
is
EventSourcedEntityFactory when the entity returned by
invalid reference
EventSourcedEntityFactory#create(Object, EventMessage)null when calling it with a null
firstEventMessage during the EventSourcingRepository.loadOrCreate(Object, ProcessingContext).Exception indicating that an instance command handler was invoked for an entity that does not exist.
A
UsagePropertyProvider implementation that reads the usage properties from the
environment variables.A functional interface to supply environment variables.
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 caught by an
EventProcessor
while processing a batch of events.Interface of the error handler that will be invoked if event processing fails.
Annotation used to mark an object as an event.
Component that appends events to an
EventSink in the context of a ProcessingContext.ParameterResolverFactory that ensures the EventAppender is resolved in the context of the current
ProcessingContext.Configuration enhancer that registers the
EventAppenderParameterResolverFactory to the
ComponentRegistry of the Configuration.Specification of the mechanism on which the Event Listeners can subscribe for events and event publishers can publish
their events.
A
ConfigurationEnhancer registering the default components for event publishing and event bus.Span factory that creates spans for the
EventBus.A converter specific for
EventMessages, acting on the payload.Coordinates appended events notifications for event storage engines.
Represents a handle to a coordination instance, allowing the engine to notify of new events and to terminate the
coordination.
Describes the criteria for
events.
EventStoreTransaction#source(SourcingCondition) sourcing or
invalid reference
streamingAnnotation to indicate that a method can be used to resolve the
EventCriteria based on the
TargetEntityId when loading an EventSourcedEntity.Describes a singular, non-nested criteria for filtering events.
Interface towards the Event Handling components of an application.
Annotation to be placed on methods that can handle
events, thus making them
EventHandlers.Interface describing a handler of
events.Interface describing a registry of
event handlers.Interface describing a group of
EventHandlers belonging to a single component.Builder interface for configuring collections of
EventHandlingComponent instances.Additional phase for specifying optional event handling components.
Final phase for applying decorations and building the component list.
Phase that allows configuring event handling components.
Initial phase for specifying event handling components.
Interface indicating that a
MessageHandlingMember is capable of handling specific event messages.Interface describing a mechanism that converts Spring Messages from an Axon Event Messages and vice versa.
Auto configuration for event processors.
A configuration module for event processing that provides a unified way to configure and manage both
EventProcessor types:
PooledStreamingEventProcessor
SubscribingEventProcessor
Exception thrown when an
EventProcessor failed to handle a batch of events.An Event Processor processes event messages from an event queue or event bus.
Configuration class to be used for
EventProcessor implementations.Service that listens to
PlatformOutboundInstructions to control
EventProcessors when requested by Axon Server.Allows customizing the
EventProcessorConfiguration.A
MessageMonitor implementation dedicated to EventMessages.A
MessageMonitor implementation dedicated to EventMessages.Builder class to instantiate a
EventProcessorLatencyMonitor.Interface for configuring individual
EventProcessor modules.Configuration phase interface that provides methods for setting up event processor configurations.
Builder phase for configuring event handling components.
Properties describing the settings for Event Processors.
Configuration for the Dead-letter-queue (DLQ).
Configuration for the Dead-Letter-Queue Caching.
The processing modes of an
EventProcessor.Processor settings.
Event processor settings.
Holder class to be able to retrieve a map of those by a single non-parameterized class.
Settings for pooled event processor.
The processing modes of an
EventProcessor.Settings for subscribing event processor.
Span factory that creates spans for the
EventProcessor implementations.Exception indication that an error occurred while publishing an event to an AMQP Broker
Interface describing a condition that the type and tags of event messages must match against in order to be
relevant.
Interface describing the option to publish
events.Annotation that informs Axon's auto configurer for Spring that a given
Component is an event-sourced entity instance.Annotation to configure several aspects of an event-sourced entity.
Defines how an
EventSourcingRepository should construct an entity of type E.Defines how an
EventSourcedEntityFactory should be constructed for an EventSourcedEntity annotated
class.An expansion of the
EntityModule, specifically for event-sourced entities.Phase of the module's building process in which a
ComponentBuilder for a CriteriaResolver should
be provided.Phase of the module's building process in which a
ComponentBuilder for an
EventSourcedEntityFactory should be provided.Phase of the module's building process in which a
ComponentBuilder for an EntityIdResolver should
be provided.Phase of the module's building process in which the user should define the messaging metamodel for the
event-sourced entity being built.
A
ConfigurationEnhancer registering the default components of the EventSourcingConfigurer.The event sourcing
ApplicationConfigurer of Axon Framework's configuration API.Annotation that marks a method in: - an Aggregate (either the root, or an entity) as a handler for Events generated
by that aggregate. - a State model needed for
CommandHandler as
a handler for Events sourced in order to handle given CommandMessage.Repository implementation that loads entities based on their historic event streams, provided by an
EventStore.Interface for providing storage engines for the
StorageEngineBackedEventStore.Interface representing the transaction of an appendEvents invocation.
Infrastructure component providing the means to start an
EventStoreTransaction to
append events and
event source models from the underlying storage solution.Indicates that the given events stream could not be stored or read due to an underlying exception.
Interface describing the actions that can be taken on a transaction to source a model from the
EventStore
based on the resulting MessageStream.Field or method level annotation that marks a field or method providing the Tag for the Event.
Container annotation for repeatable
EventTag annotation.Functional interface that determines if a given entity should be targeted for a specific
EventMessage.Defines how a
EventTargetMatcher should be constructed for an EntityMember-annotated member of an
AnnotatedEntityMetamodel.Interface describing the status of a
Segment of a StreamingEventProcessor.Represent a listener that is notified whenever the
Map of EventTrackerStatus' in the StreamingEventProcessor this component is registered to has changed.An
EventCriteria that can be restricted to a specific set of event types.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.Utility class used to serializer
Throwables into ErrorMessages.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.
A Functional Interface towards a
BiFunction which ingests both a Configuration and a BlockingQueue of
Runnable, and outputs an ExecutorService.A RetryScheduler that uses a backoff strategy, doubling the retry delay after each attempt.
A
SequencingPolicy implementation that extracts the sequence identifier from the event message payload based
on a given property extractor.An implementation of the
EntityManagerProvider that returns a new EntityManager instance
each time using the EntityManagerFactory.Implementation of
SequencingPolicy that provides exception-based fallback behavior.A
ChildEntityFieldDefinition that uses a field to access the child entity.The FieldFilter indicates whether any given Field should be accepted for processing or not.
A
ComponentDescriptor implementation inspired by filesystem structures.A RetryPolicy that delegates to another RetryPolicy when the latest exception matches a given predicate.
ParameterResolver implementation that injects a fixed value.
Exception indicating that an error occurred that prevented successful execution of a test fixture.
ParameterResolverFactory implementation for use in test cases that prevent that all declared resources on message
handlers need to be configured.
Utility methods to work with Project Reactor's
fluxes.SequencingPolicy that does not enforce any sequencing requirements on event processing.
A
CommandResult that wraps a completable future providing the Message that represents the result.Utility class containing reusable functionality for interacting with the
CompletableFuture.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.Generic implementation of the
CommandMessage interface.Generic implementation of the
CommandResultMessage interface.Generic implementation of the
EventMessage interface.Generic implementation of the
QueryMessage interface.Generic implementation of the
QueryResponseMessage interface.A
ContentTypeConverter implementation that converts an Avro GenericRecord into a
single-object-encoded byte[].Generic implementation of the
ResetContext interface.Generic implementation of
ResultMessage interface.Generic implementation of the
SubscriptionQueryUpdateMessage interface holding incremental update of a
subscription query.Jdbc token entry table factory compatible with most databases.
Implementation of
ChildEntityFieldDefinition that uses a getter and an evolver to get the child entities from
the parent, and to evolve the parent based on the child entities.Implementation of
ChildEntityFieldDefinition that uses a getter and a setter to get the child entities from
the parent, and to set the evolved child entities on the parent entity.ConsistencyMarker implementation that uses a single `long` to represent a position in an event stream.An immutable implementation of
Position which represents positions
with an index in the global event stream.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.
Converts GRPC Exceptions to
RuntimeExceptions.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.
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.
A registry of
MessageHandlerInterceptors, acting as a collection of
registered
MessageHandlerInterceptors components.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.Utility class holding additional
Status instances.The HierarchicalConfiguration is a configuration that will ensure the to-be-built child configuration will be passed
a
LifecycleRegistry that is a child of the parent configuration's LifecycleRegistry.Implementation of
MessageTypeResolver that combines two resolvers in a fallback pattern.ParameterResolverFactory that first tries to resolve a parameter using the child factory.ConfigurationEnhancer that registers a decorator for the ParameterResolverFactory that, when a parent
configuration is present, wraps both the parent and the current ParameterResolverFactory in a
HierarchicalParameterResolverFactory that delegates to the parent if a parameter cannot be resolved by the
current configuration.Implementation of
SequencingPolicy that combines two policies in a fallback pattern.StateManager that can load an entity from two delegates, giving preference to the child delegate and then the
parent.ConfigurationEnhancer that registers a decorator for the StateManager that, when a parent
configuration is present, wraps child and parent StateManager in a HierarchicalStateManager that
delegates to the parent if a state cannot be resolved by the current configuration.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.
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.
Infrastructure autoconfiguration class for Axon Framework application.
Annotation to be placed on a parameter of a
MessageHandler annotated method that should receive an entity
loaded from the StateManager.Indicates that the annotated parameter should be injected with the entity identifier of the
EntityCreator-annotated method or constructor being invoked.ParameterResolverFactory implementation that provides ParameterResolvers for
parameters annotated with InjectEntity.ConfigurationEnhancer that registers the InjectEntityParameterResolverFactory to the
ComponentRegistry.Thread-safe
EventStorageEngine implementation storing events in memory.In-memory implementation of the
Repository interface that stores entities in a ConcurrentHashMap.Implementation of a
TokenStore that stores tracking tokens in memory.Implementation of
Component and ComponentDefinition that wraps a pre-instantiated component.Responsible for sending instruction acknowledgements.
Decorator around the
EventBus interceptors all events before they are
published with dispatch interceptors.An
EventHandlingComponent implementation that supports intercepting event handling through
MessageHandlerInterceptors.Decorator around the
EventSink intercepting all events before they are
published with dispatch interceptors.Decorator around the
EventStore intercepting all events before they are
appended or
published with dispatch interceptors.Interceptor autoconfiguration class for Axon Framework application.
Parameter resolver factory that adds support for resolving current
MessageHandlerInterceptorChain.Marker annotation used to mark Axon Framework internal code.
Utility methods for IO operations.
A
ComponentDescriptor implementation that uses Jackson's ObjectMapper to create JSON representations
of components.A
Converter implementation that uses Jackson's ObjectMapper to convert
objects into and from a JSON format.Cache adapter implementation that allows providers implementing the JCache abstraction to be used.
Exception indicating an error occurred while interacting with a JDBC resource.
Jdbc class of an entry containing a serialized tracking token belonging to a given process.
A
TokenStore implementation that uses JDBC to save and load TrackingToken instances.Configuration for the
JdbcTokenStore.A
TransactionalExecutorProvider implementation for JDBC Connections which
provides a TransactionalExecutor.Autoconfiguration class that registers a bean creation method for the
SpringTransactionManager if a
PlatformTransactionManager and a DataSource is present.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.Autoconfiguration class for Axon's JPA specific infrastructure components.
Properties describing configuration of Aggregate-based JPA Event Storage engine.
Autoconfiguration class for Axon's JPA specific event store engine.
Enhancer for registration of a bean definition creating a JPA Storage Engine.
An
EventCoordinator implementation that polls a JPA-managed event table
to detect newly appended events.Implementation of a token store that uses JPA to save and load tokens.
Configuration for the
JpaTokenStore.A
TransactionalExecutorProvider implementation for JPA EntityManagers which
provides a TransactionalExecutor.Autoconfiguration class that registers a bean creation method for the
SpringTransactionManager if a
PlatformTransactionManager and a EntityManagerFactory is present.Exception indicating that a
Message has been refused due to a structural
validation failure.Utility class to retrieve the current Kotlin version at runtime.
Implementation of
Component and ComponentDefinition that instantiates a component using a configured
builder.Deprecated.
Only in use for legacy "sync" components.
Utility class to obtain resources used in previous versions of Axon Framework.
Functional interface towards a lifecycle handler used during start up or shutdown of an application.
Exception indicating a failure occurred during a lifecycle handler method invocation.
Interface describing the configuration of start and shutdown handlers within Axon's configuration.
An
EntityChildMetamodel that handles commands and events for a list of child entities.Builder for creating a
ListEntityChildMetamodel for the given parent class and child entity
metamodel.EntityChildModelDefinition for creating EntityChildMetamodel instances for child entities
that are represented as a List.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.Exception thrown by the
StateManager when the loaded entity from the Repository is not
assignable to the expected type.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.
A
MessageDispatchInterceptor and MessageHandlerInterceptor implementation that logs dispatched and
incoming messages, and their result, to a Logger.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.
A wrapper around an entity whose lifecycle is being managed by an
Repository.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.Artifact version resolver that uses Maven metadata to retrieve the jar version.
A retry policy that caps another policy to maximum number of retries
Functional interface returning the maximum amount of segments a
Coordinator may claim, based on the given
processorName.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.
Meta-annotation used to have a common grounds for the
Message.name() and Message.version() for more specific
Message annotation.A
MessageDispatchInterceptor that adds the {$code username} and {$code authorities} from the authorized
principle.A
MessageHandlerInterceptor that verifies authorization based on Secured annotations on the payload
of Messages.A converter specific for
Messages, acting on the payload.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.Annotation indicating that a member method should be able to respond to
Messages.Marker interface for a handlers or components of
messages.An implementation of a
ConfigurationEnhancer 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 a handler method as an interceptor handler.
Workflow interface that allows for customized message handler invocation chains.
An interceptor chain that manages the flow of a
Message of type M through a chain of
interceptors, and ultimately to a message handler.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.
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.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
A registry of
MessageMonitors, acting as a collection of
registered
MessageMonitor components.MessageMonitorReport is responsible for maintaining a list of reports detailing the processing status of messages.
Represents a report that provides details about the processing of a message.
Represents a failure report indicating an error occurred during the processing of a message.
Represents an ignored report, indicating that the processing of a message was bypassed or not handled.
Represents a successful report indicating that a message has been processed successfully.
A
CorrelationDataProvider implementation that provides the identifier of a
Message to other Messages that are created as result of processing the given message.ConfigurationEnhancer that registers
RecordingEventStore, RecordingEventSink and
RecordingCommandBus.A
MessageStream implementation that completes normally or with an error without returning any elements.A
MessageStream-specific container of Message implementations.A
MessageStream implementation that returns at most a single result before completing.Utility class that can resolve the result of any
MessageHandler
into the expected corresponding MessageStream.Utility methods to work with
MessageStreams.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.Record combining a
qualified name and version.Exception thrown when a
MessageTypeResolver is unable to determine the MessageType for a given
payload type.Functional interface describing a resolver from
Message payload to it's
type.Adds the message type (simple class name) to the Span.
A
ConfigurationEnhancer registering the default components of the MessagingConfigurer.The messaging
ApplicationConfigurer of Axon Framework's configuration API.Represents metadata that is passed along with a payload in a
Message.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.Utility class to convert between Axon Server metadata values and a simple
Map of String key-value pairs.A
RoutingStrategy implementation that uses the value in the Metadata of a
CommandMessage assigned to a given key.A
SequencingPolicy implementation that extracts the sequence identifier from the EventMessage's
Metadata, based on a given metadataKey.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 used for CommandHandler annotated methods to wrap a
MessageHandlingMember in a CommandHandlingMember instance.Implementation of a
HandlerEnhancerDefinition used for EventHandler annotated methods to wrap a
MessageHandlingMember in a EventHandlingMember instance.Implementation of a
MessageHandlingMember that is used to invoke message handler methods on the target type.Implementation of a
HandlerEnhancerDefinition used for QueryHandler annotated methods to wrap a
MessageHandlingMember in a QueryHandlingMember instance.Definition of
event handlers that are annotated with SequencingPolicy.Implementation of the
ConfigurationEnhancer which uses the GlobalMetricRegistry to register several
Metrics Modules to the given ComponentRegistry.Implementation of the
ConfigurationEnhancer which uses the GlobalMetricRegistry to register several
Metrics Modules to the given ComponentRegistry.Properties describing the settings for Metrics.
Auto configuration specific properties around Metrics.
Exception thrown by the
StateManager when no Repository is registered for a given state type.A
ConfigurationEnhancer registering the default components of the ModellingConfigurer.The modelling
ApplicationConfigurer of Axon Framework's configuration API, providing registration methods to,
for example, register a CommandHandlingModule.Interface describing a module of Axon Framework's configuration API.
Functional interface describing how to build a
Module of type M.A
MessageHandlerInterceptor for CommandMessage that intercepts the
MessageHandlerInterceptorChain to register the
MessageMonitor.MonitorCallback functions on the ProcessingContext hooks.A
MessageDispatchInterceptor that intercepts a MessageDispatchInterceptorChain of
EventMessage and registers the MessageMonitor.MonitorCallback hooks for reporting.A
MessageDispatchInterceptor that intercepts a MessageDispatchInterceptorChain of
EventMessage and registers the MessageMonitor.MonitorCallback hooks for reporting.A
MessageHandlerInterceptor for QueryMessage that intercepts the
MessageHandlerInterceptorChain to register the MessageMonitor.MonitorCallback functions on the
ProcessingContext hooks.A
MessageDispatchInterceptor that intercepts a MessageDispatchInterceptorChain of
SubscriptionQueryUpdateMessage and registers the MessageMonitor.MonitorCallback hooks for
reporting.Utility methods to work with Project Reactor's
monos.A
CorrelationDataProvider that combines the data of multiple other correlation providers.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.
Implementation of a
SpanFactory that delegates calls to multiple other factories.TagResolver that combines the results of multiple other tag resolvers.Implementation of the
MessageTypeResolver that maintains a mapping of payload types to their corresponding
MessageTypes.Builder interface for constructing a
NamespaceMessageTypeResolver.Cache implementation that does absolutely nothing.
Exception indicating that no suitable command handler could be found for the given command.
Exception thrown whenever an
EventHandlingComponent is given an EventMessage for which it does not
have a
invalid reference
subscribedEventHandler.Exception indicating this instance has no
QueryHandler for a given QueryMessage.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.
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.Autoconfiguration class that registers a bean creation method for a default
TransactionManager, the
NoTransactionManager.A
TransactionManager implementation that does nothing.LockFactory implementation that does nothing.
Matcher that matches against a
null or void value.Autoconfiguration that constructs a default
ObjectMapper, typically to be used by a
JacksonConverter.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.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.Jdbc token entry table factory for Oracle databases.
Utility class with some specific hacks required to get certain features to work with Oracle v11.
Builder class to construct an
EventCriteria that will match the to-be-built criteria and the already existing
criteria.Adapter class that sends Events from an event bus to a Spring Messaging Message Channel.
Enumeration describing how a
ComponentRegistry should react when a Component is to be overridden
during a ComponentRegistry.registerComponent(ComponentDefinition) invocation.Interface for a mechanism that resolves handler method parameter values from a given
ProcessingContext.Interface for objects capable of creating Parameter Resolver instances for annotated handler methods.
Utility class that provides methods to register a
ParameterResolverFactory to the ComponentRegistry.A
Converter implementation that only "passes through" input object if the sourceType and
targetType are the identical.An
EntityEvolver implementation that converts the Message.payload() to the given
payloadType to evolve an entity with.Simple implementation of the
TagResolver that is able to combine several lambdas to construct
Tags from payloads of type P.Connector implementation that converts the payload of outgoing messages into the expected format.
Connector implementation that converts the payload of outgoing messages into the expected format.
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.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 that can be used as input when registering
ComponentDefinitions with
start and/or
shutdown handlers.Polymorphic
EntityMetamodel that represents an entity that can have multiple concrete types.Builder for a polymorphic
EntityMetamodel, where a parent entity can have multiple concrete child
entities.A
StreamingEventProcessor implementation which pools its resources to enhance processing speed.Configuration class for a
PooledStreamingEventProcessor.A configuration module for configuring and registering a single
PooledStreamingEventProcessor component.Allows customizing the
PooledStreamingEventProcessorConfiguration.A configurer for managing multiple
PooledStreamingEventProcessor instances within an application.Represents a position from which sourcing may start.
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.Implementation of the
ProcessingLifecycle adding mutable resource management operations by
implementing Context.Component that publishes events to an
EventSink in the context of a ProcessingContext.ParameterResolverFactory implementation that provides a ParameterResolver for parameters of type
ProcessingContext.Utility class contain helper methods to extract information from
ProcessingInstructions.Interface dedicate to managing the lifecycle of any process.
Default phases used for the shorthand methods in the
ProcessingLifecycle.Functional interface describing an operation that's invoked when an error is detected within the
ProcessingLifecycle.Interface describing a possible phase for the
ProcessingLifecycle to perform steps in.Defines the configuration for an event processor, including which event handlers it should process and how it should
be configured.
Describes an event handler component that can be assigned to an event processor.
Final step in the processor definition fluent API for configuring the processor settings.
The second step in the processor definition fluent API for selecting which event handlers should be assigned to
the processor.
Internal class for managing multiple
EventHandlingComponent instances and processing event messages through
them.Factory for building
EventProcessorModules from a set of discovered event handler components.Exception indicating that an action was retried a maximum times, without a good result.
Processing utilities.
An
ErrorHandler implementation that rethrows the ErrorContext exception.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.
Implementation of a
EntityIdResolver that inspects the payload of a Message for an identifier.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.Interface describing a qualified
qualifiedName, providing space for a namespace,
local qualifiedName.Annotation used to mark an object as a query.
The mechanism that dispatches
queries to their appropriate query handler.The
QueryBusConnector interface defines the contract for connecting multiple
QueryBus instances.Defines a handler for processing query messages and managing subscription queries.
Defines a callback mechanism to handle update messages for subscription queries
in a reactive and asynchronous manner.
Span factory that creates spans for the
QueryBus.Utility class to convert queries during
dispatching and handling of
subscribed query
handlers in the AxonServerQueryBusConnector.Exception indicating that the execution of a Query Handler has resulted in an exception.
Interface towards the Query Handling components of an application.
Annotation to be placed on methods that can handle
queries, thus making them
QueryHandlers.Interface describing a handler of
queries.Interface describing a registry of
query handlers.Interface describing a group of
QueryHandlers belonging to a single component.Interface indicating that a
MessageHandlingMember is capable of handling specific
QueryMessages.A
Module and ModuleBuilder implementation providing operation to construct a query handling
application module.The query handler configuration phase of the query handling module.
The setup phase of the query handling module.
A
Message type that carries a Query: a request for information.Calculate the priority of
QueryMessage based on its content.Annotation used to mark an object as a query response.
A
ResultMessage implementation that contains the result of query handling.Query-specific component that interacts with
subscription queries about
update, errors,
and when there are no more update.ParameterResolverFactory that ensures the QueryUpdateEmitter is resolved in the context of the
current ProcessingContext.Span factory that creates spans for the
QueryUpdateEmitter.A specialized implementation of
AbstractQueryResponseMessageStream that processes a stream of
QueryUpdate objects and transforms them into QueryResponseMessage instances.MessageStream implementation that uses a Queue to make elements available to a consumer.
An CommandBus implementation recording all the commands that are dispatched.
CommandBus implementation that does not perform any actions on subscriptions or dispatched commands, but records them
instead.
An
EventStore implementation recording all the events that are
published.A message monitor implementation that records the processing results of messages in the provided
MessageMonitorReport instances.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.
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 for the storage of entities.Specialization of the
Repository interface that must be implemented by all implementations of
the Repository.Exception thrown by the
StateManager when trying to register an Repository for a combination of
entity type and id type for which a repository was already registered.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.
A
ProcessingContext implementation overriding a single resource from the wrapping ProcessingContext.Meta-Annotation used to demarcate
MessageHandlerInterceptor annotated methods as interceptors that should
only act on the result of a handler invocation.A
Message that represents a result of handling some form of a request message.ParameterResolverFactory that provides support for Parameters where the result of Handler execution is expected to be
injected.
A
CommandBus wrapper that will retry dispatching commands that resulted in a failure.Describes a policy for retrying failed messages.
The outcome of applying a
RetryPolicy to a given message.Interface towards a mechanism that decides whether to schedule a message for dispatching when a previous attempts
failed.
Represents the logic to dispatch a message and attempt to retrieve the result
Deprecated.
Use attributes of
} annotation to specify the routing key instead.
invalid @link
{@link @CommandHandler
EventTargetMatcher implementation that matches based on the routing key.Definition for creating
CommandTargetResolver instances based on the routing key definitions.EventTargetMatcher implementation that matches based on the routing key.Definition for creating
EventTargetMatcher instances based on the routing key definitions.Utility class for retrieving routing keys from entity members and child entities.
Interface describing a mechanism that generates a routing key for a given command.
Schedules tasks to be executed in future.
Provides functionality for incompatibility checks.
Enumeration stating on what levels to search for a
Component within the ComponentRegistry.MessageHandlerDefinition that verifies authorization based on
Secured annotation on the message handler.Autoconfiguration class that registers a bean creation method for the
SecuredMessageHandlerDefinition.A representation of a segment and corresponding mask with various capabilities.
Decorator for
EventHandlingComponent.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
Decorator implementation of
EventHandlingComponent that uses a configurable SequencingPolicy to
determine the sequence identifier for events, while delegating all other operations to an underlying
EventHandlingComponent.An
EventHandlingComponent wrapper that ensures events with the same sequence identifier are handled
sequentially.Annotation to specify a sequencing policy for event handling methods or classes.
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.
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.A simple implementation of the
CommandHandlingComponent interface, allowing for easy registration of
CommandHandlers and other CommandHandlingComponents.Implementation of the
Context providing a basic implementation for context-specific resource management.A
key
names.
CorrelationDataProvider implementation that defines correlation data by the
invalid reference
Message#metaData()Implementation of
EntityEvolvingComponent that evolves a given entity of type E
by searching a specific EntityEvolver based on the QualifiedName in the
event's type.Simple implementation of the EntityManagerProvider that returns the EntityManager instance provided at construction
time.
Simple implementation of the
MessageStream.Entry containing a single Message implementation of type M and a
Context.Simple implementation of the
EventBus that provides synchronous event publication with optional
ProcessingContext integration for transactional event handling.Simple implementation of the
EventHandlingComponent, containing a collection of
EventHandlers to invoke on SimpleEventHandlingComponent.handle(EventMessage, ProcessingContext).Simple implementation of the
HandlerAttributes which is given the attributes in the constructor.Implementation of the
QueryBus that dispatches queries (through
SimpleQueryBus.query(QueryMessage, ProcessingContext) or
SimpleQueryBus.subscriptionQuery(QueryMessage, ProcessingContext, int)) to the
QueryHandlers subscribed to that specific query's name and
response type combination.A simple implementation of the
QueryHandlingComponent interface, allowing for easy registration of
QueryHandlers and other QueryHandlingComponents.Simple implementation of the
QueryUpdateEmitter, delegating operations to a QueryBus for emitting
update, completing subscription queries, and completing subscription queries exceptionally.Simple implementation of an
Repository that can load and persist entities of a given type.Functional interface describing a component capable of loading an entity with the given identifier for the
SimpleRepository.Functional interface describing a component capable of persisting an entity with given identifier for the
SimpleRepository.A
ParameterResolverFactory implementation for simple resource injections.Simple implementation of the
StateManager.Factory for creating simple
UnitOfWork instances.An
EntityChildMetamodel that handles commands and events for a single child entity.Builder for creating a
SingleEntityChildMetamodel for the given parent class and child entity metamodel.EntityChildModelDefinition that creates EntityChildMetamodel instances for child entities that are
represented as a single entity (not iterable).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).Annotation indication that a parameter on a Message Handler method should be injected with the aggregate identifier
of a DomainEventMessage.
Interface describing the condition to
source events from an
Event Store.A
MessageStream implementation backed by a ResultStream of
SourceEventsResponses from Axon Server, translating the SourceEventsResponses
into EventMessages as it moves along.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 strategy responsible for operations on
SpecificRecordBase as a superclass of all objects you are
working on.ParameterResolverFactory implementation that resolves parameters using Spring dependency resolution.
ParameterResolverFactory implementation that resolves parameters in the Spring Application Context.
A
ComponentRegistry implementation that connects into Spring's ecosystem by means of being a
BeanPostProcessor, BeanFactoryPostProcessor, and InitializingBean.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.
A
ConfigurationEnhancer 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.A
LifecycleRegistry implementation that registers all lifecycle handlers as Spring
SmartLifecycle beans to ensure Spring weaves these lifecycles into the other
Spring bean lifecycles.A
SmartLifecycle implementation wrapping a
shutdown-specific lifecycle handler to allow it to be
managed by Spring.A
SmartLifecycle implementation wrapping a
start-specific lifecycle handler to allow it to be managed
by Spring.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.
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.
SQLStateResolver is an implementation of PersistenceExceptionResolver used to resolve sql state values to see if it
violates a unique key constraint.
An expansion on the
EntityModule, specifically for state-based entities.The "entity ID resolver" phase of the state-based entity builder.
The "messaging metamodel" phase of the state-based entity builder.
The "persister" phase of the state-based entity builder.
The repository phase of the state-based entity builder.
Exception thrown when an error occurs while evolving an entity with an event.
The
StateManager enables applications to load entities based on the type of the entity and an id, and to
persist them.An
EventStore implementation which uses an EventStorageEngine as its storage solution.Interface towards a streamable event source.
Interface describing the condition to
from a streamable
event source (like an Event Store).
invalid reference
streamA
MessageStream implementation backed by a ResultStream of
StreamEventsResponses from Axon Server, translating the StreamEventsResponses
into EventMessages as it moves along.An
EventProcessor which processes an event stream in segments.An
Spliterators.AbstractSpliterator implementation used internally to feed a Stream
through the StreamSupport.stream(Spliterator, boolean) operation.Utility methods for when dealing with
Strings.Interface for a source of
EventMessages to which event processors can subscribe.Definition for a
SubscribableEventSource.Event processor implementation that
subscribes to the EventBus for
events.Configuration class for a
SubscribingEventProcessor.A configuration module for configuring and registering a single
SubscribingEventProcessor component.Allows customizing the
SubscribingEventProcessorConfiguration.A configurer for managing multiple
SubscribingEventProcessor instances within an application.Exception thrown whenever
.
QueryBus.subscriptionQuery(SubscriptionQueryMessage, ProcessingContext, int) is
invoked multiple times for the same
invalid reference
SubscriptionQueryMessageA
ResultMessage implementation that holds incremental update of a subscription query.An
Tag refers to fields and their values within which an EventMessage
has been published, typically referring to domain-specifics used for identification.Wrapper around the Axon Framework
EventConverter that can convert
TaggedEventMessages (Axon Framework representation) to TaggedEvents
(Axon Server representation).A wrapper of an
EventMessage and its Tags.Tags configuration labeling Axon Node represented by key-value pairs.
Spring Configuration properties for
TagsConfiguration.Utility class for micrometer tag management.
Interface towards a mechanism that is capable of resolving the context name to which a
Message should be
routed.Annotation to be placed on a parameter of a field or method of the payload of a
Message, which provides the identifier of the target entity when using the
AnnotationBasedEntityIdResolver.Exception indicating that while using the
PropertyBasedEntityIdResolver the indicated field could not be
found.Configuration properties for a task timeout.
Empty
EventMessage implementation without any payload, used as the
terminal message of a MessageStream.This class detects whether the usage reporter is being used in a unit test environment, such as a JUnit test or
another testing framework.
Functional interface for operations which may throw a checked exception.
Functional interface for operations which may throw a checked exception.
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.
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 a 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.
Exception indicating that an Event could not be appended to the event store because it contains more tags than the
storage engine can support.
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.A
CommandBus wrapper that adds tracing for outgoing and incoming commands.An
EventHandlingComponent that tracks the handling of events using a Span supplier.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.Implementation of the
EventTrackerStatus, providing simply modification methods to switch from one
EventTrackerStatus value object to another.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 from the
ProcessingContext whenever it's available.Provides functionality to retrieve
TrackingTokens for the head and tail of the stream, and at a
given point in time in the stream.Interface of an object that represents a started transaction that can be committed or rolled back.
Executes transactional operations with automatic transaction management.
Provider of
TransactionalExecutors.Factory for creating
UnitOfWork instances that are bound to a transaction.Interface towards a mechanism that manages transactions
Wrapper for exceptions that occurred while calling an @BeforeTransaction or @AfterTransaction annotated method.
Represents a reference to a type of component, allowing for generic types to be specified without casting errors.
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 task.
Configuration used for the
UnitOfWork creation in the UnitOfWorkFactory.Factory for creating
UnitOfWork instances.Message handler interceptor that sets a timeout on the processing of the current
ProcessingContext.Exception indicating that a child entity indicated a routing key that is not known on the incoming message.
Set of simple
RoutingStrategy implementations.Thrown when an
MessageHandler annotated method was found that does not conform to the rules that apply to
those methods.The UpdateChecker reports Anonymous usage data to AxonIQ periodically.
Autoconfiguration class constructing the
UsagePropertyProvider that will end up in the
UpdateChecker.A
ConfigurationEnhancer that registers the UpdateChecker component.Client for checking for update and sending anonymous usage data to the AxonIQ servers.
An
UsagePropertyProvider implementation that reacts to Spring Boot properties through the
ConfigurationProperties annotation.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.
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.
Cache implementation that keeps values in the cache until the garbage collector has removed them.
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 indicating that the
PolymorphicEntityMetamodel for a given class cannot handle a command
because it is of the wrong type.