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.
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 delegages 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 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.
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.
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.
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.
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 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.
Spring Rabbit MessageConverter that uses a Marshaller and Unmarshaller.
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.
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 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.
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 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.