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

実装されたすべてのインターフェース:
AmqpTemplate、MessageListener、PublisherCallbackChannel.Listener、RabbitOperations、ChannelAwareMessageListener、ListenerContainerAware、Aware、BeanFactoryAware、BeanNameAware、DisposableBean、InitializingBean、Lifecycle
既知の直属サブクラス
BatchingRabbitTemplate, TestRabbitTemplate
```
public class RabbitTemplate
extends RabbitAccessor
implements BeanFactoryAware, RabbitOperations, ChannelAwareMessageListener, ListenerContainerAware, PublisherCallbackChannel.Listener, BeanNameAware, DisposableBean
```
同期 RabbitMQ アクセス (メッセージの送受信) を簡素化するヘルパークラス。
デフォルト設定は非トランザクションメッセージング用であり、ブローカーと交換されるデータの量が削減されます。送受信ごとに新しいトランザクションを使用するには、channelTransacted フラグを設定します。トランザクションを複数の呼び出しに拡張する (より効率的) には、Spring トランザクションを使用して呼び出しを括弧することができます (channelTransacted=true も使用)。
唯一の必須プロパティは ConnectionFactory です。メッセージを Java オブジェクトとの間で変換する ( MessageConverter ) 方法と、メッセージヘッダー (AMQP ではメッセージプロパティと呼ばれる、MessagePropertiesConverter を参照) を変換する方法があります。メッセージの content-type が適切に設定されている限り、デフォルトはおそらく典型的な使用例に対して実用的なことを行います。
「送信」メソッドにはすべてオーバーロードされたバージョンがあり、交換とルーティングキーを明示的にターゲットにするか、すべての送信操作で使用されるデフォルト値を設定できます。単純な「受信」メソッドを使用すると、受信するキューを明示的にターゲットにすることができます。または、すべての明示的な受信に適用されるテンプレートのデフォルト値を設定できます。send と receive のコンビニエンスメソッドは、交換キーまたはルーティングキーが指定されていない場合、送信者の既定値を使用しますが、受信レグには常に一時キューを使用するため、既定のキューは無視されます。
導入:
1.0
作成者:
Mark Pollack, Mark Fisher, Dave Syer, Gary Russell, Artem Bilan, Ernest Sadykov, Mark Norkin, Mohammad Hewedy, Alexey Platonov

ネストされたクラスのサマリー

ネストされたクラス
修飾子と型	クラス	説明
`static interface`	`RabbitTemplate.ConfirmCallback`	サイト運営者の確認のためのコールバック。
`static interface`	`RabbitTemplate.ReturnCallback`	使用すべきではありません。ラムダで使いやすい `RabbitTemplate.ReturnCallback.returnedMessage(ReturnedMessage)` を推奨します。
`static interface`	`RabbitTemplate.ReturnsCallback`	返されたメッセージのコールバック。
`protected static class`	`RabbitTemplate.TemplateConsumer`	`RabbitTemplate.TemplateConsumer.toString()` を `DefaultConsumer` に追加します。

インターフェース org.springframework.amqp.rabbit.core.RabbitOperations から継承されたネストクラス / インターフェース
RabbitOperations.OperationsCallback<T>

フィールドサマリー
- クラス org.springframework.amqp.rabbit.connection.RabbitAccessor から継承されたフィールド
  logger

コンストラクターのサマリー

コンストラクター
コンストラクター	説明
`RabbitTemplate()`	setter インジェクションで使用するための便利なコンストラクター。
`RabbitTemplate(ConnectionFactory connectionFactory)`	デフォルトの戦略と設定で rabbit テンプレートを作成します。

メソッドのサマリー

すべてのメソッドインスタンスメソッド具象メソッド非推奨のメソッド
修飾子と型	メソッド	説明
`void`	`addAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)`	`Channel#basicGet()` の直後、メッセージ変換が実行される前に呼び出される `MessagePostProcessor` を追加します。
`void`	`addBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)`	`MessageProperties` から `AMQP.BasicProperties` を作成する以外のすべての処理の後、`Channel#basicPublish()` を呼び出す直前に呼び出される `MessagePostProcessor` を追加します。
`void`	`addListener(com.rabbitmq.client.Channel channel)`	このテンプレートを、提供されたチャネルの確認リスナーとして追加します。
`void`	`convertAndSend(ObjectSE object)`	Java オブジェクトを Amqp `Message` に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
`void`	`convertAndSend(ObjectSE message, MessagePostProcessor messagePostProcessor)`	Java オブジェクトを Amqp `Message` に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
`void`	`convertAndSend(ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	Java オブジェクトを Amqp `Message` に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
`void`	`convertAndSend(StringSE routingKey, ObjectSE object)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
`void`	`convertAndSend(StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
`void`	`convertAndSend(StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
`void`	`convertAndSend(StringSE routingKey, ObjectSE object, CorrelationData correlationData)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
`void`	`convertAndSend(StringSE exchange, StringSE routingKey, ObjectSE object)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
`void`	`convertAndSend(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
`void`	`convertAndSend(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
`void`	`convertAndSend(StringSE exchange, StringSE routingKey, ObjectSE object, CorrelationData correlationData)`	Java オブジェクトを Amqp `Message` に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
`protected Message`	`convertMessageIfNecessary(ObjectSE object)`
`ObjectSE`	`convertSendAndReceive(ObjectSE message)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(ObjectSE message, MessagePostProcessor messagePostProcessor)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(ObjectSE message, CorrelationData correlationData)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE routingKey, ObjectSE message)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE routingKey, ObjectSE message, CorrelationData correlationData)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE exchange, StringSE routingKey, ObjectSE message)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	変換を伴う基本的な RPC パターン。
`ObjectSE`	`convertSendAndReceive(StringSE exchange, StringSE routingKey, ObjectSE message, CorrelationData correlationData)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(ObjectSE message, MessagePostProcessor messagePostProcessor, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(ObjectSE message, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(ObjectSE message, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE routingKey, ObjectSE message, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE routingKey, ObjectSE message, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`<T> T`	`convertSendAndReceiveAsType(StringSE exchange, StringSE routingKey, ObjectSE message, ParameterizedTypeReference<T> responseType)`	変換を伴う基本的な RPC パターン。
`protected Message`	`convertSendAndReceiveRaw(StringSE exchange, StringSE routingKey, ObjectSE message, MessagePostProcessor messagePostProcessor, CorrelationData correlationData)`	メッセージを変換して送信し、生の返信メッセージまたは null を返します。
`void`	`correlationConvertAndSend(ObjectSE object, CorrelationData correlationData)`	Java オブジェクトを Amqp `Message` に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
`void`	`destroy()`
`void`	`determineConfirmsReturnsCapability(ConnectionFactory connectionFactory)`
`protected Message`	`doReceiveNoWait(StringSE queueName)`	ノンブロッキング受信。
`void`	`doSend(com.rabbitmq.client.Channel channel, StringSE exchangeArg, StringSE routingKeyArg, Message message, boolean mandatory, CorrelationData correlationData)`	指定されたメッセージを指定された交換に送信します。
`protected Message`	`doSendAndReceive(StringSE exchange, StringSE routingKey, Message message, CorrelationData correlationData)`	メッセージを送信し、返信を待ちます。
`protected Message`	`doSendAndReceiveWithFixed(StringSE exchange, StringSE routingKey, Message message, CorrelationData correlationData)`
`protected Message`	`doSendAndReceiveWithTemporary(StringSE exchange, StringSE routingKey, Message message, CorrelationData correlationData)`
`protected void`	`doStart()`	追加の開始アクションを実行します。
`protected void`	`doStop()`	追加の停止アクションを実行します。
`<T> T`	`execute(ChannelCallback<T> action)`	チャネルでコールバックを実行し、その後チャネルを確実に閉じます。
`CollectionSE<StringSE>`	`expectedQueueNames()`	キューが正しく構成されていることを確認できるように、起動時にコンテナーによって呼び出されます (exchange/routingKey の代わりに単純な応答キュー名が使用されている場合)。
`CollectionSE<MessagePostProcessor>`	`getAfterReceivePostProcessors()`	`MessagePostProcessor` または `null` を受信した後に構成を返します。
`StringSE`	`getDefaultReceiveQueue()`	構成されたデフォルトの受信キューを返します。
`StringSE`	`getEncoding()`	メッセージプロパティでバイト配列と文字列を変換するときに使用されるエンコーディング。
`StringSE`	`getExchange()`
`MessageConverter`	`getMessageConverter()`	このテンプレートのメッセージコンバーターを返します。
`protected MessagePropertiesConverter`	`getMessagePropertiesConverter()`	プロパティコンバーターを返します。
`StringSE`	`getRoutingKey()`
`CollectionSE<CorrelationData>`	`getUnconfirmed(long age)`	age よりも古い未確認の相関データを取得して削除します。
`int`	`getUnconfirmedCount()`	未確認メッセージ数を取得します。
`StringSE`	`getUUID()`	この Listener を識別するために使用される UUID を返します。
`void`	`handleConfirm(PendingConfirm pendingConfirm, boolean ack)`	確認を受信したときにチャネルによって呼び出されます。
`void`	`handleReturn(int replyCode, StringSE replyText, StringSE exchange, StringSE routingKey, com.rabbitmq.client.AMQP.BasicProperties properties, byte[] body)`	返されたメッセージを処理します。
`void`	`handleReturn(com.rabbitmq.client.Return returned)`	返されたメッセージを処理します。
`protected void`	`initDefaultStrategies()`	デフォルトの戦略を設定します。
`<T> T`	`invoke(RabbitOperations.OperationsCallback<T> action, com.rabbitmq.client.ConfirmCallback acks, com.rabbitmq.client.ConfirmCallback nacks)`	同じチャネルで操作を呼び出します。
`protected boolean`	`isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)`	指定されたチャネルがローカルで処理されているかどうか、つまり、そのトランザクションが外部トランザクションコーディネーターではなく、このテンプレートのチャネル処理によって管理されているかどうかを確認します。
`boolean`	`isConfirmListener()`
`BooleanSE`	`isMandatoryFor(Message message)`	指定されたメッセージを必須フラグを設定して送信する必要があるかどうかを返します。
`boolean`	`isReturnListener()`
`boolean`	`isRunning()`
`boolean`	`isUsePublisherConnection()`	個別のパブリッシャー接続が使用されている場合は true。
`StringSE`	`nullSafeExchange(StringSE exchange)`	null の場合、取引所またはデフォルトの取引所を返します。
`StringSE`	`nullSafeRoutingKey(StringSE rk)`	null の場合は、ルーティングキーまたはデフォルトのルーティングキーを返します。
`void`	`onMessage(Message message)`	使用すべきではありません。 - `onMessage(Message, Channel)` を使用します。
`void`	`onMessage(Message message, com.rabbitmq.client.Channel channel)`	受信した Rabbit メッセージを処理するためのコールバック。
`Message`	`receive()`	デフォルトキューからのメッセージがある場合は、メッセージを受信します。
`Message`	`receive(long timeoutMillis)`	デフォルトのキューからメッセージを受信し、メッセージが利用可能になるまで必要に応じて指定された待機時間まで待機します。
`Message`	`receive(StringSE queueName)`	特定のキューからのメッセージがある場合、メッセージを受信します。
`Message`	`receive(StringSE queueName, long timeoutMillis)`	特定のキューからメッセージを受信し、メッセージが使用可能になるまで必要に応じて指定された待機時間まで待機します。
`ObjectSE`	`receiveAndConvert()`	デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。
`ObjectSE`	`receiveAndConvert(long timeoutMillis)`	デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。
`<T> T`	`receiveAndConvert(long timeoutMillis, ParameterizedTypeReference<T> type)`	デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。
`ObjectSE`	`receiveAndConvert(StringSE queueName)`	特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。
`ObjectSE`	`receiveAndConvert(StringSE queueName, long timeoutMillis)`	特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。
`<T> T`	`receiveAndConvert(StringSE queueName, long timeoutMillis, ParameterizedTypeReference<T> type)`	特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。
`<T> T`	`receiveAndConvert(StringSE queueName, ParameterizedTypeReference<T> type)`	特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。
`<T> T`	`receiveAndConvert(ParameterizedTypeReference<T> type)`	デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。
`<R,S> boolean`	`receiveAndReply(StringSE queueName, ReceiveAndReplyCallback<R,S> callback)`	提供されたキューからメッセージがある場合はメッセージを受信し、提供された `ReceiveAndReplyCallback` を呼び出し、応答メッセージを送信します。`callback` がメッセージを返す場合は、`MessageProperties` から `replyTo` `Address` に、またはデフォルト交換とデフォルトルーティングキーに送信します。
`<R,S> boolean`	`receiveAndReply(StringSE queueName, ReceiveAndReplyCallback<R,S> callback, StringSE replyExchange, StringSE replyRoutingKey)`	提供されたキューからメッセージがある場合はメッセージを受信し、提供された `ReceiveAndReplyCallback` を呼び出し、`callback` がメッセージを返す場合は、提供された `exchange` および `routingKey` に応答メッセージを送信します。
`<R,S> boolean`	`receiveAndReply(StringSE queueName, ReceiveAndReplyCallback<R,S> callback, ReplyToAddressCallback<S> replyToAddressCallback)`	指定されたキューからメッセージがあれば受信し、指定された `ReceiveAndReplyCallback` を呼び出し、`callback` がメッセージを返す場合は、応答メッセージを `ReplyToAddressCallback` の結果から `replyTo` `Address` に送信します。
`<R,S> boolean`	`receiveAndReply(ReceiveAndReplyCallback<R,S> callback)`	デフォルトキューからメッセージがあれば受信し、提供された `ReceiveAndReplyCallback` を呼び出し、`callback` がメッセージを返す場合は、応答メッセージを `MessageProperties` から `replyTo` `Address` に、またはデフォルト交換とデフォルトルーティングキーに送信します。
`<R,S> boolean`	`receiveAndReply(ReceiveAndReplyCallback<R,S> callback, StringSE exchange, StringSE routingKey)`	デフォルトキューからメッセージがある場合はメッセージを受信し、提供された `ReceiveAndReplyCallback` を呼び出し、`callback` がメッセージを返す場合は、提供された `exchange` および `routingKey` に応答メッセージを送信します。
`<R,S> boolean`	`receiveAndReply(ReceiveAndReplyCallback<R,S> callback, ReplyToAddressCallback<S> replyToAddressCallback)`	デフォルトのキューからメッセージがあれば受信し、提供された `ReceiveAndReplyCallback` を呼び出し、`callback` がメッセージを返す場合は、応答メッセージを `ReplyToAddressCallback` の結果から `replyTo` `Address` に送信します。
`boolean`	`removeAfterReceivePostProcessor(MessagePostProcessor afterReceivePostProcessor)`	提供された `MessagePostProcessor` を `afterReceivePostProcessors` リストから削除します。
`boolean`	`removeBeforePublishPostProcessor(MessagePostProcessor beforePublishPostProcessor)`	提供された `MessagePostProcessor` を `beforePublishPostProcessors` リストから削除します。
`protected void`	`replyTimedOut(StringSE correlationId)`	サブクラスはこれを実装して、応答がタイムアウトしたことを通知できます。
`void`	`revoke(com.rabbitmq.client.Channel channel)`	呼び出されると、このリスナーはチャネルへのすべての参照を削除する必要があります。チャネルによって呼び出されることはありません。
`void`	`send(StringSE exchange, StringSE routingKey, Message message)`	特定のルーティングキーを使用して、特定の交換にメッセージを送信します。
`void`	`send(StringSE exchange, StringSE routingKey, Message message, CorrelationData correlationData)`	特定のルーティングキーを使用して、特定の交換にメッセージを送信します。
`void`	`send(StringSE routingKey, Message message)`	特定のルーティングキーを使用して、デフォルトの交換にメッセージを送信します。
`void`	`send(StringSE routingKey, Message message, CorrelationData correlationData)`	特定のルーティングキーを使用して、デフォルトの交換にメッセージを送信します。
`void`	`send(Message message)`	デフォルトのルーティングキーを使用して、デフォルトの交換にメッセージを送信します。
`Message`	`sendAndReceive(StringSE exchange, StringSE routingKey, Message message)`	基本的な RPC パターン。
`Message`	`sendAndReceive(StringSE exchange, StringSE routingKey, Message message, CorrelationData correlationData)`
`Message`	`sendAndReceive(StringSE routingKey, Message message)`	基本的な RPC パターン。
`Message`	`sendAndReceive(StringSE routingKey, Message message, CorrelationData correlationData)`
`Message`	`sendAndReceive(Message message)`	基本的な RPC パターン。
`Message`	`sendAndReceive(Message message, CorrelationData correlationData)`
`protected void`	`sendToRabbit(com.rabbitmq.client.Channel channel, StringSE exchange, StringSE routingKey, boolean mandatory, Message message)`
`void`	`setAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)`	`Channel#basicGet()` の直後、メッセージ変換が実行される前に呼び出される `MessagePostProcessor` を設定します。
`void`	`setBeanFactory(BeanFactory beanFactory)`
`void`	`setBeanName(StringSE name)`
`void`	`setBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)`	`MessageProperties` から `AMQP.BasicProperties` を作成する以外のすべての処理の後、`Channel#basicPublish()` を呼び出す直前に呼び出される `MessagePostProcessor` を設定します。
`void`	`setConfirmCallback(RabbitTemplate.ConfirmCallback confirmCallback)`
`void`	`setConnectionFactory(ConnectionFactory connectionFactory)`	RabbitMQ `Connections` の取得に使用する ConnectionFactory を設定します。
`void`	`setCorrelationDataPostProcessor(CorrelationDataPostProcessor correlationDataPostProcessor)`	メッセージをパブリッシュする前に、`CorrelationDataPostProcessor` が呼び出されるように設定します。
`void`	`setCorrelationKey(StringSE correlationKey)`	"correlationId" (デフォルト) に設定すると、correlationId プロパティが使用されます。それ以外の場合は、提供されたキーが使用されます。
`void`	`setDefaultReceiveQueue(StringSE queue)`	明示的に指定されていない場合にメッセージを受信するデフォルトのキューの名前。
`void`	`setEncoding(StringSE encoding)`	メッセージプロパティでバイト配列と文字列を変換するときに使用するエンコーディング。
`void`	`setExchange(StringSE exchange)`	何も指定されていない場合に送信操作に使用するデフォルトの交換の名前。
`void`	`setMandatory(boolean mandatory)`	メッセージの送信時に必須フラグを設定します。`returnCallback` が提供された場合にのみ適用されます。
`void`	`setMandatoryExpression(Expression mandatoryExpression)`
`void`	`setMandatoryExpressionString(StringSE mandatoryExpression)`
`void`	`setMessageConverter(MessageConverter messageConverter)`	このテンプレートのメッセージコンバーターを設定します。
`void`	`setMessagePropertiesConverter(MessagePropertiesConverter messagePropertiesConverter)`	このテンプレートの `MessagePropertiesConverter` を設定します。
`void`	`setNoLocalReplyConsumer(boolean noLocalReplyConsumer)`	非ローカルコンシューマーの場合は true に設定します。
`void`	`setReceiveConnectionFactorySelectorExpression(Expression receiveConnectionFactorySelectorExpression)`	指定された `RabbitAccessor.getConnectionFactory()` が `AbstractRoutingConnectionFactory` のインスタンスである場合、各 `receivequeueName` に対して評価する SpEL `Expression`。
`void`	`setReceiveTimeout(long receiveTimeout)`	`receive()` メソッドを使用する場合の受信タイムアウトをミリ秒単位で指定します (`sendAndReceive()` メソッドについては、`replyTimeout` を参照してください。
`void`	`setRecoveryCallback(org.springframework.retry.RecoveryCallback<?> recoveryCallback)`	`retryTemplate.execute` に使用される `RecoveryCallback` を追加します。
`void`	`setReplyAddress(StringSE replyAddress)`	返信用のアドレス。指定されていない場合、RabbitMQ が "amq.rabbitmq.reply-to" をサポートしていない限り、一時的な専用の自動削除キューが各応答に使用されます - https://www.rabbitmq.com/direct-reply-to.html を参照してください
`void`	`setReplyErrorHandler(ErrorHandler replyErrorHandler)`	リクエスト / 応答操作に直接応答先コンテナーを使用する場合、応答配信が失敗したときに呼び出されるエラーハンドラーを設定します (例:
`void`	`setReplyTimeout(long replyTimeout)`	sendAndReceive メソッドのいずれかを使用するときに、応答メッセージを待機するときに使用されるタイムアウトをミリ秒単位で指定します。
`void`	`setRetryTemplate(org.springframework.retry.support.RetryTemplate retryTemplate)`	すべての rabbit 操作に使用される `RetryTemplate` を追加します。
`void`	`setReturnCallback(RabbitTemplate.ReturnCallback returnCallback)`	使用すべきではありません。 `setReturnsCallback(ReturnsCallback)` を推奨。
`void`	`setReturnsCallback(RabbitTemplate.ReturnsCallback returnCallback)`
`void`	`setRoutingKey(StringSE routingKey)`	何も指定されていない場合に送信操作に使用するデフォルトのルーティングキーの値。
`void`	`setSendConnectionFactorySelectorExpression(Expression sendConnectionFactorySelectorExpression)`	指定された `RabbitAccessor.getConnectionFactory()` が `AbstractRoutingConnectionFactory` のインスタンスである場合、各リクエストメッセージに対して評価する SpEL `Expression`。
`void`	`setTaskExecutor(ExecutorSE taskExecutor)`	`DirectReplyToMessageListenerContainer` を使用するときに使用するタスクエグゼキュータを設定します。
`void`	`setUseChannelForCorrelation(boolean useChannelForCorrelation)`	直接返信先を使用する場合は、これを true に設定して、サーバーが返信ヘッダーで相関 ID を送信する必要がないようにします。
`void`	`setUseDirectReplyToContainer(boolean useDirectReplyToContainer)`	ダイレクトリプライ可能で使用中の場合、`DirectReplyToMessageListenerContainer` を使用するかどうかを設定します。
`void`	`setUsePublisherConnection(boolean usePublisherConnection)`	接続のデッドロックを回避するために、通常、パブリッシャーとコンシューマーに別々の接続を使用することをお勧めします (パブリッシャーがコンシューマートランザクションに参加している場合を除く)。
`void`	`setUserCorrelationId(boolean userCorrelationId)`	リクエスト / 応答シナリオの相関 ID を生成する代わりに、メッセージによって提供される相関 ID を使用するには、true に設定します。
`void`	`setUserIdExpression(Expression userIdExpression)`	評価される式を設定して、userId メッセージプロパティが null 以外の値に評価され、プロパティがまだ送信されるメッセージに設定されていない場合に設定します。
`void`	`setUserIdExpressionString(StringSE userIdExpression)`	評価される式を設定して、userId メッセージプロパティが null 以外の値に評価され、プロパティがまだ送信されるメッセージに設定されていない場合に設定します。
`void`	`setUseTemporaryReplyQueues(boolean value)`	デフォルトでは、ブローカがサポートしており、`replyAddress` が提供されていない場合、送受信メソッドは直接返信先 (https://www.rabbitmq.com/direct-reply-to.html).
`void`	`start()`
`void`	`stop()`
`protected boolean`	`useDirectReplyTo()`	このメソッドをオーバーライドして、他の条件を使用して、直接返信先 (https://www.rabbitmq.com/direct-reply-to.html).
`boolean`	`waitForConfirms(long timeout)`	基礎となる専用チャネルに委譲して、確認を待ちます。
`void`	`waitForConfirmsOrDie(long timeout)`	基礎となる専用チャネルに委譲して、確認を待ちます。

クラス org.springframework.amqp.rabbit.connection.RabbitAccessor から継承されたメソッド
afterPropertiesSet, convertRabbitAccessException, createConnection, getChannel, getConnection, getConnectionFactory, getTransactionalResourceHolder, isChannelTransacted, setChannelTransacted

クラス java.lang.ObjectSE から継承されたメソッド
clone, equalsSE, finalize, getClass, hashCode, notify, notifyAll, toString, wait, waitSE, waitSE

インターフェース org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener から継承されたメソッド
onMessageBatch

インターフェース org.springframework.amqp.core.MessageListener から継承されたメソッド
containerAckMode, isAsyncReplies, onMessageBatch

インターフェース org.springframework.amqp.rabbit.core.RabbitOperations から継承されたメソッド
convertSendAndReceiveAsType, getConnectionFactory, invoke

- コンストラクターの詳細
  - RabbitTemplate
```
public RabbitTemplate()
```
    setter インジェクションで使用するための便利なコンストラクター。接続ファクトリを設定することを忘れないでください。
  - RabbitTemplate
```
public RabbitTemplate(ConnectionFactory connectionFactory)
```
    デフォルトの戦略と設定で rabbit テンプレートを作成します。
    パラメーター:
    connectionFactory - 使用する接続ファクトリ
- メソッドの詳細
  - initDefaultStrategies
```
protected void initDefaultStrategies()
```
    デフォルトの戦略を設定します。サブクラスは、必要に応じてオーバーライドできます。
  - setConnectionFactory
```
public final void setConnectionFactory(ConnectionFactory connectionFactory)
```
    クラスからコピーされた説明: RabbitAccessor
    RabbitMQ Connections の取得に使用する ConnectionFactory を設定します。
    オーバーライド:
    クラス RabbitAccessor の setConnectionFactory
    パラメーター:
    connectionFactory - 接続ファクトリ。
  - setExchange
```
public void setExchange(@Nullable
                        StringSE exchange)
```
    何も指定されていない場合に送信操作に使用するデフォルトの交換の名前。デフォルトは、ブローカーのデフォルト交換である "" です (AMQP 仕様による)。
    パラメーター:
    exchange - 送信操作に使用する交換名
  - getExchange
```
public StringSE getExchange()
```
    戻り値:
    このテンプレートで使用されるデフォルトの取引所の名前。
    導入:
    1.6
  - setRoutingKey
```
public void setRoutingKey(StringSE routingKey)
```
    何も指定されていない場合に送信操作に使用するデフォルトのルーティングキーの値。デフォルトは空であり、デフォルト (または任意の直接) 交換を使用する場合には役に立ちませんが、たとえば交換がヘッダー交換である場合は問題ありません。
    パラメーター:
    routingKey - 送信操作に使用するデフォルトのルーティングキー
  - getRoutingKey
```
public StringSE getRoutingKey()
```
    戻り値:
    このテンプレートで使用されるデフォルトのルーティングキー。
    導入:
    1.6
  - setDefaultReceiveQueue
```
public void setDefaultReceiveQueue(StringSE queue)
```
    明示的に指定されていない場合にメッセージを受信するデフォルトのキューの名前。
    パラメーター:
    queue - 受信に使用するデフォルトのキュー名
    導入:
    2.1.2
  - getDefaultReceiveQueue
```
@Nullable
public StringSE getDefaultReceiveQueue()
```
    構成されたデフォルトの受信キューを返します。
    戻り値:
    キューまたは構成されていない場合は null。
    導入:
    2.2.22
  - setEncoding
```
public void setEncoding(StringSE encoding)
```
    メッセージプロパティでバイト配列と文字列を変換するときに使用するエンコーディング。
    パラメーター:
    encoding - 設定するエンコーディング
  - getEncoding
```
public StringSE getEncoding()
```
    メッセージプロパティでバイト配列と文字列を変換するときに使用されるエンコーディング。
    戻り値:
    エンコーディング。
  - setReplyAddress
```
public void setReplyAddress(StringSE replyAddress)
```
    返信用のアドレス。指定されていない場合、RabbitMQ が "amq.rabbitmq.reply-to" をサポートしていない限り、一時的な専用の自動削除キューが各応答に使用されます - https://www.rabbitmq.com/direct-reply-to.html を参照してください
    アドレスは、単純なキュー名 (この場合、応答はデフォルトの交換を介してルーティングされます) にするか、明示的な交換およびルーティングキーを使用して応答をルーティングする exchange/routingKey の形式にすることができます。
    パラメーター:
    replyAddress - 設定する返信アドレス
  - setReceiveTimeout
```
public void setReceiveTimeout(long receiveTimeout)
```
    receive() メソッドを使用する場合の受信タイムアウトをミリ秒単位で指定します (sendAndReceive() メソッドについては、replyTimeout を参照してください。デフォルトでは、値はゼロです。これは、利用可能なメッセージがない場合、receive() メソッドがすぐに null を返すことを意味します。待機するには、ゼロ未満に設定します。無期限にメッセージを送信します。
    パラメーター:
    receiveTimeout - タイムアウト。
    導入:
    1.5
  - setReplyTimeout
```
public void setReplyTimeout(long replyTimeout)
```
    sendAndReceive メソッドのいずれかを使用するときに、応答メッセージを待機するときに使用されるタイムアウトをミリ秒単位で指定します。デフォルト値は DEFAULT_REPLY_TIMEOUT として定義されています。負の値は無期限のタイムアウトを示します。プロトコルにブロッキング受信操作が定義されていないため、通常の受信メソッドでは使用されません。
    パラメーター:
    replyTimeout - ミリ秒単位の応答タイムアウト
    関連事項:
    sendAndReceive(String, String, Message), convertSendAndReceive(String, String, Object)
  - setMessageConverter
```
public void setMessageConverter(MessageConverter messageConverter)
```
    このテンプレートのメッセージコンバーターを設定します。Object パラメーターを変換して、convertAndSend メソッドおよび receiveAndConvert メソッドからの Object 結果を解決するために使用されます。
    デフォルトのコンバーターは SimpleMessageConverter で、メッセージコンテンツ型ヘッダーに応じて、バイト配列、文字列、シリアライズ可能なオブジェクトを処理できます。
    パラメーター:
    messageConverter - メッセージコンバーター。
    関連事項:
    convertAndSend(java.lang.Object), receiveAndConvert(), SimpleMessageConverter
  - setMessagePropertiesConverter
```
public void setMessagePropertiesConverter(MessagePropertiesConverter messagePropertiesConverter)
```
    このテンプレートの MessagePropertiesConverter を設定します。このコンバーターは、メッセージヘッダーの未加工のバイトコンテンツとプレーンな Java オブジェクトとの間の変換に使用されます。特に、非常に長い文字列ヘッダーを処理する場合は制限がありますが、これは実際にはめったに発生しないことを願っていますが、長いヘッダーを使用する必要がある場合は、ここに特別なコンバーターを挿入する必要がある場合があります。
    パラメーター:
    messagePropertiesConverter - メッセージプロパティコンバーター。
  - getMessagePropertiesConverter
```
protected MessagePropertiesConverter getMessagePropertiesConverter()
```
    プロパティコンバーターを返します。
    戻り値:
    コンバーター。
    導入:
    2.0
  - getMessageConverter
```
public MessageConverter getMessageConverter()
```
    このテンプレートのメッセージコンバーターを返します。ChannelCallback 実装でコンバーターを利用したいクライアントに役立ちます。
    戻り値:
    メッセージコンバーター。
  - setConfirmCallback
```
public void setConfirmCallback(RabbitTemplate.ConfirmCallback confirmCallback)
```
  - setReturnCallback
```
@DeprecatedSE
public void setReturnCallback(RabbitTemplate.ReturnCallback returnCallback)
```
    使用すべきではありません。
    setReturnsCallback(ReturnsCallback) を推奨。
    返されたメッセージを受信するようにコールバックを設定します。
    パラメーター:
    returnCallback - コールバック。
  - setReturnsCallback
```
public void setReturnsCallback(RabbitTemplate.ReturnsCallback returnCallback)
```
  - setMandatory
```
public void setMandatory(boolean mandatory)
```
    メッセージの送信時に必須フラグを設定します。returnCallback が提供された場合にのみ適用されます。
    パラメーター:
    mandatory - 設定必須。
  - setMandatoryExpression
```
public void setMandatoryExpression(Expression mandatoryExpression)
```
    パラメーター:
    mandatoryExpression - returnCallback が提供されている場合、各リクエストメッセージに対して評価する SpEL Expression。評価の結果は、boolean 値でなければなりません。
    導入:
    1.4
  - setMandatoryExpressionString
```
public void setMandatoryExpressionString(StringSE mandatoryExpression)
```
    パラメーター:
    mandatoryExpression - returnCallback が提供されている場合、各リクエストメッセージに対して評価する SpEL Expression。評価の結果は、boolean 値でなければなりません。
    導入:
    2.0
  - setSendConnectionFactorySelectorExpression
```
public void setSendConnectionFactorySelectorExpression(Expression sendConnectionFactorySelectorExpression)
```
    指定された RabbitAccessor.getConnectionFactory() が AbstractRoutingConnectionFactory のインスタンスである場合、各リクエストメッセージに対して評価する SpEL Expression。
    この式の結果は、AbstractRoutingConnectionFactory からターゲット ConnectionFactory を直接取得するための lookupKey として使用されます。
    この式が null に評価される場合、通常の AbstractRoutingConnectionFactory ロジックにフォールバックします。
    評価された lookupKey を持つターゲット ConnectionFactory がない場合、そのプロパティが lenientFallback == true の場合にのみ、通常の AbstractRoutingConnectionFactory ロジックにフォールバックします。
    この式は、send 操作に使用されます。
    パラメーター:
    sendConnectionFactorySelectorExpression - 評価する SpEL Expression
    導入:
    1.4
  - setReceiveConnectionFactorySelectorExpression
```
public void setReceiveConnectionFactorySelectorExpression(Expression receiveConnectionFactorySelectorExpression)
```
    指定された RabbitAccessor.getConnectionFactory() が AbstractRoutingConnectionFactory のインスタンスである場合、各 receivequeueName に対して評価する SpEL Expression。
    この式の結果は、AbstractRoutingConnectionFactory からターゲット ConnectionFactory を直接取得するための lookupKey として使用されます。
    この式が null に評価される場合、通常の AbstractRoutingConnectionFactory ロジックにフォールバックします。
    評価された lookupKey を持つターゲット ConnectionFactory がない場合、そのプロパティが lenientFallback == true の場合にのみ、通常の AbstractRoutingConnectionFactory ロジックにフォールバックします。
    この式は、receive 操作に使用されます。
    パラメーター:
    receiveConnectionFactorySelectorExpression - 評価する SpEL Expression
    導入:
    1.4
  - setCorrelationKey
```
public void setCorrelationKey(StringSE correlationKey)
```
    "correlationId" (デフォルト) に設定すると、correlationId プロパティが使用されます。それ以外の場合は、提供されたキーが使用されます。
    パラメーター:
    correlationKey - 設定する correlationKey
  - setRetryTemplate
```
public void setRetryTemplate(org.springframework.retry.support.RetryTemplate retryTemplate)
```
    すべての rabbit 操作に使用される RetryTemplate を追加します。
    パラメーター:
    retryTemplate - 再試行テンプレート。
  - setRecoveryCallback
```
public void setRecoveryCallback(org.springframework.retry.RecoveryCallback<?> recoveryCallback)
```
    retryTemplate.execute に使用される RecoveryCallback を追加します。retryTemplate が指定されていない場合、recoveryCallback は無視されます。RecoveryCallback は、execute(ChannelCallback) 戻り型と互換性のある結果を生成する必要があります。
    パラメーター:
    recoveryCallback - 再試行の recoveryCallback。
    導入:
    1.4
  - setBeanFactory
```
public void setBeanFactory(BeanFactory beanFactory)
                    throws BeansException
```
    次で指定:
    インターフェース BeanFactoryAware の setBeanFactory
    例外:
    BeansException
  - setBeforePublishPostProcessors
```
public void setBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)
```
    MessageProperties から AMQP.BasicProperties を作成する以外のすべての処理の後、Channel#basicPublish() を呼び出す直前に呼び出される MessagePostProcessor を設定します。圧縮などの操作に使用できます。プロセッサーは、PriorityOrder、Order に応じて順番に呼び出され、最後に順不同で呼び出されます。
    パラメーター:
    beforePublishPostProcessors - ポストプロセッサー。
    導入:
    1.4.2
    関連事項:
    addBeforePublishPostProcessors(MessagePostProcessor...)
  - addBeforePublishPostProcessors
```
public void addBeforePublishPostProcessors(MessagePostProcessor... beforePublishPostProcessors)
```
    MessageProperties から AMQP.BasicProperties を作成する以外のすべての処理の後、Channel#basicPublish() を呼び出す直前に呼び出される MessagePostProcessor を追加します。圧縮などの操作に使用できます。プロセッサーは、PriorityOrder、Order に応じて順番に呼び出され、最後に順不同で呼び出されます。
    setBeforePublishPostProcessors(MessagePostProcessor...) とは対照的に、このメソッドは以前に追加された beforePublishPostProcessors をオーバーライドしません。
    パラメーター:
    beforePublishPostProcessors - ポストプロセッサー。
    導入:
    2.1.4
  - removeBeforePublishPostProcessor
```
public boolean removeBeforePublishPostProcessor(MessagePostProcessor beforePublishPostProcessor)
```
    提供された MessagePostProcessor を beforePublishPostProcessors リストから削除します。
    パラメーター:
    beforePublishPostProcessor - 削除する MessagePostProcessor。
    戻り値:
    提供されたポストプロセッサーが削除されている場合はブール値。
    導入:
    2.1.4
    関連事項:
    addBeforePublishPostProcessors(MessagePostProcessor...)
  - setAfterReceivePostProcessors
```
public void setAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)
```
    Channel#basicGet() の直後、メッセージ変換が実行される前に呼び出される MessagePostProcessor を設定します。減圧などの操作に使用できます。プロセッサーは、PriorityOrder、Order に応じて順番に呼び出され、最後に順不同で呼び出されます。
    パラメーター:
    afterReceivePostProcessors - ポストプロセッサー。
    導入:
    1.5
    関連事項:
    addAfterReceivePostProcessors(MessagePostProcessor...)
  - getAfterReceivePostProcessors
```
@Nullable
public CollectionSE<MessagePostProcessor> getAfterReceivePostProcessors()
```
    MessagePostProcessor または null を受信した後に構成を返します。
    戻り値:
    MessagePostProcessor または null の受信後に設定されます。
    導入:
    2.1.5
  - addAfterReceivePostProcessors
```
public void addAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors)
```
    Channel#basicGet() の直後、メッセージ変換が実行される前に呼び出される MessagePostProcessor を追加します。減圧などの操作に使用できます。プロセッサーは、PriorityOrder、Order に応じて順番に呼び出され、最後に順不同で呼び出されます。
    setAfterReceivePostProcessors(MessagePostProcessor...) とは対照的に、このメソッドは以前に追加された afterReceivePostProcessors をオーバーライドしません。
    パラメーター:
    afterReceivePostProcessors - ポストプロセッサー。
    導入:
    2.1.4
  - removeAfterReceivePostProcessor
```
public boolean removeAfterReceivePostProcessor(MessagePostProcessor afterReceivePostProcessor)
```
    提供された MessagePostProcessor を afterReceivePostProcessors リストから削除します。
    パラメーター:
    afterReceivePostProcessor - 削除する MessagePostProcessor。
    戻り値:
    提供されたポストプロセッサーが削除されている場合はブール値。
    導入:
    2.1.4
    関連事項:
    addAfterReceivePostProcessors(MessagePostProcessor...)
  - setCorrelationDataPostProcessor
```
public void setCorrelationDataPostProcessor(CorrelationDataPostProcessor correlationDataPostProcessor)
```
    メッセージをパブリッシュする前に、CorrelationDataPostProcessor が呼び出されるように設定します。相関データは、発行者の確認を相関させるために使用されます。
    パラメーター:
    correlationDataPostProcessor - ポストプロセッサー。
    導入:
    1.6.7
    関連事項:
    setConfirmCallback(ConfirmCallback)
  - setUseTemporaryReplyQueues
```
public void setUseTemporaryReplyQueues(boolean value)
```
    デフォルトでは、ブローカーがそれをサポートし、replyAddress が提供されていない場合、送信 / 受信メソッドは直接返信先 (https://www.rabbitmq.com/direct-reply-to.html)) を使用します。このプロパティを true に設定すると、その動作がオーバーライドされ、代わりに各リクエストに対して一時的な自動削除キューが使用されます。最初のリクエストが処理されると、このプロパティを変更しても効果がありません。
    パラメーター:
    value - 一時キューを使用する場合は true。
    導入:
    1.6
  - setUseDirectReplyToContainer
```
public void setUseDirectReplyToContainer(boolean useDirectReplyToContainer)
```
    ダイレクトリプライ可能で使用中の場合、DirectReplyToMessageListenerContainer を使用するかどうかを設定します。false の場合、リクエストごとに新しいコンシューマーが作成されます (2.0 より前のバージョンで使用されていたメカニズム)。デフォルトは真です。
    パラメーター:
    useDirectReplyToContainer - リクエストごとにコンシューマーを使用するには、false に設定します。
    導入:
    2.0
    関連事項:
    setUseTemporaryReplyQueues(boolean)
  - setUserIdExpression
```
public void setUserIdExpression(Expression userIdExpression)
```
    評価される式を設定して、userId メッセージプロパティが null 以外の値に評価され、プロパティがまだ送信されるメッセージに設定されていない場合に設定します。https://www.rabbitmq.com/validated-user-id.html を参照
    パラメーター:
    userIdExpression - 表現。
    導入:
    1.6
  - setUserIdExpressionString
```
public void setUserIdExpressionString(StringSE userIdExpression)
```
    評価される式を設定して、userId メッセージプロパティが null 以外の値に評価され、プロパティがまだ送信されるメッセージに設定されていない場合に設定します。https://www.rabbitmq.com/validated-user-id.html を参照
    パラメーター:
    userIdExpression - 表現。
    導入:
    1.6
  - setBeanName
```
public void setBeanName(StringSE name)
```
    次で指定:
    インターフェース BeanNameAware の setBeanName
  - setTaskExecutor
```
public void setTaskExecutor(ExecutorSE taskExecutor)
```
    DirectReplyToMessageListenerContainer を使用するときに使用するタスクエグゼキュータを設定します。
    パラメーター:
    taskExecutor - 執行者。
    導入:
    2.0
  - setUserCorrelationId
```
public void setUserCorrelationId(boolean userCorrelationId)
```
    リクエスト / 応答シナリオの相関 ID を生成する代わりに、メッセージによって提供される相関 ID を使用するには、true に設定します。相関 ID は、クロストークを回避するために、すべての処理中のリクエストに対して一意である必要があります。
    そのため、ユーザーは一意性を確保するために細心の注意を払う必要があります。
    パラメーター:
    userCorrelationId - ユーザー相関データを使用する場合は true。
  - isUsePublisherConnection
```
public boolean isUsePublisherConnection()
```
    個別のパブリッシャー接続が使用されている場合は true。
    戻り値:
    正しいか間違っているか。
    導入:
    2.0.2
    関連事項:
    setUsePublisherConnection(boolean)
  - setUsePublisherConnection
```
public void setUsePublisherConnection(boolean usePublisherConnection)
```
    接続のデッドロックを回避するために、通常、パブリッシャーとコンシューマーに別々の接続を使用することをお勧めします (パブリッシャーがコンシューマートランザクションに参加している場合を除く)。デフォルトは "false" です。これを true に設定するときは、このテンプレートを使用する RabbitAdmin がパブリッシャー接続でキューを宣言することに注意してください。これは、特にこのアプリケーションで消費される可能性のある排他的なキューでは、期待どおりではない可能性があります。
    パラメーター:
    usePublisherConnection - パブリッシャー接続を使用する場合は true。
    導入:
    2.0.2
  - setNoLocalReplyConsumer
```
public void setNoLocalReplyConsumer(boolean noLocalReplyConsumer)
```
    非ローカルコンシューマーの場合は true に設定します。デフォルトは false です。
    パラメーター:
    noLocalReplyConsumer - ローカルでないコンシューマーの場合は true。
    導入:
    2.1
    関連事項:
    AbstractMessageListenerContainer.setNoLocal(boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, com.rabbitmq.client.Consumer)
  - setReplyErrorHandler
```
public void setReplyErrorHandler(ErrorHandler replyErrorHandler)
```
    リクエスト / リプライ操作に直接リプライ先コンテナーを使用する場合は、リプライ配信が失敗した場合 (リプライの遅延など) にエラーハンドラーが呼び出されるように設定します。
    パラメーター:
    replyErrorHandler - 応答エラーハンドラー
    導入:
    2.0.11
    関連事項:
    setUseDirectReplyToContainer(boolean)
  - setUseChannelForCorrelation
```
public void setUseChannelForCorrelation(boolean useChannelForCorrelation)
```
    直接返信先を使用する場合は、これを true に設定して、サーバーが返信ヘッダーで相関 ID を送信する必要がないようにします。代わりに、チャネルを使用して応答をリクエストに関連付けます。
    パラメーター:
    useChannelForCorrelation - チャネルを使用する場合は true。
    導入:
    2.3.7
  - expectedQueueNames
```
@Nullable
public CollectionSE<StringSE> expectedQueueNames()
```
    キューが正しく構成されていることを確認できるように、起動時にコンテナーによって呼び出されます (exchange/routingKey の代わりに単純な応答キュー名が使用されている場合)。
    次で指定:
    インターフェース ListenerContainerAware の expectedQueueNames
    戻り値:
    キュー名 (構成されている場合)。
    導入:
    1.5
  - getUnconfirmed
```
@Nullable
public CollectionSE<CorrelationData> getUnconfirmed(long age)
```
    age よりも古い未確認の相関データを取得して削除します。
    パラメーター:
    age - ミリ秒単位
    戻り値:
    確認が受信されていない相関データのコレクション、またはそのような確認が存在しない場合は null。
  - getUnconfirmedCount
```
public int getUnconfirmedCount()
```
    未確認メッセージ数を取得します。
    戻り値:
    RabbitMQ によってまだ確認されていないメッセージの数。
    導入:
    2.0
  - start
```
public void start()
```
    次で指定:
    インターフェース Lifecycle の start
    次で指定:
    インターフェース RabbitOperations の start
  - doStart
```
protected void doStart()
```
    追加の開始アクションを実行します。
    導入:
    2.0
  - stop
```
public void stop()
```
    次で指定:
    インターフェース Lifecycle の stop
    次で指定:
    インターフェース RabbitOperations の stop
  - doStop
```
protected void doStop()
```
    追加の停止アクションを実行します。
    導入:
    2.0
  - isRunning
```
public boolean isRunning()
```
    次で指定:
    インターフェース Lifecycle の isRunning
    次で指定:
    インターフェース RabbitOperations の isRunning
  - destroy
```
public void destroy()
```
    次で指定:
    インターフェース DisposableBean の destroy
  - useDirectReplyTo
```
protected boolean useDirectReplyTo()
```
    このメソッドをオーバーライドして、他の条件を使用して、直接返信先 (https://www.rabbitmq.com/direct-reply-to.html)) を使用するかどうかを決定します。デフォルトの実装では、ブローカーがサポートしており、replyAddress が設定されておらず、useTemporaryReplyQueues が false である場合に true を返します。直接返信先が使用されていない場合、テンプレートは、返信用の一時的な排他的な自動削除キューを作成します。
    このメソッドは、最初のメッセージが同期ブロックから送信されたときに 1 回だけ呼び出されます。
    戻り値:
    直接返信を使用する場合は true。
  - send
```
public void send(Message message)
          throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのルーティングキーを使用して、デフォルトの交換にメッセージを送信します。
    次で指定:
    インターフェース AmqpTemplate の send
    パラメーター:
    message - 送信するメッセージ
    例外:
    AmqpException - 問題がある場合
  - send
```
public void send(StringSE routingKey,
                 Message message)
          throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のルーティングキーを使用して、デフォルトの交換にメッセージを送信します。
    次で指定:
    インターフェース AmqpTemplate の send
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    例外:
    AmqpException - 問題がある場合
  - send
```
public void send(StringSE routingKey,
                 Message message,
                 CorrelationData correlationData)
          throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    特定のルーティングキーを使用して、デフォルトの交換にメッセージを送信します。
    次で指定:
    インターフェース RabbitOperations の send
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - send
```
public void send(StringSE exchange,
                 StringSE routingKey,
                 Message message)
          throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のルーティングキーを使用して、特定の交換にメッセージを送信します。
    次で指定:
    インターフェース AmqpTemplate の send
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    例外:
    AmqpException - 問題がある場合
  - send
```
public void send(StringSE exchange,
                 StringSE routingKey,
                 Message message,
                 @Nullable
                 CorrelationData correlationData)
          throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    特定のルーティングキーを使用して、特定の交換にメッセージを送信します。
    次で指定:
    インターフェース RabbitOperations の send
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(ObjectSE object)
                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    Java オブジェクトを Amqp Message に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
    次で指定:
    インターフェース AmqpTemplate の convertAndSend
    パラメーター:
    object - 送信するメッセージ
    例外:
    AmqpException - 問題がある場合
  - correlationConvertAndSend
```
public void correlationConvertAndSend(ObjectSE object,
                                      CorrelationData correlationData)
                               throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    Java オブジェクトを Amqp Message に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
    次で指定:
    インターフェース RabbitOperations の correlationConvertAndSend
    パラメーター:
    object - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE routingKey,
                           ObjectSE object)
                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
    次で指定:
    インターフェース AmqpTemplate の convertAndSend
    パラメーター:
    routingKey - ルーティングキー
    object - 送信するメッセージ
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE routingKey,
                           ObjectSE object,
                           CorrelationData correlationData)
                    throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
    次で指定:
    インターフェース RabbitOperations の convertAndSend
    パラメーター:
    routingKey - ルーティングキー
    object - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE exchange,
                           StringSE routingKey,
                           ObjectSE object)
                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
    次で指定:
    インターフェース AmqpTemplate の convertAndSend
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    object - 送信するメッセージ
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE exchange,
                           StringSE routingKey,
                           ObjectSE object,
                           @Nullable
                           CorrelationData correlationData)
                    throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
    次で指定:
    インターフェース RabbitOperations の convertAndSend
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    object - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(ObjectSE message,
                           MessagePostProcessor messagePostProcessor)
                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    Java オブジェクトを Amqp Message に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
    次で指定:
    インターフェース AmqpTemplate の convertAndSend
    パラメーター:
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE routingKey,
                           ObjectSE message,
                           MessagePostProcessor messagePostProcessor)
                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
    次で指定:
    インターフェース AmqpTemplate の convertAndSend
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(ObjectSE message,
                           MessagePostProcessor messagePostProcessor,
                           CorrelationData correlationData)
                    throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    Java オブジェクトを Amqp Message に変換し、デフォルトのルーティングキーを使用してデフォルトの取引所に送信します。
    次で指定:
    インターフェース RabbitOperations の convertAndSend
    パラメーター:
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE routingKey,
                           ObjectSE message,
                           MessagePostProcessor messagePostProcessor,
                           CorrelationData correlationData)
                    throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用してデフォルトの交換に送信します。
    次で指定:
    インターフェース RabbitOperations の convertAndSend
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE exchange,
                           StringSE routingKey,
                           ObjectSE message,
                           MessagePostProcessor messagePostProcessor)
                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
    次で指定:
    インターフェース AmqpTemplate の convertAndSend
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    例外:
    AmqpException - 問題がある場合
  - convertAndSend
```
public void convertAndSend(StringSE exchange,
                           StringSE routingKey,
                           ObjectSE message,
                           MessagePostProcessor messagePostProcessor,
                           @Nullable
                           CorrelationData correlationData)
                    throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    Java オブジェクトを Amqp Message に変換し、特定のルーティングキーを使用して特定の取引所に送信します。
    次で指定:
    インターフェース RabbitOperations の convertAndSend
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    例外:
    AmqpException - 問題がある場合
  - receive
```
@Nullable
public Message receive()
                throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトキューからのメッセージがある場合は、メッセージを受信します。おそらく null 値で、すぐに戻ります。
    次で指定:
    インターフェース AmqpTemplate の receive
    戻り値:
    待っているメッセージがない場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receive
```
@Nullable
public Message receive(StringSE queueName)
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のキューからのメッセージがある場合、メッセージを受信します。おそらく null 値で、すぐに戻ります。
    次で指定:
    インターフェース AmqpTemplate の receive
    パラメーター:
    queueName - ポーリングするキューの名前
    戻り値:
    待っているメッセージがない場合はメッセージまたは null
  - doReceiveNoWait
```
@Nullable
protected Message doReceiveNoWait(StringSE queueName)
```
    ノンブロッキング受信。
    パラメーター:
    queueName - 受信するキュー。
    戻り値:
    メッセージ、またはすぐに利用できるメッセージがない場合は null。
    導入:
    1.5
  - receive
```
@Nullable
public Message receive(long timeoutMillis)
                throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのキューからメッセージを受信し、メッセージが利用可能になるまで必要に応じて指定された待機時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の receive
    パラメーター:
    timeoutMillis - あきらめるまでにどれだけ待つか。ゼロの値は、利用可能なメッセージがない場合、メソッドがすぐに null を返すことを意味します。負の値を指定すると、メソッドは無期限にメッセージを待ちます。
    戻り値:
    期限が切れた場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receive
```
@Nullable
public Message receive(StringSE queueName,
                       long timeoutMillis)
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のキューからメッセージを受信し、メッセージが使用可能になるまで必要に応じて指定された待機時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の receive
    パラメーター:
    queueName - 受信するキュー
    timeoutMillis - あきらめるまでにどれだけ待つか。ゼロの値は、利用可能なメッセージがない場合、メソッドがすぐに null を返すことを意味します。負の値を指定すると、メソッドは無期限にメッセージを待ちます。
    戻り値:
    期限が切れた場合はメッセージまたは null
  - receiveAndConvert
```
@Nullable
public ObjectSE receiveAndConvert()
                         throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。おそらく null 値で、すぐに戻ります。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    戻り値:
    待っているメッセージがない場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndConvert
```
@Nullable
public ObjectSE receiveAndConvert(StringSE queueName)
                         throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。おそらく null 値で、すぐに戻ります。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    パラメーター:
    queueName - ポーリングするキューの名前
    戻り値:
    待っているメッセージがない場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndConvert
```
@Nullable
public ObjectSE receiveAndConvert(long timeoutMillis)
                         throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。メッセージが利用可能になるまで、必要に応じて指定された待機時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    パラメーター:
    timeoutMillis - あきらめるまでにどれだけ待つか。ゼロの値は、利用可能なメッセージがない場合、メソッドがすぐに null を返すことを意味します。負の値を指定すると、メソッドは無期限にメッセージを待ちます。
    戻り値:
    期限が切れた場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndConvert
```
@Nullable
public ObjectSE receiveAndConvert(StringSE queueName,
                                long timeoutMillis)
                         throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。メッセージが利用可能になるまで、必要に応じて指定された待機時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    パラメーター:
    queueName - ポーリングするキューの名前
    timeoutMillis - あきらめるまでにどれだけ待つか。ゼロの値は、利用可能なメッセージがない場合、メソッドがすぐに null を返すことを意味します。負の値を指定すると、メソッドは無期限にメッセージを待ちます。
    戻り値:
    期限が切れた場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(ParameterizedTypeReference<T> type)
                        throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。おそらく null 値で、すぐに戻ります。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    型パラメーター:
    T - 型。
    パラメーター:
    type - 変換する型。
    戻り値:
    メッセージ、または待機していない場合は null。
    例外:
    AmqpException - 問題がある場合。
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(StringSE queueName,
                               ParameterizedTypeReference<T> type)
                        throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。おそらく null 値で、すぐに戻ります。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    型パラメーター:
    T - 型。
    パラメーター:
    queueName - ポーリングするキューの名前
    type - 変換する型。
    戻り値:
    待っているメッセージがない場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(long timeoutMillis,
                               ParameterizedTypeReference<T> type)
                        throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのキューからメッセージがある場合はそれを受け取り、それを Java オブジェクトに変換します。メッセージが利用可能になるまで、必要に応じて指定された待機時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    型パラメーター:
    T - 型。
    パラメーター:
    timeoutMillis - あきらめるまでにどれだけ待つか。ゼロの値は、利用可能なメッセージがない場合、メソッドがすぐに null を返すことを意味します。負の値を指定すると、メソッドは無期限にメッセージを待ちます。
    type - 変換する型。
    戻り値:
    期限が切れた場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndConvert
```
@Nullable
public <T> T receiveAndConvert(StringSE queueName,
                               long timeoutMillis,
                               ParameterizedTypeReference<T> type)
                        throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    特定のキューからのメッセージがあれば受信し、それを Java オブジェクトに変換します。メッセージが利用可能になるまで、必要に応じて指定された待機時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の receiveAndConvert
    型パラメーター:
    T - 型。
    パラメーター:
    queueName - ポーリングするキューの名前
    timeoutMillis - あきらめるまでにどれだけ待つか。ゼロの値は、利用可能なメッセージがない場合、メソッドがすぐに null を返すことを意味します。負の値を指定すると、メソッドは無期限にメッセージを待ちます。
    type - 変換する型。
    戻り値:
    期限が切れた場合はメッセージまたは null
    例外:
    AmqpException - 問題がある場合
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(ReceiveAndReplyCallback<R,S> callback)
                                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトキューからメッセージがあれば受信し、提供された ReceiveAndReplyCallback を呼び出し、callback がメッセージを返す場合は、応答メッセージを MessageProperties から replyTo Address に、またはデフォルト交換とデフォルトルーティングキーに送信します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndReply
    型パラメーター:
    R - Message からの変換後のリクエストの型。
    S - レスポンスの型。
    パラメーター:
    callback - 受信したメッセージを処理し、応答メッセージを返すためのユーザー提供の ReceiveAndReplyCallback 実装。
    戻り値:
    true、メッセージが受信された場合
    例外:
    AmqpException - 問題がある場合
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(StringSE queueName,
                                           ReceiveAndReplyCallback<R,S> callback)
                                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    提供されたキューからメッセージがある場合はメッセージを受信し、提供された ReceiveAndReplyCallback を呼び出し、応答メッセージを送信します。callback がメッセージを返す場合は、MessageProperties から replyTo Address に、またはデフォルト交換とデフォルトルーティングキーに送信します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndReply
    型パラメーター:
    R - Message からの変換後のリクエストの型。
    S - レスポンスの型。
    パラメーター:
    queueName - メッセージを受信するキュー名。
    callback - 受信したメッセージを処理し、応答メッセージを返すためのユーザー提供の ReceiveAndReplyCallback 実装。
    戻り値:
    true、メッセージが受信された場合。
    例外:
    AmqpException - 問題がある場合。
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(ReceiveAndReplyCallback<R,S> callback,
                                           StringSE exchange,
                                           StringSE routingKey)
                                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトキューからメッセージがある場合はメッセージを受信し、提供された ReceiveAndReplyCallback を呼び出し、callback がメッセージを返す場合は、提供された exchange および routingKey に応答メッセージを送信します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndReply
    型パラメーター:
    R - Message からの変換後のリクエストの型。
    S - レスポンスの型。
    パラメーター:
    callback - 受信したメッセージを処理し、応答メッセージを返すためのユーザー提供の ReceiveAndReplyCallback 実装。
    exchange - 返信メッセージを送信する交換名。
    routingKey - 応答メッセージを送信するためのルーティングキー。
    戻り値:
    true、メッセージが受信された場合。
    例外:
    AmqpException - 問題がある場合。
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(StringSE queueName,
                                           ReceiveAndReplyCallback<R,S> callback,
                                           StringSE replyExchange,
                                           StringSE replyRoutingKey)
                                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    提供されたキューからメッセージがある場合はメッセージを受信し、提供された ReceiveAndReplyCallback を呼び出し、callback がメッセージを返す場合は、提供された exchange および routingKey に応答メッセージを送信します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndReply
    型パラメーター:
    R - Message からの変換後のリクエストの型。
    S - レスポンスの型。
    パラメーター:
    queueName - メッセージを受信するキュー名。
    callback - 受信したメッセージを処理し、応答メッセージを返すためのユーザー提供の ReceiveAndReplyCallback 実装。
    replyExchange - 返信メッセージを送信する交換名。
    replyRoutingKey - 応答メッセージを送信するためのルーティングキー。
    戻り値:
    true、メッセージが受信された場合
    例外:
    AmqpException - 問題がある場合
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(ReceiveAndReplyCallback<R,S> callback,
                                           ReplyToAddressCallback<S> replyToAddressCallback)
                                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    デフォルトのキューからメッセージがあれば受信し、提供された ReceiveAndReplyCallback を呼び出し、callback がメッセージを返す場合は、応答メッセージを ReplyToAddressCallback の結果から replyTo Address に送信します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndReply
    型パラメーター:
    R - Message からの変換後のリクエストの型。
    S - レスポンスの型。
    パラメーター:
    callback - 受信したメッセージを処理し、応答メッセージを返すためのユーザー提供の ReceiveAndReplyCallback 実装。
    replyToAddressCallback - 実行時に返信先アドレスを決定するためのコールバック。
    戻り値:
    true、メッセージが受信された場合。
    例外:
    AmqpException - 問題がある場合。
  - receiveAndReply
```
public <R,S> boolean receiveAndReply(StringSE queueName,
                                           ReceiveAndReplyCallback<R,S> callback,
                                           ReplyToAddressCallback<S> replyToAddressCallback)
                                    throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    指定されたキューからメッセージがあれば受信し、指定された ReceiveAndReplyCallback を呼び出し、callback がメッセージを返す場合は、応答メッセージを ReplyToAddressCallback の結果から replyTo Address に送信します。
    次で指定:
    インターフェース AmqpTemplate の receiveAndReply
    型パラメーター:
    R - Message からの変換後のリクエストの型。
    S - レスポンスの型。
    パラメーター:
    queueName - メッセージを受信するキュー名。
    callback - 受信したメッセージを処理し、応答メッセージを返すためのユーザー提供の ReceiveAndReplyCallback 実装。
    replyToAddressCallback - 実行時に返信先アドレスを決定するためのコールバック。
    戻り値:
    true、メッセージが受信された場合
    例外:
    AmqpException - 問題がある場合
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(Message message)
                       throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    基本的な RPC パターン。デフォルトのルーティングキーを使用してデフォルトの交換にメッセージを送信し、レスポンスの受信を試みます。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の sendAndReceive
    パラメーター:
    message - 送信するメッセージ
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(Message message,
                              @Nullable
                              CorrelationData correlationData)
                       throws AmqpException
```
    例外:
    AmqpException
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(StringSE routingKey,
                              Message message)
                       throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    基本的な RPC パターン。特定のルーティングキーを使用してデフォルトの交換にメッセージを送信し、レスポンスの受信を試みます。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の sendAndReceive
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(StringSE routingKey,
                              Message message,
                              @Nullable
                              CorrelationData correlationData)
                       throws AmqpException
```
    例外:
    AmqpException
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(StringSE exchange,
                              StringSE routingKey,
                              Message message)
                       throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    基本的な RPC パターン。特定のルーティングキーを使用して特定の交換機にメッセージを送信し、レスポンスの受信を試みます。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の sendAndReceive
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - sendAndReceive
```
@Nullable
public Message sendAndReceive(StringSE exchange,
                              StringSE routingKey,
                              Message message,
                              @Nullable
                              CorrelationData correlationData)
                       throws AmqpException
```
    例外:
    AmqpException
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(ObjectSE message)
                             throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceive
    パラメーター:
    message - 送信するメッセージ
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(ObjectSE message,
                                    @Nullable
                                    CorrelationData correlationData)
                             throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceive
    パラメーター:
    message - 送信するメッセージ。
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE routingKey,
                                    ObjectSE message)
                             throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceive
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE routingKey,
                                    ObjectSE message,
                                    @Nullable
                                    CorrelationData correlationData)
                             throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceive
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE exchange,
                                    StringSE routingKey,
                                    ObjectSE message)
                             throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceive
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE exchange,
                                    StringSE routingKey,
                                    ObjectSE message,
                                    @Nullable
                                    CorrelationData correlationData)
                             throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceive
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(ObjectSE message,
                                    MessagePostProcessor messagePostProcessor)
                             throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceive
    パラメーター:
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(ObjectSE message,
                                    MessagePostProcessor messagePostProcessor,
                                    @Nullable
                                    CorrelationData correlationData)
                             throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceive
    パラメーター:
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE routingKey,
                                    ObjectSE message,
                                    MessagePostProcessor messagePostProcessor)
                             throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceive
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE routingKey,
                                    ObjectSE message,
                                    MessagePostProcessor messagePostProcessor,
                                    @Nullable
                                    CorrelationData correlationData)
                             throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceive
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE exchange,
                                    StringSE routingKey,
                                    ObjectSE message,
                                    MessagePostProcessor messagePostProcessor)
                             throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceive
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceive
```
@Nullable
public ObjectSE convertSendAndReceive(StringSE exchange,
                                    StringSE routingKey,
                                    ObjectSE message,
                                    @Nullable
                                    MessagePostProcessor messagePostProcessor,
                                    @Nullable
                                    CorrelationData correlationData)
                             throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceive
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(ObjectSE message,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    message - 送信するメッセージ。
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス。
    例外:
    AmqpException - 問題がある場合。
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(ObjectSE message,
                                         @Nullable
                                         CorrelationData correlationData,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    message - 送信するメッセージ。
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス。
    例外:
    AmqpException - 問題がある場合。
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE routingKey,
                                         ObjectSE message,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE routingKey,
                                         ObjectSE message,
                                         @Nullable
                                         CorrelationData correlationData,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE exchange,
                                         StringSE routingKey,
                                         ObjectSE message,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(ObjectSE message,
                                         @Nullable
                                         MessagePostProcessor messagePostProcessor,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(ObjectSE message,
                                         @Nullable
                                         MessagePostProcessor messagePostProcessor,
                                         @Nullable
                                         CorrelationData correlationData,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、デフォルトのルーティングキーを使用してデフォルトの交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE routingKey,
                                         ObjectSE message,
                                         @Nullable
                                         MessagePostProcessor messagePostProcessor,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE routingKey,
                                         ObjectSE message,
                                         @Nullable
                                         MessagePostProcessor messagePostProcessor,
                                         @Nullable
                                         CorrelationData correlationData,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用してデフォルトの交換に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE exchange,
                                         StringSE routingKey,
                                         ObjectSE message,
                                         MessagePostProcessor messagePostProcessor,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: AmqpTemplate
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース AmqpTemplate の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveAsType
```
@Nullable
public <T> T convertSendAndReceiveAsType(StringSE exchange,
                                         StringSE routingKey,
                                         ObjectSE message,
                                         @Nullable
                                         MessagePostProcessor messagePostProcessor,
                                         @Nullable
                                         CorrelationData correlationData,
                                         ParameterizedTypeReference<T> responseType)
                                  throws AmqpException
```
    インターフェースからコピーされた説明: RabbitOperations
    変換を伴う基本的な RPC パターン。メッセージに変換された Java オブジェクトを、特定のルーティングキーを使用して特定の交換機に送信し、レスポンスの受信を試みて、それを Java オブジェクトに変換します。実装は、通常、reply-to ヘッダーを専用キューに設定し、タイムアウトによって制限された時間まで待機します。SmartMessageConverter が必要です。
    次で指定:
    インターフェース RabbitOperations の convertSendAndReceiveAsType
    型パラメーター:
    T - 型。
    パラメーター:
    exchange - 取引所の名前
    routingKey - ルーティングキー
    message - 送信するメッセージ
    messagePostProcessor - 送信前にメッセージに適用するプロセッサー
    correlationData - パブリッシャーの確認を関連付けるためのデータ。
    responseType - 返信を変換する型。
    戻り値:
    ある場合のレスポンス
    例外:
    AmqpException - 問題がある場合
  - convertSendAndReceiveRaw
```
@Nullable
protected Message convertSendAndReceiveRaw(StringSE exchange,
                                           StringSE routingKey,
                                           ObjectSE message,
                                           @Nullable
                                           MessagePostProcessor messagePostProcessor,
                                           @Nullable
                                           CorrelationData correlationData)
```
    メッセージを変換して送信し、生の返信メッセージまたは null を返します。サブクラスは、送信メッセージで変換を実行したいが、変換前に応答メッセージに直接アクセスできる場合、このメソッドを呼び出すことができます。
    パラメーター:
    exchange - 交換。
    routingKey - ルーティングキー。
    message - 送信するデータ。
    messagePostProcessor - メッセージポストプロセッサー (null の場合もあります)。
    correlationData - 相関データ (null の場合もあります)。
    戻り値:
    応答メッセージ、またはタイムアウトが発生した場合は null。
    導入:
    1.6.6
  - convertMessageIfNecessary
```
protected Message convertMessageIfNecessary(ObjectSE object)
```
  - doSendAndReceive
```
@Nullable
protected Message doSendAndReceive(StringSE exchange,
                                   StringSE routingKey,
                                   Message message,
                                   @Nullable
                                   CorrelationData correlationData)
```
    メッセージを送信し、返信を待ちます。
    パラメーター:
    exchange - 取引所名
    routingKey - ルーティングキー
    message - 送信するメッセージ
    correlationData - 確認のための相関データ
    戻り値:
    返信で受け取ったメッセージ
  - doSendAndReceiveWithTemporary
```
@Nullable
protected Message doSendAndReceiveWithTemporary(StringSE exchange,
                                                StringSE routingKey,
                                                Message message,
                                                @Nullable
                                                CorrelationData correlationData)
```
  - doSendAndReceiveWithFixed
```
@Nullable
protected Message doSendAndReceiveWithFixed(StringSE exchange,
                                            StringSE routingKey,
                                            Message message,
                                            @Nullable
                                            CorrelationData correlationData)
```
  - replyTimedOut
```
protected void replyTimedOut(StringSE correlationId)
```
    サブクラスはこれを実装して、応答がタイムアウトしたことを通知できます。
    パラメーター:
    correlationId - 相関 ID
    導入:
    2.1.2
  - isMandatoryFor
```
public BooleanSE isMandatoryFor(Message message)
```
    指定されたメッセージを必須フラグを設定して送信する必要があるかどうかを返します。
    パラメーター:
    message - メッセージ。
    戻り値:
    必須の場合は true。
    導入:
    2.0
  - execute
```
@Nullable
public <T> T execute(ChannelCallback<T> action)
```
    インターフェースからコピーされた説明: RabbitOperations
    チャネルでコールバックを実行し、その後チャネルを確実に閉じます。
    次で指定:
    インターフェース RabbitOperations の execute
    型パラメーター:
    T - 戻り値の型。
    パラメーター:
    action - コールバック。
    戻り値:
    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)
```
    インターフェースからコピーされた説明: RabbitOperations
    同じチャネルで操作を呼び出します。コールバックが必要な場合は、両方のコールバックを指定する必要があります。
    次で指定:
    インターフェース RabbitOperations の invoke
    型パラメーター:
    T - 戻り値の型。
    パラメーター:
    action - コールバック。
    acks - ack の確認コールバック。
    nacks - nack の確認コールバック。
    戻り値:
    アクションメソッドの結果。
  - waitForConfirms
```
public boolean waitForConfirms(long timeout)
```
    インターフェースからコピーされた説明: RabbitOperations
    基礎となる専用チャネルに委譲して、確認を待ちます。パブリッシャーの確認用に接続ファクトリを構成する必要があり、このメソッドは RabbitOperations.invoke(OperationsCallback) 操作の範囲内で呼び出す必要があります。CachingConnectionFactory#setPublisherConfirms(true) が必要です。
    次で指定:
    インターフェース RabbitOperations の waitForConfirms
    パラメーター:
    timeout - タイムアウト
    戻り値:
    ack を受信し、nacks を受信しない場合は true。
    関連事項:
    Channel.waitForConfirms(long)
  - waitForConfirmsOrDie
```
public void waitForConfirmsOrDie(long timeout)
```
    インターフェースからコピーされた説明: RabbitOperations
    基礎となる専用チャネルに委譲して、確認を待ちます。パブリッシャーの確認用に接続ファクトリを構成する必要があり、このメソッドは RabbitOperations.invoke(OperationsCallback) 操作の範囲内で呼び出す必要があります。CachingConnectionFactory#setPublisherConfirms(true) が必要です。
    次で指定:
    インターフェース RabbitOperations の waitForConfirmsOrDie
    パラメーター:
    timeout - タイムアウト
    関連事項:
    Channel.waitForConfirmsOrDie(long)
  - determineConfirmsReturnsCapability
```
public void determineConfirmsReturnsCapability(ConnectionFactory connectionFactory)
```
  - doSend
```
public void doSend(com.rabbitmq.client.Channel channel,
                   StringSE exchangeArg,
                   StringSE routingKeyArg,
                   Message message,
                   boolean mandatory,
                   @Nullable
                   CorrelationData correlationData)
            throws IOExceptionSE
```
    指定されたメッセージを指定された交換に送信します。
    パラメーター:
    channel - 内部で動作する RabbitMQ チャネル。
    exchangeArg - 送信先の RabbitMQ 交換の名前。
    routingKeyArg - ルーティングキー。
    message - 送信するメッセージ。
    mandatory - 必須フラグ。
    correlationData - 相関データ。
    例外:
    IOExceptionSE - RabbitMQ API メソッドによってスローされた場合。
  - nullSafeExchange
```
public StringSE nullSafeExchange(StringSE exchange)
```
    null の場合、取引所またはデフォルトの取引所を返します。
    パラメーター:
    exchange - 交換。
    戻り値:
    結果。
    導入:
    2.3.4
  - nullSafeRoutingKey
```
public StringSE nullSafeRoutingKey(StringSE rk)
```
    null の場合は、ルーティングキーまたはデフォルトのルーティングキーを返します。
    パラメーター:
    rk - ルーティングキー。
    戻り値:
    結果。
    導入:
    2.3.4
  - sendToRabbit
```
protected void sendToRabbit(com.rabbitmq.client.Channel channel,
                            StringSE exchange,
                            StringSE routingKey,
                            boolean mandatory,
                            Message message)
                     throws IOExceptionSE
```
    例外:
    IOExceptionSE
  - isChannelLocallyTransacted
```
protected boolean isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)
```
    指定されたチャネルがローカルで処理されているかどうか、つまり、そのトランザクションが外部トランザクションコーディネーターではなく、このテンプレートのチャネル処理によって管理されているかどうかを確認します。
    パラメーター:
    channel - チェックするチャンネル
    戻り値:
    指定されたチャネルがローカルで処理されるかどうか
    関連事項:
    ConnectionFactoryUtils.isChannelTransactional(com.rabbitmq.client.Channel, org.springframework.amqp.rabbit.connection.ConnectionFactory), RabbitAccessor.isChannelTransacted()
  - addListener
```
public void addListener(com.rabbitmq.client.Channel channel)
```
    このテンプレートを、提供されたチャネルの確認リスナーとして追加します。
    パラメーター:
    channel - チャンネル。
    導入:
    2.0
  - handleConfirm
```
public void handleConfirm(PendingConfirm pendingConfirm,
                          boolean ack)
```
    インターフェースからコピーされた説明: PublisherCallbackChannel.Listener
    確認を受信したときにチャネルによって呼び出されます。
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の handleConfirm
    パラメーター:
    pendingConfirm - 相関データを含む保留中の確認。
    ack - "ack" の場合は true、"nack" の場合は false。
  - handleReturn
```
public void handleReturn(int replyCode,
                         StringSE replyText,
                         StringSE exchange,
                         StringSE routingKey,
                         com.rabbitmq.client.AMQP.BasicProperties properties,
                         byte[] body)
```
    インターフェースからコピーされた説明: PublisherCallbackChannel.Listener
    返されたメッセージを処理します。
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の handleReturn
    パラメーター:
    replyCode - 応答コード。
    replyText - 返信テキスト。
    exchange - 交換。
    routingKey - ルーティングキー。
    properties - メッセージのプロパティ。
    body - メッセージ本文。
  - handleReturn
```
public void handleReturn(com.rabbitmq.client.Return returned)
```
    インターフェースからコピーされた説明: PublisherCallbackChannel.Listener
    返されたメッセージを処理します。
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の handleReturn
    パラメーター:
    returned - メッセージとメタデータ。
  - isConfirmListener
```
public boolean isConfirmListener()
```
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の isConfirmListener
  - isReturnListener
```
public boolean isReturnListener()
```
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の isReturnListener
  - revoke
```
public void revoke(com.rabbitmq.client.Channel channel)
```
    インターフェースからコピーされた説明: PublisherCallbackChannel.Listener
    呼び出されると、このリスナーはチャネルへのすべての参照を削除する必要があります。チャネルによって呼び出されることはありません。
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の revoke
    パラメーター:
    channel - チャンネル。
  - getUUID
```
public StringSE getUUID()
```
    インターフェースからコピーされた説明: PublisherCallbackChannel.Listener
    この Listener を識別するために使用される UUID を返します。
    次で指定:
    インターフェース PublisherCallbackChannel.Listener の getUUID
    戻り値:
    UUID の文字列表現。
  - onMessage
```
public void onMessage(Message message,
                      @Nullable
                      com.rabbitmq.client.Channel channel)
```
    インターフェースからコピーされた説明: ChannelAwareMessageListener
    受信した Rabbit メッセージを処理するためのコールバック。
    実装者は、指定されたメッセージを処理し、通常、指定されたセッションを介して応答メッセージを送信します。
    次で指定:
    インターフェース ChannelAwareMessageListener の onMessage
    パラメーター:
    message - 受信した AMQP メッセージ (非 null)
    channel - 基盤となる Rabbit チャネル (ストリームリスナーコンテナーによって呼び出されない限り、null ではありません)。
  - onMessage
```
@DeprecatedSE
public void onMessage(Message message)
```
    使用すべきではありません。
    - onMessage(Message, Channel) を使用します。
    1 つのメッセージを配信します。
    次で指定:
    インターフェース ChannelAwareMessageListener の onMessage
    次で指定:
    インターフェース MessageListener の onMessage
    パラメーター:
    message - メッセージ。

クラス RabbitTemplate

ネストされたクラスのサマリー

インターフェース org.springframework.amqp.rabbit.core.RabbitOperations から継承されたネストクラス / インターフェース

フィールドサマリー

クラス org.springframework.amqp.rabbit.connection.RabbitAccessor から継承されたフィールド

コンストラクターのサマリー

メソッドのサマリー

クラス org.springframework.amqp.rabbit.connection.RabbitAccessor から継承されたメソッド

クラス java.lang.ObjectSE から継承されたメソッド

インターフェース org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener から継承されたメソッド

インターフェース org.springframework.amqp.core.MessageListener から継承されたメソッド

インターフェース org.springframework.amqp.rabbit.core.RabbitOperations から継承されたメソッド

コンストラクターの詳細

RabbitTemplate

RabbitTemplate

メソッドの詳細

initDefaultStrategies

setConnectionFactory

setExchange

getExchange

setRoutingKey

getRoutingKey

setDefaultReceiveQueue

getDefaultReceiveQueue

setEncoding

getEncoding

setReplyAddress

setReceiveTimeout

setReplyTimeout

setMessageConverter

setMessagePropertiesConverter

getMessagePropertiesConverter

getMessageConverter

setConfirmCallback

setReturnCallback

setReturnsCallback

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

setUseChannelForCorrelation

expectedQueueNames

getUnconfirmed

getUnconfirmedCount

start

doStart

stop

doStop

isRunning

destroy

useDirectReplyTo

send

send

send

send

send