All Classes and Interfaces
Class
Description
An abstract
MessageListener adapter providing the
necessary infrastructure to extract the payload of a Message.Root object for reply expression evaluation.
The mode used to shuffle the addresses.
A handler for
Error on the container thread(s).Exception that indicates that the initial setup of this container's shared Rabbit Connection failed.
A runtime exception to wrap a
Throwable.RabbitListenerContainerFactory
for Spring's base container implementation.Base model for a Rabbit listener endpoint.
Convenient base class for interceptor factories.
Abstract
ConnectionFactory implementation that routes AbstractRoutingConnectionFactory.createConnection()
calls to one of various target ConnectionFactories based on a lookup key.A mechanism to keep track of active objects.
Represents a failure to commit or rollback when performing afterCompletion
after the primary transaction completes.
A Log4j 2 appender that publishes logging events to an AMQP Exchange.
A Logback appender that publishes logging events to an AMQP Exchange.
Manager class for the appender.
Helper class to encapsulate a LoggingEvent, its MDC properties, and the number of retries.
Small helper class to encapsulate a LoggingEvent, its MDC properties, and the number of retries.
An exception thrown when a negative acknowledgement received after publishing a
message.
Represents an argument used when declaring queues etc within a
QueueBinding.A builder for argument maps.
An event that is published whenever a consumer is restarted.
An event that is published whenever a new consumer is started.
An event that is published whenever a consumer is stopped (and not restarted).
Provides asynchronous send and receive operations returning a
ListenableFuture
allowing the caller to obtain the reply later, using get() or a callback.An exception thrown if the connection is an auto recover connection that is not
currently open and is in the process of being recovered.
Base abstract class for listener container factories.
A
RabbitTemplate that permits batching individual messages into a larger
message.Strategy for batching messages.
A listener adapter for batch listeners.
Specialized consumer encapsulating knowledge of the broker
connections and having its own lifecycle (start and stop).
Represents a broker event generated by the Event Exchange Plugin
(https://www.rabbitmq.com/event-exchange.html).
When the event-exchange-plugin is enabled (see
https://www.rabbitmq.com/event-exchange.html), if an object of this type is declared as
a bean, selected events will be published as
BrokerEvents.A
ConnectionFactory implementation that (when the cache mode is CachingConnectionFactory.CacheMode.CHANNEL (default)
returns the same Connection from all CachingConnectionFactory.createConnection()
calls, and ignores calls to Connection.close() and caches
Channel.The cache mode.
The type of publisher confirms to use.
Used to receive a batch of messages if the container supports it.
A message listener that is aware of the Channel on which the message was received.
Basic callback for use in RabbitTemplate.
A listener for new channel creation and destruction.
Subinterface of
Channel to be implemented by
Channel proxies.A
RecoveryListener that closes the recovered channel, to avoid
orphaned consumers.A composite listener that invokes its delegages in turn.
ErrorHandler that conditionally wraps the Exception in an
AmqpRejectAndDontRequeueException if the configured rejection
strategy determines that the message is fatal and should not be requeued.Default implementation of
FatalExceptionStrategy.The
AmqpEvent emitted by the CachingConnectionFactory
when its connections are blocked.An interface based ConnectionFactory for creating
Connections.Utility methods for configuring connection factories.
Helper class to handle
ConnectionFactory context binding and unbinding when executing instructions.Helper class for managing a Spring based Rabbit
ConnectionFactory,
in particular for obtaining transactional Rabbit resources for a given ConnectionFactory.Callback interface for resource creation.
A listener for connection creation and closing.
A strategy to build an application-specific connection name,
which can be displayed in the management UI if RabbitMQ server supports it.
Subinterface of
Connection to be implemented by
Connection proxies.The
AmqpEvent emitted by the CachingConnectionFactory
when its connections are unblocked.An
AmqpEvent emitted by the listener container
when consumer is subscribed to the queue.Thrown when a blocking receive operation is performed but the consumeOk
was not received before the receive timeout.
Thrown when the broker cancels the consumer and the message
queue is drained.
Consumers register their primary channels with this class.
Called by the container factory after the container is created and configured.
Utility methods for listener containers.
Base class for correlating publisher confirms to sent messages.
Represents a publisher confirmation.
A callback invoked immediately before publishing a message to update, replace, or
create correlation data for publisher confirms.
Application event published when a declaration exception occurs.
A
ConnectionListener that will declare a single exchange when the
connection is established.Default implementation of the
MessagePropertiesConverter strategy.Delegates to an
InvocableHandlerMethod based on the message payload type.Encapsulates an arbitrary message - simple "bean" holder structure.
The
SimpleMessageListenerContainer is not so simple.A
RabbitListenerContainerFactory
implementation to build a regular DirectMessageListenerContainer.Listener container for Direct ReplyTo only listens to the pseudo queue
Address.AMQ_RABBITMQ_REPLY_TO.Holder for a channel; contains a consumer epoch used to prevent inappropriate release
of the consumer after it has been allocated for reuse.
Enable Rabbit listener annotated endpoints that are created under the cover
by a
RabbitListenerContainerFactory.An exchange to which to bind a
RabbitListener queue.FactoryBean for creating Expression instances.
A strategy interface for the
ConditionalRejectingErrorHandler to
decide whether an exception should be considered to be fatal and the
message should not be requeued.Exception to be thrown when the execution of a listener method failed with an
irrecoverable problem.
Exception to be thrown when the execution of a listener method failed on startup.
A wrapper for either an
InvocableHandlerMethod or
DelegatingInvocableHandler.The
MessageRecoverer implementation to throw an ImmediateRequeueAmqpException
for subsequent requeuing in the listener container.The result of a listener method invocation.
MessageListeners that also implement this
interface can have configuration verified during initialization.Published when a listener consumer fails.
Published when a listener consumer is terminated.
A Factory bean to create a listener container.
The container type.
An event that is emitted when a container is idle if the container
is configured to do so.
Exception to be thrown when the execution of a listener method failed.
Subclass of
RuleBasedTransactionAttribute that is aware that
listener exceptions are wrapped in ListenerExecutionFailedExceptions.A
RoutingConnectionFactory that determines the node on which a queue is located and
returns a factory that connects directly to that node.An object encapsulating a
Message containing the batch of messages,
the exchange, and routing key.A retry recoverer for use with a batch listener.
Message listener adapter that delegates the handling of messages to target listener methods via reflection, with
flexible message type conversion.
Internal abstraction used by the framework representing a message
listener container.
Strategy interface for converting between Spring AMQP
MessageProperties
and RabbitMQ BasicProperties.Implementations of this interface can handle failed messages after retries are
exhausted.
Exception class that indicates a rejected message on shutdown.
A
MessageListener
adapter that invokes a configurable HandlerAdapter.A
RabbitListenerEndpoint providing the method to invoke to process
an incoming message for this endpoint.Provider of listener adapters.
Event published when a missing queue is detected.
An
ImportBeanDefinitionRegistrar class that registers
a MultiRabbitListenerAnnotationBeanPostProcessor bean, if MultiRabbit
is enabled.An extension of
RabbitListenerAnnotationBeanPostProcessor that indicates the proper
RabbitAdmin bean to be used when processing to the listeners, and also associates it to the
declarables (Exchanges, Queues, and Bindings) returned.Shared utility methods for namespace parsers.
An optimization for stateful retry of message processing.
Instances of this object track pending publisher confirms.
A very simple connection factory that caches channels using Apache Pool2
GenericObjectPools (one for transactional and one for non-transactional
channels).Instances of this interface support a single listener being
registered for publisher confirms with multiple channels,
by adding context to the callbacks.
Listeners implementing this interface can participate
in publisher confirms received from multiple channels,
by invoking addListener on each channel.
A factory for
PublisherCallbackChannels.Channel wrapper to allow a single listener able to handle
confirms from multiple channels.
A queue definition used within the bindings attribute of a
QueueBinding.Defines a queue, the exchange it is to be bound to, and an optional binding key; used
with
@RabbitListener.This exception indicates that a consumer could not be started because none of
its queues are available for listening.
RabbitMQ implementation of portable AMQP administrative operations for AMQP >= 0.9.1.
Base class for admin events.
An
ImportBeanDefinitionRegistrar class that registers
a RabbitListenerAnnotationBeanPostProcessor bean capable of processing
Spring's @RabbitListener annotation.Factory bean to create a RabbitMQ ConnectionFactory, delegating most setter methods and
optionally enabling SSL, with or without certificate validation.
Translates Rabbit Exceptions to the
AmqpException class
hierarchy.Convenient super class for application classes that need RabbitMQ access.
Annotation that marks a method to be the target of a Rabbit message
listener within a class that is annotated with
RabbitListener.Annotation that marks a method to be the target of a Rabbit message listener on the
specified
RabbitListener.queues() (or RabbitListener.bindings()).Bean post-processor that registers methods annotated with
RabbitListener
to be invoked by a AMQP message listener container created under the cover
by a RabbitListenerContainerFactory
according to the parameters of the annotation.A
DeferredImportSelector implementation with the lowest order to import a
MultiRabbitBootstrapConfiguration and RabbitBootstrapConfiguration
as late as possible.Optional interface to be implemented by Spring managed bean willing
to customize how Rabbit listener endpoints are configured.
Configuration constants for internal sharing across subpackages.
Factory of
MessageListenerContainers.Model for a Rabbit listener endpoint.
Helper bean for registering
RabbitListenerEndpoint with
a RabbitListenerEndpointRegistry.Creates the necessary
MessageListenerContainer instances for the
registered endpoints.An error handler which is called when a {code @RabbitListener} method
throws an exception.
Container annotation that aggregates several
RabbitListener annotations.A specialization of
MessageSendingOperations and MessageRequestReplyOperations
for AMQP related operations that allow to specify not only the exchange but also the
routing key to use.An implementation of
RabbitMessageOperations.Namespace handler for Rabbit.
Rabbit specific methods for Amqp functionality.
Callback for using the same channel for multiple RabbitTemplate
operations.
Rabbit resource holder, wrapping a RabbitMQ Connection and Channel.
Helper class that simplifies synchronous RabbitMQ access (sending and receiving messages).
A callback for publisher confirmations.
Deprecated.
A callback for returned messages.
Adds
RabbitTemplate.TemplateConsumer.toString() to the DefaultConsumer.PlatformTransactionManager implementation for a single Rabbit
ConnectionFactory.MessageRecover that causes the listener container to reject
the message without requeuing.
Exception to be thrown when the reply of a message failed to be sent.
A Message Listener that returns a reply - intended for lambda use in a
MessageListenerAdapter.A post processor for replies.
MessageRecoverer implementation that republishes recovered messages
to a specified exchange with the exception stack trace stored in the
message header x-exception.A
RepublishMessageRecoverer supporting publisher confirms and returns.RetryInterceptorBuilder<B extends RetryInterceptorBuilder<B,T>,T extends org.aopalliance.intercept.MethodInterceptor>
Simplified facade to make it easier and simpler to build a
StatefulRetryOperationsInterceptor or
(stateless) RetryOperationsInterceptor
by providing a fluent interface to defining the behavior on error.Builder for a stateful interceptor.
Builder for a stateless interceptor.
Implementations select a connection factory based on a supplied key.
Functional sub interface enabling a lambda for the onShutDown method.
A simple batching strategy that supports only one exchange/routingKey; includes a batch
size, a batched message size limit and a timeout.
Simply a Connection.
A
ConnectionNameStrategy that returns the value of a (required) property.A
RabbitListenerContainerFactory
implementation to build a regular SimpleMessageListenerContainer.A
RabbitListenerEndpoint simply
providing the MessageListener to invoke to process an incoming message for this
endpoint.Central helper that manages resources per thread to be used by resource management
code.
An
AbstractRoutingConnectionFactory implementation which gets a lookupKey
for current ConnectionFactory from thread-bound resource by key of the instance of
this ConnectionFactory.Convenient factory bean for creating a stateful retry interceptor for use in a message listener container, giving you
a large amount of control over the behaviour of a container when a listener fails.
Convenient factory bean for creating a stateless retry interceptor for use in a message listener container, giving
you a large amount of control over the behaviour of a container when a listener fails.
A very simple connection factory that caches a channel per thread.
A very simple hardcoded implementation of the
Expression
interface that represents an immutable value.
RabbitTemplate.ReturnCallback.returnedMessage(ReturnedMessage)which is easier to use with lambdas.