org.springframework.jms.core

## Interface JmsMessageOperations

All Superinterfaces:
  org.springframework.messaging.core.MessageReceivingOperations<Destination>, org.springframework.messaging.core.MessageRequestReplyOperations<Destination>, org.springframework.messaging.core.MessageSendingOperations<Destination>

All Known Implementing Classes:
  JmsMessagingTemplate

    public interface JmsMessageOperations
    extends org.springframework.messaging.core.MessageSendingOperations<Destination>, org.springframework.messaging.core.MessageReceivingOperations<Destination>, org.springframework.messaging.core.MessageRequestReplyOperations<Destination>

A specialization of `MessageSendingOperations`, `MessageReceivingOperations` and `MessageRequestReplyOperations` for JMS related operations that allow to specify a destination name rather than the actual `Destination`.

Since:
  4.1
Author:
  Stephane Nicoll
See Also:
  `JmsTemplate`, `MessageSendingOperations`, `MessageReceivingOperations`, `MessageRequestReplyOperations`

### Method Summary

All Methods Instance Methods Abstract Methods
`void` `convertAndSend(String destinationName, Object payload)` Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message and send it to the given destination.
`void` `convertAndSend(String destinationName, Object payload, Map<String,Object> headers)` Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message with the given headers and send it to the given destination.
`void` `convertAndSend(String destinationName, Object payload, Map<String,Object> headers, org.springframework.messaging.core.MessagePostProcessor postProcessor)` Convert the given 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 given destination.
`void` `convertAndSend(String destinationName, Object payload, org.springframework.messaging.core.MessagePostProcessor postProcessor)` Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message, apply the given post processor, and send the resulting message to the given destination.
`<T> T` `convertSendAndReceive(String destinationName, 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(String destinationName, Object request, Class<T> targetClass, org.springframework.messaging.core.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(String destinationName, 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(String destinationName, Object request, Map<String,Object> headers, Class<T> targetClass, org.springframework.messaging.core.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.

`org.springframework.messaging.Message<?>` `receive(String destinationName)` Receive a message from the given destination.
`<T> T` `receiveAndConvert(String destinationName, Class<T> targetClass)` Receive a message from the given destination and convert its payload to the specified target class.
`void` `send(String destinationName, org.springframework.messaging.Message<?> message)` Send a message to the given destination.
`org.springframework.messaging.Message<?>` `sendAndReceive(String destinationName, org.springframework.messaging.Message<?> requestMessage)` Send a request message and receive the reply from the given destination.

### Methods inherited from interface org.springframework.messaging.core.MessageSendingOperations

`convertAndSend, convertAndSend, convertAndSend, convertAndSend, convertAndSend, convertAndSend, send, send`

### Methods inherited from interface org.springframework.messaging.core.MessageReceivingOperations

`receive, receive, receiveAndConvert, receiveAndConvert`

### Methods inherited from interface org.springframework.messaging.core.MessageRequestReplyOperations

`convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, sendAndReceive, sendAndReceive`

### Method Detail

#### send

    void send(String destinationName,
              org.springframework.messaging.Message<?> message)
       throws org.springframework.messaging.MessagingException

Send a message to the given destination.

Parameters:
  `destinationName` - the name of the target destination
  `message` - the message to send
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

    void convertAndSend(String destinationName,
                        Object payload)
                 throws org.springframework.messaging.MessagingException

Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message and send it to the given destination.

Parameters:
  `destinationName` - the name of the target destination
  `payload` - the Object to use as payload
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

    void convertAndSend(String destinationName,
                        Object payload,
                        Map<String,Object> headers)
                 throws org.springframework.messaging.MessagingException

Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message with the given headers and send it to the given destination.

Parameters:
  `destinationName` - the name of the target destination
  `payload` - the Object to use as payload
  `headers` - the headers for the message to send
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

    void convertAndSend(String destinationName,
                        Object payload,
                        org.springframework.messaging.core.MessagePostProcessor postProcessor)
                 throws org.springframework.messaging.MessagingException

Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message, apply the given post processor, and send the resulting message to the given destination.

Parameters:
  `destinationName` - the name of the target destination
  `payload` - the Object to use as payload
  `postProcessor` - the post processor to apply to the message
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

    void convertAndSend(String destinationName,
                        Object payload,
                        @Nullable
                        Map<String,Object> headers,
                        @Nullable
                        org.springframework.messaging.core.MessagePostProcessor postProcessor)
                 throws org.springframework.messaging.MessagingException

Convert the given 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 given destination.

Parameters:
  `destinationName` - the name of the target destination
  `payload` - the Object to use as payload
  `headers` - the headers for the message to send
  `postProcessor` - the post processor to apply to the message
Throws:
  `org.springframework.messaging.MessagingException`

#### receive

    @Nullable
    org.springframework.messaging.Message<?> receive(String destinationName)
                                                        throws org.springframework.messaging.MessagingException

Receive a message from the given destination.

Parameters:
  `destinationName` - the name of the target destination
Returns:
  the received message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `org.springframework.messaging.MessagingException`

#### receiveAndConvert

    @Nullable
    <T> T receiveAndConvert(String destinationName,
                                      Class<T> targetClass)
                               throws org.springframework.messaging.MessagingException

Receive a message from the given destination and convert its payload to the specified target class.

Parameters:
  `destinationName` - the name of the target destination
  `targetClass` - the target class to convert the payload to
Returns:
  the converted payload of the reply message, possibly `null` if the message could not be received, for example due to a timeout
Throws:
  `org.springframework.messaging.MessagingException`

#### sendAndReceive

    @Nullable
    org.springframework.messaging.Message<?> sendAndReceive(String destinationName,
                                                                      org.springframework.messaging.Message<?> requestMessage)
                                                               throws org.springframework.messaging.MessagingException

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

Parameters:
  `destinationName` - the name of 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:
  `org.springframework.messaging.MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(String destinationName,
                                          Object request,
                                          Class<T> targetClass)
                                   throws org.springframework.messaging.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:
  `destinationName` - the name of 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:
  `org.springframework.messaging.MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(String destinationName,
                                          Object request,
                                          @Nullable
                                          Map<String,Object> headers,
                                          Class<T> targetClass)
                                   throws org.springframework.messaging.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:
  `destinationName` - the name of 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:
  `org.springframework.messaging.MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(String destinationName,
                                          Object request,
                                          Class<T> targetClass,
                                          org.springframework.messaging.core.MessagePostProcessor requestPostProcessor)
                                   throws org.springframework.messaging.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:
  `destinationName` - the name of 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:
  `org.springframework.messaging.MessagingException`

#### convertSendAndReceive

    @Nullable
    <T> T convertSendAndReceive(String destinationName,
                                          Object request,
                                          Map<String,Object> headers,
                                          Class<T> targetClass,
                                          org.springframework.messaging.core.MessagePostProcessor requestPostProcessor)
                                   throws org.springframework.messaging.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:
  `destinationName` - the name of 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:
  `org.springframework.messaging.MessagingException`