org.springframework.messaging.core

## Interface MessageRequestReplyOperations<D>

- Type Parameters:
    `D` - the type of destination
  All Known Subinterfaces:
    DestinationResolvingMessageRequestReplyOperations<D>, JmsMessageOperations
  All Known Implementing Classes:
    AbstractDestinationResolvingMessagingTemplate, AbstractMessagingTemplate, GenericMessagingTemplate, JmsMessagingTemplate

      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
    Modifier and Type | Method and Description
    --- | ---
    `<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`