EventProcessingConfigurer (Axon Framework 4.6.8 API)

All Known Implementing Classes:

EventProcessingModule
```
public interface EventProcessingConfigurer
```
Defines a contract for configuring event processing.

Since:

4.0

Author:

Milan Savic

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`EventProcessingConfigurer.DeadLetteringInvokerConfiguration` Contract defining `DeadLetteringEventHandlerInvoker.Builder` based configuration when constructing a `DeadLetteringEventHandlerInvoker`.
`static interface`	`EventProcessingConfigurer.EventProcessorBuilder` Contract which defines how to build an event processor.
`static interface`	`EventProcessingConfigurer.PooledStreamingProcessorConfiguration` Contract defining `PooledStreamingEventProcessor.Builder` based configuration when constructing a `PooledStreamingEventProcessor`.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`EventProcessingConfigurer`	`assignHandlerInstancesMatching(String processingGroup, int priority, Predicate<Object> criteria)` Configures a rule to assign Event Handler beans that match the given `criteria` to the Processing Group with given `name`, with given `priority`.
`default EventProcessingConfigurer`	`assignHandlerInstancesMatching(String processingGroup, Predicate<Object> criteria)` Configures a rule to assign Event Handler beans that match the given `criteria` to the Processing Group with given `name`, with neutral priority (value 0).
`EventProcessingConfigurer`	`assignHandlerTypesMatching(String processingGroup, int priority, Predicate<Class<?>> criteria)` Configures a rule to assign Event Handler beans that match the given `criteria` to the Processing Group with given `name`, with given `priority`.
`default EventProcessingConfigurer`	`assignHandlerTypesMatching(String processingGroup, Predicate<Class<?>> criteria)` Configures a rule to assign Event Handler beans that match the given `criteria` to the Processing Group with given `name`, with neutral priority (value 0).
`EventProcessingConfigurer`	`assignProcessingGroup(Function<String,String> assignmentRule)` Defines a rule for assigning processing groups to processors if processing group to processor name mapping does not contain the entry.
`EventProcessingConfigurer`	`assignProcessingGroup(String processingGroup, String processorName)` Defines a mapping for assigning processing groups to processors.
`EventProcessingConfigurer`	`byDefaultAssignHandlerInstancesTo(Function<Object,String> assignmentFunction)` Registers a `Function` that defines the Event Processing Group name to assign Event Handler beans to when no other, more explicit, rule matches and no `ProcessingGroup` annotation is found.
`EventProcessingConfigurer`	`byDefaultAssignHandlerTypesTo(Function<Class<?>,String> assignmentFunction)` Registers a `Function` that defines the Event Processing Group name to assign Event Handler and Saga beans to when no other, more explicit, rule matches and no `ProcessingGroup` annotation is found.
`default EventProcessingConfigurer`	`byDefaultAssignTo(String processingGroup)` Registers the `processingGroup` name to assign Event Handler and Saga beans to when no other, more explicit, rule matches and no `ProcessingGroup` annotation is found.
`EventProcessingConfigurer`	`configureDefaultStreamableMessageSource(Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> defaultSource)` Configures which `StreamableMessageSource` to use for Tracking Event Processors if none was explicitly provided.
`EventProcessingConfigurer`	`configureDefaultSubscribableMessageSource(Function<Configuration,SubscribableMessageSource<EventMessage<?>>> defaultSource)` Configures which `SubscribableMessageSource` to use for Subscribing Event Processors if none was explicitly provided.
`default EventProcessingConfigurer`	`registerDeadLetteringEventHandlerInvokerConfiguration(String processingGroup, EventProcessingConfigurer.DeadLetteringInvokerConfiguration configuration)` Register a `EventProcessingConfigurer.DeadLetteringInvokerConfiguration` for the given `processingGroup`.
`default EventProcessingConfigurer`	`registerDeadLetterPolicy(String processingGroup, Function<Configuration,EnqueuePolicy<EventMessage<?>>> policyBuilder)` Register a `dead letter policy` for the given `processingGroup` using a `dead letter queue`.
`default EventProcessingConfigurer`	`registerDeadLetterQueue(String processingGroup, Function<Configuration,SequencedDeadLetterQueue<EventMessage<?>>> queueBuilder)` Register a `SequencedDeadLetterQueue` for the given `processingGroup`.
`default EventProcessingConfigurer`	`registerDefaultDeadLetterPolicy(Function<Configuration,EnqueuePolicy<EventMessage<?>>> policyBuilder)` Register a default `dead letter policy` for any processing group using a `dead letter queue`.
`EventProcessingConfigurer`	`registerDefaultErrorHandler(Function<Configuration,ErrorHandler> errorHandlerBuilder)` Registers a `Function` that builds the default `ErrorHandler`.
`EventProcessingConfigurer`	`registerDefaultHandlerInterceptor(BiFunction<Configuration,String,MessageHandlerInterceptor<? super EventMessage<?>>> interceptorBuilder)` Register the given `interceptorBuilder` as a default to build a `MessageHandlerInterceptor` for `EventProcessor`s created in this configuration.
`EventProcessingConfigurer`	`registerDefaultListenerInvocationErrorHandler(Function<Configuration,ListenerInvocationErrorHandler> listenerInvocationErrorHandlerBuilder)` Registers a `Function` that builds the default `ListenerInvocationErrorHandler`.
`EventProcessingConfigurer`	`registerDefaultSequencingPolicy(Function<Configuration,SequencingPolicy<? super EventMessage<?>>> policyBuilder)` Registers the `SequencingPolicy` created by given `policyBuilder` to the processing groups for which no explicit policy is defined (using `registerSequencingPolicy(String, Function)`).
`EventProcessingConfigurer`	`registerDefaultTransactionManager(Function<Configuration,TransactionManager> transactionManagerBuilder)` Registers a default `TransactionManager` for all `EventProcessor`s.
`EventProcessingConfigurer`	`registerErrorHandler(String eventProcessorName, Function<Configuration,ErrorHandler> errorHandlerBuilder)` Registers a `Function` that builds an `ErrorHandler` for the given `eventProcessorName`.
`EventProcessingConfigurer`	`registerEventHandler(Function<Configuration,Object> eventHandlerBuilder)` Registers a `Function` that builds an Event Handler instance.
`EventProcessingConfigurer`	`registerEventProcessor(String name, EventProcessingConfigurer.EventProcessorBuilder eventProcessorBuilder)` Registers an `EventProcessingConfigurer.EventProcessorBuilder` for the given processor `name`.
`EventProcessingConfigurer`	`registerEventProcessorFactory(EventProcessingConfigurer.EventProcessorBuilder eventProcessorBuilder)` Registers a factory that builds the default `EventProcessor`.
`EventProcessingConfigurer`	`registerHandlerInterceptor(String processorName, Function<Configuration,MessageHandlerInterceptor<? super EventMessage<?>>> interceptorBuilder)` Register the given `interceptorBuilder` to build a `MessageHandlerInterceptor` for the `EventProcessor` with given `processorName`.
`EventProcessingConfigurer`	`registerListenerInvocationErrorHandler(String processingGroup, Function<Configuration,ListenerInvocationErrorHandler> listenerInvocationErrorHandlerBuilder)` Registers a `Function` that builds a `ListenerInvocationErrorHandler` for the given `processingGroup`.
`default EventProcessingConfigurer`	`registerMessageMonitor(String eventProcessorName, Function<Configuration,MessageMonitor<Message<?>>> messageMonitorBuilder)` Registers a builder `Function` to create the `MessageMonitor` for a `EventProcessor` of the given `name`.
`EventProcessingConfigurer`	`registerMessageMonitorFactory(String eventProcessorName, MessageMonitorFactory messageMonitorFactory)` Registers the factory to create the `MessageMonitor` for a `EventProcessor` of the given `name`.
`default EventProcessingConfigurer`	`registerPooledStreamingEventProcessor(String name)` Registers a `PooledStreamingEventProcessor` in this `EventProcessingConfigurer`.
`default EventProcessingConfigurer`	`registerPooledStreamingEventProcessor(String name, Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> messageSource)` Registers a `PooledStreamingEventProcessor` in this `EventProcessingConfigurer`.
`EventProcessingConfigurer`	`registerPooledStreamingEventProcessor(String name, Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> messageSource, EventProcessingConfigurer.PooledStreamingProcessorConfiguration processorConfiguration)` Registers a `PooledStreamingEventProcessor` in this `EventProcessingConfigurer`.
`EventProcessingConfigurer`	`registerPooledStreamingEventProcessorConfiguration(EventProcessingConfigurer.PooledStreamingProcessorConfiguration pooledStreamingProcessorConfiguration)` Register a default `EventProcessingConfigurer.PooledStreamingProcessorConfiguration` to be used when constructing every `PooledStreamingEventProcessor`.
`EventProcessingConfigurer`	`registerPooledStreamingEventProcessorConfiguration(String name, EventProcessingConfigurer.PooledStreamingProcessorConfiguration pooledStreamingProcessorConfiguration)` Register a `EventProcessingConfigurer.PooledStreamingProcessorConfiguration` to be used when constructing a `PooledStreamingEventProcessor` with `name`.
`EventProcessingConfigurer`	`registerRollbackConfiguration(String name, Function<Configuration,RollbackConfiguration> rollbackConfigurationBuilder)` Registers a `Function` that builds the `RollbackConfiguration` for given processor `name`.
`default <T> EventProcessingConfigurer`	`registerSaga(Class<T> sagaType)` Registers a Saga with default configuration within this Configurer.
`<T> EventProcessingConfigurer`	`registerSaga(Class<T> sagaType, Consumer<SagaConfigurer<T>> sagaConfigurer)` Registers a Saga, allowing specific configuration to use for this Saga type.
`EventProcessingConfigurer`	`registerSagaStore(Function<Configuration,SagaStore> sagaStoreBuilder)` Registers a `Function` that builds a `SagaStore`.
`EventProcessingConfigurer`	`registerSequencingPolicy(String processingGroup, Function<Configuration,SequencingPolicy<? super EventMessage<?>>> policyBuilder)` Registers the `SequencingPolicy` created by the given `policyBuilder` to the processing group with given `processingGroup`.
`default EventProcessingConfigurer`	`registerSubscribingEventProcessor(String name)` Registers a `SubscribingEventProcessor` with given `name` within this Configurer.
`EventProcessingConfigurer`	`registerSubscribingEventProcessor(String name, Function<Configuration,SubscribableMessageSource<? extends EventMessage<?>>> messageSource)` Registers a `SubscribingEventProcessor` with given `name` and `messageSource` within this Configuration.
`EventProcessingConfigurer`	`registerTokenStore(Function<Configuration,TokenStore> tokenStore)` Register a `Function` that builds a `TokenStore` to use as the default in case no explicit token store was configured for a processor.
`EventProcessingConfigurer`	`registerTokenStore(String processorName, Function<Configuration,TokenStore> tokenStoreBuilder)` Register a `Function` that builds a `TokenStore` for the given `processorName`.
`default EventProcessingConfigurer`	`registerTrackingEventProcessor(String name)` Registers a `TrackingEventProcessor` with given `name` within this Configurer.
`EventProcessingConfigurer`	`registerTrackingEventProcessor(String name, Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> source)` Registers a `TrackingEventProcessor` with given `name` and `source` within this Configurer.
`EventProcessingConfigurer`	`registerTrackingEventProcessor(String name, Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> source, Function<Configuration,TrackingEventProcessorConfiguration> processorConfiguration)` Registers a `TrackingEventProcessor` with given `name`, `source` and `processorConfiguration` within this Configurer.
`EventProcessingConfigurer`	`registerTrackingEventProcessorConfiguration(Function<Configuration,TrackingEventProcessorConfiguration> trackingEventProcessorConfigurationBuilder)` Register a `Function` that builds a `TrackingEventProcessorConfiguration` to use as the default.
`EventProcessingConfigurer`	`registerTrackingEventProcessorConfiguration(String name, Function<Configuration,TrackingEventProcessorConfiguration> trackingEventProcessorConfigurationBuilder)` Register a `Function` that builds a `TrackingEventProcessorConfiguration` to be used by the `EventProcessor` corresponding to the given `name`.
`EventProcessingConfigurer`	`registerTransactionManager(String name, Function<Configuration,TransactionManager> transactionManagerBuilder)` Registers a `TransactionManager` for a `EventProcessor` of the given `name`.
`EventProcessingConfigurer`	`usingPooledStreamingEventProcessors()` Defaults Event Processors builders to use `PooledStreamingEventProcessor`.
`default EventProcessingConfigurer`	`usingPooledStreamingEventProcessors(EventProcessingConfigurer.PooledStreamingProcessorConfiguration pooledStreamingProcessorConfiguration)` Defaults Event Processors builders to construct a `PooledStreamingEventProcessor` using the `configuration` to configure them.
`EventProcessingConfigurer`	`usingSubscribingEventProcessors()` Defaults Event Processors builders to use `SubscribingEventProcessor`.
`EventProcessingConfigurer`	`usingTrackingEventProcessors()` Defaults Event Processors builders to use `TrackingEventProcessor`.

- Method Detail
  - registerSaga
```
default <T> EventProcessingConfigurer registerSaga(Class<T> sagaType)
```
    Registers a Saga with default configuration within this Configurer.
    
    Type Parameters:
    
    T - the type of Saga
    
    Parameters:
    
    sagaType - the type of Saga
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerSaga
```
<T> EventProcessingConfigurer registerSaga(Class<T> sagaType,
                                           Consumer<SagaConfigurer<T>> sagaConfigurer)
```
    Registers a Saga, allowing specific configuration to use for this Saga type.
    
    Type Parameters:
    
    T - The type of Saga to configure
    
    Parameters:
    
    sagaType - The type of Saga to configure
    
    sagaConfigurer - a function providing modifications on top of the defaul configuration
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerSagaStore
```
EventProcessingConfigurer registerSagaStore(Function<Configuration,SagaStore> sagaStoreBuilder)
```
    Registers a Function that builds a SagaStore.
    
    Parameters:
    
    sagaStoreBuilder - a Function that builds a SagaStore
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerEventHandler
```
EventProcessingConfigurer registerEventHandler(Function<Configuration,Object> eventHandlerBuilder)
```
    Registers a Function that builds an Event Handler instance.
    
    Parameters:
    
    eventHandlerBuilder - a Function that builds an Event Handler instance
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerDefaultListenerInvocationErrorHandler
```
EventProcessingConfigurer registerDefaultListenerInvocationErrorHandler(Function<Configuration,ListenerInvocationErrorHandler> listenerInvocationErrorHandlerBuilder)
```
    Registers a Function that builds the default ListenerInvocationErrorHandler. Defaults to a LoggingErrorHandler.
    
    Parameters:
    
    listenerInvocationErrorHandlerBuilder - a Function that builds the default ListenerInvocationErrorHandler
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerListenerInvocationErrorHandler
```
EventProcessingConfigurer registerListenerInvocationErrorHandler(String processingGroup,
                                                                 Function<Configuration,ListenerInvocationErrorHandler> listenerInvocationErrorHandlerBuilder)
```
    Registers a Function that builds a ListenerInvocationErrorHandler for the given processingGroup.
    
    Parameters:
    
    processingGroup - a String specifying the name of a processing group
    
    listenerInvocationErrorHandlerBuilder - a Function that builds ListenerInvocationErrorHandler
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTrackingEventProcessor
```
default EventProcessingConfigurer registerTrackingEventProcessor(String name)
```
    Registers a TrackingEventProcessor with given name within this Configurer.
    
    Parameters:
    
    name - a String specifying the name of the TrackingEventProcessor being registered
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - configureDefaultStreamableMessageSource
```
EventProcessingConfigurer configureDefaultStreamableMessageSource(Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> defaultSource)
```
    Configures which StreamableMessageSource to use for Tracking Event Processors if none was explicitly provided. Defaults to the Event Bus (or Store) available in the Configuration.
    Note that the configuration of a default source does not change how the decision is made to select the type of processor. Unless explicitly specified using usingSubscribingEventProcessors() or usingTrackingEventProcessors(), the default is dependent on the type of Message Source the Event Bus provides. If the Event Bus supports Tracking Processors, that is the default, otherwise Subscribing Event Processors are the default.
    
    Parameters:
    
    defaultSource - a Function that defines the Message source to use
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - configureDefaultSubscribableMessageSource
```
EventProcessingConfigurer configureDefaultSubscribableMessageSource(Function<Configuration,SubscribableMessageSource<EventMessage<?>>> defaultSource)
```
    Configures which SubscribableMessageSource to use for Subscribing Event Processors if none was explicitly provided. Defaults to the Event Bus (or Store) available in the Configuration.
    Note that the configuration of a default source does not change how the decision is made to select the type of processor. Unless explicitly specified using usingSubscribingEventProcessors() or usingTrackingEventProcessors(), the default is dependent on the type of Message Source the Event Bus provides. If the Event Bus supports Tracking Processors, that is the default, otherwise Subscribing Event Processors are the default.
    
    Parameters:
    
    defaultSource - a Function that defines the Message source to use
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTrackingEventProcessor
```
EventProcessingConfigurer registerTrackingEventProcessor(String name,
                                                         Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> source)
```
    Registers a TrackingEventProcessor with given name and source within this Configurer.
    
    Parameters:
    
    name - a String specifying the name of the TrackingEventProcessor being registered
    
    source - a Function that builds a StreamableMessageSource
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTrackingEventProcessor
```
EventProcessingConfigurer registerTrackingEventProcessor(String name,
                                                         Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> source,
                                                         Function<Configuration,TrackingEventProcessorConfiguration> processorConfiguration)
```
    Registers a TrackingEventProcessor with given name, source and processorConfiguration within this Configurer.
    
    Parameters:
    
    name - a String specifying the name of the TrackingEventProcessor being registered
    
    source - a Function that builds StreamableMessageSource
    
    processorConfiguration - a Function that builds a TrackingEventProcessorConfiguration
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerEventProcessorFactory
```
EventProcessingConfigurer registerEventProcessorFactory(EventProcessingConfigurer.EventProcessorBuilder eventProcessorBuilder)
```
    Registers a factory that builds the default EventProcessor. This is the EventProcessingConfigurer.EventProcessorBuilder to be used when there is no specific builder for given processor name.
    
    Parameters:
    
    eventProcessorBuilder - a Function that builds an EventProcessor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerEventProcessor
```
EventProcessingConfigurer registerEventProcessor(String name,
                                                 EventProcessingConfigurer.EventProcessorBuilder eventProcessorBuilder)
```
    Registers an EventProcessingConfigurer.EventProcessorBuilder for the given processor name.
    
    Parameters:
    
    name - a String specifying the name of the EventProcessor being registered
    
    eventProcessorBuilder - a Function that builds an EventProcessor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTokenStore
```
EventProcessingConfigurer registerTokenStore(String processorName,
                                             Function<Configuration,TokenStore> tokenStoreBuilder)
```
    Register a Function that builds a TokenStore for the given processorName.
    
    Parameters:
    
    processorName - a String specifying the name of a event processor
    
    tokenStoreBuilder - a Function that builds a TokenStore
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTokenStore
```
EventProcessingConfigurer registerTokenStore(Function<Configuration,TokenStore> tokenStore)
```
    Register a Function that builds a TokenStore to use as the default in case no explicit token store was configured for a processor.
    
    Parameters:
    
    tokenStore - a Function that builds a TokenStore
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - usingSubscribingEventProcessors
```
EventProcessingConfigurer usingSubscribingEventProcessors()
```
    Defaults Event Processors builders to use SubscribingEventProcessor.
    The default behavior depends on the EventBus available in the Configuration. If the Event Bus is a StreamableMessageSource, processors are Tracking by default. This method must be used to force the use of Subscribing Processors, unless specifically overridden for individual processors.
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - usingTrackingEventProcessors
```
EventProcessingConfigurer usingTrackingEventProcessors()
```
    Defaults Event Processors builders to use TrackingEventProcessor.
    The default behavior depends on the EventBus available in the Configuration. If the Event Bus is a StreamableMessageSource, processors are Tracking by default. This method must be used to force the use of Tracking Processors, unless specifically overridden for individual processors.
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - usingPooledStreamingEventProcessors
```
EventProcessingConfigurer usingPooledStreamingEventProcessors()
```
    Defaults Event Processors builders to use PooledStreamingEventProcessor.
    The default behavior depends on the EventBus available in the Configuration. If the EventBus is a StreamableMessageSource, processors are Tracking by default. This method must be used to force the use of Pooled Streaming Processors, unless specifically overridden for individual processors.
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - usingPooledStreamingEventProcessors
```
default EventProcessingConfigurer usingPooledStreamingEventProcessors(EventProcessingConfigurer.PooledStreamingProcessorConfiguration pooledStreamingProcessorConfiguration)
```
    Defaults Event Processors builders to construct a PooledStreamingEventProcessor using the configuration to configure them.
    The default behavior depends on the EventBus available in the Configuration. If the EventBus is a StreamableMessageSource, processors are Tracking by default. This method must be used to force the use of Pooled Streaming Processors, unless specifically overridden for individual processors.
    
    Parameters:
    
    pooledStreamingProcessorConfiguration - configuration used when constructing every PooledStreamingEventProcessor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerSubscribingEventProcessor
```
default EventProcessingConfigurer registerSubscribingEventProcessor(String name)
```
    Registers a SubscribingEventProcessor with given name within this Configurer.
    
    Parameters:
    
    name - a String specyfing the name of the SubscribingEventProcessor being registered
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerSubscribingEventProcessor
```
EventProcessingConfigurer registerSubscribingEventProcessor(String name,
                                                            Function<Configuration,SubscribableMessageSource<? extends EventMessage<?>>> messageSource)
```
    Registers a SubscribingEventProcessor with given name and messageSource within this Configuration.
    
    Parameters:
    
    name - a String specyfing the name of the SubscribingEventProcessor being registered
    
    messageSource - a Function that builds a SubscribableMessageSource
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerDefaultErrorHandler
```
EventProcessingConfigurer registerDefaultErrorHandler(Function<Configuration,ErrorHandler> errorHandlerBuilder)
```
    Registers a Function that builds the default ErrorHandler. Defaults to a PropagatingErrorHandler.
    
    Parameters:
    
    errorHandlerBuilder - a Function that builds an ErrorHandler
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerErrorHandler
```
EventProcessingConfigurer registerErrorHandler(String eventProcessorName,
                                               Function<Configuration,ErrorHandler> errorHandlerBuilder)
```
    Registers a Function that builds an ErrorHandler for the given eventProcessorName.
    
    Parameters:
    
    eventProcessorName - a String specifying the name of an EventProcessor
    
    errorHandlerBuilder - a Function that builds an ErrorHandler
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - byDefaultAssignTo
```
default EventProcessingConfigurer byDefaultAssignTo(String processingGroup)
```
    Registers the processingGroup name to assign Event Handler and Saga beans to when no other, more explicit, rule matches and no ProcessingGroup annotation is found.
    
    Parameters:
    
    processingGroup - a String specifying the name of a processing group
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - byDefaultAssignHandlerInstancesTo
```
EventProcessingConfigurer byDefaultAssignHandlerInstancesTo(Function<Object,String> assignmentFunction)
```
    Registers a Function that defines the Event Processing Group name to assign Event Handler beans to when no other, more explicit, rule matches and no ProcessingGroup annotation is found.
    
    Parameters:
    
    assignmentFunction - a Function that returns the Processing Group for each Event Handler bean
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - byDefaultAssignHandlerTypesTo
```
EventProcessingConfigurer byDefaultAssignHandlerTypesTo(Function<Class<?>,String> assignmentFunction)
```
    Registers a Function that defines the Event Processing Group name to assign Event Handler and Saga beans to when no other, more explicit, rule matches and no ProcessingGroup annotation is found.
    
    Parameters:
    
    assignmentFunction - a Function that returns the Processing Group for each Event Handler or Saga bean
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - assignHandlerInstancesMatching
```
default EventProcessingConfigurer assignHandlerInstancesMatching(String processingGroup,
                                                                 Predicate<Object> criteria)
```
    Configures a rule to assign Event Handler beans that match the given criteria to the Processing Group with given name, with neutral priority (value 0).
    Note that, when beans match multiple criteria for different Processing Groups with equal priority, the outcome is undefined.
    
    Parameters:
    
    processingGroup - a String specifying the name of a processing group to assign matching Event Handlers to
    
    criteria - a Predicate defining the criteria for an Event Handler to match
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - assignHandlerTypesMatching
```
default EventProcessingConfigurer assignHandlerTypesMatching(String processingGroup,
                                                             Predicate<Class<?>> criteria)
```
    Configures a rule to assign Event Handler beans that match the given criteria to the Processing Group with given name, with neutral priority (value 0).
    Note that, when beans match multiple criteria for different Processing Groups with equal priority, the outcome is undefined.
    
    Parameters:
    
    processingGroup - a String specifying the name of a processing group to assign matching Event Handlers or Sagas to
    
    criteria - a Predicate defining the criteria for an Event Handler or Saga to match
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - assignHandlerInstancesMatching
```
EventProcessingConfigurer assignHandlerInstancesMatching(String processingGroup,
                                                         int priority,
                                                         Predicate<Object> criteria)
```
    Configures a rule to assign Event Handler beans that match the given criteria to the Processing Group with given name, with given priority. Rules with higher value of priority take precedence over those with a lower value.
    Note that, when beans match multiple criteria for different processing groups with equal priority, the outcome is undefined.
    
    Parameters:
    
    processingGroup - a String specifying the name of a processing group to assign matching Event Handlers to
    
    priority - The priority for this rule
    
    criteria - a Predicate defining the criteria for an Event Handler to match
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - assignHandlerTypesMatching
```
EventProcessingConfigurer assignHandlerTypesMatching(String processingGroup,
                                                     int priority,
                                                     Predicate<Class<?>> criteria)
```
    Configures a rule to assign Event Handler beans that match the given criteria to the Processing Group with given name, with given priority. Rules with higher value of priority take precedence over those with a lower value.
    Note that, when beans match multiple criteria for different processing groups with equal priority, the outcome is undefined.
    
    Parameters:
    
    processingGroup - a String specifying the name of the Processing Group to assign matching Event Handlers or Sagas to
    
    priority - an int specifying the priority of this rule
    
    criteria - a Predicate defining the criteria for an Event Handler or Saga to match
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - assignProcessingGroup
```
EventProcessingConfigurer assignProcessingGroup(String processingGroup,
                                                String processorName)
```
    Defines a mapping for assigning processing groups to processors.
    
    Parameters:
    
    processingGroup - a String specifying the processing group to be assigned
    
    processorName - a String specifying the processor name to assign the group to
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - assignProcessingGroup
```
EventProcessingConfigurer assignProcessingGroup(Function<String,String> assignmentRule)
```
    Defines a rule for assigning processing groups to processors if processing group to processor name mapping does not contain the entry.
    
    Parameters:
    
    assignmentRule - a Function which takes a processing group and returns a processor name
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
    
    See Also:
    
    assignProcessingGroup(String, String)
  - registerHandlerInterceptor
```
EventProcessingConfigurer registerHandlerInterceptor(String processorName,
                                                     Function<Configuration,MessageHandlerInterceptor<? super EventMessage<?>>> interceptorBuilder)
```
    Register the given interceptorBuilder to build a MessageHandlerInterceptor for the EventProcessor with given processorName.
    The interceptorBuilder may return null, in which case the return value is ignored.
    
    Parameters:
    
    processorName - a String specyfing the name of the processor to register the MessageHandlerInterceptor on
    
    interceptorBuilder - a Function providing the MessageHandlerInterceptor to register, or null
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerDefaultHandlerInterceptor
```
EventProcessingConfigurer registerDefaultHandlerInterceptor(BiFunction<Configuration,String,MessageHandlerInterceptor<? super EventMessage<?>>> interceptorBuilder)
```
    Register the given interceptorBuilder as a default to build a MessageHandlerInterceptor for EventProcessors created in this configuration.
    The interceptorBuilder is invoked once for each processor created, and may return null, in which case the return value is ignored.
    
    Parameters:
    
    interceptorBuilder - a builder Function that provides a MessageHandlerInterceptor for each available processor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerSequencingPolicy
```
EventProcessingConfigurer registerSequencingPolicy(String processingGroup,
                                                   Function<Configuration,SequencingPolicy<? super EventMessage<?>>> policyBuilder)
```
    Registers the SequencingPolicy created by the given policyBuilder to the processing group with given processingGroup. Any previously configured policy for the same name will be overwritten.
    
    Parameters:
    
    processingGroup - a String specifying the name of the processing group to assign the SequencingPolicy for
    
    policyBuilder - a builder Function to create the SequencingPolicy to use
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerDefaultSequencingPolicy
```
EventProcessingConfigurer registerDefaultSequencingPolicy(Function<Configuration,SequencingPolicy<? super EventMessage<?>>> policyBuilder)
```
    Registers the SequencingPolicy created by given policyBuilder to the processing groups for which no explicit policy is defined (using registerSequencingPolicy(String, Function)).
    Defaults to a SequentialPerAggregatePolicy.
    
    Parameters:
    
    policyBuilder - a builder Function to create the SequencingPolicy to use
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerMessageMonitor
```
default EventProcessingConfigurer registerMessageMonitor(String eventProcessorName,
                                                         Function<Configuration,MessageMonitor<Message<?>>> messageMonitorBuilder)
```
    Registers a builder Function to create the MessageMonitor for a EventProcessor of the given name.
    
    Parameters:
    
    eventProcessorName - a String specifying the name of an EventProcessor
    
    messageMonitorBuilder - a builder Function to create a MessageMonitor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerMessageMonitorFactory
```
EventProcessingConfigurer registerMessageMonitorFactory(String eventProcessorName,
                                                        MessageMonitorFactory messageMonitorFactory)
```
    Registers the factory to create the MessageMonitor for a EventProcessor of the given name.
    
    Parameters:
    
    eventProcessorName - a String specifying the name of an EventProcessor
    
    messageMonitorFactory - a MessageMonitorFactory used to create a MessageMonitor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerRollbackConfiguration
```
EventProcessingConfigurer registerRollbackConfiguration(String name,
                                                        Function<Configuration,RollbackConfiguration> rollbackConfigurationBuilder)
```
    Registers a Function that builds the RollbackConfiguration for given processor name. Defaults to a RollbackConfigurationType.ANY_THROWABLE
    
    Parameters:
    
    name - a String specifying the name of an EventProcessor
    
    rollbackConfigurationBuilder - a Function that builds a RollbackConfiguration
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTransactionManager
```
EventProcessingConfigurer registerTransactionManager(String name,
                                                     Function<Configuration,TransactionManager> transactionManagerBuilder)
```
    Registers a TransactionManager for a EventProcessor of the given name.
    
    Parameters:
    
    name - a String specifying the name of an EventProcessor
    
    transactionManagerBuilder - a Function that builds a TransactionManager
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerDefaultTransactionManager
```
EventProcessingConfigurer registerDefaultTransactionManager(Function<Configuration,TransactionManager> transactionManagerBuilder)
```
    Registers a default TransactionManager for all EventProcessors. The provided TransactionManager is used whenever no processor specific TransactionManager is configured.
    
    Parameters:
    
    transactionManagerBuilder - a Function that builds a TransactionManager
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTrackingEventProcessorConfiguration
```
EventProcessingConfigurer registerTrackingEventProcessorConfiguration(String name,
                                                                      Function<Configuration,TrackingEventProcessorConfiguration> trackingEventProcessorConfigurationBuilder)
```
    Register a Function that builds a TrackingEventProcessorConfiguration to be used by the EventProcessor corresponding to the given name.
    
    Parameters:
    
    name - a String specifying the name of an EventProcessor
    
    trackingEventProcessorConfigurationBuilder - a Function that builds a TrackingEventProcessorConfiguration
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerTrackingEventProcessorConfiguration
```
EventProcessingConfigurer registerTrackingEventProcessorConfiguration(Function<Configuration,TrackingEventProcessorConfiguration> trackingEventProcessorConfigurationBuilder)
```
    Register a Function that builds a TrackingEventProcessorConfiguration to use as the default.
    
    Parameters:
    
    trackingEventProcessorConfigurationBuilder - a Function that builds a TrackingEventProcessorConfiguration
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerPooledStreamingEventProcessor
```
default EventProcessingConfigurer registerPooledStreamingEventProcessor(String name)
```
    Registers a PooledStreamingEventProcessor in this EventProcessingConfigurer. The processor will receive the given name.
    
    Parameters:
    
    name - the name of the PooledStreamingEventProcessor being registered
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerPooledStreamingEventProcessor
```
default EventProcessingConfigurer registerPooledStreamingEventProcessor(String name,
                                                                        Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> messageSource)
```
    Registers a PooledStreamingEventProcessor in this EventProcessingConfigurer. The processor will receive the given name and use the outcome of the messageSource as the StreamableMessageSource.
    
    Parameters:
    
    name - the name of the PooledStreamingEventProcessor being registered
    
    messageSource - constructs a StreamableMessageSource to be used by the PooledStreamingEventProcessor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerPooledStreamingEventProcessor
```
EventProcessingConfigurer registerPooledStreamingEventProcessor(String name,
                                                                Function<Configuration,StreamableMessageSource<TrackedEventMessage<?>>> messageSource,
                                                                EventProcessingConfigurer.PooledStreamingProcessorConfiguration processorConfiguration)
```
    Registers a PooledStreamingEventProcessor in this EventProcessingConfigurer. The processor will receive the given name and use the outcome of the messageSource as the StreamableMessageSource.
    The processorConfiguration will be used to further configure the PooledStreamingEventProcessor upon construction. Note that the processorConfiguration will override any configuration set through the registerPooledStreamingEventProcessorConfiguration(PooledStreamingProcessorConfiguration) and registerPooledStreamingEventProcessorConfiguration(String, PooledStreamingProcessorConfiguration).
    
    Parameters:
    
    name - the name of the PooledStreamingEventProcessor being registered
    
    messageSource - constructs a StreamableMessageSource to be used by the PooledStreamingEventProcessor
    
    processorConfiguration - allows further customization of the PooledStreamingEventProcessor under construction. The given Configuration can be used to extract components and use them in the PooledStreamingEventProcessor.Builder
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerPooledStreamingEventProcessorConfiguration
```
EventProcessingConfigurer registerPooledStreamingEventProcessorConfiguration(EventProcessingConfigurer.PooledStreamingProcessorConfiguration pooledStreamingProcessorConfiguration)
```
    Register a default EventProcessingConfigurer.PooledStreamingProcessorConfiguration to be used when constructing every PooledStreamingEventProcessor.
    
    Parameters:
    
    pooledStreamingProcessorConfiguration - configuration used when constructing every PooledStreamingEventProcessor
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerPooledStreamingEventProcessorConfiguration
```
EventProcessingConfigurer registerPooledStreamingEventProcessorConfiguration(String name,
                                                                             EventProcessingConfigurer.PooledStreamingProcessorConfiguration pooledStreamingProcessorConfiguration)
```
    Register a EventProcessingConfigurer.PooledStreamingProcessorConfiguration to be used when constructing a PooledStreamingEventProcessor with name.
    
    Parameters:
    
    name - the name of an PooledStreamingEventProcessor
    
    pooledStreamingProcessorConfiguration - configuration used when constructing a PooledStreamingEventProcessor with the given name
    
    Returns:
    
    the current EventProcessingConfigurer instance, for fluent interfacing
  - registerDeadLetterQueue
```
default EventProcessingConfigurer registerDeadLetterQueue(@Nonnull
                                                          String processingGroup,
                                                          @Nonnull
                                                          Function<Configuration,SequencedDeadLetterQueue<EventMessage<?>>> queueBuilder)
```
    Register a SequencedDeadLetterQueue for the given processingGroup. The SequencedDeadLetterQueue will automatically enqueue failed events and evaluate them per the queue's configuration.
    
    Parameters:
    
    processingGroup - A String specifying the name of the processing group to register the given SequencedDeadLetterQueue for.
    
    queueBuilder - A builder method returning a SequencedDeadLetterQueue based on a Configuration. The outcome is used by the given processingGroup to enqueue and evaluate failed events in.
    
    Returns:
    
    The current EventProcessingConfigurer instance, for fluent interfacing.
  - registerDefaultDeadLetterPolicy
```
default EventProcessingConfigurer registerDefaultDeadLetterPolicy(@Nonnull
                                                                  Function<Configuration,EnqueuePolicy<EventMessage<?>>> policyBuilder)
```
    Register a default dead letter policy for any processing group using a dead letter queue. The processing group uses the policy to deduce whether a failed EventMessage should be enqueued for later evaluation.
    Note that the configured component will not be used if the processing group does not have a dead letter queue.
    
    Parameters:
    
    policyBuilder - A builder method to construct a default dead letter policy.
    
    Returns:
    
    The current EventProcessingConfigurer instance, for fluent interfacing.
  - registerDeadLetterPolicy
```
default EventProcessingConfigurer registerDeadLetterPolicy(@Nonnull
                                                           String processingGroup,
                                                           @Nonnull
                                                           Function<Configuration,EnqueuePolicy<EventMessage<?>>> policyBuilder)
```
    Register a dead letter policy for the given processingGroup using a dead letter queue. The processing group uses the policy to deduce whether a failed EventMessage should be enqueued for later evaluation.
    Note that the configured component will not be used if the processing group does not have a dead letter queue.
    
    Parameters:
    
    processingGroup - The name of the processing group to build an EnqueuePolicy for.
    
    policyBuilder - A builder method to construct a dead letter policy for the given processingGroup.
    
    Returns:
    
    The current EventProcessingConfigurer instance, for fluent interfacing.
  - registerDeadLetteringEventHandlerInvokerConfiguration
```
default EventProcessingConfigurer registerDeadLetteringEventHandlerInvokerConfiguration(@Nonnull
                                                                                        String processingGroup,
                                                                                        @Nonnull
                                                                                        EventProcessingConfigurer.DeadLetteringInvokerConfiguration configuration)
```
    Register a EventProcessingConfigurer.DeadLetteringInvokerConfiguration for the given processingGroup. This configuration object allows for fine-grained customization of a dead lettering processing group through its builder.
    Note that the configured component will not be used if the processing group does not have a dead letter queue.
    
    Parameters:
    
    processingGroup - The name of the processing group to attach additional configuration too.
    
    configuration - The additional configuration for the dead lettering processing group.
    
    Returns:
    
    The current EventProcessingConfigurer instance, for fluent interfacing.

Interface EventProcessingConfigurer

Nested Class Summary

Method Summary

Method Detail

registerSaga

registerSaga

registerSagaStore

registerEventHandler

registerDefaultListenerInvocationErrorHandler

registerListenerInvocationErrorHandler

registerTrackingEventProcessor

configureDefaultStreamableMessageSource

configureDefaultSubscribableMessageSource

registerTrackingEventProcessor

registerTrackingEventProcessor

registerEventProcessorFactory

registerEventProcessor

registerTokenStore

registerTokenStore

usingSubscribingEventProcessors

usingTrackingEventProcessors

usingPooledStreamingEventProcessors

usingPooledStreamingEventProcessors

registerSubscribingEventProcessor

registerSubscribingEventProcessor

registerDefaultErrorHandler

registerErrorHandler

byDefaultAssignTo

byDefaultAssignHandlerInstancesTo

byDefaultAssignHandlerTypesTo

assignHandlerInstancesMatching

assignHandlerTypesMatching

assignHandlerInstancesMatching

assignHandlerTypesMatching

assignProcessingGroup

assignProcessingGroup

registerHandlerInterceptor

registerDefaultHandlerInterceptor

registerSequencingPolicy

registerDefaultSequencingPolicy

registerMessageMonitor

registerMessageMonitorFactory

registerRollbackConfiguration

registerTransactionManager

registerDefaultTransactionManager

registerTrackingEventProcessorConfiguration

registerTrackingEventProcessorConfiguration

registerPooledStreamingEventProcessor

registerPooledStreamingEventProcessor

registerPooledStreamingEventProcessor

registerPooledStreamingEventProcessorConfiguration

registerPooledStreamingEventProcessorConfiguration

registerDeadLetterQueue

registerDefaultDeadLetterPolicy

registerDeadLetterPolicy

registerDeadLetteringEventHandlerInvokerConfiguration