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 implementation of the
DeadlineManager to be implemented by concrete solutions for the
DeadlineManager.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 base implementation of
MessageStream that provides full state management for
consumption, completion, error propagation, closing, and callback coordination.Represents the result of attempting to fetch the next element from a
MessageStream.A
AbstractMessageStream.FetchResult indicating that the stream is exhausted and no further elements will be produced.A
AbstractMessageStream.FetchResult representing a terminal error in the stream.A
AbstractMessageStream.FetchResult indicating that no element is currently available, but the stream may produce more
elements in the future.A
AbstractMessageStream.FetchResult containing a successfully fetched value.Abstract implementation of the PropertyAccessStrategy that uses a no-arg, public method to access the property
value.
Abstract implementation for Mongo templates.
Abstract Builder class to instantiate a
AbstractMongoTemplate.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.Abstract implementation of the SagaManager interface that provides basic functionality required by most SagaManager
implementations.
Abstract Builder class to instantiate
AbstractSagaManager implementations.Abstract class for step executor implementations.
Base class for author-facing
WorkflowContext implementations.Abstract test base for workflow test, until we develop a test fixture.
Passes the aggregate scope explicitly to the
DeadlineManager calls of an Axon Framework 4 aggregate that
relied on the scope of the running handler.What the scanning phase learns about the source classes.
Adds
@AfterEach void tearDown() { <fixture>.stop(); } to test
classes that declare a field of type AxonTestFixture but have
no existing @AfterEach (and no method already named
tearDown).Scans for methods annotated with
@CommandHandler and annotates their command parameter
types with @Command.References a new
EventTrackerStatus which work just has started on.Adds the
@EntityCreator annotation to existing no-arg constructors of classes annotated with either
@EventSourcedEntity (free AF5) or the Spring stereotype @EventSourced.Scans for methods annotated with
@EventSourcingHandler and annotates their event payload
types with @Event.Adds
@EventTag(key = "<EntitySimpleName>") to the aggregate-identifier field of every
event class used in @EventSourcingHandler methods.Maps event-class FQN -> scan result needed to place
@EventTag.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.
Axon Server implementation of the
TenantEventStorageEngineFactory, building one
AggregateBasedAxonServerEventStorageEngine per tenant against that tenant's Axon Server context.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.Translates a fired
DeadlineMessage scoped to an AggregateScopeDescriptor into a command, dispatched
through a CommandGateway.A
ConfigurationEnhancer that builds the configuration's AggregateDeadlineCommandTranslator, and
registers it with the configuration's LegacyScopeAwareProvider, the same way a Saga manager registers
itself.ConfigurationEnhancer registering AggregateDeadlineEntityIdResolverDefinition as the application-wide
EntityIdResolverDefinition default.An
EntityIdResolverDefinition resolving an entity's identifier from a command's @TargetEntityId
payload field when present, falling back to the AggregateDeadlineEntityIdResolverDefinition.DESCRIPTOR_BASED_ID metadata entry
AggregateDeadlineCommandTranslator writes onto every command it dispatches.A JPA entry dedicated for storing
EventMessages in the
AggregateBasedJpaEventStorageEngine.Adds the aggregate identifier to the span when one is available on the
ProcessingContext via
LegacyResources.AGGREGATE_IDENTIFIER_KEY.Describes the scope of an Aggregate by means of its type and identifier.
An implementation of
Position based on aggregate sequence numbers.Annotation indication that a parameter on a Message Handler method should be injected with the
aggregate type of a
org.axonframework.eventhandling.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 from the
ProcessingContext if present.FieldFilter implementation that accepts all Fields.
Guard combinator that succeeds when all completed results match the predicate.
Default implementation of
AllMatchCombinator.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.Deprecated.
Deprecated.
Performing the payload conversion inside the resolver ties it to the
AnnotatedEntityMetamodel,
which prevents the EntityMetamodel component from being decorated or replaced.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
interface that allows for a POJO instance with annotated message handlers to act
as a Saga.Implementation of the SagaManager that uses annotations on the Sagas to describe the lifecycle management.
Builder class to instantiate a
AnnotatedSagaManager.SagaRepository implementation extending from the LockingSagaRepository dealing with annotated Sagas.Builder class to instantiate a
AnnotatedSagaRepository.HandlerDefinition recognizing Workflow-annotated methods, building a
MethodInvokingMessageHandlingMember for each.HandlerDefinition recognizing WorkflowStatusChangedHandler-annotated methods, building a
MethodInvokingMessageHandlingMember for each.Spring-Boot-only advisory recipe for the AF4 to AF5 sequencing-policy migration.
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.NullabilityResolver reporting a parameter as Nullability.NULLABLE when it carries an annotation
whose simple name is Nullable, regardless of which library declares it.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 configurable annotations 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.Default implementation of a
SagaMetaModelFactory.Utility class for locating annotation and attribute values on elements.
Combinator that resolves when the first completed result matches a given predicate.
Default implementation of
AnyMatchCombinator.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.
Interface for handling failures in assertions.
Failure handler that throws an
AssertionError.Failure handler that throws an
WorkflowTestFixtureException.Used to derive the value of an association property as designated by the association property name.
Immutable value object representing one or more association constraints used to correlate incoming events with a
waiting workflow step.
Encapsulates the value matcher containing of operator and the value.
A combination of key and value by which a Saga can be found.
JPA wrapper around an Association Value.
Interface describing a container of
Association Values for a single saga instance.Default implementation of the AssociationValues interface.
RetryScheduler implementation that schedules retries on a
ScheduledExecutorService based on a given
policy.A
MessageDispatchInterceptor that attaches the tenant of the dispatching ProcessingContext onto a
dispatched command or query, so it stays attributable to that tenant once it crosses a distributed command or
query bus and arrives in a fresh ProcessingContext on the receiving side.Utilities for workflow auto-detection.
Method with workflow attributes.
Converter providing support for Apache Avro, using
Single Object Encoded binary
encoding.
Autoconfigures the
AvroConverter, if configured via the ConverterProperties.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.
Unwraps Axon Framework 4
ResponseTypes wrappers on AF5-shape (typed-payload, two-argument)
J.MethodInvocation calls against QueryGateway.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.
JUnit 5 extension to manage the lifecycle of an
AxonTestFixture instance provided by a test class.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.
Configuration properties for a named persistent stream event source.
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 and SnapshotStore 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.ConfigurationEnhancer registering the default Axon Server-backed multi-tenancy components:
the TenantProvider which is responsible for managing tenants and lifecycle, backed by AxonServerTenantProvider
the MultiTenantAxonServerCommandBusConnector which fans out commands to a connector per tenant
the MultiTenantEventStorageEngine as the EventStorageEngine, routing appends and sourcing to
each tenant's own engine, and the MultiTenantSnapshotStore as the SnapshotStore, routing snapshot
writes the same way
the TenantEventStorageEngineFactory and TenantSnapshotStoreFactory building those per-tenant
components against the tenant's Axon Server context
the MultiTenantAxonServerQueryBusConnector which fans out queries to a connector per tenant
It also disables the SnapshotSourcingConfigurationEnhancer, since snapshot sourcing is composed per tenant by
the routing engine rather than once for the application.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.
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.
An Axon Server based implementation of
SnapshotStore.A
SimpleStatusAggregator implementation determining the overall health of an Axon Framework application using
Axon Server.A
TenantConnectPredicate that always receives contexts from the Axon Server and returns true, unless
it is the AxonServerConfiguration.ADMIN_CONTEXT.Axon Server implementation of the
TenantEventStorageEngineFactory, building one EventStorageEngine
per tenant against that tenant's Axon Server context.Axon Server implementation of the
TenantProvider.Axon Server implementation of the
TenantSnapshotStoreFactory, building one SnapshotStore per
tenant against that tenant's Axon Server context.ConnectionDetailsFactory class that recognizes TestContainer instances running Axon Server.
Event published after initialization of Axon through the Spring event mechanism.
Utility constructing a
ScheduledExecutorService and providing Logger instances for the
AxonTimeLimitedTask.Fixture for testing Axon Framework application.
Allow customizing the fixture setup, by
enabling it as an integration test or by
including AxonTestFixture.Customization.fieldFilters().Functional interface to supply an
AxonTestFixture instance.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.
Translates
TimeoutProperties into the HandlerTimeoutConfiguration and
TimeoutUnitOfWorkFactoryConfiguration components that drive the timeout behavior.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.
Strategy for computing delay between retry attempts.
Exception thrown when an association string is in the wrong format or uses unsupported operators.
Exception thrown when the workflow configuration is invalid.
Base implementation for custom modules that contains the ComponentRegistry required to register components, enhancers
and (sub)modules.
Base Java DSL entry point for defining workflow steps.
Factory that creates
BaseWorkflowContext instances for Java DSL
workflows.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 for Jackson 3 that converts byte[] containing UTF8 encoded JSON
string to a JsonNode.A
ContentTypeConverter implementation for Jackson 2 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.
Saga Repository implementation that adds caching behavior to the repository it wraps.
Builder class to instantiate a
CachingSagaStore.A decorator for
SequencedDeadLetterQueue that adds per-segment caching of sequence identifiers to optimize
CachingSequencedDeadLetterQueue.contains(Object, ProcessingContext) lookups.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.
Specification for terminating a single step with cancellation.
Specification for terminating a workflow with cancellation.
Discovers the
MemberCapabilities of the ServiceInstances reported by Spring Cloud Discovery, and
publishes this application's own.Calculates capacity by tracking, within the configured time window, the average message processing time and
multiplying that by the amount of messages processed.
Calculates capacity by tracking, within the configured time window, the average message processing time
and multiplying that by the amount of messages processed.
Contract describing the cause for
dead lettering a Message.Contract describing the cause of a workflow or step failure.
Autoconfigures the CBOR based
JacksonConverter if configured via the ConverterProperties.Autoconfiguration that constructs a default
CBORMapper, typically to be used by a
JacksonConverter.Thrown when the framework detects an event transformer chain misconfiguration.
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.Moves a package like OpenRewrite's
ChangePackage, but keeps the given types in the old package.Declares that an event-handling unit manages its own progress: it decides when its work for a
Segment is
durable and asks the processor to advance the stored TrackingToken through a CheckpointTrigger.AxoniqAddon implementation for the Axoniq Framework self-checkpointing event handlers.A
ConfigurationEnhancer that enables self-checkpointing support for
pooled
streaming event processors.Event handling component handling any event, which is checkpoint-aware.
SegmentProgressStrategy that lets self-checkpointing Checkpointing units manage when their segment's
stored TrackingToken advances.SegmentProgressStrategyFactory that produces a CheckpointingProgressStrategy for every segment of a
processor whose components include one or more self-checkpointing Checkpointing units.Handle through which a
Checkpointing unit tells the owning processor how far it is safe to advance the stored
TrackingToken for a single claimed Segment.A
ParameterResolverFactory constructing a ParameterResolver resolving the CheckpointTrigger
for the segment currently being handled.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.
ConfigurationEnhancer that registers the ClasspathHandlerDefinition as the default
HandlerDefinition, and the ClasspathHandlerEnhancerDefinition as the default
HandlerEnhancerDefinition.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.
Global access point for the framework's current
Clock.MessageStream implementation that invokes the given
closeHandler once the stream is closed.Utility methods for operations on collections.
Result type that all combinator methods (
AnyMatchCombinator.anyMatch(java.util.function.Predicate<io.axoniq.framework.workflow.dsl.api.WorkflowStepResult>, io.axoniq.framework.workflow.dsl.api.WorkflowStepResult...), NoneMatchCombinator.noneMatch(java.util.function.Predicate<io.axoniq.framework.workflow.dsl.api.WorkflowStepResult>, io.axoniq.framework.workflow.dsl.api.WorkflowStepResult...),
AllMatchCombinator.allMatch(java.util.function.Predicate<io.axoniq.framework.workflow.dsl.api.WorkflowStepResult>, io.axoniq.framework.workflow.dsl.api.WorkflowStepResult...)) are required to return.Combines two payloads into one.
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.
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.
The wire representation of the outcome of handling a
command on another member of the cluster.The wire representation of a
CommandMessage being sent to another member of the cluster.The kinds of failure a
CommandDispatchReply can report, and the classification a receiving member needs to
reconstruct an equivalent exception.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.Annotation marking a method as a command-specific interceptor handler on an
AnnotatedCommandHandlingComponent.Interface describing a registry of
command handlers.Interface describing a group of
CommandHandlers belonging to a single component.Handles exceptions thrown by a
CommandHandler within a CommandHandlingComponent.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.A
MessageHandlerInterceptor implementation to sequence command execution.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.
Comments out Axon Framework 4 serializer configuration under a
// TODO(axon4to5): marker, as Axon Framework
5 replaces the Serializer with a Converter.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.
Composite Workflow status change listener responsible for one status change.
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.A modular extension of an
ExtendedConfiguration.Internal helper that manages the lifecycle of
ConfigurationExtension instances for an
ExtensibleConfigurer parent configuration.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.Adds explicit
tagKey and idType attributes to @EventSourced annotations
that do not yet configure them.Records
enclosingClassFqn → idTypeFqn for every @AggregateIdentifier field.Decorator for an
EventStorageEngine that, upon an AppendEventsTransactionRejectedException,
identifies an event that caused the rejection.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 for managing the lifecycle of a connector.
Interface representing a point in an Event Stream up to where certain state has been made up-to-date.
An immutable consistent-hash ring resolving a routing key to the
Member that should handle a command.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
Scope that also carries the ProcessingContext of the invocation it is started for.Interface describing methods that can be executed after the first "given" state has been supplied.
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.
Kotlin counterpart to
ConvertCommandHandlerConstructorToStaticMethod.Rewrites Axon Framework 4
@CommandHandler constructors into static handle
methods, the AF5 idiom for "creational" command handlers.Interface describing a mechanism that can convert data from one to another type.
Autoconfiguration class dedicated to configuring the delegation behaviour for default
MessageConverter
and EventConverterA 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.
Pojo that contains the needed information for a
Task handling a
deadline, in binary form.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.
Pojo that contains the needed information for a
Task handling a
deadline, in human-readable form.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.An
EventHandlingComponent decorator that uses a SequencedDeadLetterQueue to enqueue
events for which handling failed.A functional interface describing how to convert a
ResultSet in JdbcDeadLetter implementation of type
DConverter that can convert an
EventMessage to a DeadLetterEventEntry and vice versa.Makes an enabled dead-letter queue configuration tenant-aware by routing its configured queue factory per tenant.
A
ParameterResolverFactory constructing a ParameterResolver resolving the DeadLetter that is
being processed.Spring Boot autoconfiguration that provides a
PooledStreamingEventProcessorModule.Customization for Dead Letter Queue support.Configuration class holding all settings related to Dead Letter Queue (DLQ) functionality.
A
ConfigurationEnhancer that adds Dead Letter Queue (DLQ) support to
EventHandlingComponents within a
pooled streaming event processor module.Exception signaling a
SequencedDeadLetterQueue is overflowing.Spring Boot configuration properties for Dead Letter Queue (DLQ) settings per event processor.
Configuration for the Dead Letter Queue (DLQ) on a single event processor.
Cache settings for the DLQ sequence identifier in-memory cache.
Per-processor settings containing DLQ configuration.
Schema description for an
EventMessage holding
DeadLetter entry table in JDBC.Instantiate a builder to construct a
DeadLetterSchema.A contract towards all
PreparedStatements a JdbcSequencedDeadLetterQueue
requires to function.A functional interface to create a JDBC-specific
DeadLetter entry
table and its indices.Functional interface describing a
Consumer of a DeadlineMessage.Delivers a fired deadline to the
ScopeAware components that resolve its scope,
inside a unit of work from the configured UnitOfWorkFactory.Wraps the details of a deadline scheduled through the
JobRunrDeadlineManager: the deadline's name, and its
scope descriptor, payload and metadata in their stored form.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.
A
ConfigurationEnhancer that ties every DeadlineManager of the configuration to the application's
lifecycle.Exception indicating a problem in the Deadline manager mechanism, more precisely the
DbSchedulerDeadlineManager wasn't properly supplied.A
ConfigurationEnhancer that makes a DeadlineManager handler parameter defer its calls to the
ProcessingContext of the handler.Helps validation of deadline mechanism provided by
StubDeadlineManager.An
EventMessage for a deadline, specified by its deadlineName and optionally containing a
deadlinePayload.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.Implemented by a
ComponentDecorator output class to expose the single delegate it wraps, so code holding a
decorated value can see through it back to whatever it was built from.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
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
DeadLetterJdbcConverter, converting ResultSets into
JdbcDeadLetter instances.Builder class to instantiate a
DefaultDeadLetterJdbcConverter.Default implementation of the
DeadLetterStatementFactory used by the JdbcSequencedDeadLetterQueue.Builder class to instantiate a
DefaultDeadLetterStatementFactory.Default implementation of the
DispatchInterceptorRegistry, maintaining lists of CommandMessage,
EventMessage, and QueryMessage-specific
MessageDispatchInterceptors.The default
EntityIdResolverDefinition to be used as an attribute on annotation to clarify a default is being
used.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
EventNameCustomizer that builds event names from a base name and status suffix.Builder for
DefaultEventNameCustomizer.Data class containing information for payload customization.
The default
EventStoreTransaction.Default action resolver that invokes the action supplied by the workflow definition.
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 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.MongoTemplate instance giving direct access to the saga collection via a given MongoClient instance.
Builder class to instantiate a
DefaultMongoTemplate.Factory for the default parameter resolvers.
Default implementation of
PersistentStreamEventSourceFactory, building one source per Axon Server stream.Default implementation of
ProcessorModuleFactory that assigns event handlers to processors using
ProcessorDefinitions.Default implementation of the
QueryGateway interface.Default implementation of
ReactorCommandGateway.Default implementation of the
ReactorDispatchInterceptorRegistry, maintaining lists of
CommandMessage, EventMessage, and QueryMessage-specific
ReactorMessageDispatchInterceptors.Default implementation of
ReactorEventGateway.Default implementation of
ReactorQueryGateway.Provides functionality for incompatibility checks and saves the results in a cache.
Default implementation of the
SpanAttributesProviderRegistry, maintaining a list of
SpanAttributesProvider builders resolved on DefaultSpanAttributesProviderRegistry.providers(Configuration).Default
FutureResolver that applies a 30-second safety-net timeout to future resolution.Default implementation of the
UsagePropertyProvider interface.Wall-clock timeout scheduler used in production.
Default implementation of
WorkflowTestDriver.Default implementation of
WorkflowTestFixture.An implementation of the
MessageStream that wraps a stream that will become available asynchronously.Publisher that delays the publication of events.
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
GeneralConverter implementation delegating conversion operations to a Converter.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
Functional interface for building a
MessageDispatchInterceptor for a specific component type and component
name.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.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.Autoconfiguration translating the connector-specific
axon.tracing.* properties into the
DistributedTracingSettings component read by the distributed-connector tracing enhancer of
axoniq-distributed-messaging.ConfigurationEnhancer that wires tracing into the distributed bus connectors.Spring Boot configuration properties for the distributed-connector tracing.
Tracing settings for the distributed
CommandBusConnector.Tracing settings for the distributed
QueryBusConnector.Settings controlling tracing for distributed messaging connectors.
An
EnqueueDecision stating a dead letter should not be enqueued.Autoconfiguration to set up metrics for the infrastructure components.
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.
Indicates that the annotated
SagaEventHandler method indicates the end of a Saga instance's lifecycle.A
HandlerEnhancerDefinition inspecting the existence of the EndSaga annotation on
MessageHandlingMembers.A
WrappedMessageHandlingMember implementation dedicated towards MessageHandlingMembers annotated
with EndSaga.A contract towards describing a decision among a
dead letter containing a message of type
M concerning whether to add it to a SequencedDeadLetterQueue.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.Interceptor for
CommandMessages dispatched to an entity through its EntityMetamodel.Chain allowing an
EntityCommandHandlerInterceptor to proceed dispatching a CommandMessage to an
entity, either to the next interceptor in the chain, or to the entity's own command handlers.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.Holder for the shared span attribute key under which an entity's identifier is recorded, regardless of whether
that entity is a legacy aggregate or a dynamic-consistency-boundary entity.
Defines the lifecycle operations for an event-sourced entity.
A
TransactionalExecutor implementation for EntityManagers.Provides components with an
EntityManager to access the persistence mechanism.A
TransactionManager implementation that manages JPA EntityTransactions directly
via an EntityManagerProvider.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
EventSourcedEntityFactory when the entity returned by
EventSourcedEntityFactory.create(Object, EventMessage, ProcessingContext) is null when calling it with a non-null
firstEventMessage during the EventSourcingRepository.load(Object, ProcessingContext) or
EventSourcingRepository.loadOrCreate(Object, ProcessingContext).Deprecated, for removal: This API element is subject to removal in a future version.
in favor of
EntityNotFoundException, which more broadly
serves any Repository being unable to find or> recreate an
entityException indicating that an instance command handler was invoked for an entity that does not exist.
Exception indicating that an entity could not be found in, or recreated by, the
Repository.A
UsagePropertyProvider implementation that reads the usage properties from the
environment variables.A functional interface to supply environment variables.
Executes comparison based on equality of objects.
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.DSL-level helpers for authoring serialized event associations.
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.Represents a condition for event receipt.
Helper for construction of
EventCondition.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
EventStoreTransaction#source(SourcingCondition) sourcing or
streaming events.Annotation 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.Annotation marking a method as an event-specific interceptor handler on an
AnnotatedEventHandlingComponent.Interface describing a registry of
event handlers.Functional interface describing a filter for the
EventProcessorDefinition.EventHandlerDescriptor.Interface describing a group of
EventHandlers belonging to a single component.Event handling component handling any event.
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.
Handles exceptions thrown by an
EventHandler within an EventHandlingComponent.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.
Converter responsible for converting to and from
EventMessage implementations for storage in a
SequencedDeadLetterQueue.Utility with factory methods for workflow event messages.
Customizes workflow event names.
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.Defines the configuration for an event processor, including which event handlers it should process and how it should
be configured.
Final step in the processor definition fluent API for configuring the processor settings.
Describes an event handler component that can be assigned to an event processor.
The second step in the processor definition fluent API for selecting which event handlers should be assigned to
the processor.
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.
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.
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 the user should define the messaging metamodel for the
event-sourced entity being built.
Phase of the module's building process in which optional parameters can be provided.
Event sourced collection of running workflow IDs, loaded by
WorkflowStore.Holds the current state of a workflow and modified by the
EventSourcedWorkflowState.evolve(org.axonframework.messaging.eventhandling.EventMessage, org.axonframework.messaging.core.unitofwork.ProcessingContext) method receiving messages.Event-sourcing repository-backed workflow store.
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 which manages event-sourced entities and delegates
lifecycle concerns (loading, initialization, snapshot handling, and live updates)
to an EntityLifecycleHandler.ConfigurationEnhancer contributing the built-in event-sourcing
SpanAttributesProviders to the
SpanAttributesProviderRegistry.ConfigurationEnhancer that wires tracing into axon-eventsourcing components.Per-component on/off toggles for event-sourcing tracing, read by
EventSourcingTracingConfigurationEnhancer to decide which axon-eventsourcing components to decorate,
and by TracingEventTagsHandlerEnhancerDefinition to decide whether event handler spans are enriched with the
event's tags.Toggles for the built-in
SpanAttributesProviders
contributed by the axon-eventsourcing module (read by
EventSourcingSpanAttributesProviderConfigurationEnhancer and
TracingEventTagsHandlerEnhancerDefinition).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 event-specific
MessageTransformation describing how stored events of one MessageType are
rewritten into another when they are read.Continuation of
EventTransformation.from(Predicate); optionally restricts the predicate match to a set of declared
from type names before to(...) is supplied.Continuation of
EventTransformation.from(MessageType) / EventTransformation.from(Predicate); supplies to(...).Continuation of
from(...).to(...); supplies the payload mapper.ServiceLoader-discovered
ConfigurationEnhancer that installs the
TransformingEventStore decorator on the application's EventStore.An immutable, thread-safe chain of
EventTransformation instances that transforms events at read time.Fluent builder for
EventTransformerChain.Read-side resolver that constructs a
MessageType from the stored qualified name and version of a stored
event.An
EventCriteria that can be restricted to a specific set of event types.Represents metrics collected while sourcing an event-sourced entity to its current state.
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 serialize
Throwables into ErrorMessages, and to
reconstruct AxonExceptions from error information received over the wire.Annotation marking a Handler as an interceptor for other handlers that is only interested in handling
exception results.
Exception utility methods.
Execute delegate implementing
ExecutePrimitive.Primitive for executing actions within a workflow.
Parameter object for the primitive.
Resolves the action to invoke for an "execute step".
Specification for executing an action within a workflow.
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 configuration that supports reading modular
ConfigurationExtension instances.A configurer that supports registering
ConfigurationExtension instances.A
SequencingPolicy implementation that extracts the sequence identifier from the message payload based on a
given property extractor.An implementation of the
EntityManagerProvider that returns a new EntityManager instance
each time using the EntityManagerFactory.Specification for terminating a workflow with failure.
An
EntityIdResolver implementation composing two others, a primary resolver invoked first and a
secondary resolver is invoked only if the primary fails to resolve an identifier.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.
Interface describing action to perform on a
SagaTestFixture during the configuration phase.Exception indicating that an error occurred that prevented successful execution of a test fixture.
Interface towards an object that contains the results of a Saga test fixture execution.
ParameterResolverFactory implementation for use in test cases that prevent that all declared resources on message
handlers need to be configured.
Flags Spring
@Bean methods that register an Axon Framework 4 Serializer with a
// TODO(axon4to5): comment.Utility methods to work with Project Reactor's
fluxes.Annotation that indicates that a method or constructor is a factory method for an event-sourced entity, forcing
creation at all times.
Sealed strategy for matching the
from side of a transformation.Exact-source matcher: matches an event whose
MessageType equals a fixed identity.Predicate-source matcher: matches any
MessageType the predicate accepts.SequencingPolicy that does not enforce any sequencing requirements on message processing.
A
CommandResult that wraps a completable future providing the Message that represents the result.Indicates that a
FutureResolver stopped waiting before an asynchronous operation completed.Resolves a
CompletableFuture according to a configurable waiting policy.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.A general-purpose
Converter that places no restrictions on the types it can convert.Generic implementation of the
CommandMessage interface.Generic implementation of the
CommandResultMessage interface.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 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
ReplayStatusChanged interface.Generic implementation of the
ResetContext interface.Generic implementation of
ResultMessage interface.Generic SagaSqlSchema implementation, for use in most databases.
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.Interface to an object that publishes events on behalf of an aggregate.
A stage for defining the workflow actions
Default implementation of the
GivenWhen.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.Simple
PayloadReducer that will only pass along the global payload, ignoring the local
payload, without modification.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.
Utility class that provides methods to register a
HandlerDefinition to the ComponentRegistry.Interface describing objects that are capable of enhancing a
MessageHandler, giving it additional
functionality.Utility class that provides methods to register a
HandlerEnhancerDefinition to the
ComponentRegistry.Base exception for exceptions raised by Handler methods.
Functional interface for building a
MessageHandlerInterceptor for a specific component type and component
name.A registry of
MessageHandlerInterceptors, acting as a collection of
registered MessageHandlerInterceptors components.Configuration for the timeout settings of message handlers.
A
ConfigurationEnhancer that registers a HandlerTimeoutHandlerEnhancerDefinition, driven by the
HandlerTimeoutConfiguration present in the Configuration.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.ConfigurationEnhancer that registers a decorator for the HandlerDefinition that, when a
parent configuration is present, composes both the parent and the current
HandlerDefinition into a MultiHandlerDefinition, re-assembled with the current, fully composed
HandlerEnhancerDefinition.ConfigurationEnhancer that registers a decorator for the HandlerEnhancerDefinition that, when a
parent configuration is present, composes both the parent and the current
HandlerEnhancerDefinition into a MultiHandlerEnhancerDefinition.The HierarchicalLifecycleRegistry 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.Specialization of the GenericSagaSqlSchema for use in the HSQL database.
The
RemoteCommandDispatcher that sends commands to other members over HTTP, and reads back their outcome.Sends queries to other members over HTTP, reading the responses they stream back as Server-Sent Events.
Abstract Factory class that provides access to an IdentifierFactory implementation.
Validates the structure of an object passed as Aggregate Identifier.
Id generator.
An
EnqueueDecision stating a dead letter should be ignored.FieldFilter implementation that rejects a given Field
A
CapabilityDiscoveryMode that delegates to another, and stops asking an instance for its
MemberCapabilities for a while once that instance answers with a client error.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.
Turns a
CommandDispatchRequest received from another member into an invocation of this application's local
command handler, and its outcome back into a CommandDispatchReply.Turns a
QueryDispatchRequest received from another member into an invocation of this application's local
query handler, writing every response it produces to a QueryResponseSink.Infrastructure autoconfiguration class for Axon Framework application.
Combines an
EventSourcedEntityFactory and an EntityEvolver to ensure an entity exists and apply state
transitions.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.SagaRepository implementation that stores all Saga instances in memory.
In-memory implementation of the
SequencedDeadLetterQueue.Builder class to instantiate an
InMemorySequencedDeadLetterQueue.An in-memory implementation of
SnapshotStore for testing or lightweight scenarios.Implementation of a
TokenStore that stores tracking tokens in memory.In-memory implementation of
WorkflowExecutionRepository backed by a ConcurrentHashMap.In-memory implementation of
WorkflowHistoryRepository.Implementation of
Component and ComponentDefinition that wraps a pre-instantiated component.A
CommandHandlingComponent that applies a list of interceptors around every
command before delegating to the underlying component.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.A
QueryHandlingComponent that applies a list of interceptors around every
query before delegating to the underlying component.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
Converter implementation for Jackson 2 that uses Jackson's ObjectMapper to convert objects into and
from a JSON format.Autoconfigures the
Jackson2Converter if configured via the ConverterProperties.Autoconfiguration that constructs a default
ObjectMapper, typically to be used by a
Jackson2Converter.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.Autoconfigures the
JacksonConverter if configured via the ConverterProperties.Custom Jackson deserializer for the Spring Data
Page interface.Cache adapter implementation that allows providers implementing the JCache abstraction to be used.
Autoconfiguration class for Axon's JDBC specific infrastructure components.
A
DeadLetter that was saved to a JDBC-backed database and reconstructed from it.Spring Boot autoconfiguration that registers a JDBC-backed
SequencedDeadLetterQueueFactory bean.Exception indicating an error occurred while interacting with a JDBC resource.
A
SagaStore implementation that uses JDBC to store and find Saga instances.Builder class to instantiate a
JdbcSagaStore.A JDBC-based implementation of the
SequencedDeadLetterQueue, used for storing dead letters containing
event messages durably.Builder class to instantiate a
JdbcSequencedDeadLetterQueue.JdbcSQLErrorCodesResolver is an implementation of PersistenceExceptionResolver used to resolve SQL
error codes to see if it is a duplicate key constraint violation.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.Implementation of
DeadlineManager that delegates scheduling and triggering to a JobRunr
JobScheduler.Builder class to instantiate a
JobRunrDeadlineManager.Autoconfiguration class for Axon's JPA specific infrastructure components.
A
DeadLetter that was saved to the database and reconstructed from it.Spring Boot autoconfiguration that registers a JPA-backed
SequencedDeadLetterQueueFactory bean.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.JPA implementation of the
SagaStore.Builder class to instantiate a
JpaSagaStore.JPA-backed implementation of the
SequencedDeadLetterQueue, used for storing dead letters containing
EventMessages durably as a DeadLetterEntry.Builder class to instantiate an
JpaSequencedDeadLetterQueue.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.
Utility class to create the labels of the JobRunr jobs that fire deadlines.
Implementation of
Component and ComponentDefinition that instantiates a component using a configured
builder.A
MessageStream that defers creation of its delegate stream until the first message is requested.Auto-configures a
DbSchedulerDeadlineManager when the application has a db-scheduler Scheduler, as
Axon Framework 4's Spring Boot auto-configuration did.Spring Boot properties of the Axon Framework 4 deadline managers in
axoniq-legacy, under the
axon.deadline prefix.Autoconfiguration class that registers a
JdbcSagaStore when a DataSource is available, ported
from Axon Framework 4's JDBC saga store wiring onto axon-legacy's JdbcSagaStore builder.Auto-configures a
JobRunrDeadlineManager when the application has a JobRunr JobScheduler, as Axon
Framework 4's Spring Boot auto-configuration did.Autoconfiguration class that registers a
JpaSagaStore when JPA infrastructure is available, ported from
Axon Framework 4's JPA saga store wiring onto axon-legacy's JpaSagaStore builder.Deprecated.
Only in use for legacy "sync" components.
Utility class to obtain resources used in previous versions of Axon Framework.
Autoconfiguration class enabling Spring Boot support for Axon Framework 4
Saga-annotated types, ported into axon-legacy.The
ScopeAwareProvider of a configuration, providing the ScopeAware components that a fired deadline
is delivered to: the Saga managers, and the component translating an aggregate's deadline into a command.Auto-configures the
ScopeAwareProviderSettings of the configuration's ScopeAwareProvider from the
LegacyDeadlineProperties.A
ConfigurationEnhancer that registers the configuration's LegacyScopeAwareProvider as its
ScopeAwareProvider component.AxoniqAddon implementation for the Axoniq Framework Legacy Support module.Deprecated, for removal: This API element is subject to removal in a future version.
Temporary bridge for reading Axon Framework 4 token stores after upgrading.
Deprecated, for removal: This API element is subject to removal in a future version.
Temporary bridge for reading Axon Framework 4 token stores after upgrading.
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.Predicate deciding whether a
CommandMessage that is about to be dispatched through a
CommandBusConnector should be handled by the local segment directly (taking a "local shortcut") instead of
being routed by the connector, which might hand the command to a different segment.Simple
PayloadReducer that will only pass along the local payload, ignoring the global
payload, without modification.Predicate deciding whether a
QueryMessage that is about to be dispatched through a QueryBusConnector
should be handled by the local segment directly (taking a "local shortcut") instead of being routed by the connector,
which may hand the query to a different segment.A
CommandBusConnector that offers a "local shortcut".A
ConfigurationEnhancer that when a CommandBusConnector is present in the configuration may decorate
it with a LocalShortcutCommandBusConnector wrapping a registered LocalCommandDispatchPredicate.A
QueryBusConnector that offers a "local shortcut".A
ConfigurationEnhancer that when a QueryBusConnector is present in the configuration may decorate it
with a LocalShortcutQueryBusConnector wrapping a registered LocalQueryDispatchPredicate.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.
Abstract implementation of a saga repository that locks access to a saga while the saga is being operated on.
Abstract Builder class to instantiate
LockingSagaRepository implementations.A
MessageDispatchInterceptor and MessageHandlerInterceptor implementation that logs dispatched and
incoming messages, and their result, to a Logger.A
SpanFactory that logs span lifecycle events through SLF4J, for development and debugging when no APM
backend is available.An
UpdateCheckerReporter implementation that logs the results of the update check.Loads and stores a unique machine ID in the user's home directory.
Detects the name of the operating system user account running the JVM.
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.Resolver that lets tests provide execute-step actions.
Manual timeout scheduler driven by the fixture clock.
An
EntityChildMetamodel that handles commands and events for child entities stored in a Map.Builder for creating a
MapEntityChildMetamodel for the given parent class and child entity metamodel.EntityChildModelDefinition for creating EntityChildMetamodel instances for child entities that are
represented as a Map.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.Leaves a
// TODO(axon4to5): marker on the statements that use the deadline and time support of the Axon
Framework 4 aggregate test fixture, keeping every call in place.Leaves a
// TODO(axon4to5): marker on the Saga statements that use a DeadlineManager inside an
asynchronous callback, which no longer works on the Axoniq Framework legacy module.Leaves a
// TODO(axon4to5): marker wherever an Axon Framework 4 Saga relies on resource injection, which
the Axoniq Framework legacy module does not port.Leaves a
// TODO(axon4to5): marker on the Axon Framework 4 SagaTestFixture usage that the fixture
ported by axoniq-legacy-test no longer supports, keeping every call in place.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.Optionally implemented by a
can prefer an independently-managed
resource over forcing this one to materialize - reusing it instead when it's already active.
TransactionalExecutor that lazily materializes its resource, so
invalid reference
TransactionalExecutorProvider#applyPreferringIndependentLazily obtains a resource from the given
resourceSupplier on first use, caches it, and reuses it
for every subsequent MaterializingResource.apply(ThrowingFunction) call.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.A single node in the cluster of applications distributing messages through Spring Cloud Discovery.
PrivilegedAction that makes the given method accessible for reflection.
What a member of the cluster reports about itself when asked: who it is, and what it handles.
The messages a
Member is able to handle, and the relative share of command load it asks for.Serves this application's own
capabilities over
HTTP, so that other members of the cluster can learn which commands and queries this one handles.The wire representation of a member's
MemberAdvertisement: its node id and its MemberCapabilities, as
served by MemberCapabilitiesController and read by RestCapabilityDiscoveryMode.Reports that a command could not be delivered to the
Member it was routed to, or that the member's reply
could not be read back.A
MessageStream implementation that merges two underlying message streams into a single stream.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.
Handles exceptions thrown by 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
Functional interface for building a
MessageMonitor for a specific component type and component name.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.Resolves the value returned by a message handler into the
MessageStream that carries it to the dispatcher.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.Transforms messages of type
M.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's
type (its qualified name plus version) to the
span.Workflow id provider using the message identifier as workflow id.
A
ConfigurationEnhancer registering the default components of the MessagingConfigurer.The messaging
ApplicationConfigurer of Axon Framework's configuration API.ConfigurationEnhancer contributing the built-in message-level
SpanAttributesProviders to the
SpanAttributesProviderRegistry.ConfigurationEnhancer that wires tracing into axon-messaging components.Per-component on/off toggles for messaging tracing, read by
MessagingTracingConfigurationEnhancer to decide
which axon-messaging components to decorate.Toggles for the built-in
SpanAttributesProviders
contributed by the axon-messaging module (read by
MessagingSpanAttributesProviderConfigurationEnhancer).Represents metadata that is passed along with a payload in a
Message.Used to derive the value of an association property by looking it up the event message's
Metadata.A
TenantResolver implementation that resolves the target tenant from, and attaches it back to,
message metadata.Utility class to convert between Axon Server metadata values and a simple
Map of String key-value pairs.Propagator.Getter implementation that extracts a propagated trace context from a message's
Metadata.Propagator.Setter implementation that writes the active trace context into a mutable Map.Retrieves the value based on a metadata property.
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 Message's
Metadata, based on a given metadataKey.Adds message metadata entries to the span, each under the key
<prefix><metadataKey>.Utility to work on metadata of workflow events.
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 that uses the MetricRegistry to decorate several
components with MessageMonitors with unique MetricRegistries by registering
MessageMonitorFactories with the
MessageMonitorRegistry.Implementation of the
ConfigurationEnhancer that uses the MeterRegistry to decorate several
components with MessageMonitors with unique MetricRegistries by registering
MessageMonitorFactories with the
MessageMonitorRegistry.Properties describing the settings for metrics.
Properties describing the settings for metrics.
Properties specific for usage with Micrometer.
Autoconfiguration to set up Micrometer Metrics for the infrastructure components.
Configuration container for the
MetricsConfigurationEnhancer, containing the MeterRegistry and
whether to add dimensionality to those measurements.A
ConfigurationEnhancer registering the default MicrometerMetricsConfigurationSpanFactory implementation backed by Micrometer Tracing.ConfigurationEnhancer that installs the Micrometer thread-local trace-context-propagation bridge.Autoconfiguration that toggles the Micrometer tracing binding when the
axoniq-tracing-micrometer module is on
the classpath.AxoniqAddon implementation for the Axoniq Framework Micrometer distributed tracing binding.ConfigurationEnhancer that enables Micrometer-Tracing-backed tracing.Replaces the Axon Framework 4
@DeadlineHandler of an aggregate with the Axon Framework 4
@CommandHandler that receives the deadline once it fires.What the scanning phase learns about the source classes.
Rewrites the AF4 aggregate-fixture constructor expression
new AggregateTestFixture<X>(X.class) (or its diamond form) to the AF5
fluent factory:Rewrites AF4
AggregateTestFixture test method bodies to the AF5
AxonTestFixture fluent given/when/then API.Migrates an Axon Framework 4 event-handling component that dispatches commands via a class-level
CommandGateway field to the AF5 in-handler pattern: a method-parameter CommandDispatcher.Migrates command dispatch from an Axon Framework 4
CommandGateway field in legacy Saga event handlers to
an Axon Framework 5 CommandDispatcher method parameter.Migrates the builder calls of the Axon Framework 4 deadline managers to the builders of the Axoniq Framework legacy
module.
Migrates the Axon Framework 4 configuration code around a deadline manager that the Axoniq Framework legacy module
does not keep.
Axon Framework 5's
EventGateway.publish(..) takes the ProcessingContext as its first argument.Rewrites Kotlin DSL Spring Dependency Management
mavenBom(...)
imports whose version is supplied via Kotlin string-template indirection
(typically ${property("axonFrameworkVersion")} read from an
extra["axonFrameworkVersion"] declaration).Rewrites the Axon Framework 4 interceptor lambdas registered on the legacy test fixtures to the Axon Framework 5
interceptor signatures, which the fixtures ported by
axoniq-legacy-test take.Migrates the method signatures of
MessageHandlerInterceptor
and MessageDispatchInterceptor implementations to their
Axon Framework 5 shape, while leaving the method body untouched.Migrates Axon Framework 4's static
SagaLifecycle access to the context-scoped Axon Framework 5 legacy API.Rewrites single-argument
SequencingPolicy lambdas to the AF5 two-argument shape with an
Optional return.Migrates the AF4 Spring Boot snapshotting configuration to the AF5
@Snapshotting annotation.Cross-file accumulator populated during the scan phase.
Metadata collected for a single
@Bean SnapshotTriggerDefinition method.Classification of a scanned
SnapshotTriggerDefinition bean.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.ConfigurationEnhancer contributing the built-in modelling
SpanAttributesProviders to the
SpanAttributesProviderRegistry.ConfigurationEnhancer that wires tracing into axon-modelling components.Per-component on/off toggles for modelling tracing, read by
ModellingTracingConfigurationEnhancer to decide
which axon-modelling components to decorate.Toggles for the built-in
SpanAttributesProviders contributed by the
axon-modelling module (read by
ModellingSpanAttributesProviderConfigurationEnhancer).Interface describing a module of Axon Framework's configuration API.
Functional interface describing how to build a
Module of type M.Implementations of the SagaRepository that stores Sagas and their associations in a Mongo Database.
Builder class to instantiate a
MongoSagaStore.Template object providing access to the collections necessary for the Mongo based components.
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.Moves a Saga field into a parameter of the Saga methods that use it, because the Axoniq Framework legacy module does
not inject Saga fields.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Temporary bridge for reading Axon Framework 4 multi-source token stores after upgrading.
A
TrackingToken implementation combining several TrackingTokens into one.A
StreamableEventSource implementation that allows streaming event processors to process events from multiple
underlying event sources.Intermediate builder for collecting event sources before creating a MultiStreamableEventSource.
TagResolver that combines the results of multiple other tag resolvers.Spring Boot auto-configuration wiring multi-tenancy support into Spring Boot applications.
AxoniqAddon implementation for the Axoniq Framework Multi-tenancy.ConfigurationEnhancer registering the default multi-tenancy components:
the default TenantResolver, which resolves the tenant from message metadata, unless a user registered a custom TenantResolver
the TenantRouter that every tenant-routing component shares to decide the tenant of a message
the TenantComponentProviderSubscriber to subscribe every TenantComponentProvider to the TenantProvider at startup
the RegisterTenantDescriptorHandlerInterceptor which takes the resolved TenantDescriptor from the message and stores it in the ProcessingContext
the AttachTenantDescriptorDispatchInterceptor which attaches the tenant of the dispatching ProcessingContext onto a dispatched command or query, so it survives a distributed round trip
the MultiTenantStreamingProcessorRestarter to restart the running streaming event processors when the set of tenants changes
the TenantAwareQueryBus decorator, scoping subscription-query update emission and completion to the tenant resolved from the ProcessingContext
Spring Boot auto-configuration making persistent streams multi-tenant, by replacing the
PersistentStreamEventSourceFactory with one that builds a MultiTenantPersistentStreamEventSource per
configured stream.Utility class containing reusable functionality for configuring multi-tenancy.
Interface for components that can be registered with a
TenantProvider.Multi-tenant Axon Server
CommandBusConnector.Multi-tenant Axon Server
QueryBusConnector.Tenant-routing
EventStorageEngine.A
SubscribableEventSource consuming one persistent stream per tenant, labelling every event it delivers with
the tenant it came from.A
PersistentStreamEventSourceFactory building a MultiTenantPersistentStreamEventSource, so a
configured persistent stream is consumed from every tenant's Axon Server context rather than from one.A functional interface resolving the stream id for a multi-tenant persistent stream from the supplied
configured name and
TenantDescriptor.Tenant-routing
SnapshotStore.Configuration for the
MultiTenantStreamingProcessorRestarter.Restarts the running
StreamingEventProcessors whenever the set of tenants changes, so
a processor streaming across tenants re-opens its stream with the current tenants.A
TrackingToken holding one position per tenant, positioning the merged read stream that feeds event
processors across all tenants.Mutable history repository.
Annotation used to declare the namespace (or bounded context) of a class, package, or module.
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 subscribed EventHandler.Exception indicating this instance has no
QueryHandler for a given QueryMessage.This will implement
MessageHandlerInterceptorMemberChain with no more interceptors.Guard combinator that succeeds when no completed result matches the predicate.
Default implementation of
NoneMatchCombinator.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.
Indicates that a query expected to identify one workflow instance matched more than one instance.
No-op implementation of a
Lock.A message monitor that returns a NoOp message callback
A NoOp MessageMonitor callback
SequencingPolicy that imposes no sequencing at all on the processing of messages.Autoconfiguration class that registers a bean creation method for a default
TransactionManager, the
NoTransactionManager.A
ScopeDescriptor describing no active scope.An
AxonException describing that there is no such dead letter present in a
SequencedDeadLetterQueue.A
TransactionManager implementation that does nothing.The declared nullability of a
Parameter, as reported by a NullabilityResolver.Determines whether a
Parameter is declared as accepting null.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.A
ContentTypeConverter implementation for Jackson 3 that converts an ObjectNode object
into a JsonNode.A
ContentTypeConverter implementation for Jackson 2 that converts an ObjectNode object into a
JsonNode.Miscellaneous object utility methods.
Condition implementation to check for a bean instance of a specific class *and* a specific qualifier on it,
matching if no such bean can be found.Condition implementation to check for a bean instance of a specific class *and* a specific qualifier on it.Oracle 11 does not support AUTO_INCREMENT.
Jdbc token entry table factory for Oracle databases.
Utility class with some specific hacks required to get certain features to work with Oracle v11.
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.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.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.Payload manipulation helper.
Used to derive the value of an association property by looking it up the event message's payload.
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.
Primitive implementing durable payload modifications.
Reusable payload mapping shared by primitive specs.
Matcher that matches any message (e.g.
Payload modification interface.
Implementation of a
ParameterResolver that resolves the Message payload as parameter in a handler method.Primitive modifying the workflow instance payload allowing durable data flow support.
Base payload modification command.
Action executed consuming payload and returning payload as a result run in a provided processing context.
Retrieves the value based on a payload property.
Workflow id provider accessing event message property.
Payload reducer to combine two payloads into one.
Registry of payload reducers defined by
PayloadReducer.Matches a list of Messages if the list of their payloads matches the given matcher.
Specification for modifying of payload within a workflow.
A
MessageMonitor implementation which creates a new MessageMonitor for every Message payload type
ingested by it.The PersistenceExceptionResolver is used to find out if an exception is caused by duplicate keys.
Spring Boot autoconfiguration that defines the required infrastructure for persistent streams by creating
a
PersistentStreamScheduledExecutorBuilder, a PersistentStreamEventSourceFactory and a named
SubscribableEventSource bean consuming a persistent stream for each entry under
axon.axonserver.persistent-streams using
the PersistentStreamConfigurationEnhancer configuration enhancer.A
ConfigurationEnhancer that registers a SubscribableEventSource component consuming a persistent
stream for each entry in AxonServerConfiguration.getPersistentStreams().A connection instance receiving the events for a persistent stream to pass on in batches to an event consumer.
Places resources on the
ProcessingContext that a PersistentStreamConnection spans over a batch of
events, returning the context the events of that batch are consumed with.A
SubscribableEventSource that receives events from a persistent stream on Axon Server.Factory for creating the
SubscribableEventSource that consumes a persistent stream on Axon Server.Functional interface towards constructing a
ScheduledExecutorService for a PersistentStreamEventSource.Interface defining the available persistent stream sequencing policies as string constants.
Implementation of a
LockFactory that uses a pessimistic locking strategy.Builder class for the
PessimisticLockFactory.Base phases for BDD phase.
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.
AxoniqAddon implementation for the Axon Framework PostgreSQL Extension.
Autoconfiguration class for the Axon Framework PostgreSQL extension.
A
ConfigurationEnhancer that is auto-loadable by the ApplicationConfigurer, setting the
PostgresqlEventStorageEngine as the EventStorageEngine to use when no other is present.A
EventStorageEngine and SnapshotStore implementation backed by PostgreSQL, providing
reliable event persistence and streaming with support for tagging.Properties for configuring the Axon Framework PostgreSQL extension.
SQL schema supporting PostgreSQL databases.
Jdbc token entry table factory for Postgres databases.
Matcher implementation that delegates the matching to a Predicate.
Pretty printing event store used for testing.
Commands helper.
Default publish command implementation.
Default version command implementation.
Default execute command implementation.
Default payload modification command implementation allowing asynchronous execution and returning the
.
invalid reference
WorkflowStepResultDefault wait-for-event command implementation allowing asynchronous execution and returning the
.
invalid reference
WorkflowStepResultReusable metadata shared by primitive specs.
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.Processing context utility functions.
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.Seam that is invoked immediately around every action executed by a
UnitOfWork, on the very thread
that runs the action.Kind-agnostic interceptor applied uniformly to all dispatch sites by
ProcessingLifecycleInterceptor.intercept(UniformInterceptor).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 message payload based on a
given property.Annotation to mark a field or method that provides the
AxonTestFixture.Implements the
PublishPrimitive.Primitive publishing a business event as a durable workflow step.
Parameter object for the primitive.
Specification for a
ctx.publish(stepName, event) call.Interface describing a qualified
qualifiedName, providing space for a namespace,
local qualifiedName.Implementation of
DeadlineManager that delegates scheduling and triggering to a Quartz Scheduler.Builder class to instantiate a
QuartzDeadlineManager.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.
Utility class to convert queries during
dispatching and handling of
subscribed query handlers in the
AxonServerQueryBusConnector.Raised when a query could not be sent to a member, or its responses could not be read from one.
The wire representation of a failure that ended a query's response stream.
The wire representation of a query sent to another member of the cluster.
The wire representation of one response to a query, carried by a single event of the response stream.
What kind of failure ended a query's response stream, as reported to the member that dispatched the query.
Exception indicating that the execution of a Query Handler has resulted in an exception.
Interface towards the Query Handling components of an application.
Factory for creating a named
QueryGateway component with optional shutdown-tracking decorators.Annotation to be placed on methods that can handle
queries, thus making them
QueryHandlers.Interface describing a handler of
queries.Annotation marking a method as a query-specific interceptor handler on an
AnnotatedQueryHandlingComponent.Interface describing a registry of
query handlers.Interface describing a group of
QueryHandlers belonging to a single component.Handles exceptions thrown by a
QueryHandler within a QueryHandlingComponent.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.Where a member writes the responses to a query it is answering for another member.
Auto-configuration that integrates
QueryShutdownManager beans with Spring's lifecycle.Manages the graceful shutdown of locally-initiated query streams, ensuring they are terminated
during application shutdown.
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.A specialized implementation of
AbstractQueryResponseMessageStream that processes a stream of
QueryUpdate objects and transforms them into QueryResponseMessage instances.A
MessageStream implementation backed by a BlockingQueue.Records steps reached by one workflow body invocation for replay-drift detection.
AutoConfiguration for the Axon Framework Reactor extension.Reactor command gateway that runs dispatch interceptors inside the Reactor subscription.
A
ConfigurationEnhancer registering the default reactor components for the Reactor extension.Functional interface for building a
ReactorMessageDispatchInterceptor for a specific component type and
component name.A registry of
ReactorMessageDispatchInterceptors for the Reactor extension.Reactor event gateway that runs dispatch interceptors inside the Reactor subscription.
Reactor equivalent of
MessageDispatchInterceptor.Reactor equivalent of
MessageDispatchInterceptorChain.Reactor query gateway that runs dispatch interceptors inside the Reactor subscription.
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.
A registry that holds references to the recording components created by
MessagesRecordingConfigurationEnhancer.An
EventStore implementation recording all the events that are
published.Recording id generator.
A message monitor implementation that records the processing results of messages in the provided
MessageMonitorReport instances.Classifies an exception that escaped a workflow body as recoverable or not.
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.A
MessageHandlerInterceptor that registers the TenantDescriptor of the handled Message in the
ProcessingContext, so components further down the handling chain route to that tenant without inspecting the
message again.Interface that provides a mechanism to cancel a registration.
Marker to specify the registration scope for objects that are registered in the registry.
Registration scope.
Sends a command to another member of the cluster and reports back the outcome of handling it there.
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.
Sends a query to another member of the cluster and reports the responses it streams back.
What a member reports about a subscription besides the updates themselves.
References an
EventTrackerStatus which no active work is occurring on.Strips generic type arguments from references to a specific fully-qualified type.
Replaces calls to
AggregateLifecycle.apply(...) with calls to eventAppender.append(...) on an
injected EventAppender parameter, matching the AF5 entity migration pattern documented at
docs/reference-guide/.../paths/aggregates/index.adoc.An implementation of the
HandlerEnhancerDefinition that is used for AllowReplay annotated
event handling methods .An
EventHandlingComponent that blocks all event handling during replay.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.
A
Message signalling that the ReplayStatus of an Event Handling Component changed.Annotation that can be placed on a method that is to be invoked when the
ReplayStatus is about to change.Functional interface for handling
ReplayStatusChanged messages.Registry for subscribing
ReplayStatusChangedHandler instances.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.
Functional interface for handling
ResetContext messages.Registry for subscribing
ResetHandler instances.Exception indicating that a reset is not supported by a component.
A
ProcessingContext implementation overriding a single resource from the wrapping ProcessingContext.Raised when a query's responses can no longer be written to the member that asked for them.
A
CapabilityDiscoveryMode that asks each ServiceInstance for its MemberCapabilities over
HTTP, against the endpoint served by MemberCapabilitiesController.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.
Decorator that adds retry behavior to an
ExecuteDelegate.Context passed to a
RetryHandler on each retry attempt.Callback invoked on each retry attempt, before publishing the RETRYING event.
A
CommandBus wrapper that will retry dispatching commands that resulted in a failure.Retry policy for execute steps.
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
EventTargetMatcher implementation that matches based on the routing key.Definition for creating
CommandTargetResolver instances based on the
routing key attribute.EventTargetMatcher implementation that matches based on the routing key.Definition for creating
EventTargetMatcher instances based on the
routing key attribute.RoutingKeySequencingPolicy that requires sequential processing of commands targeting the same
routing key.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.
Tracks running
CompletableFutures for workflow steps, keyed by step name.Identifies workflow instances that have started and have not yet reached a terminal state.
Interface describing an implementation of a Saga.
Annotation that informs Axon's auto configurer for Spring that a given
Component is a saga instance.Assertions on the contents of the
SagaStore of a running Configuration.Configures the components used to manage and store Sagas of a given type.
Exception triggered when a new saga instance could not be instantiated.
Enumeration containing the possible Creation Policies for Sagas.
Java representation of sagas stored in a mongo instance
Java Persistence Entity allowing sagas to be stored in a relational database.
Method-level annotation indicating that the annotated method is an event handler method for the saga instance.
Exception triggered by a saga while it is processing an event or processing a task.
Describes the conditions under which a Saga should be created, and which AssociationValue it should be initialized
with.
Exception triggered during initialization of a Saga.
Component giving a Saga's event handler methods access to lifecycle operations, such as managing
AssociationValues and ending the Saga.ParameterResolverFactory that resolves the SagaLifecycle registered on the ProcessingContext
for any @SagaEventHandler method that declares a SagaLifecycle-typed parameter.Interface of a factory for a
SagaModel for any given saga type.Utility class that inspects annotation on a Saga instance and returns the relevant configuration for its Event
Handlers.
A data holder containing information of
SagaEventHandler annotated methods.Interface of a model that describes a Saga of type
T.Assembles the event processors carrying the Axon Framework 4 Sagas discovered in a Spring application context.
Configures the event processor carrying one or more Axon Framework 4
@Saga types, declared as a Spring
bean.The step naming the processor mode the customization is written for, and the customization itself.
Interface towards the storage mechanism of Saga instances.
SagaSchema allows specification of custom storage locations for the saga repositories.
Builder for an
SagaSchema that gets initialized with default values.Describes the scope of a Saga by means of its type and identifier.
Interface describing the SQL statements that the JdbcSagaRepository needs to execute against the underlying
database.
Exception indicating that an error has occurred while storing a Saga.
Provides a mechanism to find, load update and delete sagas of type
T from an underlying storage like a
database.Interface describing a Saga entry fetched from a SagaStore.
Fixture for testing Sagas in a given-when-then style, carrying the Axon Framework 4 API so a migrating test suite
keeps its shape.
Holds the data regarding deadline schedule.
Schedules tasks to be executed in future.
Provides functionality for incompatibility checks.
Controls whether and how
PostgresqlEventStorageEngine ensures its PostgreSQL schema (tables, sequence,
indices, and internal migrations) is present when it is constructed.Describes functionality of 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.Exception thrown by the
LegacyScopeAwareProvider when a deadline fires before the configuration has started
its event processors, and the provider therefore cannot provide every component the deadline may be delivered to.Settings of the
LegacyScopeAwareProvider of a configuration.Denotes the description of a
Scope.Factory for a
ScopeDescriptor ParameterResolver.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.
Listener invoked when a processor claims or releases a
Segment.Utility class that matches a resolved sequence identifier against a
Segment.Implementation of a
ParameterResolverFactory that resolves the Segment from the
ProcessingContext whenever it's available.The handle a
SegmentProgressStrategy uses to observe and persist the progress of the single Segment it
is bound to, provided to the strategy on
creation.Decides how a single
Segment's progress is persisted as its events are processed.Creates a
SegmentProgressStrategy for a single segment, binding it to that segment's
SegmentProgressContext.Decorator for
EventHandlingComponent.AxoniqAddon implementation for the Axoniq Framework Sequenced Dead-Letter Queue.Contract describing a component that can process
dead letters that it has enqueued.Interface describing the required functionality for a dead letter queue.
Factory that creates a
SequencedDeadLetterQueue for a given processing group.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 message handling methods or classes.
Interface to a policy definition for concurrent message processing.
Concurrency policy that requires sequential processing of events raised by the same aggregate.
SequencingPolicy that requires sequential handling of all messages delivered to a message handler.
Canonical serialized representation of an event association.
A single event read from a Server-Sent Events stream.
Indicates a
ServiceInstance answered a request for its
capabilities with a client error.An identity for a
ServiceInstance that can safely be used as a map key.Holds the single canonical
AxonServerContainer configuration meant to be shared by every IT test suite in
the build, instead of each test class declaring its own.An
EnqueueDecision stating a dead letter should be enqueued.Exception indicating a process tried to register an activity whilst the application is shutting down.
A latch implementation to be used in shutdown scenarios.
A
QueryGateway decorator that automatically registers subscription queries and streaming queries with a
QueryShutdownManager, ensuring they are canceled during application shutdown.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
CorrelationDataProvider implementation that defines correlation data by the Message.metadata() key
names.Implementation of
DeadlineManager which uses Java's ScheduledExecutorService as scheduling and
triggering mechanism.Builder class to instantiate a
SimpleDeadlineManager.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.A simple implementation of
EntityLifecycleHandler that reconstructs an entity
by sourcing events directly from an EventStore.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, EventHandlerRegistry, and
ResetHandlerRegistry.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
SegmentChangeListener implementation backed by claim and release handlers.Simple implementation of the
StateManager.Factory for creating simple
UnitOfWork instances.In-memory workflow definition registry implementation.
Convenience Java DSL built on top of
BaseWorkflowContext.Factory that creates
SimpleWorkflowContext instances for the
convenience Java DSL.Workflow instance implementation.
Workflow Manager backed by the workflow history projection and live cancellation coordinators.
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, and not a Map).Abstraction interface to bridge old
FluxSink and Sinks.Many API with a common
API.Simple sleep utilities.
A reservoir of measurements constrained by a sliding window that stores only the measurements made
in the last
N seconds (or other time unit).Represents a snapshot of an entity at a specific position in the event stream.
Decorator for an
EventStorageEngine that adds support for the SourcingStrategy.Snapshot sourcing
strategy for stores that do not support this strategy natively.Message containing a snapshot.
Defines a policy for determining when an event-sourced entity should be snapshotted.
A
ConfigurationEnhancer making the EventStorageEngine support the
snapshot sourcing strategy, by decorating it with the configured
SnapshotStore through SnapshotCapableEventStorageEngine.decorate(EventStorageEngine, SnapshotStore).Represents storage for snapshots of event-sourced entities.
Configures snapshotting behaviour for an event-sourced entity when using the annotation-based registration path
(see
EventSourcedEntityModule.autodetected(Class, Class)).An
EntityLifecycleHandler implementation that reconstructs an entity from the
EventStore, using snapshots to improve efficiency when available.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.Handles the sourcing of an entity from its historical event stream.
Defines how a sourcing operation should construct the message stream when reading events
from an event store.
Absolute start position in the event stream.
Snapshot-based sourcing strategy.
Represents one unit of traced work.
A registry of
SpanAttributesProviders, collecting the providers a
SpanFactory implementation is constructed with.The sole public abstraction for creating tracing
spans in Axon Framework.The active-span scope returned by
Span.start().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.
Autoconfiguration for the Axoniq Framework Spring Cloud connector.
The connector's own beans, registered unless
axon.springcloud.enabled is set to false.Rejects an application that distributes messages over Spring Cloud without being able to receive any.
Rejects an application that distributes messages over Spring Cloud from a WebFlux stack.
The
AxoniqAddon identifying the Spring Cloud connector, so that it is detected and logged at start-up and
accounted for by the license entitlement system.A
CommandBusConnector distributing commands across the nodes discovered through Spring Cloud Discovery.Receives commands sent by other members of the cluster over HTTP.
A
ConfigurationEnhancer, auto-loadable by the ApplicationConfigurer, registering the
SpringCloudCommandBusConnector as the CommandBusConnector to distribute commands with, and the
SpringCloudQueryBusConnector as the QueryBusConnector to distribute queries with.Discovers the members of the cluster through Spring Cloud Discovery, and resolves the member a command or query is
routed to from what it discovered.
Properties for configuring the Axoniq Framework Spring Cloud connector.
A
QueryBusConnector distributing queries over the members a Spring Cloud discovery implementation reports.Receives queries sent by other members of the cluster over HTTP, answering them with a stream of responses.
Configuration of the
SpringCloudQueryController.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 Entity types and registers a
configurer for each Entity found.ConfigurationEnhancer that composes HandlerDefinition and HandlerEnhancerDefinition beans
from a Spring ApplicationContext into the ComponentRegistry.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.Describes an Axon Framework 4 Saga discovered in a Spring application context, carrying everything
SagaProcessorConfigurer needs to assemble that Saga's event processor.A
BeanDefinitionRegistryPostProcessor implementation that scans for Saga types and registers a
configurer for each Saga found.TransactionManager implementation that uses a
PlatformTransactionManager as
underlying transaction manager.Utility class for Spring specific helper functions.
SQLErrorCodesResolver is an implementation of PersistenceExceptionResolver used to resolve sql error codes to see if
it is an duplicate key constraint violation.
SQLStateResolver is an implementation of PersistenceExceptionResolver used to resolve sql state values to see if it
violates a unique key constraint.
Writes a query's responses to the member that asked, as events of a Server-Sent Events stream.
Deprecated, for removal: This API element is subject to removal in a future version.
The
axon-legacy module exists to let already-running Axon Framework 4 Sagas drain out, not to
start new ones.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.
Workflow Step result based on the Workflow State.
Blocks until the workflow state changes.
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.A
TenantConnectPredicate that accepts a fixed set of tenant identifiers.Exception thrown when an individual step is cancelled.
Base exception type for individual step failures surfaced by the DSL.
Exception used as the failure cause when a step's action was in-flight at a crash and, under the engine's
at-most-once execution guarantee, is not re-run on recovery.
Exception thrown into the workflow body when a step's blocking wait is interrupted because the
workflow itself reached a terminal state (cancelled, failed, timed out) or the engine is shutting down.
Payload for the RETRYING event.
Step status.
Exception thrown when an individual step reaches its configured timeout before completing.
An
EventStore implementation which uses an EventStorageEngine as its storage solution.Converts the parts of a deadline that the persistent deadline managers store, its payload, metadata and scope
descriptor, to and from their stored form, keeping the layout Axon Framework 4.13 wrote.
Interface towards a streamable event source.
Interface describing the condition to
stream from a streamable
event source (like an Event Store).A
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.A
MessageTypeResolver that resolves structural carrier types (byte[], Map,
Collection, String, Number, and JSON tree nodes) to Optional.empty(),
delegating every other payload type to the wrapped resolver.Stub implementation of
DeadlineManager.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(QueryMessage, ProcessingContext, int) is
invoked multiple times for the same QueryMessage.Raised when the members able to answer a subscription query changed while it was active.
A subscription query as one member sends it to another.
A
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.
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.
QueryBus decorator scoping subscription-query update emission and completion to the tenant resolved from the
current ProcessingContext.Application-facing factory for creating the concrete
SequencedDeadLetterQueue of one tenant.Listener notified whenever the tenants a component holds change.
Creates and destroys the per-tenant instances held by a
TenantComponentProvider.Functional interface for looking up a component instance for a given tenant.
ParameterResolverFactory injecting tenant-scoped components into message-handling methods.Configuration enhancer that registers the
TenantComponentParameterResolverFactory to the
ComponentRegistry of the Configuration.Provides the per-tenant instance of a single application component of type
T.Finds
TenantComponentProviders registered in a configuration hierarchy.Predicate that during runtime determines whether a newly registered
tenant should be added
to the tenant-aware infrastructure components.A descriptor for tenants holding the
tenantId and a Map of provider specific properties that
can be used for tenant resolution.Interface for components that can provide a list of tenant descriptors.
Factory providing the
EventStorageEngine of a single tenant.Exception thrown when no tenant can be established for a message or an operation.
Contract towards a component that provisions the registered set of
tenants and
MultiTenantAwareComponents.Decides which tenant an operation is routed to, wrapping a
TenantResolver to resolve a Message (or
the ProcessingContext carrying it) to one of the known tenants, and yielding an Optional instead of
throwing when no known tenant matches.Routes dead-letter queue operations to a queue dedicated to the tenant carried by the processing context.
Owns the tenant lifecycle and tenant-specific dead-letter queues created by routing queue factories.
Annotation indication that a parameter on a Message Handler method should be injected with a
tenant-scoped instance of a component.A cache of one infrastructure component per tenant that creates each component lazily on first use and evicts it when
its tenant is removed.
A
SequencingPolicy that sequences messages by the tenant resolved for message processing.Factory providing the
SnapshotStore of a single tenant.Empty
EventMessage implementation without any payload, used as the
terminal message of a MessageStream.Mutable clock for fixture-controlled workflow time.
This class detects whether the usage reporter is being used in a unit test environment, such as a JUnit test or
another testing framework.
Test-oriented event publishing adapter for workflow tests.
A stage for defining the workflow assertions.
Default implementation of the
Then.Spring Boot configuration properties for the Micrometer tracing thread-local context-propagation bridge.
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 through the
UnitOfWork and
message handlers in Axon Framework.Timeout properties for
message handlers.Timeout properties for the
UnitOfWork.A
UnitOfWorkFactory that decorates another factory, setting a timeout on every UnitOfWork it
creates.Configuration for the timeout settings of an entire
ProcessingContext, per bus or event processor.A
ConfigurationEnhancer that decorates the UnitOfWorkFactory used by the CommandBus,
QueryBus, and every event processor, so every UnitOfWork it creates has a timeout, based on the
TimeoutUnitOfWorkFactoryConfiguration present in the Configuration.Annotation indication that a parameter on an Event Handler method should be injected with the Timestamp of an Event
Message.
Reusable timing configuration shared by primitive specs.
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.Default
SegmentProgressStrategy: persists the batch-end token (SegmentProgressContext.lastConsumedToken())
on every commit, so the stored TrackingToken advances to the position consumed by each batch.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.Autoconfiguration translating the
axon.tracing.* properties into the framework's native tracing
configuration.Delegating
CommandBus decorator that opens a tracing span around command dispatch and command handling.Type-preserving tracing decorator for
CommandBusConnector.ConfigurationEnhancer registering the tracing defaults of the axon-messaging module.Ordering constants shared by the tracing modules'
ConfigurationEnhancers and
decorators.Type-preserving tracing decorator for
EntityLifecycleHandler.Type-preserving tracing decorator for
EventBus.Delegating
EventHandlingComponent decorator that opens a per-event handler span around each event handled,
and -- for streaming-processor batches -- a single enclosing batch span.Delegating
EventSink decorator that opens tracing spans around event publication.Tracing decorator for an
EventStorageEngine.Type-preserving tracing decorator for
EventStore.HandlerEnhancerDefinition that enriches the active tracing span with an event's
Tags when an @EventHandler is invoked.HandlerEnhancerDefinition that wraps annotated message handlers in a tracing span named after the handling
method (for example "BookRoomHandler.handle(BookRoom)").Spring Boot configuration properties for Axon Framework distributed tracing.
Toggles for the built-in
SpanAttributesProviders, bound at
axon.tracing.attribute-providers.*.Tracing settings for the
CommandBus.Tracing settings for event processors (event handling).
Tracing settings for the
EventSink (event publication).Tracing settings for the
EventStorageEngine.Tracing settings for the
QueryBus (queries and subscription-query updates).Tracing settings for
Repository.Tracing settings for
SnapshotStore.Tracing settings for
StateManager.Delegating
QueryBus decorator that opens a tracing span around query dispatch, query handling, subscription
queries, and query-update operations.Type-preserving tracing decorator for
QueryBusConnector.Delegating
Repository decorator that opens internal tracing spans around the repository lifecycle operations
(load, loadOrCreate, persist, attach).Delegating
SnapshotStore decorator that opens internal tracing spans around the snapshot store / load
operations.Delegating
StateManager decorator that opens internal tracing spans around state-manager load operations.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.Utility methods to combine collections of
TrackingTokens.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.
Immutable per-invocation context handed to a
MessageTransformation when it transforms a
single message.EventStore decorator that applies an EventTransformerChain to every
read path (entity loads, DCB reads, tracking-processor reads, ...).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.The payload of a fired deadline whose stored payload type name could not be resolved to a class.
Exception indicating that a child entity indicated a routing key that is not known on the incoming message.
Raised when a query received from another member cannot be read.
Thrown when a
WorkflowEngine cannot resolve a workflow configuration for a durable workflow definition it
encountered while restoring a segment.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.
Bumps the Java compiler target to a configurable LTS, with validation that the target satisfies
the Axon Framework 5 minimum (Java 21).
Bumps Kotlin to a configurable 2.x line, with validation that the target satisfies the Axon Framework 5
minimum (Kotlin 2.0).
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.
Association value comparison operator.
Comparison operator registry.
Retrieves association value from the event message.
Workflow version value type.
Implements the
VersionPrimitive.Describes a component that has a
qualified name and a version.Primitive for forking workflow logic mid-flight.
Parameter object for the primitive.
Specification for a
ctx.migrateVersion(changeId, newVersion) call.Delegate implementing
WaitForPrimitive.Primitive that allows waiting for an event to occur.
Parameter object for the primitive.
Specification for waiting for an event within a workflow.
Cache implementation that keeps values in the cache until the garbage collector has removed them.
Interface to an object that publishes events on behalf of an aggregate, recording what the Saga does in reaction.
Interface providing an API to methods in the "when" state of the fixture execution.
The encoding members share when writing a failure to each other, whatever kind of message it answers.
Annotation to mark the workflow definition method.
Autoconfiguration for workflow infrastructure.
Definition of the
AxoniqAddon for licensing, loaded through SPI during boot to log its existence to the user,
and warn that a license is needed.Coordinates cancellation requests for one running workflow instance.
Represents one pending workflow-cancellation request owned by the cancellation coordinator.
Provides pending workflow-cancellation requests to the workflow driver.
Internal entry point for requesting cancellation of running workflows by identifier.
Exception thrown when a workflow is cancelled via the terminate primitive.
Method marker to register a workflow lifecycle cancellation listener.
Method marker to register a workflow lifecycle completed successfully listener.
Configures definition, context factory and correlation provider.
Defaults for workflow configuration.
Registry for holding workflow configurations with corresponding start conditions.
Holder for the SLF4J logger used by routing decisions (interfaces cannot have static loggers directly).
The workflow
ApplicationConfigurer of Axon Framework's configuration API.Author-facing DSL API based on step definitions.
Workflow execution factory adopting an author-facing context implementing
AbstractWorkflowContext.Creates a context for workflow execution.
Encapsulates workflow module configuration.
Definition of the workflow.
Workflow definition lookup looking for beans with
} annotated methods.
invalid @link
{@link @Workflow
ServiceLoader-discovered
ConfigurationEnhancer that registers the standard Java DSL workflow context
factories.Main workflow component responsible for managing and executing workflows.
A
Checkpointing implementation dedicated for a WorkflowEngine, to separate check pointing behavior
from it.Coordinates workflow work that must complete before checkpoint advancement.
Shared selection and assertion state for workflow fixture tests.
Compact, serialization-friendly representation of a
Throwable stored in workflow events.Read-only execution data required to create workflow event messages.
Resolves workflow-specific event-store tags for engine-published events.
Constant holder for workflow event tags.
Represents the mechanics of a workflow execution accessed by the workflow engine and its primitives.
Receives transitions of checkpoint-relevant workflow work.
Stackless
RuntimeException produced when a WorkflowError is rehydrated from an event payload.Factory to create a workflow execution.
Primitive operations and execution metadata used by the workflow runtime.
Implementation of
WorkflowExecutionOperations that delegates all operations to the underlying
WorkflowExecution and primitive implementations.Repository for retrieving workflow executions, storing new ones, and removing them.
Exception thrown when a workflow fails.
Method marker to register a workflow lifecycle failure listener.
Represents a workflow history of a passed execution.
Workflow history projector collecting historic information.
Repository to access workflow history entries.
Responsible for delivery of workflow id from provided event message.
Represents one workflow instance selected by a query.
Provides operations for requesting lifecycle changes to a workflow instance.
Represents a lazy collection of
workflow instances matching a query.Represents a query result containing at most one
workflow instance.Lifecycle control contract for programmatically changing workflow and step lifecycle state.
Command carrying the intent to cancel a single running step.
Command carrying the intent to cancel an entire workflow.
Command carrying the intent to fail an entire workflow.
Delegate that applies workflow and step lifecycle-control commands on the workflow control thread.
Provides the outside-in API for locating workflow instances and requesting cancellation from application or
administrative code.
Parameter resolver factory serving both
Workflow body methods and
WorkflowStatusChangedHandler lifecycle methods, resolving
WorkflowContext, WorkflowStatus, WorkflowState, and any type wrapping a
WorkflowContext.A workflow
Module that encapsulates the configuration for one or more workflow definitions, all sharing the
same WorkflowContext type defined by the generic C.Terminal phase of the module's building process, in which a multitude of optional components can be set:
WorkflowModule.OptionalPhase.definition(Function) - add another workflow definition to this module.
WorkflowModule.OptionalPhase.processorConfiguration(Function) - customize the
PooledStreamingEventProcessorConfiguration backing this module's event processor.
WorkflowModule.OptionalPhase.withHistory(ComponentBuilder) / WorkflowModule.OptionalPhase.withoutHistory() - enable or disable workflow history
tracking.
WorkflowModule.OptionalPhase.historyProcessorConfiguration(Function) - customize the
PooledStreamingEventProcessorConfiguration backing the history projector's own event
processor.
WorkflowModule.OptionalPhase.contextFactory(ComponentBuilder) - override the WorkflowContextFactory used to create
the WorkflowContext for each workflow execution.
WorkflowModule.OptionalPhase.configurationRegistry(ComponentBuilder) - override the WorkflowConfigurationRegistry
storing workflow configurations and their start conditions.
WorkflowModule.OptionalPhase.executionRepository(ComponentBuilder) - override the WorkflowExecutionRepository
persisting and retrieving workflow instances.
Phase of the module's building process in which one or more workflow definitions are provided.
Phase of the workflow definition process in which the detection strategy is chosen.
Terminal phase of the workflow definition process, indicating the workflow definition is complete.
Phase of the declarative workflow definition process in which the workflow is named.
Phase of the declarative workflow definition process in which the trigger condition is defined.
Phase of the declarative workflow definition process in which optional customizations can be applied.
Configuration enhancer responsible for creation of
WorkflowModule instances, based on workflow definitions
detected by the WorkflowDefinitionLookup.The workflow properties exposed to Spring Boot applications under the
axon.workflow prefix.The properties of the history projector's own, dedicated event processor.
Reflection utilities.
Thrown when a workflow's replay reaches an event-emitting primitive that would corrupt an in-flight workflow —
specifically, when state contains terminal steps the current invocation has not yet referenced.
Delivers workflow timeout and retry-backoff deadlines.
Scheduled task handle.
Method marker to register a workflow lifecycle start listener.
State of a workflow execution.
Immutable value-based criteria for selecting workflow states.
A value-based condition used to select workflow instances.
Selects workflows by an exact payload entry value.
Selects workflows containing a named step.
Selects workflows by a named step's status.
Selects workflows by the effective version of a change identifier.
Selects workflows with a recorded version migration for a change identifier.
Selects workflows by their definition identity.
Selects a workflow by its identifier.
Selects workflows by their status.
Evaluates
WorkflowStateQuery criteria against an in-memory workflow state.Utility functions for inspecting
WorkflowState.Status of the workflow execution.
Method marker to register a workflow lifecycle listener based on the status of the workflow.
Functional interface describing a
WorkflowStatus change listener, invoked on every status change.Basic step of workflow execution.
Represents a result of a step execution.
Utility containing
WorkflowStepResult factory methods.Narrow adapter around workflow-state repositories used during startup.
Imperative test driver for workflow runtime tests.
Test configuration enhancer that installs workflow test event-publication components.
Staged fixture for BDD-style workflow runtime tests.
Runtime exception used by the workflow test fixture to report assertion failures.
Test configuration enhancer that decorates the event store with a pretty-printing recording wrapper.
Aggregates workflow runtime services used by workflow tests.
Test configuration enhancer that switches workflow execution into stepping mode.
Method marker to register a workflow lifecycle timeout listener.
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.
Exception indicating that the
PolymorphicEntityMetamodel for a given class cannot handle a command
because it is of the wrong type.Deprecated, for removal: This API element is subject to removal in a future version.
Only intended to drain Axon Framework 4 XStream-serialized sagas, deadlines, and scheduled events during
a migration period.
AnnotatedEntityMetamodelprevents theEntityMetamodelfrom being decorated or replaced, since resolution would break whenever the registered component is not anAnnotatedEntityMetamodel.