RabbitTemplate (Spring AMQP 2.1.13.RELEASE API)

java.lang.Object
- org.springframework.amqp.rabbit.connection.RabbitAccessor
- - org.springframework.amqp.rabbit.core.RabbitTemplate

All Implemented Interfaces:

AmqpTemplate, MessageListener, PublisherCallbackChannel.Listener, RabbitOperations, ListenerContainerAware, Aware, BeanFactoryAware, BeanNameAware, InitializingBean, Lifecycle

Direct Known Subclasses:

BatchingRabbitTemplate, TestRabbitTemplate
```
public class RabbitTemplate
extends RabbitAccessor
implements BeanFactoryAware, RabbitOperations, MessageListener, ListenerContainerAware, PublisherCallbackChannel.Listener, Lifecycle, BeanNameAware
```
Helper class that simplifies synchronous RabbitMQ access (sending and receiving messages).

The default settings are for non-transactional messaging, which reduces the amount of data exchanged with the broker. To use a new transaction for every send or receive set the channelTransacted flag. To extend the transaction over multiple invocations (more efficient), you can use a Spring transaction to bracket the calls (with channelTransacted=true as well).

The only mandatory property is the ConnectionFactory. There are strategies available for converting messages to and from Java objects ( MessageConverter) and for converting message headers (known as message properties in AMQP, see MessagePropertiesConverter ). The defaults probably do something sensible for typical use cases, as long as the message content-type is set appropriately.

The "send" methods all have overloaded versions that allow you to explicitly target an exchange and a routing key, or you can set default values to be used in all send operations. The plain "receive" methods allow you to explicitly target a queue to receive from, or you can set a default value for the template that applies to all explicit receives. The convenience methods for send and receive use the sender defaults if no exchange or routing key is specified, but they always use a temporary queue for the receive leg, so the default queue is ignored.

Since:

1.0

Author:

Mark Pollack, Mark Fisher, Dave Syer, Gary Russell, Artem Bilan, Ernest Sadykov, Mark Norkin, Mohammad Hewedy

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`RabbitTemplate.ConfirmCallback` A callback for publisher confirmations.
`static interface`	`RabbitTemplate.ReturnCallback` A callback for returned messages.
`protected static class`	`RabbitTemplate.TemplateConsumer` Adds `RabbitTemplate.TemplateConsumer.toString()` to the `DefaultConsumer`.

Nested classes/interfaces inherited from interface org.springframework.amqp.rabbit.core.RabbitOperations
RabbitOperations.OperationsCallback<T>

Field Summary
- Fields inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor
  logger

Constructor Summary

Constructors
Constructor and Description
`RabbitTemplate()` Convenient constructor for use with setter injection.
`RabbitTemplate(ConnectionFactory connectionFactory)` Create a rabbit template with default strategies and settings.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)` Add `MessagePostProcessor` that will be invoked immediately after a `Channel#basicGet()` and before any message conversion is performed.
`void`	`addBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)` Add `MessagePostProcessor` that will be invoked immediately before invoking `Channel#basicPublish()`, after all other processing, except creating the `AMQP.BasicProperties` from `MessageProperties`.
`void`	`addListener(com.rabbitmq.client.Channel channel)` Add this template as a confirms listener for the provided channel.
`void`	`convertAndSend(Object object)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a default routing key.
`void`	`convertAndSend(Object message, MessagePostProcessor messagePostProcessor)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a default routing key.
`void`	`convertAndSend(Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a default routing key.
`void`	`convertAndSend(String routingKey, Object object)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a specific routing key.
`void`	`convertAndSend(String routingKey, Object object, CorrelationData correlationData)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a specific routing key.
`void`	`convertAndSend(String routingKey, Object message, MessagePostProcessor messagePostProcessor)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a specific routing key.
`void`	`convertAndSend(String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a specific routing key.
`void`	`convertAndSend(String exchange, String routingKey, Object object)` Convert a Java object to an Amqp `Message` and send it to a specific exchange with a specific routing key.
`void`	`convertAndSend(String exchange, String routingKey, Object object, CorrelationData correlationData)` Convert a Java object to an Amqp `Message` and send it to a specific exchange with a specific routing key.
`void`	`convertAndSend(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor)` Convert a Java object to an Amqp `Message` and send it to a specific exchange with a specific routing key.
`void`	`convertAndSend(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Convert a Java object to an Amqp `Message` and send it to a specific exchange with a specific routing key.
`protected Message`	`convertMessageIfNecessary(Object object)`
`Object`	`convertSendAndReceive(Object message)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(Object message, CorrelationData correlationData)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(Object message, MessagePostProcessor messagePostProcessor)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String routingKey, Object message)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String routingKey, Object message, CorrelationData correlationData)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String routingKey, Object message, MessagePostProcessor messagePostProcessor)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String exchange, String routingKey, Object message)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String exchange, String routingKey, Object message, CorrelationData correlationData)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor)` Basic RPC pattern with conversion.
`Object`	`convertSendAndReceive(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(Object message, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(Object message, MessagePostProcessor messagePostProcessor, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(Object message, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String routingKey, Object message, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String routingKey, Object message, MessagePostProcessor messagePostProcessor, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String routingKey, Object message, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`<T> T`	`convertSendAndReceiveAsType(String exchange, String routingKey, Object message, ParameterizedTypeReference<T> responseType)` Basic RPC pattern with conversion.
`protected Message`	`convertSendAndReceiveRaw(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)` Convert and send a message and return the raw reply message, or null.
`void`	`correlationConvertAndSend(Object object, CorrelationData correlationData)` Convert a Java object to an Amqp `Message` and send it to a default exchange with a default routing key.
`void`	`determineConfirmsReturnsCapability(ConnectionFactory connectionFactory)`
`protected Message`	`doReceiveNoWait(String queueName)` Non-blocking receive.
`void`	`doSend(com.rabbitmq.client.Channel channel, String exchangeArg, String routingKeyArg, Message message, boolean mandatory, CorrelationData correlationData)` Send the given message to the specified exchange.
`protected Message`	`doSendAndReceive(String exchange, String routingKey, Message message, CorrelationData correlationData)` Send a message and wait for a reply.
`protected Message`	`doSendAndReceiveWithFixed(String exchange, String routingKey, Message message, CorrelationData correlationData)`
`protected Message`	`doSendAndReceiveWithTemporary(String exchange, String routingKey, Message message, CorrelationData correlationData)`
`protected void`	`doStart()` Perform additional start actions.
`protected void`	`doStop()` Perform additional stop actions.
`<T> T`	`execute(ChannelCallback<T> action)` Execute the callback with a channel and reliably close the channel afterwards.
`Collection<String>`	`expectedQueueNames()` Invoked by the container during startup so it can verify the queue is correctly configured (if a simple reply queue name is used instead of exchange/routingKey).
`Collection<MessagePostProcessor>`	`getAfterReceivePostProcessors()` Return configured after receive `MessagePostProcessor`s or `null`.
`String`	`getEncoding()` The encoding used when converting between byte arrays and Strings in message properties.
`String`	`getExchange()`
`MessageConverter`	`getMessageConverter()` Return the message converter for this template.
`protected MessagePropertiesConverter`	`getMessagePropertiesConverter()` Return the properties converter.
`String`	`getRoutingKey()`
`Collection<CorrelationData>`	`getUnconfirmed(long age)` Gets unconfirmed correlation data older than age and removes them.
`int`	`getUnconfirmedCount()` Gets unconfirmed messages count.
`String`	`getUUID()` Returns the UUID used to identify this Listener for returns.
`void`	`handleConfirm(PendingConfirm pendingConfirm, boolean ack)` Invoked by the channel when a confirm is received.
`void`	`handleReturn(int replyCode, String replyText, String exchange, String routingKey, com.rabbitmq.client.AMQP.BasicProperties properties, byte[] body)`
`protected void`	`initDefaultStrategies()` Set up the default strategies.
`<T> T`	`invoke(RabbitOperations.OperationsCallback<T> action, com.rabbitmq.client.ConfirmCallback acks, com.rabbitmq.client.ConfirmCallback nacks)` Invoke operations on the same channel.
`protected boolean`	`isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)` Check whether the given Channel is locally transacted, that is, whether its transaction is managed by this template's Channel handling and not by an external transaction coordinator.
`boolean`	`isConfirmListener()`
`Boolean`	`isMandatoryFor(Message message)` Return whether the provided message should be sent with the mandatory flag set.
`boolean`	`isReturnListener()`
`boolean`	`isRunning()`
`boolean`	`isUsePublisherConnection()` True if separate publisher connection(s) are used.
`void`	`onMessage(Message message)`
`Message`	`receive()` Receive a message if there is one from a default queue.
`Message`	`receive(long timeoutMillis)` Receive a message from a default queue, waiting up to the specified wait time if necessary for a message to become available.
`Message`	`receive(String queueName)` Receive a message if there is one from a specific queue.
`Message`	`receive(String queueName, long timeoutMillis)` Receive a message from a specific queue, waiting up to the specified wait time if necessary for a message to become available.
`Object`	`receiveAndConvert()` Receive a message if there is one from a default queue and convert it to a Java object.
`Object`	`receiveAndConvert(long timeoutMillis)` Receive a message if there is one from a default queue and convert it to a Java object.
`<T> T`	`receiveAndConvert(long timeoutMillis, ParameterizedTypeReference<T> type)` Receive a message if there is one from a default queue and convert it to a Java object.
`<T> T`	`receiveAndConvert(ParameterizedTypeReference<T> type)` Receive a message if there is one from a default queue and convert it to a Java object.
`Object`	`receiveAndConvert(String queueName)` Receive a message if there is one from a specific queue and convert it to a Java object.
`Object`	`receiveAndConvert(String queueName, long timeoutMillis)` Receive a message if there is one from a specific queue and convert it to a Java object.
`<T> T`	`receiveAndConvert(String queueName, long timeoutMillis, ParameterizedTypeReference<T> type)` Receive a message if there is one from a specific queue and convert it to a Java object.
`<T> T`	`receiveAndConvert(String queueName, ParameterizedTypeReference<T> type)` Receive a message if there is one from a specific queue and convert it to a Java object.
`<R,S> boolean`	`receiveAndReply(ReceiveAndReplyCallback<R,S> callback)` Receive a message if there is one from a default queue, invoke provided `ReceiveAndReplyCallback` and send reply message, if the `callback` returns one, to the `replyTo` `Address` from `MessageProperties` or to default exchange and default routingKey.
`<R,S> boolean`	`receiveAndReply(ReceiveAndReplyCallback<R,S> callback, ReplyToAddressCallback<S> replyToAddressCallback)` Receive a message if there is one from a default queue, invoke provided `ReceiveAndReplyCallback` and send reply message, if the `callback` returns one, to the `replyTo` `Address` from result of `ReplyToAddressCallback`.
`<R,S> boolean`	`receiveAndReply(ReceiveAndReplyCallback<R,S> callback, String exchange, String routingKey)` Receive a message if there is one from default queue, invoke provided `ReceiveAndReplyCallback` and send reply message, if the `callback` returns one, to the provided `exchange` and `routingKey`.
`<R,S> boolean`	`receiveAndReply(String queueName, ReceiveAndReplyCallback<R,S> callback)` Receive a message if there is one from provided queue, invoke provided `ReceiveAndReplyCallback` and send reply message, if the `callback` returns one, to the `replyTo` `Address` from `MessageProperties` or to default exchange and default routingKey.
`<R,S> boolean`	`receiveAndReply(String queueName, ReceiveAndReplyCallback<R,S> callback, ReplyToAddressCallback<S> replyToAddressCallback)` Receive a message if there is one from provided queue, invoke provided `ReceiveAndReplyCallback` and send reply message, if the `callback` returns one, to the `replyTo` `Address` from result of `ReplyToAddressCallback`.
`<R,S> boolean`	`receiveAndReply(String queueName, ReceiveAndReplyCallback<R,S> callback, String replyExchange, String replyRoutingKey)` Receive a message if there is one from provided queue, invoke provided `ReceiveAndReplyCallback` and send reply message, if the `callback` returns one, to the provided `exchange` and `routingKey`.
`boolean`	`removeAfterReceivePostProcessor(MessagePostProcessor afterReceivePostProcessor)` Remove the provided `MessagePostProcessor` from the `afterReceivePostProcessors` list.
`boolean`	`removeBeforePublishPostProcessor(MessagePostProcessor beforePublishPostProcessor)` Remove the provided `MessagePostProcessor` from the `beforePublishPostProcessors` list.
`protected void`	`replyTimedOut(String correlationId)` Subclasses can implement this to be notified that a reply has timed out.
`void`	`revoke(com.rabbitmq.client.Channel channel)` When called, this listener should remove all references to the channel - it will no longer be invoked by the channel.
`void`	`send(Message message)` Send a message to a default exchange with a default routing key.
`void`	`send(String routingKey, Message message)` Send a message to a default exchange with a specific routing key.
`void`	`send(String exchange, String routingKey, Message message)` Send a message to a specific exchange with a specific routing key.
`void`	`send(String exchange, String routingKey, Message message, CorrelationData correlationData)` Send a message to a specific exchange with a specific routing key.
`Message`	`sendAndReceive(Message message)` Basic RPC pattern.
`Message`	`sendAndReceive(Message message, CorrelationData correlationData)`
`Message`	`sendAndReceive(String routingKey, Message message)` Basic RPC pattern.
`Message`	`sendAndReceive(String routingKey, Message message, CorrelationData correlationData)`
`Message`	`sendAndReceive(String exchange, String routingKey, Message message)` Basic RPC pattern.
`Message`	`sendAndReceive(String exchange, String routingKey, Message message, CorrelationData correlationData)`
`protected void`	`sendToRabbit(com.rabbitmq.client.Channel channel, String exchange, String routingKey, boolean mandatory, Message message)`
`void`	`setAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)` Set a `MessagePostProcessor` that will be invoked immediately after a `Channel#basicGet()` and before any message conversion is performed.
`void`	`setBeanFactory(BeanFactory beanFactory)`
`void`	`setBeanName(String name)`
`void`	`setBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)` Set `MessagePostProcessor`s that will be invoked immediately before invoking `Channel#basicPublish()`, after all other processing, except creating the `AMQP.BasicProperties` from `MessageProperties`.
`void`	`setConfirmCallback(RabbitTemplate.ConfirmCallback confirmCallback)`
`void`	`setCorrelationDataPostProcessor(CorrelationDataPostProcessor correlationDataPostProcessor)` Set a `CorrelationDataPostProcessor` to be invoked before publishing a message.
`void`	`setCorrelationKey(String correlationKey)` If set to 'correlationId' (default) the correlationId property will be used; otherwise the supplied key will be used.
`void`	`setDefaultReceiveQueue(String queue)` The name of the default queue to receive messages from when none is specified explicitly.
`void`	`setEncoding(String encoding)` The encoding to use when converting between byte arrays and Strings in message properties.
`void`	`setExchange(String exchange)` The name of the default exchange to use for send operations when none is specified.
`void`	`setMandatory(boolean mandatory)` Set the mandatory flag when sending messages; only applies if a `returnCallback` had been provided.
`void`	`setMandatoryExpression(Expression mandatoryExpression)`
`void`	`setMandatoryExpressionString(String mandatoryExpression)`
`void`	`setMessageConverter(MessageConverter messageConverter)` Set the message converter for this template.
`void`	`setMessagePropertiesConverter(MessagePropertiesConverter messagePropertiesConverter)` Set the `MessagePropertiesConverter` for this template.
`void`	`setNoLocalReplyConsumer(boolean noLocalReplyConsumer)` Set to true for a no-local consumer.
`void`	`setQueue(String queue)` Deprecated. in favor of `setDefaultReceiveQueue(String)`.
`void`	`setReceiveConnectionFactorySelectorExpression(Expression receiveConnectionFactorySelectorExpression)` A SpEL `Expression` to evaluate against each `receive` `queueName`, if the provided `RabbitAccessor.getConnectionFactory()` is an instance of `AbstractRoutingConnectionFactory`.
`void`	`setReceiveTimeout(long receiveTimeout)` Specify the receive timeout in milliseconds when using `receive()` methods (for `sendAndReceive()` methods, refer to `replyTimeout`.
`void`	`setRecoveryCallback(org.springframework.retry.RecoveryCallback<?> recoveryCallback)` Add a `RecoveryCallback` which is used for the `retryTemplate.execute`.
`void`	`setReplyAddress(String replyAddress)` An address for replies; if not provided, a temporary exclusive, auto-delete queue will be used for each reply, unless RabbitMQ supports 'amq.rabbitmq.reply-to' - see https://www.rabbitmq.com/direct-reply-to.html
`void`	`setReplyErrorHandler(ErrorHandler replyErrorHandler)` When using a direct reply-to container for request/reply operations, set an error handler to be invoked when a reply delivery fails (e.g.
`void`	`setReplyTimeout(long replyTimeout)` Specify the timeout in milliseconds to be used when waiting for a reply Message when using one of the sendAndReceive methods.
`void`	`setRetryTemplate(org.springframework.retry.support.RetryTemplate retryTemplate)` Add a `RetryTemplate` which will be used for all rabbit operations.
`void`	`setReturnCallback(RabbitTemplate.ReturnCallback returnCallback)`
`void`	`setRoutingKey(String routingKey)` The value of a default routing key to use for send operations when none is specified.
`void`	`setSendConnectionFactorySelectorExpression(Expression sendConnectionFactorySelectorExpression)` A SpEL `Expression` to evaluate against each request message, if the provided `RabbitAccessor.getConnectionFactory()` is an instance of `AbstractRoutingConnectionFactory`.
`void`	`setTaskExecutor(Executor taskExecutor)` Set a task executor to use when using a `DirectReplyToMessageListenerContainer`.
`void`	`setUseDirectReplyToContainer(boolean useDirectReplyToContainer)` Set whether or not to use a `DirectReplyToMessageListenerContainer` when direct reply-to is available and being used.
`void`	`setUsePublisherConnection(boolean usePublisherConnection)` To avoid deadlocked connections, it is generally recommended to use a separate connection for publishers and consumers (except when a publisher is participating in a consumer transaction).
`void`	`setUserCorrelationId(boolean userCorrelationId)` Set to true to use correlation id provided by the message instead of generating the correlation id for request/reply scenarios.
`void`	`setUserIdExpression(Expression userIdExpression)` Set an expression to be evaluated to set the userId message property if it evaluates to a non-null value and the property is not already set in the message to be sent.
`void`	`setUserIdExpressionString(String userIdExpression)` Set an expression to be evaluated to set the userId message property if it evaluates to a non-null value and the property is not already set in the message to be sent.
`void`	`setUseTemporaryReplyQueues(boolean value)` By default, when the broker supports it and no `replyAddress` is provided, send/receive methods will use Direct reply-to (https://www.rabbitmq.com/direct-reply-to.html).
`void`	`start()`
`void`	`stop()`
`protected boolean`	`useDirectReplyTo()` Override this method use some other criteria to decide whether or not to use direct reply-to (https://www.rabbitmq.com/direct-reply-to.html).
`boolean`	`waitForConfirms(long timeout)` Delegate to the underlying dedicated channel to wait for confirms.
`void`	`waitForConfirmsOrDie(long timeout)` Delegate to the underlying dedicated channel to wait for confirms.

Methods inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor
afterPropertiesSet, convertRabbitAccessException, createConnection, getChannel, getConnection, getConnectionFactory, getTransactionalResourceHolder, isChannelTransacted, setChannelTransacted, setConnectionFactory

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.springframework.amqp.rabbit.core.RabbitOperations
convertSendAndReceiveAsType, getConnectionFactory, invoke

Methods inherited from interface org.springframework.amqp.core.MessageListener
containerAckMode

- Constructor Detail
  - RabbitTemplate
```
public RabbitTemplate()
```
    Convenient constructor for use with setter injection. Don't forget to set the connection factory.
  - RabbitTemplate
```
public RabbitTemplate(ConnectionFactory connectionFactory)
```
    Create a rabbit template with default strategies and settings.
    
    Parameters:
    
    connectionFactory - the connection factory to use
- Method Detail
  - initDefaultStrategies
```
protected void initDefaultStrategies()
```
    Set up the default strategies. Subclasses can override if necessary.
  - setExchange
```
public void setExchange(@Nullable
                        String exchange)
```
    The name of the default exchange to use for send operations when none is specified. Defaults to "" which is the default exchange in the broker (per the AMQP specification).
    
    Parameters:
    
    exchange - the exchange name to use for send operations
  - getExchange
```
public String getExchange()
```
    Returns:
    
    the name of the default exchange used by this template.
    
    Since:
    
    1.6
  - setRoutingKey
```
public void setRoutingKey(String routingKey)
```
    The value of a default routing key to use for send operations when none is specified. Default is empty which is not helpful when using the default (or any direct) exchange, but fine if the exchange is a headers exchange for instance.
    
    Parameters:
    
    routingKey - the default routing key to use for send operations
  - getRoutingKey
```
public String getRoutingKey()
```
    Returns:
    
    the default routing key used by this template.
    
    Since:
    
    1.6
  - setQueue
```
@Deprecated
public void setQueue(String queue)
```
    Deprecated. in favor of setDefaultReceiveQueue(String).
    
    The name of the default queue to receive messages from when none is specified explicitly.
    
    Parameters:
    
    queue - the default queue name to use for receive
  - setDefaultReceiveQueue
```
public void setDefaultReceiveQueue(String queue)
```
    The name of the default queue to receive messages from when none is specified explicitly.
    
    Parameters:
    
    queue - the default queue name to use for receive
    
    Since:
    
    2.1.2
  - setEncoding
```
public void setEncoding(String encoding)
```
    The encoding to use when converting between byte arrays and Strings in message properties.
    
    Parameters:
    
    encoding - the encoding to set
  - getEncoding
```
public String getEncoding()
```
    The encoding used when converting between byte arrays and Strings in message properties.
    
    Returns:
    
    the encoding.
  - setReplyAddress
```
public void setReplyAddress(String replyAddress)
```
    An address for replies; if not provided, a temporary exclusive, auto-delete queue will be used for each reply, unless RabbitMQ supports 'amq.rabbitmq.reply-to' - see https://www.rabbitmq.com/direct-reply-to.html
    The address can be a simple queue name (in which case the reply will be routed via the default exchange), or with the form exchange/routingKey to route the reply using an explicit exchange and routing key.
    
    Parameters:
    
    replyAddress - the replyAddress to set
  - setReceiveTimeout
```
public void setReceiveTimeout(long receiveTimeout)
```
    Specify the receive timeout in milliseconds when using receive() methods (for sendAndReceive() methods, refer to replyTimeout. By default, the value is zero, which means the receive() methods will return null immediately if there is no message available. Set to less than zero to wait for a message indefinitely.
    
    Parameters:
    
    receiveTimeout - the timeout.
    
    Since:
    
    1.5
  - setReplyTimeout
```
public void setReplyTimeout(long replyTimeout)
```
    Specify the timeout in milliseconds to be used when waiting for a reply Message when using one of the sendAndReceive methods. The default value is defined as DEFAULT_REPLY_TIMEOUT. A negative value indicates an indefinite timeout. Not used in the plain receive methods because there is no blocking receive operation defined in the protocol.
    
    Parameters:
    
    replyTimeout - the reply timeout in milliseconds
    
    See Also:
    
    sendAndReceive(String, String, Message), convertSendAndReceive(String, String, Object)
  - setMessageConverter
```
public void setMessageConverter(MessageConverter messageConverter)
```
    Set the message converter for this template. Used to resolve Object parameters to convertAndSend methods and Object results from receiveAndConvert methods.
    The default converter is a SimpleMessageConverter, which is able to handle byte arrays, Strings, and Serializable Objects depending on the message content type header.
    
    Parameters:
    
    messageConverter - The message converter.
    
    See Also:
    
    convertAndSend(java.lang.Object), receiveAndConvert(), SimpleMessageConverter
  - setMessagePropertiesConverter
```
public void setMessagePropertiesConverter(MessagePropertiesConverter messagePropertiesConverter)
```
    Set the MessagePropertiesConverter for this template. This converter is used to convert between raw byte content in the message headers and plain Java objects. In particular there are limitations when dealing with very long string headers, which hopefully are rare in practice, but if you need to use long headers you might need to inject a special converter here.
    
    Parameters:
    
    messagePropertiesConverter - The message properties converter.
  - getMessagePropertiesConverter
```
protected MessagePropertiesConverter getMessagePropertiesConverter()
```
    Return the properties converter.
    
    Returns:
    
    the converter.
    
    Since:
    
    2.0
  - getMessageConverter
```
public MessageConverter getMessageConverter()
```
    Return the message converter for this template. Useful for clients that want to take advantage of the converter in ChannelCallback implementations.
    
    Returns:
    
    The message converter.
  - setConfirmCallback
```
public void setConfirmCallback(RabbitTemplate.ConfirmCallback confirmCallback)
```
  - setReturnCallback
```
public void setReturnCallback(RabbitTemplate.ReturnCallback returnCallback)
```
  - setMandatory
```
public void setMandatory(boolean mandatory)
```
    Set the mandatory flag when sending messages; only applies if a returnCallback had been provided.
    
    Parameters:
    
    mandatory - the mandatory to set.
  - setMandatoryExpression
```
public void setMandatoryExpression(Expression mandatoryExpression)
```
    Parameters:
    
    mandatoryExpression - a SpEL Expression to evaluate against each request message, if a returnCallback has been provided. The result of the evaluation must be a boolean value.
    
    Since:
    
    1.4
  - setMandatoryExpressionString
```
public void setMandatoryExpressionString(String mandatoryExpression)
```
    Parameters:
    
    mandatoryExpression - a SpEL Expression to evaluate against each request message, if a returnCallback has been provided. The result of the evaluation must be a boolean value.
    
    Since:
    
    2.0
  - setSendConnectionFactorySelectorExpression
```
public void setSendConnectionFactorySelectorExpression(Expression sendConnectionFactorySelectorExpression)
```
    A SpEL Expression to evaluate against each request message, if the provided RabbitAccessor.getConnectionFactory() is an instance of AbstractRoutingConnectionFactory.
    The result of this expression is used as lookupKey to get the target ConnectionFactory from AbstractRoutingConnectionFactory directly.
    If this expression is evaluated to null, we fallback to the normal AbstractRoutingConnectionFactory logic.
    If there is no target ConnectionFactory with the evaluated lookupKey, we fallback to the normal AbstractRoutingConnectionFactory logic only if its property lenientFallback == true.
    This expression is used for send operations.
    
    Parameters:
    
    sendConnectionFactorySelectorExpression - a SpEL Expression to evaluate
    
    Since:
    
    1.4
  - setReceiveConnectionFactorySelectorExpression
```
public void setReceiveConnectionFactorySelectorExpression(Expression receiveConnectionFactorySelectorExpression)
```
    A SpEL Expression to evaluate against each receive queueName, if the provided RabbitAccessor.getConnectionFactory() is an instance of AbstractRoutingConnectionFactory.
    The result of this expression is used as lookupKey to get the target ConnectionFactory from AbstractRoutingConnectionFactory directly.
    If this expression is evaluated to null, we fallback to the normal AbstractRoutingConnectionFactory logic.
    If there is no target ConnectionFactory with the evaluated lookupKey, we fallback to the normal AbstractRoutingConnectionFactory logic only if its property lenientFallback == true.
    This expression is used for receive operations.
    
    Parameters:
    
    receiveConnectionFactorySelectorExpression - a SpEL Expression to evaluate
    
    Since:
    
    1.4
  - setCorrelationKey
```
public void setCorrelationKey(String correlationKey)
```
    If set to 'correlationId' (default) the correlationId property will be used; otherwise the supplied key will be used.
    
    Parameters:
    
    correlationKey - the correlationKey to set
  - setRetryTemplate
```
public void setRetryTemplate(org.springframework.retry.support.RetryTemplate retryTemplate)
```
    Add a RetryTemplate which will be used for all rabbit operations.
    
    Parameters:
    
    retryTemplate - The retry template.
  - setRecoveryCallback
```
public void setRecoveryCallback(org.springframework.retry.RecoveryCallback<?> recoveryCallback)
```
    Add a RecoveryCallback which is used for the retryTemplate.execute. If retryTemplate isn't provided recoveryCallback is ignored. RecoveryCallback should produce result compatible with execute(ChannelCallback) return type.
    
    Parameters:
    
    recoveryCallback - The retry recoveryCallback.
    
    Since:
    
    1.4
  - setBeanFactory
```
public void setBeanFactory(BeanFactory beanFactory)
                    throws BeansException
```
    Specified by:
    
    setBeanFactory in interface BeanFactoryAware
    
    Throws:
    
    BeansException
  - setBeforePublishPostProcessors
```
public void setBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)
```
    Set MessagePostProcessors that will be invoked immediately before invoking Channel#basicPublish(), after all other processing, except creating the AMQP.BasicProperties from MessageProperties. May be used for operations such as compression. Processors are invoked in order, depending on PriorityOrder, Order and finally unordered.
    
    Parameters:
    
    beforePublishPostProcessors - the post processor.
    
    Since:
    
    1.4.2
    
    See Also:
    
    addBeforePublishPostProcessors(MessagePostProcessor...)
  - addBeforePublishPostProcessors
```
public void addBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)
```
    Add MessagePostProcessor that will be invoked immediately before invoking Channel#basicPublish(), after all other processing, except creating the AMQP.BasicProperties from MessageProperties. May be used for operations such as compression. Processors are invoked in order, depending on PriorityOrder, Order and finally unordered.
    In contrast to setBeforePublishPostProcessors(MessagePostProcessor...), this method does not override the previously added beforePublishPostProcessors.
    
    Parameters:
    
    beforePublishPostProcessors - the post processor.
    
    Since:
    
    2.1.4
  - removeBeforePublishPostProcessor
```
public boolean removeBeforePublishPostProcessor(MessagePostProcessor beforePublishPostProcessor)
```
    Remove the provided MessagePostProcessor from the beforePublishPostProcessors list.
    
    Parameters:
    
    beforePublishPostProcessor - the MessagePostProcessor to remove.
    
    Returns:
    
    the boolean if the provided post processor has been removed.
    
    Since:
    
    2.1.4
    
    See Also:
    
    addBeforePublishPostProcessors(MessagePostProcessor...)
  - setAfterReceivePostProcessors
```
public void setAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)
```
    Set a MessagePostProcessor that will be invoked immediately after a Channel#basicGet() and before any message conversion is performed. May be used for operations such as decompression. Processors are invoked in order, depending on PriorityOrder, Order and finally unordered.
    
    Parameters:
    
    afterReceivePostProcessors - the post processor.
    
    Since:
    
    1.5
    
    See Also:
    
    addAfterReceivePostProcessors(MessagePostProcessor...)
  - getAfterReceivePostProcessors
```
@Nullable
public Collection<MessagePostProcessor> getAfterReceivePostProcessors()
```
    Return configured after receive MessagePostProcessors or null.
    
    Returns:
    
    configured after receive MessagePostProcessors or null.
    
    Since:
    
    2.1.5
  - addAfterReceivePostProcessors
```
public void addAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)
```
    Add MessagePostProcessor that will be invoked immediately after a Channel#basicGet() and before any message conversion is performed. May be used for operations such as decompression. Processors are invoked in order, depending on PriorityOrder, Order and finally unordered.
    In contrast to setAfterReceivePostProcessors(MessagePostProcessor...), this method does not override the previously added afterReceivePostProcessors.
    
    Parameters:
    
    afterReceivePostProcessors - the post processor.
    
    Since:
    
    2.1.4
  - removeAfterReceivePostProcessor
```
public boolean removeAfterReceivePostProcessor(MessagePostProcessor afterReceivePostProcessor)
```
    Remove the provided MessagePostProcessor from the afterReceivePostProcessors list.
    
    Parameters:
    
    afterReceivePostProcessor - the MessagePostProcessor to remove.
    
    Returns:
    
    the boolean if the provided post processor has been removed.
    
    Since:
    
    2.1.4
    
    See Also:
    
    addAfterReceivePostProcessors(MessagePostProcessor...)
  - setCorrelationDataPostProcessor
```
public void setCorrelationDataPostProcessor(CorrelationDataPostProcessor correlationDataPostProcessor)
```
    Set a CorrelationDataPostProcessor to be invoked before publishing a message. Correlation data is used to correlate publisher confirms.
    
    Parameters:
    
    correlationDataPostProcessor - the post processor.
    
    Since:
    
    1.6.7
    
    See Also:
    
    setConfirmCallback(ConfirmCallback)
  - setUseTemporaryReplyQueues
```
public void setUseTemporaryReplyQueues(boolean value)
```
    By default, when the broker supports it and no replyAddress is provided, send/receive methods will use Direct reply-to (https://www.rabbitmq.com/direct-reply-to.html). Setting this property to true will override that behavior and use a temporary, auto-delete, queue for each request instead. Changing this property has no effect once the first request has been processed.
    
    Parameters:
    
    value - true to use temporary queues.
    
    Since:
    
    1.6
  - setUseDirectReplyToContainer
```
public void setUseDirectReplyToContainer(boolean useDirectReplyToContainer)
```
    Set whether or not to use a DirectReplyToMessageListenerContainer when direct reply-to is available and being used. When false, a new consumer is created for each request (the mechanism used in versions prior to 2.0). Default true.
    
    Parameters:
    
    useDirectReplyToContainer - set to false to use a consumer per request.
    
    Since:
    
    2.0
    
    See Also:
    
    setUseTemporaryReplyQueues(boolean)
  - setUserIdExpression
```
public void setUserIdExpression(Expression userIdExpression)
```
    Set an expression to be evaluated to set the userId message property if it evaluates to a non-null value and the property is not already set in the message to be sent. See https://www.rabbitmq.com/validated-user-id.html
    
    Parameters:
    
    userIdExpression - the expression.
    
    Since:
    
    1.6
  - setUserIdExpressionString
```
public void setUserIdExpressionString(String userIdExpression)
```
    Set an expression to be evaluated to set the userId message property if it evaluates to a non-null value and the property is not already set in the message to be sent. See https://www.rabbitmq.com/validated-user-id.html
    
    Parameters:
    
    userIdExpression - the expression.
    
    Since:
    
    1.6
  - setBeanName
```
public void setBeanName(String name)
```
    Specified by:
    
    setBeanName in interface BeanNameAware
  - setTaskExecutor
```
public void setTaskExecutor(Executor taskExecutor)
```
    Set a task executor to use when using a DirectReplyToMessageListenerContainer.
    
    Parameters:
    
    taskExecutor - the executor.
    
    Since:
    
    2.0
  - setUserCorrelationId
```
public void setUserCorrelationId(boolean userCorrelationId)
```
    Set to true to use correlation id provided by the message instead of generating the correlation id for request/reply scenarios. The correlation id must be unique for all in-process requests to avoid cross talk.
    Users must therefore take create care to ensure uniqueness.
    
    Parameters:
    
    userCorrelationId - true to use user correlation data.
  - isUsePublisherConnection
```
public boolean isUsePublisherConnection()
```
    True if separate publisher connection(s) are used.
    
    Returns:
    
    true or false.
    
    Since:
    
    2.0.2
    
    See Also:
    
    setUsePublisherConnection(boolean)
  - setUsePublisherConnection
```
public void setUsePublisherConnection(boolean usePublisherConnection)
```
    To avoid deadlocked connections, it is generally recommended to use a separate connection for publishers and consumers (except when a publisher is participating in a consumer transaction). Default 'false'.
    
    Parameters:
    
    usePublisherConnection - true to use a publisher connection.
    
    Since:
    
    2.0.2
  - setNoLocalReplyConsumer
```
public void setNoLocalReplyConsumer(boolean noLocalReplyConsumer)
```
    Set to true for a no-local consumer. Defaults to false.
    
    Parameters:
    
    noLocalReplyConsumer - true for a no-local consumer.
    
    Since:
    
    2.1
    
    See Also:
    
    AbstractMessageListenerContainer.setNoLocal(boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, com.rabbitmq.client.Consumer)
  - setReplyErrorHandler
```
public void setReplyErrorHandler(ErrorHandler replyErrorHandler)
```
    When using a direct reply-to container for request/reply operations, set an error handler to be invoked when a reply delivery fails (e.g. due to a late reply).
    
    Parameters:
    
    replyErrorHandler - the reply error handler
    
    Since:
    
    2.0.11
    
    See Also:
    
    setUseDirectReplyToContainer(boolean)
  - expectedQueueNames
```
@Nullable
public Collection<String> expectedQueueNames()
```
    Invoked by the container during startup so it can verify the queue is correctly configured (if a simple reply queue name is used instead of exchange/routingKey).
    
    Specified by:
    
    expectedQueueNames in interface ListenerContainerAware
    
    Returns:
    
    the queue name, if configured.
    
    Since:
    
    1.5
  - getUnconfirmed
```
@Nullable
public Collection<CorrelationData> getUnconfirmed(long age)
```
    Gets unconfirmed correlation data older than age and removes them.
    
    Parameters:
    
    age - in milliseconds
    
    Returns:
    
    the collection of correlation data for which confirms have not been received or null if no such confirms exist.
  - getUnconfirmedCount
```
public int getUnconfirmedCount()
```
    Gets unconfirmed messages count.
    
    Returns:
    
    The count of the messages that are not confirmed yet by RabbitMQ.
    
    Since:
    
    2.0
  - start
```
public final void start()
```
    Specified by:
    
    start in interface Lifecycle
  - doStart
```
protected void doStart()
```
    Perform additional start actions.
    
    Since:
    
    2.0
  - stop
```
public final void stop()
```
    Specified by:
    
    stop in interface Lifecycle
  - doStop
```
protected void doStop()
```
    Perform additional stop actions.
    
    Since:
    
    2.0
  - isRunning
```
public boolean isRunning()
```
    Specified by:
    
    isRunning in interface Lifecycle
  - useDirectReplyTo
```
protected boolean useDirectReplyTo()
```
    Override this method use some other criteria to decide whether or not to use direct reply-to (https://www.rabbitmq.com/direct-reply-to.html). The default implementation returns true if the broker supports it and there is no replyAddress set and useTemporaryReplyQueues is false. When direct reply-to is not used, the template will create a temporary, exclusive, auto-delete queue for the reply.
    This method is invoked once only - when the first message is sent, from a synchronized block.
    
    Returns:
    
    true to use direct reply-to.
  - send
```
public void send(Message message)
          throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Send a message to a default exchange with a default routing key.
    
    Specified by:
    
    send in interface AmqpTemplate
    
    Parameters:
    
    message - a message to send
    
    Throws:
    
    AmqpException - if there is a problem
  - send
```
public void send(String routingKey,
                 Message message)
          throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Send a message to a default exchange with a specific routing key.
    
    Specified by:
    
    send in interface AmqpTemplate
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    Throws:
    
    AmqpException - if there is a problem
  - send
```
public void send(String exchange,
                 String routingKey,
                 Message message)
          throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Send a message to a specific exchange with a specific routing key.
    
    Specified by:
    
    send in interface AmqpTemplate
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    Throws:
    
    AmqpException - if there is a problem
  - send
```
public void send(String exchange,
                 String routingKey,
                 Message message,
                 @Nullable
                 CorrelationData correlationData)
          throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Send a message to a specific exchange with a specific routing key.
    
    Specified by:
    
    send in interface RabbitOperations
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(Object object)
                    throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a default routing key.
    
    Specified by:
    
    convertAndSend in interface AmqpTemplate
    
    Parameters:
    
    object - a message to send
    
    Throws:
    
    AmqpException - if there is a problem
  - correlationConvertAndSend
```
public void correlationConvertAndSend(Object object,
                                      CorrelationData correlationData)
                               throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a default routing key.
    
    Specified by:
    
    correlationConvertAndSend in interface RabbitOperations
    
    Parameters:
    
    object - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String routingKey,
                           Object object)
                    throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface AmqpTemplate
    
    Parameters:
    
    routingKey - the routing key
    
    object - a message to send
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String routingKey,
                           Object object,
                           CorrelationData correlationData)
                    throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface RabbitOperations
    
    Parameters:
    
    routingKey - the routing key
    
    object - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String exchange,
                           String routingKey,
                           Object object)
                    throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Convert a Java object to an Amqp Message and send it to a specific exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface AmqpTemplate
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    object - a message to send
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String exchange,
                           String routingKey,
                           Object object,
                           @Nullable
                           CorrelationData correlationData)
                    throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Convert a Java object to an Amqp Message and send it to a specific exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface RabbitOperations
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    object - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(Object message,
                           MessagePostProcessor messagePostProcessor)
                    throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a default routing key.
    
    Specified by:
    
    convertAndSend in interface AmqpTemplate
    
    Parameters:
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String routingKey,
                           Object message,
                           MessagePostProcessor messagePostProcessor)
                    throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface AmqpTemplate
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(Object message,
                           MessagePostProcessor messagePostProcessor,
                           CorrelationData correlationData)
                    throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a default routing key.
    
    Specified by:
    
    convertAndSend in interface RabbitOperations
    
    Parameters:
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String routingKey,
                           Object message,
                           MessagePostProcessor messagePostProcessor,
                           CorrelationData correlationData)
                    throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Convert a Java object to an Amqp Message and send it to a default exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface RabbitOperations
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String exchange,
                           String routingKey,
                           Object message,
                           MessagePostProcessor messagePostProcessor)
                    throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Convert a Java object to an Amqp Message and send it to a specific exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface AmqpTemplate
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    Throws:
    
    AmqpException - if there is a problem
  - convertAndSend
```
public void convertAndSend(String exchange,
                           String routingKey,
                           Object message,
                           MessagePostProcessor messagePostProcessor,
                           @Nullable
                           CorrelationData correlationData)
                    throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Convert a Java object to an Amqp Message and send it to a specific exchange with a specific routing key.
    
    Specified by:
    
    convertAndSend in interface RabbitOperations
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    Throws:
    
    AmqpException - if there is a problem
  - receive
```
@Nullable
public Message receive()
                          throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue. Returns immediately, possibly with a null value.
    
    Specified by:
    
    receive in interface AmqpTemplate
    
    Returns:
    
    a message or null if there is none waiting
    
    Throws:
    
    AmqpException - if there is a problem
  - receive
```
@Nullable
public Message receive(String queueName)
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a specific queue. Returns immediately, possibly with a null value.
    
    Specified by:
    
    receive in interface AmqpTemplate
    
    Parameters:
    
    queueName - the name of the queue to poll
    
    Returns:
    
    a message or null if there is none waiting
  - doReceiveNoWait
```
@Nullable
protected Message doReceiveNoWait(String queueName)
```
    Non-blocking receive.
    
    Parameters:
    
    queueName - the queue to receive from.
    
    Returns:
    
    The message, or null if none immediately available.
    
    Since:
    
    1.5
  - receive
```
@Nullable
public Message receive(long timeoutMillis)
                          throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message from a default queue, waiting up to the specified wait time if necessary for a message to become available.
    
    Specified by:
    
    receive in interface AmqpTemplate
    
    Parameters:
    
    timeoutMillis - how long to wait before giving up. Zero value means the method will return null immediately if there is no message available. Negative value makes method wait for a message indefinitely.
    
    Returns:
    
    a message or null if the time expires
    
    Throws:
    
    AmqpException - if there is a problem
  - receive
```
@Nullable
public Message receive(String queueName,
                                 long timeoutMillis)
```
    Description copied from interface: AmqpTemplate
    
    Receive a message from a specific queue, waiting up to the specified wait time if necessary for a message to become available.
    
    Specified by:
    
    receive in interface AmqpTemplate
    
    Parameters:
    
    queueName - the queue to receive from
    
    timeoutMillis - how long to wait before giving up. Zero value means the method will return null immediately if there is no message available. Negative value makes method wait for a message indefinitely.
    
    Returns:
    
    a message or null if the time expires
  - receiveAndConvert
```
@Nullable
public Object receiveAndConvert()
                                   throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue and convert it to a Java object. Returns immediately, possibly with a null value.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Returns:
    
    a message or null if there is none waiting
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndConvert
```
@Nullable
public Object receiveAndConvert(String queueName)
                                   throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a specific queue and convert it to a Java object. Returns immediately, possibly with a null value.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Parameters:
    
    queueName - the name of the queue to poll
    
    Returns:
    
    a message or null if there is none waiting
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndConvert
```
@Nullable
public Object receiveAndConvert(long timeoutMillis)
                                   throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue and convert it to a Java object. Wait up to the specified wait time if necessary for a message to become available.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Parameters:
    
    timeoutMillis - how long to wait before giving up. Zero value means the method will return null immediately if there is no message available. Negative value makes method wait for a message indefinitely.
    
    Returns:
    
    a message or null if the time expires
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndConvert
```
@Nullable
public Object receiveAndConvert(String queueName,
                                          long timeoutMillis)
                                   throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a specific queue and convert it to a Java object. Wait up to the specified wait time if necessary for a message to become available.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Parameters:
    
    queueName - the name of the queue to poll
    
    timeoutMillis - how long to wait before giving up. Zero value means the method will return null immediately if there is no message available. Negative value makes method wait for a message indefinitely.
    
    Returns:
    
    a message or null if the time expires
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(ParameterizedTypeReference<T> type)
                                  throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue and convert it to a Java object. Returns immediately, possibly with a null value. Requires a SmartMessageConverter.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    type - the type to convert to.
    
    Returns:
    
    a message or null if there is none waiting.
    
    Throws:
    
    AmqpException - if there is a problem.
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(String queueName,
                                         ParameterizedTypeReference<T> type)
                                  throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a specific queue and convert it to a Java object. Returns immediately, possibly with a null value. Requires a SmartMessageConverter.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    queueName - the name of the queue to poll
    
    type - the type to convert to.
    
    Returns:
    
    a message or null if there is none waiting
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(long timeoutMillis,
                                         ParameterizedTypeReference<T> type)
                                  throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue and convert it to a Java object. Wait up to the specified wait time if necessary for a message to become available. Requires a SmartMessageConverter.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    timeoutMillis - how long to wait before giving up. Zero value means the method will return null immediately if there is no message available. Negative value makes method wait for a message indefinitely.
    
    type - the type to convert to.
    
    Returns:
    
    a message or null if the time expires
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(String queueName,
                                         long timeoutMillis,
                                         ParameterizedTypeReference<T> type)
                                  throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a specific queue and convert it to a Java object. Wait up to the specified wait time if necessary for a message to become available. Requires a SmartMessageConverter.
    
    Specified by:
    
    receiveAndConvert in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    queueName - the name of the queue to poll
    
    timeoutMillis - how long to wait before giving up. Zero value means the method will return null immediately if there is no message available. Negative value makes method wait for a message indefinitely.
    
    type - the type to convert to.
    
    Returns:
    
    a message or null if the time expires
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(ReceiveAndReplyCallback<R,S> callback)
                              throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue, invoke provided ReceiveAndReplyCallback and send reply message, if the callback returns one, to the replyTo Address from MessageProperties or to default exchange and default routingKey.
    
    Specified by:
    
    receiveAndReply in interface AmqpTemplate
    
    Type Parameters:
    
    R - The type of the request after conversion from the Message.
    
    S - The type of the response.
    
    Parameters:
    
    callback - a user-provided ReceiveAndReplyCallback implementation to process received message and return a reply message.
    
    Returns:
    
    true, if message was received
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(String queueName,
                                     ReceiveAndReplyCallback<R,S> callback)
                              throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from provided queue, invoke provided ReceiveAndReplyCallback and send reply message, if the callback returns one, to the replyTo Address from MessageProperties or to default exchange and default routingKey.
    
    Specified by:
    
    receiveAndReply in interface AmqpTemplate
    
    Type Parameters:
    
    R - The type of the request after conversion from the Message.
    
    S - The type of the response.
    
    Parameters:
    
    queueName - the queue name to receive a message.
    
    callback - a user-provided ReceiveAndReplyCallback implementation to process received message and return a reply message.
    
    Returns:
    
    true, if message was received.
    
    Throws:
    
    AmqpException - if there is a problem.
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(ReceiveAndReplyCallback<R,S> callback,
                                     String exchange,
                                     String routingKey)
                              throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from default queue, invoke provided ReceiveAndReplyCallback and send reply message, if the callback returns one, to the provided exchange and routingKey.
    
    Specified by:
    
    receiveAndReply in interface AmqpTemplate
    
    Type Parameters:
    
    R - The type of the request after conversion from the Message.
    
    S - The type of the response.
    
    Parameters:
    
    callback - a user-provided ReceiveAndReplyCallback implementation to process received message and return a reply message.
    
    exchange - the exchange name to send reply message.
    
    routingKey - the routing key to send reply message.
    
    Returns:
    
    true, if message was received.
    
    Throws:
    
    AmqpException - if there is a problem.
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(String queueName,
                                     ReceiveAndReplyCallback<R,S> callback,
                                     String replyExchange,
                                     String replyRoutingKey)
                              throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from provided queue, invoke provided ReceiveAndReplyCallback and send reply message, if the callback returns one, to the provided exchange and routingKey.
    
    Specified by:
    
    receiveAndReply in interface AmqpTemplate
    
    Type Parameters:
    
    R - The type of the request after conversion from the Message.
    
    S - The type of the response.
    
    Parameters:
    
    queueName - the queue name to receive a message.
    
    callback - a user-provided ReceiveAndReplyCallback implementation to process received message and return a reply message.
    
    replyExchange - the exchange name to send reply message.
    
    replyRoutingKey - the routing key to send reply message.
    
    Returns:
    
    true, if message was received
    
    Throws:
    
    AmqpException - if there is a problem
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(ReceiveAndReplyCallback<R,S> callback,
                                     ReplyToAddressCallback<S> replyToAddressCallback)
                              throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from a default queue, invoke provided ReceiveAndReplyCallback and send reply message, if the callback returns one, to the replyTo Address from result of ReplyToAddressCallback.
    
    Specified by:
    
    receiveAndReply in interface AmqpTemplate
    
    Type Parameters:
    
    R - The type of the request after conversion from the Message.
    
    S - The type of the response.
    
    Parameters:
    
    callback - a user-provided ReceiveAndReplyCallback implementation to process received message and return a reply message.
    
    replyToAddressCallback - the callback to determine replyTo address at runtime.
    
    Returns:
    
    true, if message was received.
    
    Throws:
    
    AmqpException - if there is a problem.
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(String queueName,
                                     ReceiveAndReplyCallback<R,S> callback,
                                     ReplyToAddressCallback<S> replyToAddressCallback)
                              throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Receive a message if there is one from provided queue, invoke provided ReceiveAndReplyCallback and send reply message, if the callback returns one, to the replyTo Address from result of ReplyToAddressCallback.
    
    Specified by:
    
    receiveAndReply in interface AmqpTemplate
    
    Type Parameters:
    
    R - The type of the request after conversion from the Message.
    
    S - The type of the response.
    
    Parameters:
    
    queueName - the queue name to receive a message.
    
    callback - a user-provided ReceiveAndReplyCallback implementation to process received message and return a reply message.
    
    replyToAddressCallback - the callback to determine replyTo address at runtime.
    
    Returns:
    
    true, if message was received
    
    Throws:
    
    AmqpException - if there is a problem
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(Message message)
                                 throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern. Send a message to a default exchange with a default routing key and attempt to receive a response. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    sendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    message - a message to send
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(Message message,
                                        @Nullable
                                        CorrelationData correlationData)
                                 throws AmqpException
```
    Throws:
    
    AmqpException
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(String routingKey,
                                        Message message)
                                 throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern. Send a message to a default exchange with a specific routing key and attempt to receive a response. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    sendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(String routingKey,
                                        Message message,
                                        @Nullable
                                        CorrelationData correlationData)
                                 throws AmqpException
```
    Throws:
    
    AmqpException
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(String exchange,
                                        String routingKey,
                                        Message message)
                                 throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern. Send a message to a specific exchange with a specific routing key and attempt to receive a response. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    sendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(String exchange,
                                        String routingKey,
                                        Message message,
                                        @Nullable
                                        CorrelationData correlationData)
                                 throws AmqpException
```
    Throws:
    
    AmqpException
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(Object message)
                                       throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    message - a message to send
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(Object message,
                                              @Nullable
                                              CorrelationData correlationData)
                                       throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface RabbitOperations
    
    Parameters:
    
    message - a message to send.
    
    correlationData - data to correlate publisher confirms.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String routingKey,
                                              Object message)
                                       throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String routingKey,
                                              Object message,
                                              @Nullable
                                              CorrelationData correlationData)
                                       throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface RabbitOperations
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String exchange,
                                              String routingKey,
                                              Object message)
                                       throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String exchange,
                                              String routingKey,
                                              Object message,
                                              @Nullable
                                              CorrelationData correlationData)
                                       throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface RabbitOperations
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(Object message,
                                              MessagePostProcessor messagePostProcessor)
                                       throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(Object message,
                                              MessagePostProcessor messagePostProcessor,
                                              @Nullable
                                              CorrelationData correlationData)
                                       throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface RabbitOperations
    
    Parameters:
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String routingKey,
                                              Object message,
                                              MessagePostProcessor messagePostProcessor)
                                       throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String routingKey,
                                              Object message,
                                              MessagePostProcessor messagePostProcessor,
                                              @Nullable
                                              CorrelationData correlationData)
                                       throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface RabbitOperations
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String exchange,
                                              String routingKey,
                                              Object message,
                                              MessagePostProcessor messagePostProcessor)
                                       throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface AmqpTemplate
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceive
```
@Nullable
public Object convertSendAndReceive(String exchange,
                                              String routingKey,
                                              Object message,
                                              @Nullable
                                              MessagePostProcessor messagePostProcessor,
                                              @Nullable
                                              CorrelationData correlationData)
                                       throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout.
    
    Specified by:
    
    convertSendAndReceive in interface RabbitOperations
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(Object message,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    message - a message to send.
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one.
    
    Throws:
    
    AmqpException - if there is a problem.
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(Object message,
                                                   @Nullable
                                                   CorrelationData correlationData,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface RabbitOperations
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    message - a message to send.
    
    correlationData - data to correlate publisher confirms.
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one.
    
    Throws:
    
    AmqpException - if there is a problem.
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String routingKey,
                                                   Object message,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String routingKey,
                                                   Object message,
                                                   @Nullable
                                                   CorrelationData correlationData,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface RabbitOperations
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    correlationData - data to correlate publisher confirms.
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String exchange,
                                                   String routingKey,
                                                   Object message,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(Object message,
                                                   @Nullable
                                                   MessagePostProcessor messagePostProcessor,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(Object message,
                                                   @Nullable
                                                   MessagePostProcessor messagePostProcessor,
                                                   @Nullable
                                                   CorrelationData correlationData,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a default routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface RabbitOperations
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String routingKey,
                                                   Object message,
                                                   @Nullable
                                                   MessagePostProcessor messagePostProcessor,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String routingKey,
                                                   Object message,
                                                   @Nullable
                                                   MessagePostProcessor messagePostProcessor,
                                                   @Nullable
                                                   CorrelationData correlationData,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a default exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface RabbitOperations
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String exchange,
                                                   String routingKey,
                                                   Object message,
                                                   MessagePostProcessor messagePostProcessor,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: AmqpTemplate
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface AmqpTemplate
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(String exchange,
                                                   String routingKey,
                                                   Object message,
                                                   @Nullable
                                                   MessagePostProcessor messagePostProcessor,
                                                   @Nullable
                                                   CorrelationData correlationData,
                                                   ParameterizedTypeReference<T> responseType)
                                            throws AmqpException
```
    Description copied from interface: RabbitOperations
    
    Basic RPC pattern with conversion. Send a Java object converted to a message to a specific exchange with a specific routing key and attempt to receive a response, converting that to a Java object. Implementations will normally set the reply-to header to an exclusive queue and wait up for some time limited by a timeout. Requires a SmartMessageConverter.
    
    Specified by:
    
    convertSendAndReceiveAsType in interface RabbitOperations
    
    Type Parameters:
    
    T - the type.
    
    Parameters:
    
    exchange - the name of the exchange
    
    routingKey - the routing key
    
    message - a message to send
    
    messagePostProcessor - a processor to apply to the message before it is sent
    
    correlationData - data to correlate publisher confirms.
    
    responseType - the type to convert the reply to.
    
    Returns:
    
    the response if there is one
    
    Throws:
    
    AmqpException - if there is a problem
  - convertSendAndReceiveRaw
```
@Nullable
protected Message convertSendAndReceiveRaw(String exchange,
                                                     String routingKey,
                                                     Object message,
                                                     @Nullable
                                                     MessagePostProcessor messagePostProcessor,
                                                     @Nullable
                                                     CorrelationData correlationData)
```
    Convert and send a message and return the raw reply message, or null. Subclasses can invoke this method if they want to perform conversion on the outbound message but have direct access to the reply message before conversion.
    
    Parameters:
    
    exchange - the exchange.
    
    routingKey - the routing key.
    
    message - the data to send.
    
    messagePostProcessor - a message post processor (can be null).
    
    correlationData - correlation data (can be null).
    
    Returns:
    
    the reply message or null if a timeout occurs.
    
    Since:
    
    1.6.6
  - convertMessageIfNecessary
```
protected Message convertMessageIfNecessary(Object object)
```
  - doSendAndReceive
```
@Nullable
protected Message doSendAndReceive(String exchange,
                                             String routingKey,
                                             Message message,
                                             @Nullable
                                             CorrelationData correlationData)
```
    Send a message and wait for a reply.
    
    Parameters:
    
    exchange - the exchange name
    
    routingKey - the routing key
    
    message - the message to send
    
    correlationData - the correlation data for confirms
    
    Returns:
    
    the message that is received in reply
  - doSendAndReceiveWithTemporary
```
@Nullable
protected Message doSendAndReceiveWithTemporary(String exchange,
                                                          String routingKey,
                                                          Message message,
                                                          CorrelationData correlationData)
```
  - doSendAndReceiveWithFixed
```
@Nullable
protected Message doSendAndReceiveWithFixed(String exchange,
                                                      String routingKey,
                                                      Message message,
                                                      CorrelationData correlationData)
```
  - replyTimedOut
```
protected void replyTimedOut(String correlationId)
```
    Subclasses can implement this to be notified that a reply has timed out.
    
    Parameters:
    
    correlationId - the correlationId
    
    Since:
    
    2.1.2
  - isMandatoryFor
```
public Boolean isMandatoryFor(Message message)
```
    Return whether the provided message should be sent with the mandatory flag set.
    
    Parameters:
    
    message - the message.
    
    Returns:
    
    true for mandatory.
    
    Since:
    
    2.0
  - execute
```
@Nullable
public <T> T execute(ChannelCallback<T> action)
```
    Description copied from interface: RabbitOperations
    
    Execute the callback with a channel and reliably close the channel afterwards.
    
    Specified by:
    
    execute in interface RabbitOperations
    
    Type Parameters:
    
    T - the return type.
    
    Parameters:
    
    action - the call back.
    
    Returns:
    
    the result from the ChannelCallback.doInRabbit(com.rabbitmq.client.Channel).
  - invoke
```
@Nullable
public <T> T invoke(RabbitOperations.OperationsCallback<T> action,
                              @Nullable
                              com.rabbitmq.client.ConfirmCallback acks,
                              @Nullable
                              com.rabbitmq.client.ConfirmCallback nacks)
```
    Description copied from interface: RabbitOperations
    
    Invoke operations on the same channel. If callbacks are needed, both callbacks must be supplied.
    
    Specified by:
    
    invoke in interface RabbitOperations
    
    Type Parameters:
    
    T - the return type.
    
    Parameters:
    
    action - the callback.
    
    acks - a confirm callback for acks.
    
    nacks - a confirm callback for nacks.
    
    Returns:
    
    the result of the action method.
  - waitForConfirms
```
public boolean waitForConfirms(long timeout)
```
    Description copied from interface: RabbitOperations
    
    Delegate to the underlying dedicated channel to wait for confirms. The connection factory must be configured for publisher confirms and this method must be called within the scope of an RabbitOperations.invoke(OperationsCallback) operation. Requires CachingConnectionFactory#setPublisherConfirms(true).
    
    Specified by:
    
    waitForConfirms in interface RabbitOperations
    
    Parameters:
    
    timeout - the timeout
    
    Returns:
    
    true if acks and no nacks are received.
    
    See Also:
    
    Channel.waitForConfirms(long)
  - waitForConfirmsOrDie
```
public void waitForConfirmsOrDie(long timeout)
```
    Description copied from interface: RabbitOperations
    
    Delegate to the underlying dedicated channel to wait for confirms. The connection factory must be configured for publisher confirms and this method must be called within the scope of an RabbitOperations.invoke(OperationsCallback) operation. Requires CachingConnectionFactory#setPublisherConfirms(true).
    
    Specified by:
    
    waitForConfirmsOrDie in interface RabbitOperations
    
    Parameters:
    
    timeout - the timeout
    
    See Also:
    
    Channel.waitForConfirmsOrDie(long)
  - determineConfirmsReturnsCapability
```
public void determineConfirmsReturnsCapability(ConnectionFactory connectionFactory)
```
  - doSend
```
public void doSend(com.rabbitmq.client.Channel channel,
                   String exchangeArg,
                   String routingKeyArg,
                   Message message,
                   boolean mandatory,
                   @Nullable
                   CorrelationData correlationData)
            throws Exception
```
    Send the given message to the specified exchange.
    
    Parameters:
    
    channel - The RabbitMQ Channel to operate within.
    
    exchangeArg - The name of the RabbitMQ exchange to send to.
    
    routingKeyArg - The routing key.
    
    message - The Message to send.
    
    mandatory - The mandatory flag.
    
    correlationData - The correlation data.
    
    Throws:
    
    Exception - If thrown by RabbitMQ API methods
  - sendToRabbit
```
protected void sendToRabbit(com.rabbitmq.client.Channel channel,
                            String exchange,
                            String routingKey,
                            boolean mandatory,
                            Message message)
                     throws IOException
```
    Throws:
    
    IOException
  - isChannelLocallyTransacted
```
protected boolean isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)
```
    Check whether the given Channel is locally transacted, that is, whether its transaction is managed by this template's Channel handling and not by an external transaction coordinator.
    
    Parameters:
    
    channel - the Channel to check
    
    Returns:
    
    whether the given Channel is locally transacted
    
    See Also:
    
    ConnectionFactoryUtils.isChannelTransactional(com.rabbitmq.client.Channel, org.springframework.amqp.rabbit.connection.ConnectionFactory), RabbitAccessor.isChannelTransacted()
  - addListener
```
public void addListener(com.rabbitmq.client.Channel channel)
```
    Add this template as a confirms listener for the provided channel.
    
    Parameters:
    
    channel - the channel.
    
    Since:
    
    2.0
  - handleConfirm
```
public void handleConfirm(PendingConfirm pendingConfirm,
                          boolean ack)
```
    Description copied from interface: PublisherCallbackChannel.Listener
    
    Invoked by the channel when a confirm is received.
    
    Specified by:
    
    handleConfirm in interface PublisherCallbackChannel.Listener
    
    Parameters:
    
    pendingConfirm - The pending confirmation, containing correlation data.
    
    ack - true when 'ack', false when 'nack'.
  - handleReturn
```
public void handleReturn(int replyCode,
                         String replyText,
                         String exchange,
                         String routingKey,
                         com.rabbitmq.client.AMQP.BasicProperties properties,
                         byte[] body)
                  throws IOException
```
    Specified by:
    
    handleReturn in interface PublisherCallbackChannel.Listener
    
    Throws:
    
    IOException
  - isConfirmListener
```
public boolean isConfirmListener()
```
    Specified by:
    
    isConfirmListener in interface PublisherCallbackChannel.Listener
  - isReturnListener
```
public boolean isReturnListener()
```
    Specified by:
    
    isReturnListener in interface PublisherCallbackChannel.Listener
  - revoke
```
public void revoke(com.rabbitmq.client.Channel channel)
```
    Description copied from interface: PublisherCallbackChannel.Listener
    
    When called, this listener should remove all references to the channel - it will no longer be invoked by the channel.
    
    Specified by:
    
    revoke in interface PublisherCallbackChannel.Listener
    
    Parameters:
    
    channel - The channel.
  - getUUID
```
public String getUUID()
```
    Description copied from interface: PublisherCallbackChannel.Listener
    
    Returns the UUID used to identify this Listener for returns.
    
    Specified by:
    
    getUUID in interface PublisherCallbackChannel.Listener
    
    Returns:
    
    A string representation of the UUID.
  - onMessage
```
public void onMessage(Message message)
```
    Specified by:
    
    onMessage in interface MessageListener

Class RabbitTemplate

Nested Class Summary

Nested classes/interfaces inherited from interface org.springframework.amqp.rabbit.core.RabbitOperations

Field Summary

Fields inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor

Constructor Summary

Method Summary

Methods inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.amqp.rabbit.core.RabbitOperations

Methods inherited from interface org.springframework.amqp.core.MessageListener

Constructor Detail

RabbitTemplate

RabbitTemplate

Method Detail

initDefaultStrategies

setExchange

getExchange

setRoutingKey

getRoutingKey

setQueue

setDefaultReceiveQueue

setEncoding

getEncoding

setReplyAddress

setReceiveTimeout

setReplyTimeout

setMessageConverter

setMessagePropertiesConverter

getMessagePropertiesConverter

getMessageConverter

setConfirmCallback

setReturnCallback

setMandatory

setMandatoryExpression

setMandatoryExpressionString

setSendConnectionFactorySelectorExpression

setReceiveConnectionFactorySelectorExpression

setCorrelationKey

setRetryTemplate

setRecoveryCallback

setBeanFactory

setBeforePublishPostProcessors

addBeforePublishPostProcessors

removeBeforePublishPostProcessor

setAfterReceivePostProcessors

getAfterReceivePostProcessors

addAfterReceivePostProcessors

removeAfterReceivePostProcessor

setCorrelationDataPostProcessor

setUseTemporaryReplyQueues

setUseDirectReplyToContainer

setUserIdExpression

setUserIdExpressionString

setBeanName

setTaskExecutor

setUserCorrelationId

isUsePublisherConnection

setUsePublisherConnection

setNoLocalReplyConsumer

setReplyErrorHandler

expectedQueueNames

getUnconfirmed

getUnconfirmedCount

start

doStart

stop

doStop

isRunning

useDirectReplyTo

send

send

send

send

convertAndSend

correlationConvertAndSend

convertAndSend

convertAndSend

convertAndSend

convertAndSend