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.
Default implementation of
ConditionalExceptionLogger for logging channel close exceptions.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.Default implementation of
ConditionalExceptionLogger for logging exclusive
consumer failures.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.Extension of the
DefaultMessageHandlerMethodFactory for Spring AMQP requirements.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
CompletableFutures.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.An
AbstractBuilder extension for generics support.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
BrokerEvents.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 delegates in turn.
Implementation of
ContainerCustomizer providing the configuration of
multiple customizers at the same time.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
AbstractExchange extension for Consistent Hash exchange type.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.No-op resolver for method arguments of type
Continuation.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 MessagePostProcessors
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
Exchanges.An
ExchangeBuilder extension for the ConsistentHashExchange.Constants for the standard Exchange type names.
FactoryBean for creating Expression instances.
Callback to determine the connection factory using the provided information.
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.
The utilities for Jackson
ObjectMapper instances.Chained utility methods to simplify some Java repetitive code.
Utility methods for JUnit rules and conditions.
An
InvocableHandlerMethod extension for supporting Kotlin suspend function.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.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.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.
Abstraction to avoid hard reference to Micrometer.
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.
Used to obtain a connection factory for the queue leader.
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).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
PublisherCallbackChannels.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
CompletableFutures 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
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.
Spring Rabbit Observation for listeners.
Default
RabbitListenerObservationConvention for Rabbit listener key values.High cardinality tags.
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 Messages.SenderContext for Messages.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.Spring Rabbit Observation for stream listeners.
Default
RabbitStreamListenerObservationConvention for Rabbit listener key values.Low cardinality tags.
ObservationConvention for Rabbit stream listener key values.ReceiverContext for stream Messages.Default
RabbitListenerObservationConvention for Rabbit listener key values.SenderContext for Messages.Provides methods for sending messages using a RabbitMQ Stream producer.
Default implementation of
RabbitStreamOperations.Spring RabbitMQ Observation for
RabbitStreamTemplate.Default
RabbitStreamTemplateObservationConvention for Rabbit template key values.Low cardinality tags.
ObservationConvention for Rabbit stream template key values.
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
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.
Used to provision streams.
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
Declarables.Builds a Spring AMQP Super Stream using a fluent API.
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
NodeLocator using the Spring WebFlux WebClient.A post processor that uses a
ZipOutputStream to compress the message body.