Search Java Classes and Packages

Search Java Frameworks and Libraries

255581 classes and counting ...
Search Tips Index Status



# Classes and Interfaces in #Axon - 640 results found.
NameDescriptionTypePackageFramework
AbstractAggregateFactoryAbstract AggregateFactory implementation that is aware of snapshot events.Classorg.axonframework.eventsourcingAxon
AbstractAggregateRootVery basic implementation of the AggregateRoot interface.Classorg.axonframework.domainAxon
AbstractAnnotatedAggregateRootConvenience super type for aggregate roots that have their event handler methods annotated with the EventSourcingHandler annotation (and EventHandler for backwards compatibility).Classorg.axonframework.eventsourcing.annotationAxon
AbstractAnnotatedEntityConvenience super type for entities (other than aggregate roots) that have their event handler methods annotated with the EventHandler annotation.Classorg.axonframework.eventsourcing.annotationAxon
AbstractAnnotatedHandlerDefinitionAbstract implementation of the HandlerDefinition that uses annotations to recognise handler methods or constructors.Classorg.axonframework.common.annotationAxon
AbstractAnnotatedParameterResolverFactoryParameterResolverFactory that will supply a parameter resolver when a matching parameter annotation is paired with a suitable type of parameter.Classorg.axonframework.eventhandling.annotationAxon
AbstractAnnotatedSagaClassorg.axonframework.saga.annotationAxon
AbstractAnnotationHandlerBeanPostProcessorAbstract bean post processor that finds candidates for proxying.Classorg.axonframework.common.annotationAxon
AbstractCacheAdapterAbstract implementation of the Cache interface which makes it easier to implement Adapters.Classorg.axonframework.cacheAxon
AbstractClusterAbstract Cluster implementation that keeps track of Cluster members (EventListeners).Classorg.axonframework.eventhandlingAxon
AbstractClusterSelectorAbstract implementation of the ClusterSelector interface that detects proxies and passes the actual Class of the Event Listener implementation.Classorg.axonframework.eventhandlingAxon
AbstractCommandGatewayAbstract implementation of a CommandGateway, which handles the dispatch interceptors and retrying on failure.Classorg.axonframework.commandhandling.gatewayAxon
AbstractContentTypeConverterAbstract implementation of the ContentTypeConverter for convenience purposes.Classorg.axonframework.serializerAxon
AbstractEventEntryData needed by different types of event logs.Classorg.axonframework.eventstore.jpaAxon
AbstractEventEntryDataAbstract JPA Entity, which defines all fields except for the payload and metaData field.Classorg.axonframework.eventstore.jpaAxon
AbstractEventSourcedAggregateRootAbstract convenience class to be extended by all aggregate roots.Classorg.axonframework.eventsourcingAxon
AbstractEventSourcedEntityBase class for Event Sourced entities that are not at the root of the aggregate.Classorg.axonframework.eventsourcingAxon
AbstractMessageHandlerAbstract superclass for annotation based Message handlers.Classorg.axonframework.common.annotationAxon
AbstractMethodPropertyAccessStrategyAbstract implementation of the PropertyAccessStrategy that uses a no-arg, public method to access the property value.Classorg.axonframework.common.propertyAxon
AbstractReplayAwareSagaManagerAbstract implementation of the SagaManager interface that provides basic functionality required by most SagaManager implementations.Classorg.axonframework.sagaAxon
AbstractRepositoryAbstract implementation of the Repository that takes care of the dispatching of events when an aggregate is persisted.Classorg.axonframework.repositoryAxon
AbstractRoutingStrategyAbstract implementation of the RoutingStrategy interface that uses a policy to prescribe what happens when a routing cannot be resolved.Classorg.axonframework.commandhandling.distributedAxon
AbstractSagaManagerAbstract implementation of the SagaManager interface that provides basic functionality required by most SagaManager implementations.Classorg.axonframework.sagaAxon
AbstractSagaManagerBeanDefinitionParserAbstract SagaManager parser that parses common properties for all SagaManager implementations.Classorg.axonframework.contextsupport.springAxon
AbstractSagaRepositoryAbstract implementation for saga repositories.Classorg.axonframework.saga.repositoryAxon
AbstractSingleEntryUpcasterAbstract implementation of an upcaster that only needs to convert one serialized object to another using the same This class is not suitable when an upcaster needs to convert a single serialized object to multiple new serializedClassorg.axonframework.upcastingAxon
AbstractSnapshotterAbstract implementation of the Snapshotter that uses a task executor to creates snapshots.Classorg.axonframework.eventsourcingAxon
AbstractUpcasterChainAbstract implementation of the UpcasterChain interface.Classorg.axonframework.upcastingAxon
AbstractXStreamSerializerAbstract implementation for XStream based serializers.Classorg.axonframework.serializerAxon
AcceptAllConflictResolver contains changes that were not expected by the command handler.Classorg.axonframework.eventsourcing.conflictresolversAxon
AggregateAnnotationCommandHandlerCommand handler that handles commands based on CommandHandler annotations on an aggregate.Classorg.axonframework.commandhandling.annotationAxon
AggregateAnnotationCommandHandlerFactoryBeanSpring FactoryBean that creates an AggregateAnnotationCommandHandler instance.Classorg.axonframework.commandhandling.annotationAxon
AggregateAnnotationInspectorInspects objects to find aggregate specific annotations, such as AggregateIdentifier and EventSourcedMember.Classorg.axonframework.eventsourcing.annotationAxon
AggregateBlacklistedExceptionException indicating that an aggregate has been blacklisted by the DisruptorCommandBus.Classorg.axonframework.commandhandling.disruptorAxon
AggregateCommandHandlerBeanDefinitionParserBean Definition parser that parses AggregateAnnotationCommandHandler type beans (aggregate-command-handler element).Classorg.axonframework.contextsupport.springAxon
AggregateCommandHandlerInspectorHandler inspector that finds annotated constructors and methods on a given aggregate type and provides handlers forSince:1.Classorg.axonframework.commandhandling.annotationAxon
AggregateDeletedExceptionSpecial case of the AggregateNotFoundException that indicates that historic information of an aggregate was found, but the aggregate has been deleted.Classorg.axonframework.eventsourcingAxon
AggregateFactoryInterface describing objects capable of creating instances of aggregates to be initialized with an event stream.Interfaceorg.axonframework.eventsourcingAxon
AggregateIdentifierClassorg.axonframework.eventsourcing.annotationAxon
AggregateIdentifierNotInitializedExceptionException indicating that an AggregateRoot instance has failed to provide a valid aggregate identifier in time.Classorg.axonframework.domainAxon
AggregateNotFoundExceptionException indicating that the an aggregate could not be found in the repository.Classorg.axonframework.repositoryAxon
AggregateRootInterface defining a contract for entities that represent the aggregate root.Interfaceorg.axonframework.domainAxon
AggregateSnapshotter motivation is that an aggregate always contains all relevant state.Classorg.axonframework.eventsourcingAxon
AggregateStateCorruptedExceptionException indicating that the changes in an aggregate (generated events) are ignored by the DisruptorCommandBus, because it cannot guarantee that these changes have been applied to an aggregate instance with the correct state.Classorg.axonframework.commandhandling.disruptorAxon
AllFieldsFilterFieldFilter implementation that accepts all Fields.Classorg.axonframework.test.matchersAxon
AMQPConfigurationBeanDefinitionParserBeanDefinitionParser that parses AMQP Configuration elements into SpringAMQPConsumerConfiguration Bean Definitions.Classorg.axonframework.contextsupport.spring.amqpAxon
AMQPConsumerConfigurationInterfaceorg.axonframework.eventhandling.amqpAxon
AMQPMessageRepresentation of an AMQP Message.Classorg.axonframework.eventhandling.amqpAxon
AMQPMessageConverterInterface describing a mechanism that converts AMQP Messages from an Axon Messages and vice versa.Interfaceorg.axonframework.eventhandling.amqpAxon
AndRepresentation of an AND operator for Mongo selection criteria.Classorg.axonframework.eventstore.mongo.criteriaAxon
AnnotatedSagaManager the SimpleSagaManager, this implementation can manage several types of Saga in a single AnnotatedSagaManager.Classorg.axonframework.saga.annotationAxon
AnnotatedSagaTestFixtureFixture for testing Annotated Sagas based on events and time passing.Classorg.axonframework.test.sagaAxon
AnnotationClusterSelectorCluster Selector implementation that selects a cluster if an Annotation is present on the Event Listener class.Classorg.axonframework.eventhandlingAxon
AnnotationCommandHandlerAdapterAdapter that turns any @CommandHandler annotated bean into a CommandHandler implementation.Classorg.axonframework.commandhandling.annotationAxon
AnnotationCommandHandlerBeanPostProcessorSpring Bean post processor that automatically generates an adapter for each bean containing CommandHandler annotated methods.Classorg.axonframework.commandhandling.annotationAxon
AnnotationCommandTargetResolverCommandTargetResolver that uses annotations on the command to identify the methods that provide the Aggregate Identifier of the targeted Aggregate and optionally the expected version of the aggregate.Classorg.axonframework.commandhandling.annotationAxon
AnnotationConfigurationBeanDefinitionParserThe AnnotationConfigurationBeanDefinitionParser is responsible for parsing the annotation-config element from the Axon namespace.Classorg.axonframework.contextsupport.springAxon
AnnotationDrivenAnnotation for @Configuration that will automatically subscribe @CommandHandler and @EventHandler annotated beans with the CommandBus andClassorg.axonframework.contextsupport.springAxon
AnnotationDrivenConfigurationSpring @Configuration related class that adds Axon Annotation PostProcessors to the BeanDefinitionRegistry.Classorg.axonframework.contextsupport.springAxon
AnnotationEventListenerAdapterAdapter that turns any bean with EventHandler annotated methods into an EventListener.Classorg.axonframework.eventhandling.annotationAxon
AnnotationEventListenerBeanPostProcessorSpring Bean post processor that automatically generates an adapter for each bean containing EventHandlerSince:0.Classorg.axonframework.eventhandling.annotationAxon
AnnotationRevisionResolverRevision Resolver implementation that checks for the presence of an @Revision annotation.Classorg.axonframework.serializerAxon
AnnotationRoutingStrategyRoutingStrategy that expects an TargetAggregateIdentifier annotation on the command message's payload.Classorg.axonframework.commandhandling.distributedAxon
ApplicationContextLookupParameterResolverFactoryFactoryBean implementation that create a ParameterResolverFactory, which auto-detects beans implementing ParameterResolverFactory beans in the application context.Classorg.axonframework.contextsupport.springAxon
AssertUtility class (inspired by Springs Assert class) for doing assertions on parameters and object state.Classorg.axonframework.commonAxon
AssociationValueA combination of key and value by which a Saga can be found.Classorg.axonframework.sagaAxon
AssociationValueEntryJPA wrapper around an Association Value.Classorg.axonframework.saga.repository.jpaAxon
AssociationValueMapIn-memory storage for AssociationValue to Saga mappings.Classorg.axonframework.saga.repositoryAxon
AssociationValueResolverInterface describing the mechanism that resolves Association Values from events.Interfaceorg.axonframework.sagaAxon
AssociationValuesInterface describing a container of Association Values for a single Saga instance.Interfaceorg.axonframework.sagaAxon
AssociationValuesImplDefault implementation of the AssociationValues interface.Classorg.axonframework.saga.annotationAxon
AsyncAnnotatedSagaManagerA SagaManager implementation that processes Sagas asynchronously.Classorg.axonframework.saga.annotationAxon
AsynchronousClusterCluster implementation that publishes events to the subscribed Event Listeners asynchronously from the publishing thread.Classorg.axonframework.eventhandling.asyncAxon
AsynchronousCommandBusSpecialization of the SimpleCommandBus that processed Commands asynchronously from the calling thread.Classorg.axonframework.commandhandlingAxon
AsyncSagaCreationElectorManages the election of which asynchronous saga event processor is responsible for creating a new Saga instance,Since:2.Classorg.axonframework.saga.annotationAxon
AsyncSagaEventProcessorProcesses events by forwarding it to Saga instances "owned" by each processor.Classorg.axonframework.saga.annotationAxon
AsyncSagaManagerBeanDefinitionParserBeanDefinitionParser that parses saga-manager elements in the application context.Classorg.axonframework.contextsupport.springAxon
AsyncSagaProcessingEventPlaceholder for information required by the AsyncSagaEventProcessor for processing Events.Classorg.axonframework.saga.annotationAxon
AuditDataProviderInterface describing the instance that provides the relevant information for auditing purposes.Interfaceorg.axonframework.auditingAxon
AuditingInterceptorInterceptor that keeps track of commands and the events that were dispatched as a result of handling that command.Classorg.axonframework.auditingAxon
AuditingUnitOfWorkListenerListener implementation that adds auditing information to events being tracked by the unit of work this listener isSince:0.Classorg.axonframework.auditingAxon
AuditLoggerInterface describing a component capable of writing auditing entries to a log.Interfaceorg.axonframework.auditingAxon
AuthenticatingMongoTemplateAbstract implementation for Mongo templates.Classorg.axonframework.common.mongoAxon
AutowiredBeanSpecial type of BeanDefinition that references can be use to explicitly define a property as being autowired.Classorg.axonframework.contextsupport.springAxon
AutowiredDependencyFactoryBeanConvenience factory bean that locates a bean of a number of given types.Classorg.axonframework.contextsupport.springAxon
AutowiredResourceInjectorResource injector that uses setter methods to inject resources.Classorg.axonframework.test.utilsAxon
AutowiringClusterSelectorCluster selector implementation that uses a Spring Application Context to find all selector beans available.Classorg.axonframework.eventhandlingAxon
AxonAMQPNamespaceHandlerThe Axon AMQP namespace handler is responsible for parsing the elements of the Axon AMQP namespace and adjusting the Spring context configuration accordingly.Classorg.axonframework.contextsupport.spring.amqpAxon
AxonAssertionErrorError indication that an Assertion failed during a test case.Classorg.axonframework.testAxon
AxonConfigurationExceptionException indicating that a configuration error has been made in the Axon configuration.Classorg.axonframework.commonAxon
AxonExceptionBase exception of all Axon Framework related exceptions.Classorg.axonframework.commonAxon
AxonNamespaceHandlerThe Axon namespace handler is responsible for parsing the elements of the Axon namespace and adjusting the Spring context configuration accordingly.Classorg.axonframework.contextsupport.springAxon
AxonNonTransientExceptionException indicating an error has been cause that cannot be resolved without intervention.Classorg.axonframework.commonAxon
AxonThreadFactoryThread factory that created threads in a given group.Classorg.axonframework.commonAxon
AxonTransientExceptionException indicating an error occurred that might be resolved by retrying the operation that caused the exception.Classorg.axonframework.commonAxon
BackloggingIncomingMessageHandlerIncomingMessageHandler implementation that maintains a backlog of all Events published to a cluster while it is in replay mode.Classorg.axonframework.eventhandling.replayAxon
BeanPropertyAccessStrategyBeanPropertyAccessStrategy implementation that uses JavaBean style property access.Classorg.axonframework.common.propertyAxon
BeanValidationInterceptorInterceptor that applies JSR303 bean validation on incoming commands.Classorg.axonframework.commandhandling.interceptorsAxon
BinaryOperatorClassorg.axonframework.eventstore.jdbc.criteriaAxon
BinaryOperatorClassorg.axonframework.eventstore.jpa.criteriaAxon
BlacklistDetectingCallbackWrapper for command handler Callbacks that detects blacklisted aggregates and starts a cleanup process when an aggregate is blacklisted.Classorg.axonframework.commandhandling.disruptorAxon
BlobToInputStreamConverterClassorg.axonframework.serializer.convertersAxon
BSONNodeRepresents a node in a BSON structure.Classorg.axonframework.serializer.bsonAxon
ByteArrayToInputStreamConverterContentTypeConverter that converts byte arrays into InputStream.Classorg.axonframework.serializer.convertersAxon
ByteArrayToJsonNodeConverterContentTypeConverter implementation that converts byte[] containing UTF8 encoded JSON string to a Jackson JsonNode.Classorg.axonframework.serializer.jsonAxon
ByteArrayToStringConverterContentTypeConverter that converts byte arrays into Strings.Classorg.axonframework.serializer.convertersAxon
CacheAbstraction for a Caching mechanism.Interfaceorg.axonframework.cacheAxon
CachingEventSourcingRepository the need to read all events from disk, at the cost of memory usage.Classorg.axonframework.eventsourcingAxon
CachingSagaRepositorySaga Repository implementation that adds caching behavior to the repository it wraps.Classorg.axonframework.saga.repositoryAxon
CallbackBehaviorInterface towards a mechanism that replicates the behavior of a Command Handling component.Interfaceorg.axonframework.test.utilsAxon
CannotConvertBetweenTypesExceptionException indicating that a conversion is required between to upcasters, but there is no converter capable of doingSince:2.Classorg.axonframework.serializerAxon
CapturingEventVisitorClassorg.axonframework.eventstore.supportingAxon
ChainedConverterA converter that delegates to a chain of other ContentTypeConverters to convert from a source to a target for which there is not necessarily a single converter available.Classorg.axonframework.serializerAxon
ChainingConverterFactoryConverterFactory implementation that will combine converters to form chains of converters to be able to convert from one type to another, for which there is no suitable single converter.Classorg.axonframework.serializerAxon
ClassNamePatternClusterSelectorClusterSelector implementation that chooses a Cluster based on whether the Listener's Class Name matches a given The given pattern must match the entire class name, not just part of it.Classorg.axonframework.eventhandlingAxon
ClassNamePrefixClusterSelectorClusterSelector implementation that chooses a Cluster based on a mapping of the Listener's Class Name.Classorg.axonframework.eventhandlingAxon
ClasspathParameterResolverFactoryParameterResolverFactory instance that locates other ParameterResolverFactory instances on the class path.Classorg.axonframework.common.annotationAxon
ClusterA cluster represents a group of Event Listeners that are treated as a single group by the ClusteringEventBus.Interfaceorg.axonframework.eventhandlingAxon
ClusterBeanDefinitionParserBeanDefinitionParser implementation that parses "cluster" elements.Classorg.axonframework.contextsupport.springAxon
ClusteringEventBusEventBus implementation that supports clustering of Event Listeners.Classorg.axonframework.eventhandlingAxon
ClusterMessageListenerMessageListener implementation that deserializes incoming messages and forwards them to one or more clusters.Classorg.axonframework.eventhandling.amqp.springAxon
ClusterMetaDataAllows arbitrary information to be attached to a cluster.Interfaceorg.axonframework.eventhandlingAxon
ClusterSelectorThe ClusterSelector defines the mechanism that assigns each of the subscribed listeners to a Cluster instance.Interfaceorg.axonframework.eventhandlingAxon
CollectionCriteriaClassorg.axonframework.eventstore.mongo.criteriaAxon
CollectionOperatorAbstract implementation to use for testing whether an item is present in a collection or not.Classorg.axonframework.eventstore.jdbc.criteriaAxon
CollectionOperatorAbstract implementation to use for testing whether an item is present in a collection or not.Classorg.axonframework.eventstore.jpa.criteriaAxon
CollectionUtilsUtility methods for operations on collections.Classorg.axonframework.commonAxon
CommandBusThe mechanism that dispatches Command objects to their appropriate CommandHandler.Interfaceorg.axonframework.commandhandlingAxon
CommandBusConnectorInterface describing the component that remotely connects multiple CommandBus instances.Interfaceorg.axonframework.commandhandling.distributedAxon
CommandCallbackInterface describing a callback that is invoked when command handler execution has finished.Interfaceorg.axonframework.commandhandlingAxon
CommandDispatchExceptionException indicating that an error has occurred while trying to dispatch a command to another (potentially remote) segment of the CommandBus.Classorg.axonframework.commandhandling.distributedAxon
CommandDispatchInterceptorInterceptor that allows commands to be intercepted and modified before they are dispatched by the Command Bus.Interfaceorg.axonframework.commandhandlingAxon
CommandExecutionExceptionIndicates that an exception has occurred while handling a command.Classorg.axonframework.commandhandlingAxon
CommandGatewayInterface towards the Command Handling components of an application.Interfaceorg.axonframework.commandhandling.gatewayAxon
CommandGatewayFactoryBeanFactoryBean that creates a gateway instance for any given (compatible) interface.Classorg.axonframework.commandhandling.gatewayAxon
CommandGeneratorRunner that uses the provided CommandGateway to send some commands to our application.Classorg.axonframework.quickstartAxon
CommandHandlerMarker annotation to mark any method on an object as being a CommandHandler.Classorg.axonframework.commandhandling.annotationAxon
CommandHandlerMarks an instance that is capable of handling commands.Interfaceorg.axonframework.commandhandlingAxon
CommandHandlerInterceptorWorkflow interface that allows for customized command handler invocation chains.Interfaceorg.axonframework.commandhandlingAxon
CommandHandlerInvokerComponent of the DisruptorCommandBus that invokes the command handler.Classorg.axonframework.commandhandling.disruptorAxon
CommandHandlingEntryDataHolder for the DisruptorCommandBus.Classorg.axonframework.commandhandling.disruptorAxon
CommandHandlingMemberMarker annotation for field that contain an Entity capable of handling Commands on behalf of the aggregate.Classorg.axonframework.commandhandling.annotationAxon
CommandHandlingMemberCollectionMarker annotation for field that contain an Entity capable of handling Commands on behalf of the aggregate.Classorg.axonframework.commandhandling.annotationAxon
CommandHandlingMemberMapMarker annotation for fields that contain a Map of Entities capable of handling Commands on behalf of the aggregate.Classorg.axonframework.commandhandling.annotationAxon
CommandMessageRepresents a Message carrying a command as its payload.Interfaceorg.axonframework.commandhandlingAxon
CommandMessageHandlerUtilsUtility class that resolves the name of a Command accepted by a given handler.Classorg.axonframework.commandhandling.annotationAxon
CommandMetaDataProviderAuditDataProvider implementation that attaches a Command's MetaData to each event generated as result of thatSince:2.Classorg.axonframework.auditingAxon
CommandResponseProcessingFailedExceptionException indicating that a failure occurred during processing of a command response.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
CommandTargetResolverInterface towards a mechanism that is capable of extracting an Aggregate Identifier and Version form a command that identifies the aggregate instance the command should be invoked on.Interfaceorg.axonframework.commandhandlingAxon
CommandValidatorHelper class for validation of dispatched commands.Classorg.axonframework.test.sagaAxon
CompactDriverXStream HierarchicalStreamDriver implementation that uses a CompactWriter to write XML without newlines and indentation, while writing it using the (default) XPPReader.Classorg.axonframework.serializer.xmlAxon
CompositeClusterSelectorClusterSelector implementation that delegates the selection to a list of other ClusterSelectors.Classorg.axonframework.eventhandlingAxon
CompositeEventStreamDecoratorEventStreamDecorator implementation that delegates to several other decorator instances.Classorg.axonframework.eventsourcingAxon
ConcurrencyExceptionException indicating that concurrent access to a repository was detected.Classorg.axonframework.repositoryAxon
ConflictingAggregateVersionExceptionException indicating that the (actual) version of a loaded aggregate did not match the given expected version number.Classorg.axonframework.repositoryAxon
ConflictingModificationExceptionRoot of a hierarchy of exceptions indicating the detection of conflicting concurrent modifications.Classorg.axonframework.repositoryAxon
ConflictResolverInterface describing an object that is capable of detecting conflicts between changes applied to an aggregate, and unseen changes made to the aggregate.Interfaceorg.axonframework.eventsourcingAxon
ConnectionFailedExceptionException indicating that a CommandBusConnector failed to connect to other instances.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
ConnectionProviderInterface towards a mechanism that provides access to a JDBC Connection.Interfaceorg.axonframework.common.jdbcAxon
ConnectionWrapperFactoryFactory for creating wrappers around a Connection, allowing one to override the behavior of the Connection.Classorg.axonframework.common.jdbcAxon
ConsistentHashBasic implementation of a Consistent Hashing algorithm, using the MD5 algorithm to build the hash values for given keys and node names.Classorg.axonframework.commandhandling.distributedAxon
ConstructorCommandMessageHandlerCommand Handler that creates a new aggregate instance by invoking that aggregate's constructor.Classorg.axonframework.commandhandling.annotationAxon
ContainerManagedEntityManagerProviderEntityManagerProvider implementation that expects the container to inject the default container managed instance.Classorg.axonframework.common.jpaAxon
ContentTypeConverterInterface describing a mechanism that converts the data type of IntermediateRepresentations of SerializedObjects for Upcasters.Interfaceorg.axonframework.serializerAxon
ContinuedGivenStateInterface describing methods that can be executed after the first "given" state has been supplied.Interfaceorg.axonframework.test.sagaAxon
ConverterFactoryInterface describing a mechanism that provides instances of ContentTypeConverter for a given source and target dataSince:2.Interfaceorg.axonframework.serializerAxon
CorrelationAuditDataProviderAuditDataProvider implementation that attaches the command identifier to each Event generated as result of thatSince:2.Classorg.axonframework.auditingAxon
CorrelationDataHolderDataHolder for meta data entries that need to be attached to messages being generated by this thread.Classorg.axonframework.correlationAxon
CorrelationDataProviderObject defining the the data from a Message that should be attached as correlation data to messages generated as result of the processing of that message.Interfaceorg.axonframework.correlationAxon
CreateToDoCommandHandlerClassorg.axonframework.quickstart.handlerAxon
CreateToDoItemCommandCommand used to create a new ToDoItemAuthor:Jettro CoenradieClassorg.axonframework.quickstart.apiAxon
CriteriaInterface describing the criteria that DomainEvent entries must match against.Interfaceorg.axonframework.eventstore.managementAxon
CriteriaBuilderInterface providing access to the criteria API of an Event Store.Interfaceorg.axonframework.eventstore.managementAxon
CurrentUnitOfWorkDefault entry point to gain access to the current UnitOfWork.Classorg.axonframework.unitofworkAxon
CurrentUnitOfWorkParameterResolverFactoryParameterResolverFactory that add support for the UnitOfWork parameter type in annotated handlers.Classorg.axonframework.commandhandling.annotationAxon
DataSourceConnectionProviderConnectionProvider implementation that obtains a connection from a given DataSource.Classorg.axonframework.common.jdbcAxon
DBObjectHierarchicalStreamReaderHierarchicalStreamReader implementation that reads from a Mongo DBObject structure that has been created using the DBObjectHierarchicalStreamWriter.Classorg.axonframework.serializer.bsonAxon
DBObjectHierarchicalStreamWriterHierarchicalStreamWriter implementation that writes objects into a MongoDB DBObject structure.Classorg.axonframework.serializer.bsonAxon
DBObjectToStringContentTypeConverterContentTypeConverter implementation that converts a DBObject structure into a String containing its Binary JSONSince:2.Classorg.axonframework.serializer.bsonAxon
DBObjectXStreamSerializerXStream based serializer implementation that serializes objects into a Binary JSON structure.Classorg.axonframework.serializer.bsonAxon
DeadlockExceptionException indicating that a deadlock has been detected while a thread was attempting to acquire a lock.Classorg.axonframework.common.lockAxon
DefaultAMQPConsumerConfiguration specifies an exclusive consumer and no explicit prefetch count.Classorg.axonframework.eventhandling.amqpAxon
DefaultAMQPMessageConverterDefault implementation of the AMQPMessageConverter interface.Classorg.axonframework.eventhandling.amqpAxon
DefaultCallbackBehaviorDefault implementation of the CallbackBehavior interface.Classorg.axonframework.test.utilsAxon
DefaultClusterMetaDataDefault implementation of ClusterMetaData.Classorg.axonframework.eventhandlingAxon
DefaultClusterSelectorClusterSelector implementation that always selects the same cluster.Classorg.axonframework.eventhandlingAxon
DefaultCommandGatewayDefault implementation of the CommandGateway interface.Classorg.axonframework.commandhandling.gatewayAxon
DefaultErrorHandlerAn ErrorHandler implementation that returns a fixed RetryPolicy instance when an error occurs.Classorg.axonframework.eventhandling.asyncAxon
DefaultEventEntryFactory of Events as byte arrays.Classorg.axonframework.eventstore.jpaAxon
DefaultEventEntryStore SnapshotEventEntry table.Classorg.axonframework.eventstore.jdbcAxon
DefaultEventEntryStore SnapshotEventEntry entities.Classorg.axonframework.eventstore.jpaAxon
DefaultIdentifierFactoryDefault IdentifierFactory implementation that uses generates random java.Classorg.axonframework.domainAxon
DefaultInterceptorChainMechanism that takes care of interceptor and event handler execution.Classorg.axonframework.commandhandlingAxon
DefaultMongoTemplateDefault implementation for the MongoTemplate.Classorg.axonframework.eventstore.mongoAxon
DefaultMongoTemplateMongoTemplate instance providing access to the MongoDB Collection containing stored Sagas.Classorg.axonframework.saga.repository.mongoAxon
DefaultParameterResolverFactoryFactory for the default parameter resolvers.Classorg.axonframework.common.annotationAxon
DefaultRabbitMqStrategyStrategy for creating a SimpleMessageListenerContainer instance using the Spring AMQP 1.Classorg.axonframework.eventhandling.amqp.springAxon
DefaultUnitOfWork been explicitly save in their aggregates will be saved when the UnitOfWork commits.Classorg.axonframework.unitofworkAxon
DefaultUnitOfWorkFactoryUnitOfWorkFactory implementation that creates instances of the DefaultUnitOfWork.Classorg.axonframework.unitofworkAxon
DescriptionUtilsUtility class for creating a description.Classorg.axonframework.test.sagaAxon
DigesterUtility class for generating hashes for values using several algorithms.Classorg.axonframework.common.digestAxon
DirectExecutorSimple executor implementation that runs a given Runnable immediately in the calling thread.Classorg.axonframework.commonAxon
DiscardingIncomingMessageHandlerIncomingMessageHandler implementation that simply discards all messages dispatch during a replay process.Classorg.axonframework.eventhandling.replayAxon
DispatchMessageJGroups message that contains a CommandMessage that needs to be dispatched on a remote command bus segment.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
DisruptorCommandBusAsynchronous CommandBus implementation with very high performance characteristics.Classorg.axonframework.commandhandling.disruptorAxon
DisruptorCommandBusBeanDefinitionParserBeanDefinitionParser that parses elements in the Spring contextSince:2.Classorg.axonframework.contextsupport.springAxon
DisruptorConfigurationConfiguration object for the DisruptorCommandBus.Classorg.axonframework.commandhandling.disruptorAxon
DisruptorRepositoryBeanDefinitionParserBean Definition parsers that parses disruptor-repository elements.Classorg.axonframework.contextsupport.springAxon
DisruptorUnitOfWorkSpecialized UnitOfWork instance for the DisruptorCommandBus.Classorg.axonframework.commandhandling.disruptorAxon
DistributedCommandBus spread load.Classorg.axonframework.commandhandling.distributedAxon
DocumentPerCommitStorageStrategy containing each separate event.Classorg.axonframework.eventstore.mongoAxon
DocumentPerEventStorageStrategy the event store for specific events, but does not allow for atomic storage of a single commit.Classorg.axonframework.eventstore.mongoAxon
Dom4JToByteArrayConverterConverter that converts Dom4j Document instances to a byte array.Classorg.axonframework.serializer.xmlAxon
DomainEventEntryJPA compliant wrapper around a DomainEvent.Classorg.axonframework.eventstore.jpaAxon
DomainEventMessageRepresents a Message that wraps a DomainEvent and an Event representing an important change in the Domain.Interfaceorg.axonframework.domainAxon
DomainEventStreamThe DomainEventStream represents a stream of historical domain events.Interfaceorg.axonframework.domainAxon
EhCacheAdapterCache implementation that delegates all calls to an EhCache instance.Classorg.axonframework.cacheAxon
EmptyCollectionMatcherMatches any empty collection.Classorg.axonframework.test.matchersAxon
EmptyDataProviderClassorg.axonframework.auditingAxon
EndSagaIndicates that the annotated SagaEventHandler method indicates the end of a Saga instance's lifecycle.Classorg.axonframework.saga.annotationAxon
EntityManagerProviderProvides components with an EntityManager to access the persistence mechanism.Interfaceorg.axonframework.common.jpaAxon
EqualFieldsMatcherMatcher that will match an Object if all the fields on that Object contain values equal to the same field in theSince:1.Classorg.axonframework.test.matchersAxon
EqualsClassorg.axonframework.eventstore.jdbc.criteriaAxon
EqualsClassorg.axonframework.eventstore.jpa.criteriaAxon
EqualsRepresentation of an Equals operator for Mongo selection criteria.Classorg.axonframework.eventstore.mongo.criteriaAxon
ErrorHandlerInterface describing a mechanism that decides what should happen when an asynchronously handled event raises anSince:2.Interfaceorg.axonframework.eventhandling.asyncAxon
ErrorHandlerDefines the behavior of a component when an error occurs during Event Processing in a Saga.Interfaceorg.axonframework.saga.annotationAxon
EventBusSpecification of the mechanism on which the Event Listeners can subscribe for events and event publishers can their events.Interfaceorg.axonframework.eventhandlingAxon
EventBusBeanDefinitionParserThe EventBusBeanDefinitionParser is responsible for parsing the eventBus element from the Axon namespace.Classorg.axonframework.contextsupport.springAxon
EventBusTerminalInterface describing a mechanism that connects Event Bus clusters.Interfaceorg.axonframework.eventhandlingAxon
EventContainerContainer for events related to a single aggregate.Classorg.axonframework.domainAxon
EventCountSnapshotterTriggerSnapshotter trigger mechanism that counts the number of events to decide when to create a snapshot.Classorg.axonframework.eventsourcingAxon
EventEntryClass that represents an event to store in the google app engine data store.Classorg.axonframework.gae.eventstoreAxon
EventEntryFactoryInterface describing a factory that creates Entities for the JpaEventStore to persist.Interfaceorg.axonframework.eventstore.jpaAxon
EventEntryStoreInterface describing the mechanism that stores Events into the backing data store.Interfaceorg.axonframework.eventstore.jdbcAxon
EventEntryStoreInterface describing the mechanism that stores Events into the backing data store.Interfaceorg.axonframework.eventstore.jpaAxon
EventFileResolverInterface that allows basic access to InputStreams and appending OutputStreams to event logs for aggregates.Interfaceorg.axonframework.eventstore.fsAxon
EventFilterInterface describing an Event Filter.Interfaceorg.axonframework.integration.adapterAxon
EventFilterInterface describing an Event Filter.Interfaceorg.axonframework.springmessaging.adapterAxon
EventHandlerAnnotation to be placed on methods that can handle events.Classorg.axonframework.eventhandling.annotationAxon
EventListenerInterface to be implemented by classes that can handle events.Interfaceorg.axonframework.eventhandlingAxon
EventListenerOrderComparatorComparator implementation that uses an OrderResolver instance to define the expected order of two candidates.Classorg.axonframework.eventhandlingAxon
EventListenerProxySpecialist interface for implementations of an event listener that redirect actual processing to another instance.Interfaceorg.axonframework.eventhandlingAxon
EventListenerSubscriptionFailedExceptionException indicating that the subscription of an Event Listener has not succeeded.Classorg.axonframework.eventhandlingAxon
EventListeningMessageChannelAdapterAdapter class that sends Events from an event bus to a Spring Integration Message Channel.Classorg.axonframework.integration.adapterAxon
EventListeningMessageChannelAdapterAdapter class that sends Events from an event bus to a Spring Messaging Message Channel.Classorg.axonframework.springmessaging.adapterAxon
EventMessageRepresents a Message wrapping an Event, which is represented by its payload.Interfaceorg.axonframework.domainAxon
EventMessageReaderReader that reads EventMessage instances written to the underlying input.Classorg.axonframework.eventhandling.ioAxon
EventMessageTypeenum EventMessageTypeextends EnumEnumeration of supported Message Types by the EventMessageWriter and EventMessageReader.Classorg.axonframework.eventhandling.ioAxon
EventMessageWriterWriter that writes Event Messages onto a an OutputStream.Classorg.axonframework.eventhandling.ioAxon
EventProcessingMonitorInterface describing a mechanism that listens for the results of events being processed.Interfaceorg.axonframework.eventhandlingAxon
EventProcessingMonitorCollectionClassorg.axonframework.eventhandlingAxon
EventProcessingMonitorSupportInterface indicating that the implementing class is capable of notifying monitors when event processing completes.Interfaceorg.axonframework.eventhandlingAxon
EventProcessorScheduler that keeps track of (Event processing) tasks that need to be executed sequentially.Classorg.axonframework.eventhandling.asyncAxon
EventPublicationFailedExceptionException indication that an error occurred while publishing an event to an AMQP BrokerSince:2.Classorg.axonframework.eventhandling.amqpAxon
EventPublisherComponent of the DisruptorCommandBus that stores and publishes events generated by the command's execution.Classorg.axonframework.commandhandling.disruptorAxon
EventPublishingMessageChannelAdapterAdapter class that publishes Events from a Spring Integration Message Channel on the Event Bus.Classorg.axonframework.integration.adapterAxon
EventPublishingMessageChannelAdapterAdapter class that publishes Events from a Spring Messaging Message Channel on the Event Bus.Classorg.axonframework.springmessaging.adapterAxon
EventRegistrationCallbackCallback that allows components to be notified of an event being registered with an Aggregate.Interfaceorg.axonframework.domainAxon
EventReplayUnsupportedExceptionException that indicates that event replays are not supported by a component.Classorg.axonframework.eventhandling.replayAxon
EventSchedulerInterface towards a mechanism capable of scheduling the publication of events.Interfaceorg.axonframework.eventhandling.schedulingAxon
EventSchedulerValidatorHelper class for validating evets scheduled in a given event scheduler.Classorg.axonframework.test.sagaAxon
EventSourcedAggregateRootAggregate that can be initialized using a DomainEventStream.Interfaceorg.axonframework.eventsourcingAxon
EventSourcedEntityInterface towards an Event Sourced Entity that is part of an aggregate, but not its root.Interfaceorg.axonframework.eventsourcingAxon
EventSourcedMemberField-level annotation that indicates the objects referred to in the field are a child of the current entity.Classorg.axonframework.eventsourcing.annotationAxon
EventSourcingHandlerAnnotation that marks a method in an Aggregate (either the root, or an entity) as a handler for Events generated by that aggregate.Classorg.axonframework.eventsourcing.annotationAxon
EventSourcingRepositoryAbstract repository implementation that allows easy implementation of an Event Sourcing mechanism.Classorg.axonframework.eventsourcingAxon
EventSqlSchemaInterface describing the operations that the JDBC Event Store needs to do on a backing database.Interfaceorg.axonframework.eventstore.jdbcAxon
EventStoreAbstraction of the event storage mechanism.Interfaceorg.axonframework.eventstoreAxon
EventStoreExceptionIndicates that the given events stream could not be stored or read due to an underlying exception.Classorg.axonframework.eventstoreAxon
EventStoreManagementInterface describing operations useful for management purposes.Interfaceorg.axonframework.eventstore.managementAxon
EventStreamDecoratorInterface describing a class that can decorates DomainEventStreams when events for aggregates are read or appended.Interfaceorg.axonframework.eventsourcingAxon
EventStreamNotFoundExceptionException indicating that the event store could not find an event stream for a given aggregate type and identifier.Classorg.axonframework.eventstoreAxon
EventTemplateTemplate class that dispatches Events to an EventBus, taking active UnitOfWork into account.Classorg.axonframework.eventhandlingAxon
EventValidatorHelper class for validating events published on a given EventBus.Classorg.axonframework.test.sagaAxon
EventVisitorInterface describing an instance of a visitor that receives events for processing.Interfaceorg.axonframework.eventstoreAxon
ExactSequenceMatcherA matcher that will match if all the given matchers against the event in a list at their respective index.Classorg.axonframework.test.matchersAxon
ExtendedMessageListenerContainerSpecialization of the SimpleMessageListenerContainer that allows consumer to be registered as exclusive on a channel.Classorg.axonframework.eventhandling.amqp.springAxon
ExtendedUpcasterExtension of the Upcaster interface that allows type upcasting to be based on the contents of the serialized object.Interfaceorg.axonframework.upcastingAxon
FieldFilterThe FieldFilter indicates whether any given Field should be accepted for processing or not.Interfaceorg.axonframework.test.matchersAxon
FileSystemBufferedReaderDomainEventStreamDomainEventStream implementation that reads DomainEvents from the filesystem using an InputStream.Classorg.axonframework.eventstore.fsAxon
FileSystemEventMessageReaderReads events from the file system returns an event in a raw form as SerializedDomainEventData.Classorg.axonframework.eventstore.fsAxon
FileSystemEventMessageWriterWrites a domain event message to the given DataOutput.Classorg.axonframework.eventstore.fsAxon
FileSystemEventStore writes them to files to disk.Classorg.axonframework.eventstore.fsAxon
FileSystemEventStoreBeanDefinitionParserThe FileSystemEventStoreBeanDefinitionParser is responsible for parsing the eventStore element form the Axon namespace.Classorg.axonframework.contextsupport.springAxon
FileSystemSnapshotEventReaderReads the latest snapshot event from a given snapshotEventFile and skips the correct number of bytes in the given eventFile.Classorg.axonframework.eventstore.fsAxon
FileSystemSnapshotEventWriterWrites snapshot events to the given snapshotEventFile.Classorg.axonframework.eventstore.fsAxon
FireEventJobQuartz Job that publishes an event on an Event Bus.Classorg.axonframework.eventhandling.scheduling.quartzAxon
FixedValueParameterResolverParameterResolver implementation that injects a fixed value.Classorg.axonframework.common.annotationAxon
FixedValueRevisionResolverRevisionResolver implementation that returns a fixed value as revision, regardless of the type of serialized object involved.Classorg.axonframework.serializerAxon
FixtureConfigurationInterface describing the operations available on a test fixture in the configuration stage.Interfaceorg.axonframework.testAxon
FixtureConfigurationInterface describing action to perform on a Saga Test Fixture during the configuration phase.Interfaceorg.axonframework.test.sagaAxon
FixtureExecutionExceptionException indicating that an error occurred that prevented successful execution of a test fixture.Classorg.axonframework.testAxon
FixtureExecutionResultInterface towards an object that contains the results of a Fixture execution.Interfaceorg.axonframework.test.sagaAxon
FixtureExecutionResultImplDefault implementation of FixtureExecutionResult.Classorg.axonframework.test.sagaAxon
FixtureResourceParameterResolverFactoryParameterResolverFactory implementation that is aware of test-specific use cases.Classorg.axonframework.testAxon
FixturesUtility class providing access to fixture instances in the Axon Test module.Classorg.axonframework.testAxon
FullConcurrencyPolicySequencingPolicy that does not enforce any sequencing requirements on event processing.Classorg.axonframework.eventhandling.asyncAxon
FutureCallbackCommand Handler Callback that allows the dispatching thread to wait for the result of the callback, using the Future mechanism.Classorg.axonframework.commandhandling.callbacksAxon
GaeEventStoreEventStore implementation that uses Google App Engine's DatastoreService to store Event Streams.Classorg.axonframework.gae.eventstoreAxon
GaeSnapshotterClassorg.axonframework.gae.eventstoreAxon
GaeXStreamClassorg.axonframework.gae.serializerAxon
GatewayProxyFactoryFactory that creates Gateway implementations from custom interface definitions.Classorg.axonframework.commandhandling.gatewayAxon
GenericAggregateFactoryAggregate factory that uses a convention to create instances of aggregates.Classorg.axonframework.eventsourcingAxon
GenericCommandMessageClassorg.axonframework.commandhandlingAxon
GenericDomainEventMessageGeneric implementation of the DomainEventMessage interface.Classorg.axonframework.domainAxon
GenericEventMessageGeneric implementation of the EventMessage interface.Classorg.axonframework.domainAxon
GenericEventSqlSchemaClassorg.axonframework.eventstore.jdbcAxon
GenericJpaRepositoryGeneric repository implementation that stores JPA annotated aggregates.Classorg.axonframework.repositoryAxon
GenericMessageGeneric implementation of the Message interface.Classorg.axonframework.domainAxon
GenericSagaFactorySagaFactory implementation that uses the default (no-arg) constructor on the saga to initialize.Classorg.axonframework.sagaAxon
GenericSagaSqlSchemaGeneric SagaSqlSchema implementation, for use in most databases.Classorg.axonframework.saga.repository.jdbcAxon
GivenAggregateEventPublisherInterface to an object that publishes events on behalf of an aggregate.Interfaceorg.axonframework.test.sagaAxon
GivenWhenThenTestFixtureA test fixture that allows the execution of given-when-then style test cases.Classorg.axonframework.testAxon
HandlerDefinitionDefines which members (methods, constructors, etc) are considered message handlers.Interfaceorg.axonframework.common.annotationAxon
HashChangeListenerReceive updates from the JGroupsConnector when the consistent hash changes.Interfaceorg.axonframework.commandhandling.distributed.jgroupsAxon
HsqlSagaSqlSchemaSpecialization of the GenericSagaSqlSchema for use in the HSQL database.Classorg.axonframework.saga.repository.jdbcAxon
HybridJpaRepositoryRepository that stores both a (JPA based) relational model of the current state of an aggregate and the events produced by that aggregate.Classorg.axonframework.eventsourcingAxon
IdentifierBasedLockLocking mechanism that allows multiple threads to hold a lock, as long as the identifier of the lock they hold is not equal.Classorg.axonframework.common.lockAxon
IdentifierFactoryAbstract Factory class that provides access to an IdentifierFactory implementation.Classorg.axonframework.domainAxon
IdentifierValidatorValidates the structure of an object passed as Aggregate Identifier.Classorg.axonframework.commonAxon
IgnoreFieldFieldFilter implementation that rejects a given FieldSince:2.Classorg.axonframework.test.matchersAxon
IllegalLockUsageExceptionException indicating that an illegal use of a lock was detect (e.Classorg.axonframework.common.lockAxon
IncomingMessageHandlerInterface of a mechanism that receives Messages dispatched to a Cluster that is in Replay mode.Interfaceorg.axonframework.eventhandling.replayAxon
IncompatibleAggregateExceptionException indicating that an aggregate was not compatible with the requirements of the GenericAggregateFactory.Classorg.axonframework.eventsourcingAxon
InMemorySagaRepositorySagaRepository implementation that stores all Saga instances in memory.Classorg.axonframework.saga.repository.inmemoryAxon
InputStreamToByteArrayConverterConverter that converts an InputStream to a byte array.Classorg.axonframework.serializer.convertersAxon
InputStreamToDom4jConverterConverter that converts an input stream to a Dom4J document.Classorg.axonframework.serializer.xmlAxon
InputStreamToXomConverterConverter that converts an input stream to a XOM document.Classorg.axonframework.serializer.xmlAxon
InterceptorChainThe interceptor chain manages the flow of a command through a chain of interceptors and ultimately to the command handler.Interfaceorg.axonframework.commandhandlingAxon
IntervalRetrySchedulerRetryScheduler implementation that retries commands at regular intervals when they fail because of an exception that is not explicitly non-transient.Classorg.axonframework.commandhandling.gatewayAxon
IOUtilsUtility methods for IO operations.Classorg.axonframework.common.ioAxon
JacksonSerializerSerializer implementation that uses Jackson to serialize objects into a JSON format.Classorg.axonframework.serializer.jsonAxon
JavaSerializerSerializer implementation that uses Java serialization to serialize and deserialize object instances.Classorg.axonframework.serializerAxon
JCacheAdapterCache adapter implementation that allows providers implementing the JCache abstraction to be used.Classorg.axonframework.cacheAxon
JdbcCriteriaAbstract implementation of the Criteria interface for a Jdbc Event Store.Classorg.axonframework.eventstore.jdbc.criteriaAxon
JdbcCriteriaBuilderCriteriaBuilder implementation for the Jdbc Event StoreSince:2.Classorg.axonframework.eventstore.jdbc.criteriaAxon
JdbcEventStoreAn EventStore implementation that uses JPA to store DomainEvents in a database.Classorg.axonframework.eventstore.jdbcAxon
JdbcEventStoreBeanDefinitionParserBeanDefinitionParser that provides Spring namespace support for defining JDBC Event Stores.Classorg.axonframework.contextsupport.springAxon
JdbcPropertyProperty implementation for Jdbc Event Store.Classorg.axonframework.eventstore.jdbc.criteriaAxon
JdbcSagaRepositoryJdbc implementation of the Saga Repository.Classorg.axonframework.saga.repository.jdbcAxon
JdbcSagaRepositoryBeanDefinitionParserBeanDefinitionParser that provides Spring namespace support for defining JDBC Saga Repositories.Classorg.axonframework.contextsupport.springAxon
JdbcSQLErrorCodesResolverSQLErrorCodesResolver is an implementation of PersistenceExceptionResolver used to resolve sql error codes to see if it is an duplicate key constraint violation.Classorg.axonframework.eventstore.jdbcAxon
JdbcTransactionExceptionException indicating an error occurred while interacting with a JDBC resource.Classorg.axonframework.common.jdbcAxon
JdbcUtilsUtility class for silently closing JDBC resourcesSince:2.Classorg.axonframework.common.jdbcAxon
JGroupsConnectorA CommandBusConnector that uses JGroups to discover and connect to other JGroupsConnectors in the network.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
JGroupsConnectorFactoryBeanSpring Factory bean that creates a JGroupsConnector and starts it when the application context is started.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
JmxMonitorRegistryUtility class that allows Axon-related components to be configured with an MBeanServer.Classorg.axonframework.monitoring.jmxAxon
JodaDeserializerJackson Serializer used to serialize and deserialize Joda DateTime classes.Classorg.axonframework.serializer.jsonAxon
JoinMessageThis message represents a notification of a Member joining the DistributedCommandBus with a given loadFactor.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
JpaCriteriaAbstract implementation of the Criteria interface for a JPA Event Store.Classorg.axonframework.eventstore.jpa.criteriaAxon
JpaCriteriaBuilderCriteriaBuilder implementation for the Jpa Event StoreSince:2.Classorg.axonframework.eventstore.jpa.criteriaAxon
JpaEventStoreAn EventStore implementation that uses JPA to store DomainEvents in a database.Classorg.axonframework.eventstore.jpaAxon
JpaEventStoreBeanDefinitionParserThe JpaEventStoreBeanDefinitionParser is responsible for parsing the eventStore element form the Axon namespace.Classorg.axonframework.contextsupport.springAxon
JpaPropertyProperty implementation for JPA Event Store.Classorg.axonframework.eventstore.jpa.criteriaAxon
JpaRepositoryBeanDefinitionParserBeanDefinitionParser for the jpa-repository elements in a Spring context.Classorg.axonframework.contextsupport.springAxon
JpaSagaRepositoryJPA implementation of the Saga Repository.Classorg.axonframework.saga.repository.jpaAxon
JpaSagaRepositoryBeanDefinitionParserBean definition parser that parses elements into Spring bean definitions.Classorg.axonframework.contextsupport.springAxon
JsonNodeToByteArrayConverterContentTypeConverter implementation that converts a JsonNode object into a byte[].Classorg.axonframework.serializer.jsonAxon
JSR303ViolationExceptionSpecialized version of the StructuralCommandValidationFailedException that provides a set of JSR303 constraint violations that provide details about the exact failure of the command.Classorg.axonframework.commandhandling.interceptorsAxon
LazyDeserializingObjectRepresents a serialized object that can be deserializedObjects upon request.Classorg.axonframework.serializerAxon
LazyUpcasterChainUpcasterChain implementation that delays the actual upcasting until the data inside the returned SerializedObject is actually fetched.Classorg.axonframework.upcastingAxon
LegacyRabbitMqStrategyStrategy for creating a SimpleMessageListenerContainer instance using the Spring AMQP 1.Classorg.axonframework.eventhandling.amqp.springAxon
ListenerContainerFactoryFactory for SimpleMessageListenerContainer beans.Classorg.axonframework.eventhandling.amqp.springAxon
ListenerContainerLifecycleManagerManages the lifecycle of the SimpleMessageListenerContainers that have been created to receive messages for Clusters.Classorg.axonframework.eventhandling.amqp.springAxon
ListMatcherAbstract implementation for matchers that use event-specific matchers to match against a list of items.Classorg.axonframework.test.matchersAxon
ListWithAllOfMatcherA matcher that will match if all the given matchers match against at least one item in a given List.Classorg.axonframework.test.matchersAxon
ListWithAnyOfMatcherA matcher that will match if all the given matchers match against at least one item in a given List.Classorg.axonframework.test.matchersAxon
LockAcquisitionFailedExceptionException indicating that a lock could not be obtained.Classorg.axonframework.common.lockAxon
LockingRepository modifications of persisted aggregates.Classorg.axonframework.repositoryAxon
LockingStrategyenum LockingStrategyextends EnumEnum indicating possible locking strategies for repositories.Classorg.axonframework.contextsupport.springAxon
LockManagerInterface to the lock manager.Interfaceorg.axonframework.repositoryAxon
LoggingCallbackCommandCallback implementation that simply logs the results of a command.Classorg.axonframework.commandhandling.callbacksAxon
LoggingInterceptorCommand Handler Interceptor that logs incoming commands and their result to a SLF4J logger.Classorg.axonframework.commandhandling.interceptorsAxon
MarkCompletedCommandCommand used to mark an existing ToDoItem as completed.Classorg.axonframework.quickstart.apiAxon
MarkCompletedCommandHandlerClassorg.axonframework.quickstart.handlerAxon
MarkToDoItemOverdueCommandClassorg.axonframework.quickstart.apiAxon
MatchAllFieldFilterFieldFilter that delegates to an arbitrary number of other filters.Classorg.axonframework.test.matchersAxon
MatcherExecutionExceptionException indicating that an error occurred that prevented successful execution of a matcher.Classorg.axonframework.test.matchersAxon
MatchersUtility class containing static methods to obtain instances of (List) Matchers.Classorg.axonframework.test.matchersAxon
MavenArtifactRevisionResolverRevisionResolver that uses Maven meta data to retrieve the application version.Classorg.axonframework.serializerAxon
MemberAccessibilityCallbackPrivilegedAction that makes the given method accessible for reflection.Classorg.axonframework.commonAxon
MemberAwareCommandCallbackCallback implementation which wraps another callback, and is aware of the JGroups node responsible for providing the value to invoke the wrapped callback with.Classorg.axonframework.commandhandling.distributed.jgroups.support.callbacksAxon
MembershipUpdateFailedExceptionException indicating that a node has failed to update its membership details with the other nodes.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
MessageRepresentation of a Message, containing a Payload and MetaData.Interfaceorg.axonframework.domainAxon
MessageHandlerAdapterAdapter that allows an EventListener to be registered as a Spring Integration MessageHandler.Classorg.axonframework.integration.eventbusAxon
MessageHandlerAdapterAdapter that allows an EventListener to be registered as a Spring Messaging MessageHandler.Classorg.axonframework.springmessaging.eventbusAxon
MessageHandlerInvocationExceptionMessageHandlerInvocationException is a runtime exception that wraps an exception thrown by an invoked messageSince:2.Classorg.axonframework.common.annotationAxon
MessageHandlerInvokerAbstract class to support implementations that need to invoke methods based on an annotation.Classorg.axonframework.common.annotationAxon
MessageSerializerWrapper around a serializer that provides SerializationAware support.Classorg.axonframework.serializerAxon
MetaDataAnnotation that indicates the parameter needs to be resolved to the value of the Message MetaData stored under the given key.Classorg.axonframework.common.annotationAxon
MetaDataRepresents MetaData that is passed along with a payload in a Message.Classorg.axonframework.domainAxon
MetaDataCommandTargetResolverCommandTargetResolver implementation that uses MetaData entries to extract the identifier and optionally the version of the aggregate that the command targets.Classorg.axonframework.commandhandlingAxon
MetaDataDeserializerJsonDeserializer implementation that deserializes MetaData instances.Classorg.axonframework.serializer.jsonAxon
MetaDataMutatingUnitOfWorkListenerAdapterSpecialist UnitOfWorkListenerAdapter that allows modification of Meta Data of Events during the "beforeCommit" phase of a Unit of Work.Classorg.axonframework.unitofworkAxon
MetaDataRoutingStrategyRoutingStrategy implementation that uses the value in the MetaData of a CommandMessage assigned to a given key.Classorg.axonframework.commandhandling.distributedAxon
MethodAccessedPropertyProperty implementation that invokes a method to obtain a value of a property for a given instance.Classorg.axonframework.common.propertyAxon
MethodMessageHandlerRepresents a method recognized as a handler by the handler inspector (see MethodMessageHandlerInspector).Classorg.axonframework.common.annotationAxon
MethodMessageHandlerInspectorUtility class that inspects handler methods for a given class and handler definition.Classorg.axonframework.common.annotationAxon
MongoCriteriaAbstract class for Mongo-based criteria.Classorg.axonframework.eventstore.mongo.criteriaAxon
MongoCriteriaBuilderThe CriteriaBuilder implementation for use with the Mongo event store.Classorg.axonframework.eventstore.mongo.criteriaAxon
MongoEventStore are not explicitly supported.Classorg.axonframework.eventstore.mongoAxon
MongoFactoryConvenience class for creating Mongo instances.Classorg.axonframework.eventstore.mongoAxon
MongoOptionsFactoryFactory class used to create a MongoOptions instance.Classorg.axonframework.eventstore.mongoAxon
MongoPropertyProperty implementation for use by the Mongo Event Store.Classorg.axonframework.eventstore.mongo.criteriaAxon
MongoSagaRepository its associations is stored as a single document.Classorg.axonframework.saga.repository.mongoAxon
MongoTemplateInterface describing a mechanism that provides access to the Database and Collections required by theSince:2.Interfaceorg.axonframework.eventstore.mongoAxon
MongoTemplateGeneric template for accessing Mongo for the axon sagas.Interfaceorg.axonframework.saga.repository.mongoAxon
MonitorRegistryAbstract Factory providing access to the MonitorRegistry implementations available at runtime.Classorg.axonframework.monitoringAxon
MultiCorrelationDataProviderCorrelationDataProvider that combines the data of multiple other correlation providers.Classorg.axonframework.correlationAxon
MultiParameterResolverFactoryParameterResolverFactory instance that delegates to multiple other instances, in the order provided.Classorg.axonframework.common.annotationAxon
MultiplexingEventProcessingMonitor translates that to a single invocation to a target monitor.Classorg.axonframework.eventhandlingAxon
NestableUnitOfWorkAbstract implementation of the UnitOfWork interface.Classorg.axonframework.unitofworkAxon
NoCacheCache implementation that does absolutely nothing.Classorg.axonframework.cacheAxon
NoFilterClassorg.axonframework.integration.adapterAxon
NoFilterClassorg.axonframework.springmessaging.adapterAxon
NoHandlerForCommandExceptionException indicating that no suitable handler could be found for the given command.Classorg.axonframework.commandhandlingAxon
NonTransientFieldsFilterFieldFilter implementation that only accepts non-transient Fields.Classorg.axonframework.test.matchersAxon
NoOpCallbackCallback that does absolutely nothing when invoked.Classorg.axonframework.commandhandling.callbacksAxon
NotEqualsClassorg.axonframework.eventstore.jdbc.criteriaAxon
NotEqualsClassorg.axonframework.eventstore.jpa.criteriaAxon
NoTransactionManagerTransactionManager implementation that does nothing.Classorg.axonframework.unitofworkAxon
NullAuditLoggerAn implementation of AuditLogger that does nothing.Classorg.axonframework.auditingAxon
NullLockManagerLockManager implementation that does nothing.Classorg.axonframework.repositoryAxon
NullOrVoidMatcherMatcher that matches against a null or void value.Classorg.axonframework.test.matchersAxon
OptimisticLockManager the last committed event to detect concurrent access.Classorg.axonframework.repositoryAxon
OrRepresents the OR operator for use by the Mongo Event Store.Classorg.axonframework.eventstore.mongo.criteriaAxon
OrderResolverInterface describing a mechanism that provides the order for any given Event Listener.Interfaceorg.axonframework.eventhandlingAxon
PackageRoutingKeyResolverRoutingKeyResolver implementation that uses the package name of the Message's payload as routing key.Classorg.axonframework.eventhandling.amqpAxon
ParameterRegistryThe registry that keeps track of parameterized values.Classorg.axonframework.eventstore.jdbc.criteriaAxon
ParameterRegistryThe registry that keeps track of parameterized values.Classorg.axonframework.eventstore.jpa.criteriaAxon
ParameterResolverInterface for a mechanism that resolves handler method parameter values from a given Message.Interfaceorg.axonframework.common.annotationAxon
ParameterResolverFactoryInterface for objects capable of creating Parameter Resolver instances for annotated handler methods.Interfaceorg.axonframework.common.annotationAxon
PartialStreamSupportInterface implemented by Event Stores that support reading partial event streams.Interfaceorg.axonframework.eventstoreAxon
PayloadMatcherMatcher that matches any message (e.Classorg.axonframework.test.matchersAxon
PayloadsMatcherMatches a list of Messages if the list of their payloads matches the given matcher.Classorg.axonframework.test.matchersAxon
PersistenceExceptionResolverThe PersistenceExceptionResolver is used to find out if an exception is caused by duplicate keys.Interfaceorg.axonframework.common.jdbcAxon
PersistenceExceptionResolverThe PersistenceExceptionResolver is used to find out if an exception is caused by duplicate keys.Interfaceorg.axonframework.eventstore.jpaAxon
PessimisticLockManager until a lock could be obtained.Classorg.axonframework.repositoryAxon
PostgresEventSqlSchemaSQL schema supporting postgres databases.Classorg.axonframework.eventstore.jdbcAxon
PostgresSagaSqlSchemaSQL schema supporting postgres databases.Classorg.axonframework.saga.repository.jdbcAxon
PriorityIndicates the relative priority of the annotated component.Classorg.axonframework.commonAxon
PriorityAnnotationComparatorComparator that compares objects based on the value on an @PrioritySince:2.Classorg.axonframework.common.annotationAxon
ProceedingErrorHandlerErrorHandler implementation that logs the error and proceeds with the next event.Classorg.axonframework.saga.annotationAxon
PropertyInterface describing a mechanism that can read a predefined property from a given instance.Interfaceorg.axonframework.common.propertyAxon
PropertyRepresents a property of the Domain Event entry stored by an Event Store.Interfaceorg.axonframework.eventstore.managementAxon
PropertyAccessExceptionException indicating that a predefined property is not accessible.Classorg.axonframework.common.propertyAxon
PropertyAccessStrategyAbstract Strategy that provides access to all PropertyAccessStrategy implementations.Classorg.axonframework.common.propertyAxon
QuartzEventSchedulerEventScheduler implementation that delegates scheduling and triggering to a Quartz Scheduler.Classorg.axonframework.eventhandling.scheduling.quartzAxon
QuartzEventSchedulerFactoryBeanSpring FactoryBean that creates a QuartzEventScheduler instance using resources found in the Spring Application QuartzEventScheduler delegates the actual scheduling and triggering to a Quartz Scheduler, making it more suitableClassorg.axonframework.eventhandling.scheduling.quartzAxon
QuartzScheduleTokenScheduleToken implementation representing a scheduled Quartz Job.Classorg.axonframework.eventhandling.scheduling.quartzAxon
RabbitMqStrategyInterface describing a strategy for creating a SimpleMessageListenerContainer class and setting the exclusive mode on the underlying subscriptions.Interfaceorg.axonframework.eventhandling.amqp.springAxon
RecordingCommandBusCommandBus implementation that does not perform any actions on subscriptions or dispatched commands, but records them instead.Classorg.axonframework.test.utilsAxon
ReflectionUtilsUtility class for working with Java Reflection API.Classorg.axonframework.commonAxon
RemoteCommandHandlingExceptionException indicating that an error has occurred while remotely handling a command.Classorg.axonframework.commandhandling.distributedAxon
ReplayAwareInterface indicating a component is aware of "replays".Interfaceorg.axonframework.eventhandling.replayAxon
ReplayFailedExceptionException indicating that a replay task has failed.Classorg.axonframework.eventhandling.replayAxon
ReplayingClusterCluster implementation that wraps another Cluster, adding the capability to replay events from an Event Store.Classorg.axonframework.eventhandling.replayAxon
ReplyingCallbackCallback implementation that forwards the callback invocation as a reply to an incoming message.Classorg.axonframework.commandhandling.distributed.jgroups.support.callbacksAxon
ReplyMessageJGroups Message representing a reply to a dispatched command.Classorg.axonframework.commandhandling.distributed.jgroupsAxon
ReporterThe reporter generates extensive human readable reports of what the expected outcome of a test was, and what the actual results were.Classorg.axonframework.testAxon
RepositoryThe repository provides an abstraction of the storage of aggregates.Interfaceorg.axonframework.repositoryAxon
RepositoryBeanDefinitionParserThe RepositoryBeanDefinitionParser is responsible for parsing the repository element from the Axon namespace.Classorg.axonframework.contextsupport.springAxon
RepositoryContentValidatorHelper class for the validation of Saga Repository content.Classorg.axonframework.test.sagaAxon
ResourceInjectorInterface describing a mechanism to inject resources into Saga instances.Interfaceorg.axonframework.sagaAxon
ResultValidatorInterface describing the operations available on the "validate result" (a.Interfaceorg.axonframework.testAxon
ResultValidatorImplClassorg.axonframework.testAxon
RetryingCallbackCallback implementation that will invoke a retry scheduler if a command results in a runtime exception.Classorg.axonframework.commandhandling.gatewayAxon
RetryingErrorHandlerErrorHandler implementation that retries Events on non-transient exceptions.Classorg.axonframework.saga.annotationAxon
RetryPolicyThis policy tells the EventProcessor how it should deal with failed transactions.Classorg.axonframework.eventhandling.asyncAxon
RetrySchedulerInterface towards a mechanism that decides whether to schedule a command for execution when a previous attempts resulted in an exception.Interfaceorg.axonframework.commandhandling.gatewayAxon
RevisionAnnotation that attaches revision information to a Serializable object.Classorg.axonframework.serializerAxon
RevisionResolverInterface towards a mechanism that resolves the revision of a given payload type.Interfaceorg.axonframework.serializerAxon
RollbackConfigurationThe RollbackConfiguration defines when a UnitOfWork should be rolled back when the command handler or any reported a failure.Interfaceorg.axonframework.commandhandlingAxon
RollbackOnAllExceptionsConfigurationThe default implementation of the RollbackConfiguration interface.Classorg.axonframework.commandhandlingAxon
RollbackOnUncheckedExceptionConfigurationRollbackConfiguration that indicates a rollback should be triggered for all but checked exceptions.Classorg.axonframework.commandhandlingAxon
RoutingKeyResolverInterface toward a mechanism that provides the AMQP Routing Key for a given EventMessage.Interfaceorg.axonframework.eventhandling.amqpAxon
RoutingStrategyInterface describing a mechanism that generates a routing key for a given command.Interfaceorg.axonframework.commandhandling.distributedAxon
RunAnnotatedAggregateSetting up the basic ToDoItem sample with a simple command and event bus and a file based event store.Classorg.axonframework.quickstartAxon
RunAnnotatedAggregateWithSpringSetting up the basic ToDoItem sample with a simple command and event bus and a file based event store.Classorg.axonframework.quickstartAxon
RunBasicCommandHandlingSetting up the basic ToDoItem sample with as little as possible help from axon utilities.Classorg.axonframework.quickstartAxon
RunClusteringEventBusThis example creates two clusters and assigns different listeners to each cluster.Classorg.axonframework.quickstartAxon
RunClusteringEventBusWithSpringClassorg.axonframework.quickstartAxon
RunDisruptorCommandBusSetting up the basic ToDoItem sample with a disruptor command and event bus and a file based event store.Classorg.axonframework.quickstartAxon
RunDisruptorCommandBusWithSpringSetting up the basic ToDoItem sample with a disruptor command and event bus and a file based event store.Classorg.axonframework.quickstartAxon
RunDistributedCommandBusThis runner demonstrates the basic capabilities of the distributed command bus.Classorg.axonframework.quickstartAxon
RunDistributedCommandBusWithSpringSee RunDistributedCommandBus, only difference is that we use spring to wire all the beans.Classorg.axonframework.quickstartAxon
RunEventReplayClassorg.axonframework.quickstartAxon
RunEventReplayWithSpringClassorg.axonframework.quickstartAxon
RunSagaSimple Example that shows how to Create Saga instances, schedule deadlines and inject resourcesSince:2.Classorg.axonframework.quickstartAxon
RunSagaWithSpringSimple Example that shows how to Create Saga instances, schedule deadlines and inject resources using Spring.Classorg.axonframework.quickstartAxon
RunUpcasterClassorg.axonframework.quickstartAxon
RunUpcasterWithSpringClassorg.axonframework.quickstartAxon
SagaInterface describing an implementation of a Saga.Interfaceorg.axonframework.sagaAxon
SagaCreationPolicyenum SagaCreationPolicyextends EnumEnumeration containing the possible Creation Policies for Sagas.Classorg.axonframework.sagaAxon
SagaEntryJava Persistence Entity allowing sagas to be stored in a relational database.Classorg.axonframework.saga.repository.jpaAxon
SagaEntryJava representation of sagas stored in a mongo instanceSince:2.Classorg.axonframework.saga.repository.mongoAxon
SagaEventHandlerMethod-level annotation indicating that the annotated method i an event handler method for the saga instance.Classorg.axonframework.saga.annotationAxon
SagaFactoryInterface describing a mechanism that creates implementations of a Saga.Interfaceorg.axonframework.sagaAxon
SagaInitializationPolicyDescribes the conditions under which a Saga should be created, and which AssociationValue it should be initializedSince:2.Classorg.axonframework.sagaAxon
SagaManagerInterface toward the Manager of one or more types of Saga.Interfaceorg.axonframework.sagaAxon
SagaManagerBeanDefinitionParserParses the saga-manager element.Classorg.axonframework.contextsupport.springAxon
SagaMethodMessageHandlerA data holder containing information of SagaEventHandler annotated methods.Classorg.axonframework.saga.annotationAxon
SagaMethodMessageHandlerInspectorUtility class that inspects annotation on a Saga instance and returns the relevant configuration for its EventSince:0.Classorg.axonframework.saga.annotationAxon
SagaRepositoryInterface towards the storage mechanism of Saga instances.Interfaceorg.axonframework.sagaAxon
SagaSqlSchemaInterface describing the SQL statements that the JdbcSagaRepository needs to execute against the underlyingSince:2.Interfaceorg.axonframework.saga.repository.jdbcAxon
SagaStorageExceptionException indicating that an error has occurred while storing a Saga.Classorg.axonframework.sagaAxon
SaveAggregateCallbackCallback used by UnitOfWork instances to be invoked when the UnitOfWork wishes to store an aggregate.Interfaceorg.axonframework.unitofworkAxon
ScheduledItemInterface describing an event to be scheduled at a given date and time.Interfaceorg.axonframework.test.eventschedulerAxon
ScheduleTokenToken that identifies a single scheduled Event.Interfaceorg.axonframework.eventhandling.schedulingAxon
SchedulingExceptionException indicating a problem in the Event Scheduling mechanism.Classorg.axonframework.eventhandling.schedulingAxon
SchemaConfigurationSchemaConfiguration allows specification of custom storage locations for domain event and snapshot event entries.Classorg.axonframework.eventstore.jdbcAxon
SchemaConfigurationSchemaConfiguration allows specification of custom storage locations for the saga repositories.Classorg.axonframework.saga.repository.jdbcAxon
SequenceEventStoreJoins two EventStores together.Classorg.axonframework.eventstore.supportingAxon
SequenceMatcherA matcher that will match if all the given matchers each match against an item that the previous matcher matched against.Classorg.axonframework.test.matchersAxon
SequenceNumberAnnotation indication that a parameter on an Event Handler method should be injected with the SequenceNumber of a DomainEventMessage.Classorg.axonframework.eventhandling.annotationAxon
SequenceNumberParameterResolverFactoryAn extension of the AbstractAnnotatedParameterResolverFactory that accepts parameters of a Long type annotated with the SequenceNumber annotation and assigns the sequenceNumber of the DomainEventMessage.Classorg.axonframework.eventhandling.annotationAxon
SequencingPolicyInterface to a policy definition for concurrent processing, for example event handling.Interfaceorg.axonframework.eventhandling.asyncAxon
SequentialPerAggregatePolicyConcurrency policy that requires sequential processing of events raised by the same aggregate.Classorg.axonframework.eventhandling.asyncAxon
SequentialPolicySequencingPolicy that requires serialized handling of all events delivered to an event handler.Classorg.axonframework.eventhandling.asyncAxon
SerializationAwareMarker interface for messages that have special serialization awareness.Interfaceorg.axonframework.serializerAxon
SerializationAwareDomainEventMessageWrapper around a DomainEventMessage that adds "Serialization Awareness" to the message it wraps.Classorg.axonframework.serializerAxon
SerializationAwareEventMessageWrapper around am EventMessage that adds "Serialization Awareness" to the message it wraps.Classorg.axonframework.serializerAxon
SerializationExceptionIndicates that an exception occurred while serializing or deserializing an object.Classorg.axonframework.serializerAxon
SerializationOptimizingInterceptorInterceptor that register a unit of work listener that wraps each EventMessage in a SerializationAware message.Classorg.axonframework.commandhandling.interceptorsAxon
SerializedDomainEventDataInterface describing the properties of serialized Domain Event Messages.Interfaceorg.axonframework.serializerAxon
SerializedDomainEventMessageDomainEventMessage implementation that is optimized to cope with serialized Payload and MetaData.Classorg.axonframework.serializerAxon
SerializedDomainEventUpcastingContextClassorg.axonframework.upcastingAxon
SerializedEventMessageEventMessage implementation that is optimized to cope with serialized Payload and MetaData.Classorg.axonframework.serializerAxon
SerializedMessageMessage implementation that is optimized to cope with serialized Payload and MetaData.Classorg.axonframework.serializerAxon
SerializedMetaDataRepresents the serialized form of a MetaData instance.Classorg.axonframework.serializerAxon
SerializedObjectInterface describing the structure of a serialized object.Interfaceorg.axonframework.serializerAxon
SerializedObjectHolderHolder that keeps references to serialized representations of a payload and meta data of a specific message.Classorg.axonframework.serializerAxon
SerializedSagaSpecialization of the SerializedObject for Sagas represented as byte array.Classorg.axonframework.saga.repository.jpaAxon
SerializedTypeDescribes the type of a serialized object.Interfaceorg.axonframework.serializerAxon
SerializerInterface describing a serialization mechanism.Interfaceorg.axonframework.serializerAxon
SerializerHandlerDisruptor Event Handler that serializes EventMessage implementations that are also SerializationAware.Classorg.axonframework.commandhandling.disruptorAxon
SerialVersionUIDRevisionResolverRevisionResolver implementation that returns the (String representation of the) serialVersionUID of a class.Classorg.axonframework.serializerAxon
SimpleClusterA simple Cluster implementation that invokes each of the members of a cluster when an Event is published.Classorg.axonframework.eventhandlingAxon
SimpleClusterFactoryBeanFactoryBean that creates an instance of a SimpleCluster, allowing easier access to the MetaData.Classorg.axonframework.eventhandlingAxon
SimpleCommandBus command.Classorg.axonframework.commandhandlingAxon
SimpleCommandBusBeanDefinitionParserThe SimpleCommandBusBeanDefinitionParser does the actual work of parsing the commandBus element from Axon namespace.Classorg.axonframework.contextsupport.springAxon
SimpleCommandBusStatisticsStatistics object to store information about the internals of the SimpleCommandBus.Classorg.axonframework.commandhandlingAxon
SimpleCommandBusStatisticsMXBeanManagement interface for the SimpleCommandBus monitor As required by the JMX specification.Interfaceorg.axonframework.commandhandlingAxon
SimpleCorrelationDataProviderCorrelationDataProvider implementation defines correlation headers by the header names.Classorg.axonframework.correlationAxon
SimpleDomainEventStreamCreates a DomainEventStream that streams the contents of a list.Classorg.axonframework.domainAxon
SimpleEntityManagerProviderSimple implementation of the EntityManagerProvider that returns the EntityManager instance provided at constructionSince:1.Classorg.axonframework.common.jpaAxon
SimpleEventBus subscribed listeners.Classorg.axonframework.eventhandlingAxon
SimpleEventBusStatisticsStatistics object to store information about the internal of the SimpleEventBus.Classorg.axonframework.eventhandlingAxon
SimpleEventBusStatisticsMXBeanManagement interface the SimpleEventBus monitor.Interfaceorg.axonframework.eventhandlingAxon
SimpleEventBusWithoutStatisticsThis is a temporary copy of the SimpleEventBus, made to run on google app engine.Classorg.axonframework.gae.commandhandlingAxon
SimpleEventFileResolverVery straightforward implementation of the EventFileResolver that stores files in a directory structure underneath a given base directory.Classorg.axonframework.eventstore.fsAxon
SimpleEventSchedulerAn EventScheduler implementation that uses Java's ScheduledExecutorService as scheduling and triggering Note that this mechanism is non-persistent.Classorg.axonframework.eventhandling.scheduling.javaAxon
SimpleEventSchedulerFactoryBeanSpring FactoryBean that creates a SimpleEventScheduler instance using resources found in the Spring Application Context.Classorg.axonframework.eventhandling.scheduling.javaAxon
SimpleMongoOperator Less Than Equals, etc.Classorg.axonframework.eventstore.mongo.criteriaAxon
SimpleOperatorClassorg.axonframework.eventstore.jdbc.criteriaAxon
SimpleOperatorClassorg.axonframework.eventstore.jpa.criteriaAxon
SimpleResourceInjectorResource injector that uses setter methods to inject resources.Classorg.axonframework.sagaAxon
SimpleResourceParameterResolverFactoryParameterResolverFactory implementation that resolves parameters for a specific given Resource.Classorg.axonframework.common.annotationAxon
SimpleSagaManagerSimple SagaManager implementation.Classorg.axonframework.sagaAxon
SimpleScheduleTokenScheduleToken for tasks event scheduled using the SimpleEventScheduler.Classorg.axonframework.eventhandling.scheduling.javaAxon
SimpleSerializedDomainEventDataSimple implementation of the SerializedDomainEventData class, used to reduce memory consumptions by queries accessing Event Entries.Classorg.axonframework.eventstore.jpaAxon
SimpleSerializedObjectSerializedObject implementation that takes all properties as constructor parameters.Classorg.axonframework.serializerAxon
SimpleSerializedTypeSerializedType implementation that takes its properties as constructor parameters.Classorg.axonframework.serializerAxon
SimpleUpcasterChainRepresents a series of upcasters which are combined to upcast a SerializedObject to the most recent revision of that payload.Classorg.axonframework.upcastingAxon
SnapshotEventEntryJPA compatible entry that stores data required for the use of snapshot events.Classorg.axonframework.eventstore.jpaAxon
SnapshotEventStoreInterface describing an event store that is able to store snapshot events.Interfaceorg.axonframework.eventstoreAxon
SnapshotterInterface describing instances that are capable of creating snapshot events for aggregates.Interfaceorg.axonframework.eventsourcingAxon
SnapshotterBeanDefinitionParserThe SnapshotterBeanDefinitionParser is responsible for parsing the snapshotter element form the Axon namespace.Classorg.axonframework.contextsupport.springAxon
SnapshotterTriggerInterface for Event Stream Decorators that have the intent to trigger snapshots.Interfaceorg.axonframework.eventsourcingAxon
SnapshotterTriggerBeanDefinitionParserBeanDefinitionParser that parses elements.Classorg.axonframework.contextsupport.springAxon
SpringAggregateSnapshotter used within a Spring Application Context.Classorg.axonframework.eventsourcingAxon
SpringAMQPConsumerConfigurationAMQPConsumerConfiguration implementation that has additional support for all Spring-specific AMQP Configuration properties.Classorg.axonframework.eventhandling.amqp.springAxon
SpringAMQPTerminalEventBusTerminal implementation that uses an AMQP 0.Classorg.axonframework.eventhandling.amqp.springAxon
SpringAnnotationOrderResolverOrderResolver implementation that checks for @Order annotations on the type level.Classorg.axonframework.eventhandlingAxon
SpringBeanParameterResolverFactoryParameterResolverFactory implementation that resolves parameters in the Spring Application Context.Classorg.axonframework.common.annotationAxon
SpringContextParameterResolverFactoryBuilderCreates and registers a bean definition for a Spring Context aware ParameterResolverFactory.Classorg.axonframework.contextsupport.springAxon
SpringDataSourceConnectionProviderConnectionProvider implementation that is aware of Transaction Managers and provides the connection attached to an active transaction manager, instead of asking a Data Source directly.Classorg.axonframework.common.jdbcAxon
SpringIntegrationEventBusEventBus implementation that delegates all subscription and publishing requests to a Spring Integration channel.Classorg.axonframework.integration.eventbusAxon
SpringMessagingEventBusEventBus implementation that delegates all subscription and publishing requests to a Spring Messaging channel.Classorg.axonframework.springmessaging.eventbusAxon
SpringParameterResolverFactoryBeanSpring 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.Classorg.axonframework.contextsupport.springAxon
SpringPrototypeAggregateFactoryAggregateFactory implementation that uses Spring prototype beans to create new uninitialized instances ofSince:1.Classorg.axonframework.eventsourcingAxon
SpringResourceInjectorResourceInjector implementation that injects Saga instances with resources available from the Spring Application context the injector is registered in.Classorg.axonframework.saga.springAxon
SpringTransactionManagerTransactionManager implementation that uses a PlatformTransactionManager as underlying transaction manager.Classorg.axonframework.unitofworkAxon
SQLErrorCodesResolverSQLErrorCodesResolver is an implementation of PersistenceExceptionResolver used to resolve sql error codes to see if it is an duplicate key constraint violation.Classorg.axonframework.eventstore.jpaAxon
SQLStateResolverSQLStateResolver is an implementation of PersistenceExceptionResolver used to resolve sql state values to see if it violates a unique key constraint.Classorg.axonframework.eventstore.jpaAxon
StartSagaIndicates that the annotated SagaEventHandler method can trigger the creation of a new Saga instance.Classorg.axonframework.saga.annotationAxon
StorageStrategyInterface towards the mechanism that prescribes the structure in which events are stored in the Event Store.Interfaceorg.axonframework.eventstore.mongoAxon
StringToByteArrayConverterContentTypeConverter that converts String into byte arrays.Classorg.axonframework.serializer.convertersAxon
StringToDBObjectContentTypeConverterContentTypeConverter implementation that converts a String containing its Binary JSON representation into a DBObjectSince:2.Classorg.axonframework.serializer.bsonAxon
StructuralCommandValidationFailedExceptionException indicating that a Command has been refused due to a structural validation failure.Classorg.axonframework.commandhandlingAxon
StubEventSchedulerEventScheduler implementation that uses it's own concept of "Current Time" for the purpose of testing.Classorg.axonframework.test.eventschedulerAxon
StubScheduleTokenScheduleToken returned by the StubEventScheduler.Classorg.axonframework.test.eventschedulerAxon
SubscribableInterface describing components that are able to subscribe themselves to a component that can be subscribed to, such as the CommandBus and EventBus.Interfaceorg.axonframework.commonAxon
SyncSagaManagerBeanDefinitionParserBeanDefinitionParser that parses saga-manager elements in the application context.Classorg.axonframework.contextsupport.springAxon
TargetAggregateIdentifierField or method level annotation that marks a field or method providing the identifier of the aggregate that a If placed on a method, that method must contain no parameters.Classorg.axonframework.commandhandling.annotationAxon
TargetAggregateVersionField or method level annotation that marks a field or method providing the expected version of the aggregate that a If placed on a method, that method must contain no parameters.Classorg.axonframework.commandhandling.annotationAxon
TerminalBeanDefinitionParserBeanDefinitionParser that parses elements into a SpringAMQPTerminal instance.Classorg.axonframework.contextsupport.spring.amqpAxon
TestExecutorInterface describing the operations available on a test fixture in the execution stage.Interfaceorg.axonframework.testAxon
TimeoutClass or method level annotation that indicates the calling thread should not wait longer than the provided timeout for the results of a command.Classorg.axonframework.commandhandling.gatewayAxon
TimestampAnnotation indication that a parameter on an Event Handler method should be injected with the Timestamp of an Event Message.Classorg.axonframework.eventhandling.annotationAxon
TimestampCutoffReadonlyEventStore Takes a backend, both EventStore and EventStoreManagement, and functions as a filter based on a Only events that are older than the provided cut-off datetime are returned to caller or handed to anClassorg.axonframework.eventstore.supportingAxon
TimestampParameterResolverFactoryAbstractAnnotatedParameterResolverFactory that accepts parameters with type DateTime that are annotated with the Timestamp annotation and assigns the timestamp of the EventMessage.Classorg.axonframework.eventhandling.annotationAxon
ToDoEventHandlerEvent handler that listens to both events and prints a message to the system output stream.Classorg.axonframework.quickstart.annotatedAxon
ToDoEventListenerEvent listener for all events, results are printed to system out.Classorg.axonframework.quickstart.handlerAxon
ToDoItemClassorg.axonframework.quickstart.annotatedAxon
ToDoItemClassorg.axonframework.quickstart.handlerAxon
ToDoItemCompletedEventThe ToDoItem belonging to the provided aggregate identifier is completed.Classorg.axonframework.quickstart.apiAxon
ToDoItemCreatedEventA new ToDoItem is createdAuthor:Jettro CoenradieClassorg.axonframework.quickstart.apiAxon
ToDoItemDeadlineExpiredEventClassorg.axonframework.quickstart.apiAxon
ToDoSagaClassorg.axonframework.quickstart.sagaAxon
TransactionManagerInterface towards a mechanism that manages transactions Typically, this will involve opening database transactions or connecting to external systems.Interfaceorg.axonframework.unitofworkAxon
TransactionManagerFactoryBeanFactory Bean that wraps transaction manager instances with an implementation of TransactionManager, if necessary (and possible).Classorg.axonframework.contextsupport.springAxon
TransactionMethodExecutionExceptionWrapper for exceptions that occurred while calling an @BeforeTransaction or @AfterTransaction annotated method.Classorg.axonframework.eventhandling.annotationAxon
UniformPropertyAccessStrategyPropertyAccessStrategy implementation that finds properties defined according to the Uniform Access Principle For example, a property called myProperty, it will use a method called myProperty();Classorg.axonframework.common.propertyAxon
UnitOfWorkThis class represents a UnitOfWork in which modifications are made to aggregates.Interfaceorg.axonframework.unitofworkAxon
UnitOfWorkAwareConnectionProviderWrapperWrapper for a ConnectionProvider that checks if a connection is already attached to the Unit of Work, favoring that connection over creating a new one.Classorg.axonframework.common.jdbcAxon
UnitOfWorkFactoryThe UnitOfWorkFactory interface is used to obtain UnitOfWork instances to manage activity in command handling processes.Interfaceorg.axonframework.unitofworkAxon
UnitOfWorkListenerInterface describing a listener that is notified of state changes in the UnitOfWork it has been registered with.Interfaceorg.axonframework.unitofworkAxon
UnitOfWorkListenerAdapterAbstract implementation of the UnitOfWorkListener that provides empty implementation of all methods declared in UnitOfWorkListener.Classorg.axonframework.unitofworkAxon
UnitOfWorkListenerCollectionThis class is responsible for notifying registered listeners in a specific order of precedence.Classorg.axonframework.unitofworkAxon
UnknownSerializedTypeExceptionException indicating that an object could not be deserialized, because its serialized type cannot be mapped to aSince:2.Classorg.axonframework.serializerAxon
UnresolvedRoutingKeyPolicyenum UnresolvedRoutingKeyPolicyextends EnumSince:2.Classorg.axonframework.commandhandling.distributedAxon
UnsupportedHandlerExceptionThrown when an @.Classorg.axonframework.common.annotationAxon
UpcasterInterface for Upcasters.Interfaceorg.axonframework.upcastingAxon
UpcasterAwareInterface indicating that the implementing mechanism is aware of Upcasters.Interfaceorg.axonframework.upcastingAxon
UpcasterChainRepresents a series of upcasters which are combined to upcast a SerializedObject to the most recent revision of that payload.Interfaceorg.axonframework.upcastingAxon
UpcasterChainBeanDefinitionParserBeanDefinitionParser that parses UpcasterChain elements.Classorg.axonframework.contextsupport.springAxon
UpcastingContextInterface describing an object that provides contextual information about the object being upcast.Interfaceorg.axonframework.upcastingAxon
UpcastSerializedDomainEventDataSerializedDomainEventData implementation that can be used to duplicate existing SerializedDomainEventData instances after upcasting a payload.Classorg.axonframework.upcastingAxon
UpcastUtilsUtility class that optimizes tasks related to upcasting.Classorg.axonframework.upcastingAxon
VersionedAggregateIdentifierStructure that holds an Aggregate Identifier and an expected version of an aggregate.Classorg.axonframework.commandhandlingAxon
VoidCallbackAbstract callback that can be extended when no result is expected from the command handler execution.Classorg.axonframework.commandhandling.callbacksAxon
VolatileEventStoreClassorg.axonframework.eventstore.supportingAxon
WeakReferenceCacheCache implementation that keeps values in the cache until the garbage collector has removed them.Classorg.axonframework.cacheAxon
WhenAggregateEventPublisherInterface to an object that publishes events on behalf of an aggregate.Interfaceorg.axonframework.test.sagaAxon
WhenStateInterface providing an API to methods in the "when" state of the fixture execution.Interfaceorg.axonframework.test.sagaAxon
XomToStringConverterConverter that converts XOM Document instances to a String.Classorg.axonframework.serializer.xmlAxon
XStreamFactoryClassorg.axonframework.gae.serializerAxon
XStreamSerializerSerializer that uses XStream to serialize and deserialize arbitrary objects.Classorg.axonframework.serializer.xmlAxon