org.axonframework.eventhandling

Class AbstractEventProcessor

java.lang.Object

org.axonframework.eventhandling.AbstractEventProcessor

All Implemented Interfaces:

EventProcessor

Direct Known Subclasses:

SubscribingEventProcessor, TrackingEventProcessor

public abstract class AbstractEventProcessor
extends Object
implements EventProcessor

Abstract implementation of an EventProcessor. Before processing of a batch of messages this implementation creates a Unit of Work to process the batch.

Actual handling of events is deferred to an EventHandlerInvoker. Before each message is handled by the invoker this event processor creates an interceptor chain containing all registered interceptors.

Implementations are in charge of providing the events that need to be processed. Once these events are obtained they can be passed to method processInUnitOfWork(List, UnitOfWork, Segment) for processing.

Author:

Rene de Waele

Constructor Summary

Constructors

Constructor and Description
AbstractEventProcessor(String name, EventHandlerInvoker eventHandlerInvoker, RollbackConfiguration rollbackConfiguration, ErrorHandler errorHandler, MessageMonitor<? super EventMessage<?>> messageMonitor) Initializes an event processor with given name.

Method Summary

Modifier and Type	Method and Description
protected boolean	canHandle(EventMessage<?> eventMessage, Segment segment) Indicates whether the processor can/should handle the given eventMessage for the given segment.
String	getName() Returns the name of this event processor.
protected void	processInUnitOfWork(List<? extends EventMessage<?>> eventMessages, UnitOfWork<? extends EventMessage<?>> unitOfWork, Segment segment) Process a batch of events.
Registration	registerInterceptor(MessageHandlerInterceptor<? super EventMessage<?>> interceptor) Registers the given interceptor to this event processor.
protected void	reportIgnored(EventMessage<?> eventMessage) Report the given eventMessage as ignored.
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.axonframework.eventhandling.EventProcessor

shutDown, start

Constructor Detail

AbstractEventProcessor

public AbstractEventProcessor(String name,
                              EventHandlerInvoker eventHandlerInvoker,
                              RollbackConfiguration rollbackConfiguration,
                              ErrorHandler errorHandler,
                              MessageMonitor<? super EventMessage<?>> messageMonitor)

Initializes an event processor with given name. Actual handling of event messages is deferred to the given eventHandlerInvoker.

Parameters:

name - The name of the event processor

eventHandlerInvoker - The component that handles the individual events

rollbackConfiguration - Determines rollback behavior of the UnitOfWork while processing a batch of events

errorHandler - Invoked when a UnitOfWork is rolled back during processing. If null a PropagatingErrorHandler is used.

messageMonitor - Monitor to be invoked before and after event processing. If null a NoOpMessageMonitor is used.

Method Detail

getName

public String getName()

Description copied from interface: EventProcessor

Returns the name of this event processor. This name is used to detect distributed instances of the same event processor. Multiple instances referring to the same logical event processor (on different JVM's) must have the same name.

Specified by:

getName in interface EventProcessor

Returns:

the name of this event processor

registerInterceptor

public Registration registerInterceptor(MessageHandlerInterceptor<? super EventMessage<?>> interceptor)

Description copied from interface: EventProcessor

Registers the given interceptor to this event processor. The interceptor will receive each event message that is about to be published but before it has reached its event handlers. Interceptors are free to modify the event message or stop publication altogether. In addition, interceptors are able to interact with the UnitOfWork that is created to process the message.

For example, if a CorrelationDataInterceptor is registered, each command or event message triggered in response to an intercepted event will get correlation metadata from the intercepted event.

Specified by:

registerInterceptor in interface EventProcessor

Parameters:

interceptor - The interceptor to register.

Returns:

a handle to unregister the interceptor. When unregistered the interceptor will no longer receive events from this event processor.

toString

public String toString()

Overrides:

toString in class Object

canHandle

protected boolean canHandle(EventMessage<?> eventMessage,
                            Segment segment)

Indicates whether the processor can/should handle the given eventMessage for the given segment.

This implementation will delegate the decision to the EventHandlerInvoker.

Parameters:

eventMessage - The message for which to identify if the processor can handle it

segment - The segment for which the event should be processed

Returns:

true if the event message should be handled, otherwise false

processInUnitOfWork

protected void processInUnitOfWork(List<? extends EventMessage<?>> eventMessages,
                                   UnitOfWork<? extends EventMessage<?>> unitOfWork,
                                   Segment segment)
                            throws Exception

Process a batch of events. The messages are processed in a new UnitOfWork. Before each message is handled the event processor creates an interceptor chain containing all registered interceptors.

Parameters:

eventMessages - The batch of messages that is to be processed

unitOfWork - The Unit of Work that has been prepared to process the messages

segment - The segment for which the events should be processed

Throws:

Exception - when an exception occurred during processing of the batch

reportIgnored

protected void reportIgnored(EventMessage<?> eventMessage)

Report the given eventMessage as ignored. Any registered MessageMonitor shall be notified of the ignored message.

Typically, messages are ignored when they are received by a processor that has no suitable Handler for the type of Event received.

Parameters:

eventMessage - the message that has been ignored.