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.
Base class for builders supporting arguments.
Base class for post processors that compress the message body.
The mode used to shuffle the addresses.
Base class for
Declarable
classes.Base class for post processors that decompress the message body if the
MessageProperties.SPRING_AUTO_DECOMPRESS
header is true or to optionally always
decompress if the content encoding matches AbstractDecompressingPostProcessor.getEncoding()
, or starts with
AbstractDecompressingPostProcessor.getEncoding()
+ ":", in which case the encoding following the colon becomes
the final content encoding of the decompressed message.Base class for post processors based on
Deflater
.Common properties that describe all exchange types.
Abstract Jackson2 message converter.
Abstract type mapper.
Convenient base class for
MessageConverter
implementations.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.Acknowledgment modes supported by the listener container.
A mechanism to keep track of active objects.
Represents an address for publication of an AMQP message.
Represents a failure to commit or rollback when performing afterCompletion
after the primary transaction completes.
MessageConverters that potentially use Java deserialization.
Specifies a basic set of portable AMQP administrative operations for AMQP > 0.9.
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.
Thrown when the connection factory has been destroyed during
context close; the factory can no longer open connections.
Runtime wrapper for an authentication exception.
RuntimeException wrapper for an
ConnectException
which can be commonly
thrown from AMQP operations if the remote process dies or there is a network issue.Base class for events.
Base RuntimeException for errors that occur when executing AMQP operations.
Strategy interface for mapping messaging Message headers to an outbound
MessageProperties
(e.g.Pre-defined names and prefixes to be used for setting and/or retrieving AMQP
MessageProperties from/to
Message
Headers.Equivalent of an IllegalStateException but within the AmqpException hierarchy.
RuntimeException wrapper for an
IOException
which
can be commonly thrown from AMQP operations.A
MessageHeaderAccessor
implementation giving access to AMQP-specific headers.Exception thrown if the request message cannot be delivered when the mandatory flag is
set.
An exception thrown when a negative acknowledgement received after publishing a
message.
Exception for listener implementations used to indicate the
basic.reject will be sent with requeue=false in order to enable
features such as DLQ.
An exception that wraps an exception thrown by the server in a
request/reply scenario.
Async reply timeout.
The
AmqpException
thrown when some resource can't be accessed.Specifies a basic set of AMQP operations.
Exception thrown when some time-bound operation fails to execute in the
desired time.
RuntimeException for unsupported encoding in an AMQP operation.
Represents an anonymous, non-durable, exclusive, auto-delete queue.
Represents an argument used when declaring queues etc within a
QueueBinding
.A builder for argument maps.
Classes implementing this interface can perform asynchronous send and
receive operations using
CompletableFuture
s.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
CompletableFuture
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.
Generates names with the form
<prefix><base64url>
where 'prefix' is
'spring.gen-' by default (e.g.Base abstract class for listener container factories.
A
RabbitTemplate
that permits batching individual messages into a larger
message.Strategy for batching messages.
Used to receive a batch of messages if the container supports it.
A listener adapter for batch listeners.
Simple container collecting information to describe a binding.
The binding destination.
Basic builder class to create bindings for a more fluent API style in code based configuration.
General destination configurer.
Direct exchange routing key configurer.
Generic argument configurer.
Generic exchange routing key configurer.
Headers exchange configurer.
Topic exchange routing key configurer.
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
BrokerEvent
s.A rule that prevents integration tests from failing if the Rabbit broker application is
not running or not accessible.
A class that can be used to prevent integration tests from failing if the Rabbit broker application is
not running or not accessible.
The
RuntimeException
thrown when broker is not available
on the provided host port.Global convenience class for all integration tests, carrying constants and other utilities for broker set up.
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.Strategy for setting metadata on messages such that one can create the class
that needs to be instantiated when receiving a message.
A
RecoveryListener
that closes the recovered channel, to avoid
orphaned consumers.A composite listener that invokes its delegages in turn.
For components that support customization of the logging of certain events, users can
provide an implementation of this interface to modify the existing logging behavior.
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.
Customizer for
ConsumerBuilder
.A strategy interface to determine the consumer tag to be used when issuing a
basicConsume
operation.Called by the container factory after the container is created and configured.
Utility methods for listener containers.
A composite
MessageConverter
that delegates to an actual MessageConverter
based on the contentType header.A marker interface for data used to correlate information about sent messages.
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.
Simple container collecting information to describe a custom exchange.
Classes implementing this interface can be auto-declared
with the broker during context initialization by an
AmqpAdmin
.Beans of this type are invoked by the
AmqpAdmin
before declaring the
Declarable
, allowing customization thereof.A collection of
Declarable
objects; used to declare multiple objects on the
broker using a single bean declaration for the collection.Application event published when a declaration exception occurs.
A
ConnectionListener
that will declare a single exchange when the
connection is established.Maps to/from JSON using type information in the
MessageProperties
; the default
name of the message property containing the type is
"__TypeId__".Jackson 2 type mapper.
Default implementation of the
MessagePropertiesConverter
strategy.Default
StreamMessageConverter
.A post processor that uses a
DeflaterOutputStream
to compress the message body.A
MessagePostProcessor
that delegates to one of its MessagePostProcessor
s
depending on the content encoding.Delegates to an
InvocableHandlerMethod
based on the message payload type.Encapsulates an arbitrary message - simple "bean" holder structure.
Simple container collecting information to describe a direct exchange.
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
.Interface for all exchanges.
An exchange to which to bind a
RabbitListener
queue.Builder providing a fluent API for building
Exchange
s.Constants for the standard Exchange type names.
FactoryBean for creating Expression instances.
Simple container collecting information to describe a fanout exchange.
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 post processor that uses a
GZIPInputStream
to decompress the
message body.A post processor that uses a
GZIPOutputStream
to compress the message body.A wrapper for either an
InvocableHandlerMethod
or
DelegatingInvocableHandler
.Headers exchange.
Special exception for listener implementations that want to signal that the current
batch of messages should be acknowledged immediately (i.e.
The special
AmqpException
to be thrown from the listener (e.g.The
MessageRecoverer
implementation to throw an ImmediateRequeueAmqpException
for subsequent requeuing in the listener container.A post processor that uses a
InflaterInputStream
to decompress the
message body.The result of a listener method invocation.
Strategy for setting metadata on messages such that one can create the class that needs
to be instantiated when receiving a message.
The precedence for type conversion - inferred from the method parameter or message
headers.
JSON converter that uses the Jackson 2 Json library.
XML converter that uses the Jackson 2 Xml library.
Chained utility methods to simplify some Java repetitive code.
Utility methods for JUnit rules and conditions.
An
Answer
to optionally call the real method and allow
returning a custom result.An
Answer
for void returning methods that calls the real
method and counts down a latch.MessageListener
s 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 ListenerExecutionFailedException
s.A
RoutingConnectionFactory
that determines the node on which a queue is located and
returns a factory that connects directly to that node.Callback to determine the connection factory using the provided information.
Used to obtain a connection factory for the queue leader.
A JUnit method @Rule that changes the logger level for a set of classes
while a test method is running.
Test classes annotated with this will change logging levels between tests.
JUnit condition that adjusts and reverts log levels before/after each test.
Test classes annotated with this will not run if an environment variable or system
property (default
RUN_LONG_INTEGRATION_TESTS
) is not present or does not have
the value that Boolean.parseBoolean(String)
evaluates to true
.Rule to prevent long running tests from running on every build; set environment
variable RUN_LONG_INTEGRATION_TESTS on a CI nightly build to ensure coverage.
ExecutionCondition
to skip long running tests unless an environment
variable or property is set.A
Builder
pattern implementation for a Map
.The 0-8 and 0-9-1 AMQP specifications do not define an Message class or interface.
A listener for message ack when using
AcknowledgeMode.AUTO
.An object encapsulating a
Message
containing the batch of messages,
the exchange, and routing key.A retry recoverer for use with a batch listener.
Builds a Spring AMQP Message either from a byte[] body or
another Message using a fluent API.
Support class for building
Message
and MessageProperties
fluent API.
Exception to be thrown by message converters if they encounter a problem with converting a message or object.
Message converter interface.
Enumeration for the message delivery mode.
Listener interface to receive asynchronous delivery of Amqp Messages.
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.
Used in several places in the framework, such as
AmqpTemplate#convertAndSend(Object, MessagePostProcessor)
where it can be used
to add/modify headers or properties after the message conversion has been performed.Utilities for message post processors.
Message Properties for an AMQP message.
Builds a Spring AMQP MessageProperties object using a fluent API.
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.
Convert a
Message
from the messaging abstraction to and from a
Message
using an underlying
MessageConverter
for the payload and a
AmqpHeaderMapper
to map the
AMQP headers to and from standard message headers.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.
A strategy to generate names.
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
GenericObjectPool
s (one for transactional and one for non-transactional
channels).Called to enable customization of the
ProducerBuilder
when a new producer is
created.Uses a Spring Data
ProjectionFactory
to bind incoming messages to projection
interfaces.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
PublisherCallbackChannel
s.Channel wrapper to allow a single listener able to handle
confirms from multiple channels.
Simple container collecting information to describe a queue.
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
.Builds a Spring AMQP Queue using a fluent API.
Locate the queue leader.
Overflow argument values.
Information about a queue, resulting from a passive declaration.
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.
Test classes annotated with this will not run if there is no broker on localhost.
JUnit5
ExecutionCondition
.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.
A
RabbitFuture
with a return type of the template's
generic parameter.Translates Rabbit Exceptions to the
AmqpException
class
hierarchy.Base class for
CompletableFuture
s returned by AsyncRabbitTemplate
.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
MessageListenerContainer
s.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.
Spring Rabbit Observation for listeners.
Default
RabbitListenerObservationConvention
for Rabbit listener key values.Low cardinality tags.
ObservationConvention
for Rabbit listener key values.Container annotation that aggregates several
RabbitListener
annotations.Annotate a
@Configuration
class with this to enable proxying
@RabbitListener
beans to capture arguments and result (if any).Overrides the default BPP with a
RabbitListenerTestHarness
.BeanPostProcessor extending
RabbitListenerAnnotationBeanPostProcessor
.A
RabbitListenerConfigurationSelector
extension to register
a RabbitListenerTestBootstrap
, but already with the higher order,
so the RabbitListenerTestHarness
bean is registered earlier,
than RabbitListenerAnnotationBeanPostProcessor
.A
RabbitFuture
with a return type of Message
.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.ReceiverContext
for Message
s.SenderContext
for Message
s.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.
RuntimeHintsRegistrar
for spring-rabbit.Provides methods for sending messages using a RabbitMQ Stream producer.
Default implementation of
RabbitStreamOperations
.
Helper class that simplifies synchronous RabbitMQ access (sending and receiving messages).
A callback for publisher confirmations.
A callback for returned messages.
Adds
RabbitTemplate.TemplateConsumer.toString()
to the DefaultConsumer
.Spring RabbitMQ Observation for
RabbitTemplate
.Default
RabbitTemplateObservationConvention
for Rabbit template key values.Low cardinality tags.
ObservationConvention
for Rabbit template key values.PlatformTransactionManager
implementation for a single Rabbit
ConnectionFactory
.To be used with the receive-and-reply methods of
AmqpTemplate
as processor for inbound object and producer for outbound object.Message
exchanging contract of ReceiveAndReplyCallback
.MessageRecover that causes the listener container to reject
the message without requeuing.
A delegating adapter that unwraps
RemoteInvocationResult
after invoking
the delegate to convert from a message.Encapsulates a remote invocation result, holding a result value or an exception.
General utilities for handling remote invocations.
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.
To be used with the receive-and-reply methods of
AmqpTemplate
to determine Address
for Message
to send at runtime.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.A
LocalizedQueueConnectionFactory.NodeLocator
using the RestTemplate
.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.
Returned message and its metadata.
Implementations select a connection factory based on a supplied key.
Type safe accessor for retried message sending.
Static utility to help with serialization.
Implementation of
MessageConverter
that can work with Strings or native objects
of any kind via the Serializer
and Deserializer
abstractions in Spring.Functional sub interface enabling a lambda for the onShutDown method.
Simple implementation of
AmqpHeaderMapper
.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.
Implementation of
MessageConverter
that can work with Strings, Serializable
instances, or byte arrays.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
.An extended
MessageConverter
SPI with conversion hint support.Adds infrastructure beans to a Spring test context; do not use with Spring Boot since
it has its own auto configuration mechanism.
Container type.
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 listener container for RabbitMQ Streams.
Converts between
Message
and
Message
.A message listener that receives native stream messages.
A listener adapter that receives native stream messages.
MessageProperties
extension for stream messages.Implementations of this interface can handle failed messages after retries are
exhausted.
Factory for StreamListenerContainer.
Convenient factory bean for creating a stateless retry interceptor for use in a
StreamListenerContainer
when consuming native stream messages, giving you a
large amount of control over the behavior of a container when a listener fails.Used to complete the future exceptionally when sending fails.
Create Super Stream Topology
Declarable
s.A
RabbitTemplate
that invokes @RabbitListener
s directly.See Spring Integration TestUtils.
A very simple connection factory that caches a channel per thread.
A
Runnable
used to time out a RabbitFuture
.Simple container collecting information to describe a topic exchange.
A "catch-all" exception type within the AmqpException hierarchy
when no more specific cause is known.
A post processor that uses a
ZipInputStream
to decompress the
message body.Generates names using
UUID.randomUUID()
.A very simple hardcoded implementation of the
Expression
interface that represents an immutable value.A
LocalizedQueueConnectionFactory.NodeLocator
using the Spring WebFlux WebClient
.A post processor that uses a
ZipOutputStream
to compress the message body.