org.springframework.jms.core

## Class JmsMessagingTemplate

- java.lang.Object
- - org.springframework.messaging.core.AbstractMessageSendingTemplate<D>
  - - org.springframework.messaging.core.AbstractMessageReceivingTemplate<D>
    - - org.springframework.messaging.core.AbstractMessagingTemplate<Destination>
      - - org.springframework.jms.core.JmsMessagingTemplate

All Implemented Interfaces:
  org.springframework.beans.factory.InitializingBean, JmsMessageOperations, org.springframework.messaging.core.MessageReceivingOperations<Destination>, org.springframework.messaging.core.MessageRequestReplyOperations<Destination>, org.springframework.messaging.core.MessageSendingOperations<Destination>

    public class JmsMessagingTemplate
    extends org.springframework.messaging.core.AbstractMessagingTemplate<Destination>
    implements JmsMessageOperations, org.springframework.beans.factory.InitializingBean

An implementation of `JmsMessageOperations`.

Since:
  4.1
Author:
  Stephane Nicoll, Juergen Hoeller

### Field Summary

### Fields inherited from class org.springframework.messaging.core.AbstractMessageSendingTemplate

`CONVERSION_HINT_HEADER, logger`

### Constructor Summary

Constructors
Constructor and Description
`JmsMessagingTemplate()` Constructor for use with bean properties.
`JmsMessagingTemplate(ConnectionFactory connectionFactory)` Create a `JmsMessagingTemplate` instance with the JMS `ConnectionFactory` to use, implicitly building a `JmsTemplate` based on it.
`JmsMessagingTemplate(JmsTemplate jmsTemplate)` Create a `JmsMessagingTemplate` instance with the `JmsTemplate` to use.

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `afterPropertiesSet()`
`void` `convertAndSend(Object payload)`
`void` `convertAndSend(Object payload, org.springframework.messaging.core.MessagePostProcessor postProcessor)`
`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.
`protected org.springframework.messaging.MessagingException` `convertJmsException(JmsException ex)`
`protected org.springframework.messaging.Message<?>` `convertJmsMessage(Message message)`
`<T> T` `convertSendAndReceive(Object request, Class<T> targetClass)`
`<T> T` `convertSendAndReceive(Object request, Class<T> targetClass, org.springframework.messaging.core.MessagePostProcessor postProcessor)`
`<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 postProcessor)`
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.

`protected org.springframework.messaging.Message<?>` `doReceive(Destination destination)`
`protected org.springframework.messaging.Message<?>` `doReceive(String destinationName)`
`protected void` `doSend(Destination destination, org.springframework.messaging.Message<?> message)`
`protected void` `doSend(String destinationName, org.springframework.messaging.Message<?> message)`
`protected org.springframework.messaging.Message<?>` `doSendAndReceive(Destination destination, org.springframework.messaging.Message<?> requestMessage)`
`protected org.springframework.messaging.Message<?>` `doSendAndReceive(String destinationName, org.springframework.messaging.Message<?> requestMessage)`
`ConnectionFactory` `getConnectionFactory()` Return the ConnectionFactory that the underlying `JmsTemplate` uses.
`String` `getDefaultDestinationName()` Return the configured default destination name.
`MessageConverter` `getJmsMessageConverter()` Return the `MessageConverter` to use to convert a `Message` from the messaging to and from a `Message`.
`JmsTemplate` `getJmsTemplate()` Return the configured `JmsTemplate`.
`protected String` `getRequiredDefaultDestinationName()`
`org.springframework.messaging.Message<?>` `receive()`
`org.springframework.messaging.Message<?>` `receive(String destinationName)` Receive a message from the given destination.
`<T> T` `receiveAndConvert(Class<T> targetClass)`
`<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(org.springframework.messaging.Message<?> message)`
`void` `send(String destinationName, org.springframework.messaging.Message<?> message)` Send a message to the given destination.
`org.springframework.messaging.Message<?>` `sendAndReceive(org.springframework.messaging.Message<?> requestMessage)`
`org.springframework.messaging.Message<?>` `sendAndReceive(String destinationName, org.springframework.messaging.Message<?> requestMessage)` Send a request message and receive the reply from the given destination.
`void` `setConnectionFactory(ConnectionFactory connectionFactory)` Set the ConnectionFactory to use for the underlying `JmsTemplate`.
`void` `setDefaultDestinationName(String defaultDestinationName)` Configure the default destination name to use in send methods that don't have a destination argument.
`void` `setJmsMessageConverter(MessageConverter jmsMessageConverter)` Set the `MessageConverter` to use to convert a `Message` from the messaging to and from a `Message`.
`void` `setJmsTemplate(JmsTemplate jmsTemplate)` Set the `JmsTemplate` to use.

### Methods inherited from class org.springframework.messaging.core.AbstractMessagingTemplate

`convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, sendAndReceive`

### Methods inherited from class org.springframework.messaging.core.AbstractMessageReceivingTemplate

`doConvert, receive, receiveAndConvert`

### Methods inherited from class org.springframework.messaging.core.AbstractMessageSendingTemplate

`convertAndSend, convertAndSend, convertAndSend, convertAndSend, doConvert, getDefaultDestination, getMessageConverter, getRequiredDefaultDestination, processHeadersToSend, send, setDefaultDestination, setMessageConverter`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

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

`convertAndSend, convertAndSend, convertAndSend, convertAndSend, send`

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

`receive, receiveAndConvert`

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

`convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, convertSendAndReceive, sendAndReceive`

### Constructor Detail

#### JmsMessagingTemplate

    public JmsMessagingTemplate()

Constructor for use with bean properties. Requires `setConnectionFactory(javax.jms.ConnectionFactory)` or `setJmsTemplate(org.springframework.jms.core.JmsTemplate)` to be called.

#### JmsMessagingTemplate

    public JmsMessagingTemplate(ConnectionFactory connectionFactory)

Create a `JmsMessagingTemplate` instance with the JMS `ConnectionFactory` to use, implicitly building a `JmsTemplate` based on it.

Since:
  4.1.2

#### JmsMessagingTemplate

    public JmsMessagingTemplate(JmsTemplate jmsTemplate)

Create a `JmsMessagingTemplate` instance with the `JmsTemplate` to use.

### Method Detail

#### setConnectionFactory

    public void setConnectionFactory(ConnectionFactory connectionFactory)

Set the ConnectionFactory to use for the underlying `JmsTemplate`.

Since:
  4.1.2

#### getConnectionFactory

    @Nullable
    public ConnectionFactory getConnectionFactory()

Return the ConnectionFactory that the underlying `JmsTemplate` uses.

Since:
  4.1.2

#### setJmsTemplate

    public void setJmsTemplate(@Nullable
                               JmsTemplate jmsTemplate)

Set the `JmsTemplate` to use.

#### getJmsTemplate

    @Nullable
    public JmsTemplate getJmsTemplate()

Return the configured `JmsTemplate`.

#### setJmsMessageConverter

    public void setJmsMessageConverter(MessageConverter jmsMessageConverter)

Set the `MessageConverter` to use to convert a `Message` from the messaging to and from a `Message`. By default, a `MessagingMessageConverter` is defined using a `SimpleMessageConverter` to convert the payload of the message.

Consider configuring a `MessagingMessageConverter` with a different `payload converter` for more advanced scenarios.

See Also:
  `MessagingMessageConverter`

#### getJmsMessageConverter

    public MessageConverter getJmsMessageConverter()

Return the `MessageConverter` to use to convert a `Message` from the messaging to and from a `Message`.

#### setDefaultDestinationName

    public void setDefaultDestinationName(@Nullable
                                          String defaultDestinationName)

Configure the default destination name to use in send methods that don't have a destination argument. If a default destination is not configured, send methods without a destination argument will raise an exception if invoked.

See Also:
  `AbstractMessageSendingTemplate.setDefaultDestination(Object)`

#### getDefaultDestinationName

    @Nullable
    public String getDefaultDestinationName()

Return the configured default destination name.

#### afterPropertiesSet

    public void afterPropertiesSet()

Specified by:
  `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`

#### send

    public void send(org.springframework.messaging.Message<?> message)

Specified by:
  `send` in interface `org.springframework.messaging.core.MessageSendingOperations<Destination>`
Overrides:
  `send` in class `org.springframework.messaging.core.AbstractMessageSendingTemplate<Destination>`

#### convertAndSend

    public void convertAndSend(Object payload)
                        throws org.springframework.messaging.MessagingException

Specified by:
  `convertAndSend` in interface `org.springframework.messaging.core.MessageSendingOperations<Destination>`
Overrides:
  `convertAndSend` in class `org.springframework.messaging.core.AbstractMessageSendingTemplate<Destination>`
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

    public void convertAndSend(Object payload,
                               @Nullable
                               org.springframework.messaging.core.MessagePostProcessor postProcessor)
                        throws org.springframework.messaging.MessagingException

Specified by:
  `convertAndSend` in interface `org.springframework.messaging.core.MessageSendingOperations<Destination>`
Overrides:
  `convertAndSend` in class `org.springframework.messaging.core.AbstractMessageSendingTemplate<Destination>`
Throws:
  `org.springframework.messaging.MessagingException`

#### send

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

Description copied from interface: `JmsMessageOperations`
Send a message to the given destination.

Specified by:
  `send` in interface `JmsMessageOperations`
Parameters:
  `destinationName` - the name of the target destination
  `message` - the message to send
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

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

Description copied from interface: `JmsMessageOperations`
Convert the given Object to serialized form, possibly using a `MessageConverter`, wrap it as a message and send it to the given destination.

Specified by:
  `convertAndSend` in interface `JmsMessageOperations`
Parameters:
  `destinationName` - the name of the target destination
  `payload` - the Object to use as payload
Throws:
  `org.springframework.messaging.MessagingException`

#### convertAndSend

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

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertAndSend` in interface `JmsMessageOperations`
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

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

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertAndSend` in interface `JmsMessageOperations`
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

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

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertAndSend` in interface `JmsMessageOperations`
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
    public org.springframework.messaging.Message<?> receive()

Specified by:
  `receive` in interface `org.springframework.messaging.core.MessageReceivingOperations<Destination>`
Overrides:
  `receive` in class `org.springframework.messaging.core.AbstractMessageReceivingTemplate<Destination>`

#### receiveAndConvert

    @Nullable
    public <T> T receiveAndConvert(Class<T> targetClass)

Specified by:
  `receiveAndConvert` in interface `org.springframework.messaging.core.MessageReceivingOperations<Destination>`
Overrides:
  `receiveAndConvert` in class `org.springframework.messaging.core.AbstractMessageReceivingTemplate<Destination>`

#### receive

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

Description copied from interface: `JmsMessageOperations`
Receive a message from the given destination.

Specified by:
  `receive` in interface `JmsMessageOperations`
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
    public <T> T receiveAndConvert(String destinationName,
                                             Class<T> targetClass)
                                      throws org.springframework.messaging.MessagingException

Description copied from interface: `JmsMessageOperations`
Receive a message from the given destination and convert its payload to the specified target class.

Specified by:
  `receiveAndConvert` in interface `JmsMessageOperations`
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
    public org.springframework.messaging.Message<?> sendAndReceive(org.springframework.messaging.Message<?> requestMessage)

Specified by:
  `sendAndReceive` in interface `org.springframework.messaging.core.MessageRequestReplyOperations<Destination>`
Overrides:
  `sendAndReceive` in class `org.springframework.messaging.core.AbstractMessagingTemplate<Destination>`

#### sendAndReceive

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

Description copied from interface: `JmsMessageOperations`
Send a request message and receive the reply from the given destination.

Specified by:
  `sendAndReceive` in interface `JmsMessageOperations`
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
    public <T> T convertSendAndReceive(String destinationName,
                                                 Object request,
                                                 Class<T> targetClass)
                                          throws org.springframework.messaging.MessagingException

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertSendAndReceive` in interface `JmsMessageOperations`
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
    public <T> T convertSendAndReceive(Object request,
                                                 Class<T> targetClass)

Specified by:
  `convertSendAndReceive` in interface `org.springframework.messaging.core.MessageRequestReplyOperations<Destination>`
Overrides:
  `convertSendAndReceive` in class `org.springframework.messaging.core.AbstractMessagingTemplate<Destination>`

#### convertSendAndReceive

    @Nullable
    public <T> T convertSendAndReceive(String destinationName,
                                                 Object request,
                                                 @Nullable
                                                 Map<String,Object> headers,
                                                 Class<T> targetClass)
                                          throws org.springframework.messaging.MessagingException

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertSendAndReceive` in interface `JmsMessageOperations`
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
    public <T> T convertSendAndReceive(Object request,
                                                 Class<T> targetClass,
                                                 @Nullable
                                                 org.springframework.messaging.core.MessagePostProcessor postProcessor)

Specified by:
  `convertSendAndReceive` in interface `org.springframework.messaging.core.MessageRequestReplyOperations<Destination>`
Overrides:
  `convertSendAndReceive` in class `org.springframework.messaging.core.AbstractMessagingTemplate<Destination>`

#### convertSendAndReceive

    @Nullable
    public <T> T convertSendAndReceive(String destinationName,
                                                 Object request,
                                                 Class<T> targetClass,
                                                 @Nullable
                                                 org.springframework.messaging.core.MessagePostProcessor requestPostProcessor)
                                          throws org.springframework.messaging.MessagingException

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertSendAndReceive` in interface `JmsMessageOperations`
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
    public <T> T convertSendAndReceive(String destinationName,
                                                 Object request,
                                                 @Nullable
                                                 Map<String,Object> headers,
                                                 Class<T> targetClass,
                                                 @Nullable
                                                 org.springframework.messaging.core.MessagePostProcessor postProcessor)

Description copied from interface: `JmsMessageOperations`
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.

Specified by:
  `convertSendAndReceive` in interface `JmsMessageOperations`
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
  `postProcessor` - 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

#### doSend

    protected void doSend(Destination destination,
                          org.springframework.messaging.Message<?> message)

Specified by:
  `doSend` in class `org.springframework.messaging.core.AbstractMessageSendingTemplate<Destination>`

#### doSend

    protected void doSend(String destinationName,
                          org.springframework.messaging.Message<?> message)

#### doReceive

    @Nullable
    protected org.springframework.messaging.Message<?> doReceive(Destination destination)

Specified by:
  `doReceive` in class `org.springframework.messaging.core.AbstractMessageReceivingTemplate<Destination>`

#### doReceive

    @Nullable
    protected org.springframework.messaging.Message<?> doReceive(String destinationName)

#### doSendAndReceive

    @Nullable
    protected org.springframework.messaging.Message<?> doSendAndReceive(Destination destination,
                                                                                  org.springframework.messaging.Message<?> requestMessage)

Specified by:
  `doSendAndReceive` in class `org.springframework.messaging.core.AbstractMessagingTemplate<Destination>`

#### doSendAndReceive

    @Nullable
    protected org.springframework.messaging.Message<?> doSendAndReceive(String destinationName,
                                                                                  org.springframework.messaging.Message<?> requestMessage)

#### getRequiredDefaultDestinationName

    protected String getRequiredDefaultDestinationName()

#### convertJmsMessage

    @Nullable
    protected org.springframework.messaging.Message<?> convertJmsMessage(@Nullable
                                                                                   Message message)

#### convertJmsException

    protected org.springframework.messaging.MessagingException convertJmsException(JmsException ex)