All Known Implementing Classes:

Outboxes.DurableQueueBasedOutboxes.DurableQueueBasedOutbox
```
public interface Outbox
```
The Outbox supports the transactional Store and Forward pattern from Enterprise Integration Patterns supporting At-Least-Once delivery guarantee.
The Outbox pattern is used to handle outgoing messages, that are created as a side effect of adding/updating an entity in a database, but where the message infrastructure (such as a Queue, Kafka, EventBus, etc.) that doesn't share the same underlying transactional resource as the database.
Instead, you need to use an Outbox that can join in the same UnitOfWork/transactional-resource that the database is using.
The message is added to the Outbox in a transaction/UnitOfWork and afterwards the UnitOfWork is committed.
If the transaction fails then both the entity and the message will be rolled back when then UnitOfWork rolls back.
After the UnitOfWork has been committed, the messages will be asynchronously delivered to the message consumer in a new UnitOfWork.
The Outbox itself supports Message Redelivery in case the Message consumer experiences failures.
This means that the Message consumer, registered with the Outbox, can and will receive Messages more than once and therefore its message handling has to be idempotent.
If you're working with OrderedMessage's then the Outbox consumer must be configured with OutboxConfig.getMessageConsumptionMode() having value MessageConsumptionMode.SingleGlobalConsumer in order to be able to guarantee that OrderedMessage's are delivered in OrderedMessage.getOrder() per OrderedMessage.getKey() across as many OutboxConfig.numberOfParallelMessageConsumers as you wish to use.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`Outbox`	`consume(Consumer<Message> messageConsumer)`	Start consuming messages from the Outbox using the provided message consumer. Only needs to be called if the instance was created without a message consumer
`long`	`getNumberOfOutgoingMessages()`	Get the number of message in the outbox that haven't been sent yet
`boolean`	`hasAMessageConsumer()`	Has the instance been created with a Message consumer or has `consume(Consumer)` been called
`boolean`	`isConsumingMessages()`	Is the provided Message consumer consuming messages from the `Outbox`
`OutboxName`	`name()`	The name of the outbox
`void`	`sendMessage(Message message)`	Send a message asynchronously. This message will be stored durably (without any duplication check) in connection with the currently active `UnitOfWork` (or a new `UnitOfWork` will be created in case no there isn't an active `UnitOfWork`). The message will be delivered asynchronously to the message consumer
`default void`	`sendMessage(Object payload)`	Send a message (without meta-data) asynchronously. This message will be stored durably (without any duplication check) in connection with the currently active `UnitOfWork` (or a new `UnitOfWork` will be created in case no there isn't an active `UnitOfWork`). The message will be delivered asynchronously to the message consumer
`default void`	`sendMessage(Object payload, MessageMetaData metaData)`	Send a message (with meta-data) asynchronously. This message will be stored durably (without any duplication check) in connection with the currently active `UnitOfWork` (or a new `UnitOfWork` will be created in case no there isn't an active `UnitOfWork`). The message will be delivered asynchronously to the message consumer
`void`	`stopConsuming()`	Stop consuming messages from the `Outbox`.

- Method Detail
  - consume
```
Outbox consume(Consumer<Message> messageConsumer)
```
    Start consuming messages from the Outbox using the provided message consumer.
    Only needs to be called if the instance was created without a message consumer
    If an OrderedMessage is delivered via an Outbox using a FencedLock (such as the Outboxes.durableQueueBasedOutboxes(DurableQueues, FencedLockManager)) to coordinate message consumption, then you can find the FencedLock.getCurrentToken() of the consumer in the Message.getMetaData() under key MessageMetaData.FENCED_LOCK_TOKEN
    
    Parameters:
    
    messageConsumer - the message consumer. See PatternMatchingMessageHandler
    
    Returns:
    
    this outbox instance
  - stopConsuming
```
void stopConsuming()
```
    Stop consuming messages from the Outbox. Calling this method will remove the message consumer and to resume message consumption you need to call consume(Consumer)
  - hasAMessageConsumer
```
boolean hasAMessageConsumer()
```
    Has the instance been created with a Message consumer or has consume(Consumer) been called
    
    Returns:
    
    Has the instance been created with a Message consumer or has consume(Consumer) been called
  - isConsumingMessages
```
boolean isConsumingMessages()
```
    Is the provided Message consumer consuming messages from the Outbox
    
    Returns:
    
    Is the provided Message consumer consuming messages from the Outbox
  - name
```
OutboxName name()
```
    The name of the outbox
    
    Returns:
    
    the name of the outbox
  - sendMessage
```
default void sendMessage(Object payload)
```
    Send a message (without meta-data) asynchronously.
    This message will be stored durably (without any duplication check) in connection with the currently active UnitOfWork (or a new UnitOfWork will be created in case no there isn't an active UnitOfWork).
    The message will be delivered asynchronously to the message consumer
    
    Parameters:
    
    payload - the message payload
  - sendMessage
```
default void sendMessage(Object payload,
                         MessageMetaData metaData)
```
    Send a message (with meta-data) asynchronously.
    This message will be stored durably (without any duplication check) in connection with the currently active UnitOfWork (or a new UnitOfWork will be created in case no there isn't an active UnitOfWork).
    The message will be delivered asynchronously to the message consumer
    
    Parameters:
    
    payload - the message payload
    
    metaData - the message meta-data
  - sendMessage
```
void sendMessage(Message message)
```
    Send a message asynchronously.
    This message will be stored durably (without any duplication check) in connection with the currently active UnitOfWork (or a new UnitOfWork will be created in case no there isn't an active UnitOfWork).
    The message will be delivered asynchronously to the message consumer
    
    Parameters:
    
    message - the message
    
    See Also:
    
    OrderedMessage
  - getNumberOfOutgoingMessages
```
long getNumberOfOutgoingMessages()
```
    Get the number of message in the outbox that haven't been sent yet
    
    Returns:
    
    Get the number of message in the outbox that haven't been sent yet

Interface Outbox

Method Summary

Method Detail

consume

stopConsuming

hasAMessageConsumer

isConsumingMessages

name

sendMessage

sendMessage

sendMessage

getNumberOfOutgoingMessages