Package org.axonframework.eventhandling.deadletter

Class DeadLetteringEventHandlerInvoker

java.lang.Object

org.axonframework.eventhandling.SimpleEventHandlerInvoker

org.axonframework.eventhandling.deadletter.DeadLetteringEventHandlerInvoker

All Implemented Interfaces:

EventHandlerInvoker, SequencedDeadLetterProcessor<EventMessage<?>>, MessageHandlerInterceptorSupport<EventMessage<?>>

public class DeadLetteringEventHandlerInvoker
extends SimpleEventHandlerInvoker
implements SequencedDeadLetterProcessor<EventMessage<?>>, MessageHandlerInterceptorSupport<EventMessage<?>>

Implementation of an EventHandlerInvoker utilizing a SequencedDeadLetterQueue to enqueue events for which handling failed.

Will use an EnqueuePolicy to deduce whether failed event handling should result in an enqueue operation. Subsequent events belonging to an already contained "sequence identifier", according to the SequencingPolicy, are also enqueued. This ensures event ordering is maintained in face of failures.

This dead lettering invoker provides several operations to process dead letters it has enqueued. It will ensure the same set of Event Handling Components is invoked as with regular event handling when processing a dead letter. These methods will try to process an entire sequence of dead letters. Furthermore, these are exposed through the SequencedDeadLetterProcessor contract.

Since:

4.6.0

Author:

Steven van Beelen

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	DeadLetteringEventHandlerInvoker.Builder	Builder class to instantiate a DeadLetteringEventHandlerInvoker.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	DeadLetteringEventHandlerInvoker(DeadLetteringEventHandlerInvoker.Builder builder)	Instantiate a dead-lettering EventHandlerInvoker based on the given builder.

Method Summary

Modifier and Type	Method	Description
static DeadLetteringEventHandlerInvoker.Builder	builder()	Instantiate a builder to construct a DeadLetteringEventHandlerInvoker.
void	handle(EventMessage<?> message, Segment segment)	Handle the given message for the given segment.
void	performReset()	Performs any activities that are required to reset the state managed by handlers assigned to this invoker.
<R> void	performReset(R resetContext)	Performs any activities that are required to reset the state managed by handlers assigned to this invoker.
boolean	process(Predicate<DeadLetter<? extends EventMessage<?>>> sequenceFilter)	Process a sequence of dead letters matching the given sequenceFilter.
Registration	registerHandlerInterceptor(MessageHandlerInterceptor<? super EventMessage<?>> interceptor)	Register the given handlerInterceptor.
void	segmentReleased(Segment segment)	This is a way for an event processor to communicate that a segment which was being processed is released.

Methods inherited from class org.axonframework.eventhandling.SimpleEventHandlerInvoker

canHandle, canHandleType, eventHandlers, getListenerInvocationErrorHandler, getSequencingPolicy, invokeHandlers, sequenceIdentifier, sequencingPolicyMatchesSegment, supportsReset

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.axonframework.messaging.deadletter.SequencedDeadLetterProcessor

processAny

Constructor Details

DeadLetteringEventHandlerInvoker

protected DeadLetteringEventHandlerInvoker(DeadLetteringEventHandlerInvoker.Builder builder)

Instantiate a dead-lettering EventHandlerInvoker based on the given builder. Uses a SequencedDeadLetterQueue to maintain and retrieve dead letters from.

Parameters:

builder - The DeadLetteringEventHandlerInvoker.Builder used to instantiate a DeadLetteringEventHandlerInvoker instance.

Method Details

builder

public static DeadLetteringEventHandlerInvoker.Builder builder()

Instantiate a builder to construct a DeadLetteringEventHandlerInvoker.

The EnqueuePolicy defaults to returning Decisions.enqueue(Throwable) that truncates the Throwable.getMessage() size to 1024 characters when invoked for any dead letter, the ListenerInvocationErrorHandler is defaulted to a PropagatingErrorHandler, the SequencingPolicy to a SequentialPerAggregatePolicy, allowReset defaults to false, sequenceIdentifierCacheEnabled defaults to false and sequenceIdentifierCacheSize defaults to 1024. Providing at least one Event Handler, a SequencedDeadLetterQueue, and a TransactionManager are hard requirements and as such should be provided.

Returns:

A builder that can construct a DeadLetteringEventHandlerInvoker.

handle

public void handle(@Nonnull
 EventMessage<?> message,
 @Nonnull
 Segment segment)
            throws Exception

Description copied from interface: EventHandlerInvoker

Handle the given message for the given segment.

Callers are recommended to invoke EventHandlerInvoker.canHandle(EventMessage, Segment) prior to invocation, but aren't required to do so. Implementations must ensure to take the given segment into account when processing messages.

Specified by:

handle in interface EventHandlerInvoker

Overrides:

handle in class SimpleEventHandlerInvoker

Parameters:

message - The message to handle

segment - The segment for which to handle the message

Throws:

Exception - when an exception occurs while handling the message

performReset

public void performReset()

Description copied from interface: EventHandlerInvoker

Performs any activities that are required to reset the state managed by handlers assigned to this invoker.

Specified by:

performReset in interface EventHandlerInvoker

Overrides:

performReset in class SimpleEventHandlerInvoker

performReset

public <R> void performReset(R resetContext)

Description copied from interface: EventHandlerInvoker

Performs any activities that are required to reset the state managed by handlers assigned to this invoker.

Specified by:

performReset in interface EventHandlerInvoker

Overrides:

performReset in class SimpleEventHandlerInvoker

Type Parameters:

R - the type of the provided resetContext

Parameters:

resetContext - a R used to support the reset operation

process

public boolean process(Predicate<DeadLetter<? extends EventMessage<?>>> sequenceFilter)

Description copied from interface: SequencedDeadLetterProcessor

Process a sequence of dead letters matching the given sequenceFilter.

Note that only a single matching sequence is processed! Furthermore, the sequenceFilter is only invoked for the first letter of a sequence, as the first entry blocks the entire sequence.

Specified by:

process in interface SequencedDeadLetterProcessor<EventMessage<?>>

Parameters:

sequenceFilter - A filter for the first dead letter entries of each sequence.

Returns:

true if at least one dead letter was processed successfully, false otherwise.

registerHandlerInterceptor

public Registration registerHandlerInterceptor(@Nonnull
 MessageHandlerInterceptor<? super EventMessage<?>> interceptor)

Description copied from interface: MessageHandlerInterceptorSupport

Register the given handlerInterceptor. After registration, the interceptor will be invoked for each handled Message on the messaging component that it was registered to, prior to invoking the message's handler.

Specified by:

registerHandlerInterceptor in interface MessageHandlerInterceptorSupport<EventMessage<?>>

Parameters:

interceptor - The interceptor to register

Returns:

A Registration, which may be used to deregister the interceptor.

segmentReleased

public void segmentReleased(Segment segment)

Description copied from interface: EventHandlerInvoker

This is a way for an event processor to communicate that a segment which was being processed is released. This might be needed or required to free resources, are clean up state which is related to the Segment.

Specified by:

segmentReleased in interface EventHandlerInvoker

Parameters:

segment - the segment which was released.