org.springframework.messaging.core

## Interface MessageRequestReplyOperations<D>

Type Parameters:
  `D` - the type of destination

All Known Subinterfaces:
  DestinationResolvingMessageRequestReplyOperations<D>

All Known Implementing Classes:
  AbstractDestinationResolvingMessagingTemplate, AbstractMessagingTemplate, GenericMessagingTemplate

    public interface MessageRequestReplyOperations<D>

Operations for sending messages to and receiving the reply from a destination.

Since:
  4.0
Author:
  Mark Fisher, Rossen Stoyanchev
See Also:
  `GenericMessagingTemplate`

### Method Summary

All Methods Instance Methods Abstract Methods
`<T> T` `convertSendAndReceive(D destination, Object request, Class<T> targetClass)` Convert the given request Object to serialized form, possibly using a `MessageConverter`, send it as a `Message` to the given destination, receive the reply and convert its body of the specified target class.
`<T> T` `convertSendAndReceive(D destination, Object request, Class<T> targetClass, MessagePostProcessor requestPostProcessor)` Convert the given request Object to serialized form, possibly using a `MessageConverter`, apply the given post processor and send the resulting `Message` to the given destination, receive the reply and convert its body of the given target class.
`<T> T` `convertSendAndReceive(D destination, Object request, Map<String,Object> headers, Class<T> targetClass)` Convert the given request Object to serialized form, possibly using a `MessageConverter`, send it as a `Message` with the given headers, to the specified destination, receive the reply and convert its body of the specified target class.

`<T> T`

`convertSendAndReceive(D destination, Object request, Map<String,Object> headers, Class<T> targetClass, MessagePostProcessor requestPostProcessor)`
Convert the given request Object to serialized form, possibly using a `MessageConverter`, wrap it as a message with the given headers, apply the given post processor and send the resulting `Message` to the specified destination, receive the reply and convert its body of the given target class.

`<T> T` `convertSendAndReceive(Object request, Class<T> targetClass)` Convert the given request Object to serialized form, possibly using a `MessageConverter`, send it as a `Message` to a default destination, receive the reply and convert its body of the specified target class.
`<T> T` `convertSendAndReceive(Object request, Class<T> targetClass, MessagePostProcessor requestPostProcessor)` Convert the given request Object to serialized form, possibly using a `MessageConverter`, apply the given post processor and send the resulting `Message` to a default destination, receive the reply and convert its body of the given target class.
`Message<?>` `sendAndReceive(D destination, Message<?> requestMessage)` Send a request message and receive the reply from the given destination.
`Message<?>` `sendAndReceive(Message<?> requestMessage)` Send a request message and receive the reply from a default destination.

### Method Detail

#### sendAndReceive

    @Nullable
    Message<?> sendAndReceive(Message<?> requestMessage)
                                 throws MessagingException

Send a request message and receive the reply from a default destination.

Parameters:
  `requestMessage` - the message to send
Returns:
  the reply, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### sendAndReceive

    @Nullable
    Message<?> sendAndReceive(D destination,
                                        Message<?> requestMessage)
                                 throws MessagingException

Send a request message and receive the reply from the given destination.

Parameters:
  `destination` - the target destination
  `requestMessage` - the message to send
Returns:
  the reply, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(Object request,
                                          Class<T> targetClass)
                                   throws MessagingException

Convert the given request Object to serialized form, possibly using a `MessageConverter`, send it as a `Message` to a default destination, receive the reply and convert its body of the specified target class.

Parameters:
  `request` - payload for the request message to send
  `targetClass` - the target type to convert the payload of the reply to
Returns:
  the payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(D destination,
                                          Object request,
                                          Class<T> targetClass)
                                   throws MessagingException

Convert the given request Object to serialized form, possibly using a `MessageConverter`, send it as a `Message` to the given destination, receive the reply and convert its body of the specified target class.

Parameters:
  `destination` - the target destination
  `request` - payload for the request message to send
  `targetClass` - the target type to convert the payload of the reply to
Returns:
  the payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(D destination,
                                          Object request,
                                          @Nullable
                                          Map<String,Object> headers,
                                          Class<T> targetClass)
                                   throws MessagingException

Convert the given request Object to serialized form, possibly using a `MessageConverter`, send it as a `Message` with the given headers, to the specified destination, receive the reply and convert its body of the specified target class.

Parameters:
  `destination` - the target destination
  `request` - payload for the request message to send
  `headers` - the headers for the request message to send
  `targetClass` - the target type to convert the payload of the reply to
Returns:
  the payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(Object request,
                                          Class<T> targetClass,
                                          @Nullable
                                          MessagePostProcessor requestPostProcessor)
                                   throws MessagingException

Convert the given request Object to serialized form, possibly using a `MessageConverter`, apply the given post processor and send the resulting `Message` to a default destination, receive the reply and convert its body of the given target class.

Parameters:
  `request` - payload for the request message to send
  `targetClass` - the target type to convert the payload of the reply to
  `requestPostProcessor` - post process to apply to the request message
Returns:
  the payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(D destination,
                                          Object request,
                                          Class<T> targetClass,
                                          MessagePostProcessor requestPostProcessor)
                                   throws MessagingException

Convert the given request Object to serialized form, possibly using a `MessageConverter`, apply the given post processor and send the resulting `Message` to the given destination, receive the reply and convert its body of the given target class.

Parameters:
  `destination` - the target destination
  `request` - payload for the request message to send
  `targetClass` - the target type to convert the payload of the reply to
  `requestPostProcessor` - post process to apply to the request message
Returns:
  the payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(D destination,
                                          Object request,
                                          @Nullable
                                          Map<String,Object> headers,
                                          Class<T> targetClass,
                                          @Nullable
                                          MessagePostProcessor requestPostProcessor)
                                   throws MessagingException

Convert the given request Object to serialized form, possibly using a `MessageConverter`, wrap it as a message with the given headers, apply the given post processor and send the resulting `Message` to the specified destination, receive the reply and convert its body of the given target class.

Parameters:
  `destination` - the target destination
  `request` - payload for the request message to send
  `targetClass` - the target type to convert the payload of the reply to
  `requestPostProcessor` - post process to apply to the request message
Returns:
  the payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `MessagingException`