Package org.axonframework.messaging.eventhandling.deadletter.jdbc

Class DefaultDeadLetterStatementFactory<E extends EventMessage>

java.lang.Object

org.axonframework.messaging.eventhandling.deadletter.jdbc.DefaultDeadLetterStatementFactory<E>

Type Parameters:

E - An implementation of EventMessage within the DeadLetter this factory constructs PreparedStatements for.

All Implemented Interfaces:

DeadLetterStatementFactory<E>

public class DefaultDeadLetterStatementFactory<E extends EventMessage>
extends Object
implements DeadLetterStatementFactory<E>

Default implementation of the DeadLetterStatementFactory used by the JdbcSequencedDeadLetterQueue. Constructs PreparedStatements that are compatible with most databases.

This factory expects a DeadLetterSchema to base the table and columns names used for all PreparedStatements. Furthermore, it uses the configurable genericConverter to convert TrackingTokens and diagnostics. Lastly, this factory uses the eventConverter to convert the event payload and Metadata of any DeadLetter.

This factory and the DeadLetterJdbcConverter must use the same Converter and EventConverter and DeadLetterSchema for the applicable fields.

Since:

4.8.0

Author:

Steven van Beelen

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected static class	DefaultDeadLetterStatementFactory.Builder<E extends EventMessage>	Builder class to instantiate a DefaultDeadLetterStatementFactory.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	DefaultDeadLetterStatementFactory(DefaultDeadLetterStatementFactory.Builder<E> builder)	Instantiate a default DeadLetterStatementFactory based on the given builder.

Method Summary

Modifier and Type	Method	Description
PreparedStatement	amountOfSequencesStatement(Connection connection, String processingGroup)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#amountOfSequences() operation.
static <E extends EventMessage> DefaultDeadLetterStatementFactory.Builder<E>	builder()	Instantiate a builder to construct a DefaultDeadLetterStatementFactory.
PreparedStatement	claimableSequencesStatement(Connection connection, String processingGroup, Instant processingStartedLimit, int offset, int maxSize)	Constructs the PreparedStatement used to retrieve the identifiers of the first entries of each sequence with that can be claimed.
PreparedStatement	claimStatement(Connection connection, String identifier, Instant current, Instant processingStartedLimit)	Constructs the PreparedStatement used to claim a DeadLetter entry.
PreparedStatement	clearStatement(Connection connection, String processingGroup)	Constructs the PreparedStatement used for the invalid reference clear operation.
PreparedStatement	containsStatement(Connection connection, String processingGroup, String sequenceId)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#contains(Object) operation.
PreparedStatement	enqueueStatement(Connection connection, String processingGroup, String sequenceIdentifier, DeadLetter<? extends E> letter, long sequenceIndex)	Constructs the PreparedStatement used for the JdbcSequencedDeadLetterQueue.enqueue(Object, DeadLetter, ProcessingContext) operation.
PreparedStatement	evictStatement(Connection connection, String identifier)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#evict(DeadLetter) operation.
PreparedStatement	letterSequenceStatement(Connection connection, String processingGroup, String sequenceId, int offset, int maxSize)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#deadLetterSequence(Object) operation.
PreparedStatement	maxIndexStatement(Connection connection, String processingGroup, String sequenceId)	Constructs the PreparedStatement used to retrieve the maximum index of the sequence identified with the given sequenceIdentifier.
PreparedStatement	nextLetterInSequenceStatement(Connection connection, String processingGroup, String sequenceIdentifier, long sequenceIndex)	Constructs the PreparedStatement used to retrieve the following DeadLetter from the sequence identified with the given sequenceIdentifier.
PreparedStatement	requeueStatement(Connection connection, String letterIdentifier, Cause cause, Instant lastTouched, Metadata diagnostics)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#requeue(DeadLetter, UnaryOperator) operation.
PreparedStatement	sequenceIdentifiersStatement(Connection connection, String processingGroup)	Constructs the PreparedStatement used to iterate over all sequences contained in the queue for the invalid reference JdbcSequencedDeadLetterQueue#deadLetters() operation.
PreparedStatement	sequenceSizeStatement(Connection connection, String processingGroup, String sequenceId)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#sequenceSize(Object) operation.
PreparedStatement	sizeStatement(Connection connection, String processingGroup)	Constructs the PreparedStatement used for the invalid reference JdbcSequencedDeadLetterQueue#size() operation.

Methods inherited from class java.lang.Object

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

Constructor Details

DefaultDeadLetterStatementFactory

protected DefaultDeadLetterStatementFactory(DefaultDeadLetterStatementFactory.Builder<E> builder)

Instantiate a default DeadLetterStatementFactory based on the given builder.

Will validate whether the generic Converter and EventConverter are set. If for either this is not the case an AxonConfigurationException is thrown.

Parameters:

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

Method Details

builder

public static <E extends EventMessage>
DefaultDeadLetterStatementFactory.Builder<E> builder()

Instantiate a builder to construct a DefaultDeadLetterStatementFactory.

The schema is defaulted to a DeadLetterSchema.defaultSchema(). The generic Converter and EventConverter are hard requirements and should be provided.

Type Parameters:

E - An implementation of EventMessage within the DeadLetter this factory constructs PreparedStatements for.

Returns:

A builder that can construct a DefaultDeadLetterStatementFactory.

enqueueStatement

public PreparedStatement enqueueStatement(Connection connection,
 String processingGroup,
 String sequenceIdentifier,
 DeadLetter<? extends E> letter,
 long sequenceIndex)
                                   throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the JdbcSequencedDeadLetterQueue.enqueue(Object, DeadLetter, ProcessingContext) operation.

Context resources (e.g., tracking token, aggregate data) are read from DeadLetter.context().

Specified by:

enqueueStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to enqueue the given letter.

sequenceIdentifier - The identifier of the sequence the letter belongs to.

letter - The letter to enqueue.

sequenceIndex - The index of the letter within the sequence, to ensure the processing order is maintained.

Returns:

The PreparedStatement used to enqueue.

Throws:

SQLException - When the statement could not be created.

maxIndexStatement

public PreparedStatement maxIndexStatement(Connection connection,
 String processingGroup,
 String sequenceId)
                                    throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used to retrieve the maximum index of the sequence identified with the given sequenceIdentifier.

Used by the

invalid reference

JdbcSequencedDeadLetterQueue#enqueue(Object, DeadLetter)

to deduce the index of the DeadLetter in its sequence.

Specified by:

maxIndexStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to retrieve the maximum index of the sequence identified through the given sequenceIdentifier.

sequenceId - The identifier of the sequence for which to retrieve the maximum index for.

Returns:

The PreparedStatement used to retrieve the maximum index with.

Throws:

SQLException - When the statement could not be created.

evictStatement

public PreparedStatement evictStatement(Connection connection,
 String identifier)
                                 throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#evict(DeadLetter)

operation.

Specified by:

evictStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

identifier - The identifier of the DeadLetter to evict.

Returns:

The PreparedStatement used to

invalid reference

evict

.

Throws:

SQLException - When the statement could not be created.

requeueStatement

public PreparedStatement requeueStatement(Connection connection,
 String letterIdentifier,
 Cause cause,
 Instant lastTouched,
 Metadata diagnostics)
                                   throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#requeue(DeadLetter, UnaryOperator)

operation.

Specified by:

requeueStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

letterIdentifier - The identifier of the DeadLetter to requeue.

cause - The cause of requeueing the DeadLetter identified through the given identifier.

lastTouched - The Instant the DeadLetter to requeue was last processed.

diagnostics - The new diagnostics to attach to the DeadLetter to requeue.

Returns:

The PreparedStatement used to

invalid reference

requeue

.

Throws:

SQLException - When the statement could not be created.

containsStatement

public PreparedStatement containsStatement(Connection connection,
 String processingGroup,
 String sequenceId)
                                    throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#contains(Object)

operation.

Specified by:

containsStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to check whether the sequence identified by the given sequenceIdentifier.

sequenceId - The identifier of the sequence to validate whether it is contained in the queue.

Returns:

The PreparedStatement used to check whether the given sequenceIdentifier is

invalid reference

contained

in the queue.

Throws:

SQLException - When the statement could not be created.

letterSequenceStatement

public PreparedStatement letterSequenceStatement(Connection connection,
 String processingGroup,
 String sequenceId,
 int offset,
 int maxSize)
                                          throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#deadLetterSequence(Object)

operation.

As dead-letter sequences can be large, the JdbcSequencedDeadLetterQueue assumes it needs to page through the result set. To that end it is recommended to use the given offset to define the starting point of the query (for example by validate the DeadLetterSchema.sequenceIndexColumn()). The given maxSize can be used to limit the result.

Specified by:

letterSequenceStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to retrieve a dead-letter sequence.

sequenceId - The identifier of the sequence to retrieve.

offset - The offset from where to start the PreparedStatement under construction.

maxSize - The maximum size to limit the PreparedStatement under construction.

Returns:

The PreparedStatement used to return the dead letter sequence for the given sequenceIdentifier with.

Throws:

SQLException - When the statement could not be created.

sequenceIdentifiersStatement

public PreparedStatement sequenceIdentifiersStatement(Connection connection,
 String processingGroup)
                                               throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used to iterate over all sequences contained in the queue for the

invalid reference

JdbcSequencedDeadLetterQueue#deadLetters()

operation.

Specified by:

sequenceIdentifiersStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to retrieve all sequence identifiers.

Returns:

The PreparedStatement used to return all sequence identifiers enqueued in the given processingGroup with.

Throws:

SQLException - When the statement could not be created.

sizeStatement

public PreparedStatement sizeStatement(Connection connection,
 String processingGroup)
                                throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#size()

operation.

Specified by:

sizeStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to retrieve the size for.

Returns:

The PreparedStatement used to retrieve the size with.

Throws:

SQLException - When the statement could not be created.

sequenceSizeStatement

public PreparedStatement sequenceSizeStatement(Connection connection,
 String processingGroup,
 String sequenceId)
                                        throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#sequenceSize(Object)

operation.

Specified by:

sequenceSizeStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to retrieve the size of the identified sequence.

sequenceId - The identifier of the sequence for which to retrieve the size.

Returns:

The PreparedStatement used to retrieve the size of the sequence identified by the given sequenceIdentifier with.

Throws:

SQLException - When the statement could not be created.

amountOfSequencesStatement

public PreparedStatement amountOfSequencesStatement(Connection connection,
 String processingGroup)
                                             throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

JdbcSequencedDeadLetterQueue#amountOfSequences()

operation.

Specified by:

amountOfSequencesStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to retrieve the amount of sequences.

Returns:

The PreparedStatement used to retrieve the amount of sequences with.

Throws:

SQLException - When the statement could not be created.

claimableSequencesStatement

public PreparedStatement claimableSequencesStatement(Connection connection,
 String processingGroup,
 Instant processingStartedLimit,
 int offset,
 int maxSize)
                                              throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used to retrieve the identifiers of the first entries of each sequence with that can be claimed.

Used by the

invalid reference

JdbcSequencedDeadLetterQueue#process(Function)

and

invalid reference

JdbcSequencedDeadLetterQueue#process(Predicate, Function)

operations. A row may be claimed if the processing started field is older than the given processingStartedLimit.

The amount of sequences in a queue can be vast, hence the JdbcSequencedDeadLetterQueue assumes it needs to page through the result set. To that end it is recommended to use the given offset to define the starting point of the query (for example by validate the DeadLetterSchema.sequenceIndexColumn()). The given maxSize can be used to limit the result.

Specified by:

claimableSequencesStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group to find claimable sequences for.

processingStartedLimit - The Instant used to compare with the processing started field.

offset - The offset from where to start the PreparedStatement under construction.

maxSize - The maximum size to limit the PreparedStatement under construction.

Returns:

The PreparedStatement used to find the identifier of the first entries of each sequence that are claimable.

Throws:

SQLException - When the statement could not be created.

claimStatement

public PreparedStatement claimStatement(Connection connection,
 String identifier,
 Instant current,
 Instant processingStartedLimit)
                                 throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used to claim a DeadLetter entry.

Claiming a DeadLetter ensures only a single thread

invalid reference

processes

the DeadLetter. This operation typically update the processing started field with the given current Instant, marking it as claimed for a certain timeframe.

The returned statement is used after the JdbcSequencedDeadLetterQueue searched for claimable sequences during a

invalid reference

JdbcSequencedDeadLetterQueue#process(Function)

or

invalid reference

JdbcSequencedDeadLetterQueue#process(Predicate, Function)

invocation.

Specified by:

claimStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

identifier - The identifier of the DeadLetter to claim.

current - The Instant used to update the processing started field with to mark it as claimed.

processingStartedLimit - The Instant used to compare with the processing started field, to ensure it wasn't claimed by another process.

Returns:

The PreparedStatement used to claim a DeadLetter with for

invalid reference

processing

, ensuring no two threads are processing the same letter.

Throws:

SQLException - When the statement could not be created.

nextLetterInSequenceStatement

public PreparedStatement nextLetterInSequenceStatement(Connection connection,
 String processingGroup,
 String sequenceIdentifier,
 long sequenceIndex)
                                                throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used to retrieve the following DeadLetter from the sequence identified with the given sequenceIdentifier. The returned statement is used after the

The returned statement is used after the JdbcSequencedDeadLetterQueue claimed a letter and successfully processed it during a

invalid reference

JdbcSequencedDeadLetterQueue#process(Function)

or

invalid reference

JdbcSequencedDeadLetterQueue#process(Predicate, Function)

invocation.

Specified by:

nextLetterInSequenceStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to return the following DeadLetter in the sequence identified by the given sequenceIdentifier.

sequenceIdentifier - The identifier of the sequence for which to retrieve the following DeadLetter for.

sequenceIndex - The index of the letter preceding the following DeadLetter to retrieve.

Returns:

The PreparedStatement used to retrieve the DeadLetter in the sequence identified by the given sequenceIdentifier with.

Throws:

SQLException - When the statement could not be created.

clearStatement

public PreparedStatement clearStatement(Connection connection,
 String processingGroup)
                                 throws SQLException

Description copied from interface: DeadLetterStatementFactory

Constructs the PreparedStatement used for the

invalid reference

clear

operation.

Will only remove all entries for the given processingGroup.

Specified by:

clearStatement in interface DeadLetterStatementFactory<E extends EventMessage>

Parameters:

connection - The Connection used to create the PreparedStatement.

processingGroup - The processing group for which to clear all entries.

Returns:

The PreparedStatement used to

invalid reference

clear

all entries for the given processingGroup with.

Throws:

SQLException - When the statement could not be created.