org.springframework.jms.support.converter

## Class MappingJackson2MessageConverter

- java.lang.Object
- - org.springframework.jms.support.converter.MappingJackson2MessageConverter

All Implemented Interfaces:
  org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanClassLoaderAware, MessageConverter, SmartMessageConverter

    public class MappingJackson2MessageConverter
    extends Object
    implements SmartMessageConverter, org.springframework.beans.factory.BeanClassLoaderAware

Message converter that uses Jackson 2.x to convert messages to and from JSON. Maps an object to a `BytesMessage`, or to a `TextMessage` if the `targetType` is set to `MessageType.TEXT`. Converts from a `TextMessage` or `BytesMessage` to an object.

It customizes Jackson's default properties with the following ones:

- `MapperFeature.DEFAULT_VIEW_INCLUSION` is disabled
- `DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES` is disabled

Compatible with Jackson 2.6 and higher, as of Spring 4.3.

Since:
  3.1.4
Author:
  Mark Pollack, Dave Syer, Juergen Hoeller, Stephane Nicoll

### Field Summary

Fields
`static String` `DEFAULT_ENCODING` The default encoding used for writing to text messages: UTF-8.

### Constructor Summary

Constructors
Constructor and Description
`MappingJackson2MessageConverter()`

### Method Summary

All Methods Instance Methods Concrete Methods
`protected Object` `convertFromBytesMessage(BytesMessage message, JavaType targetJavaType)` Convert a BytesMessage to a Java Object with the specified type.
`protected Object` `convertFromMessage(Message message, JavaType targetJavaType)` Template method that allows for custom message mapping.
`protected Object` `convertFromTextMessage(TextMessage message, JavaType targetJavaType)` Convert a TextMessage to a Java Object with the specified type.
`Object` `fromMessage(Message message)` Convert from a JMS Message to a Java object.
`protected JavaType` `getJavaTypeForMessage(Message message)` Determine a Jackson JavaType for the given JMS Message, typically parsing a type id message property.
`protected Class<?>` `getSerializationView(Object conversionHint)` Determine a Jackson serialization view based on the given conversion hint.
`protected BytesMessage` `mapToBytesMessage(Object object, Session session, ObjectWriter objectWriter)` Map the given object to a `BytesMessage`.
`protected Message` `mapToMessage(Object object, Session session, ObjectWriter objectWriter, MessageType targetType)` Template method that allows for custom message mapping.
`protected TextMessage` `mapToTextMessage(Object object, Session session, ObjectWriter objectWriter)` Map the given object to a `TextMessage`.
`void` `setBeanClassLoader(ClassLoader classLoader)`
`void` `setEncoding(String encoding)` Specify the encoding to use when converting to and from text-based message body content.
`void` `setEncodingPropertyName(String encodingPropertyName)` Specify the name of the JMS message property that carries the encoding from bytes to String and back is BytesMessage is used during the conversion process.
`void` `setObjectMapper(ObjectMapper objectMapper)` Specify the `ObjectMapper` to use instead of using the default.
`void` `setTargetType(MessageType targetType)` Specify whether `toMessage(Object, Session)` should marshal to a `BytesMessage` or a `TextMessage`.
`void` `setTypeIdMappings(Map<String,Class<?>> typeIdMappings)` Specify mappings from type ids to Java classes, if desired.
`protected void` `setTypeIdOnMessage(Object object, Message message)` Set a type id for the given payload object on the given JMS Message.
`void` `setTypeIdPropertyName(String typeIdPropertyName)` Specify the name of the JMS message property that carries the type id for the contained object: either a mapped id value or a raw Java class name.
`Message` `toMessage(Object object, Session session)` Convert a Java object to a JMS Message using the supplied session to create the message object.
`Message` `toMessage(Object object, Session session, Class<?> jsonView)` Convert a Java object to a JMS Message using the specified json view and the supplied session to create the message object.
`Message` `toMessage(Object object, Session session, Object conversionHint)` A variant of `MessageConverter.toMessage(Object, Session)` which takes an extra conversion context as an argument, allowing to take e.g.
`protected Message` `toMessage(Object object, Session session, ObjectWriter objectWriter)`

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

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

### Field Detail

#### DEFAULT_ENCODING

    public static final String DEFAULT_ENCODING

The default encoding used for writing to text messages: UTF-8.

See Also:
  Constant Field Values

### Constructor Detail

#### MappingJackson2MessageConverter

    public MappingJackson2MessageConverter()

### Method Detail

#### setObjectMapper

    public void setObjectMapper(ObjectMapper objectMapper)

Specify the `ObjectMapper` to use instead of using the default.

#### setTargetType

    public void setTargetType(MessageType targetType)

Specify whether `toMessage(Object, Session)` should marshal to a `BytesMessage` or a `TextMessage`.

The default is `MessageType.BYTES`, i.e. this converter marshals to a `BytesMessage`. Note that the default version of this converter supports `MessageType.BYTES` and `MessageType.TEXT` only.

See Also:
  `MessageType.BYTES`, `MessageType.TEXT`

#### setEncoding

    public void setEncoding(String encoding)

Specify the encoding to use when converting to and from text-based message body content. The default encoding will be "UTF-8".

When reading from a text-based message, an encoding may have been suggested through a special JMS property which will then be preferred over the encoding set on this MessageConverter instance.

See Also:
  `setEncodingPropertyName(java.lang.String)`

#### setEncodingPropertyName

    public void setEncodingPropertyName(String encodingPropertyName)

Specify the name of the JMS message property that carries the encoding from bytes to String and back is BytesMessage is used during the conversion process.

Default is none. Setting this property is optional; if not set, UTF-8 will be used for decoding any incoming bytes message.

See Also:
  `setEncoding(java.lang.String)`

#### setTypeIdPropertyName

    public void setTypeIdPropertyName(String typeIdPropertyName)

Specify the name of the JMS message property that carries the type id for the contained object: either a mapped id value or a raw Java class name.

Default is none. NOTE: This property needs to be set in order to allow for converting from an incoming message to a Java object.

See Also:
  `setTypeIdMappings(java.util.Map<java.lang.String, java.lang.Class<?>>)`

#### setTypeIdMappings

    public void setTypeIdMappings(Map<String,Class<?>> typeIdMappings)

Specify mappings from type ids to Java classes, if desired. This allows for synthetic ids in the type id message property, instead of transferring Java class names.

Default is no custom mappings, i.e. transferring raw Java class names.

Parameters:
  `typeIdMappings` - a Map with type id values as keys and Java classes as values

#### setBeanClassLoader

    public void setBeanClassLoader(ClassLoader classLoader)

Specified by:
  `setBeanClassLoader` in interface `org.springframework.beans.factory.BeanClassLoaderAware`

#### toMessage

    public Message toMessage(Object object,
                             Session session)
                      throws JMSException,
                             MessageConversionException

Description copied from interface: `MessageConverter`
Convert a Java object to a JMS Message using the supplied session to create the message object.

Specified by:
  `toMessage` in interface `MessageConverter`
Parameters:
  `object` - the object to convert
  `session` - the Session to use for creating a JMS Message
Returns:
  the JMS Message
Throws:
  `JMSException` - if thrown by JMS API methods
  `MessageConversionException` - in case of conversion failure

#### toMessage

    public Message toMessage(Object object,
                             Session session,
                             @Nullable
                             Object conversionHint)
                      throws JMSException,
                             MessageConversionException

Description copied from interface: `SmartMessageConverter`
A variant of `MessageConverter.toMessage(Object, Session)` which takes an extra conversion context as an argument, allowing to take e.g. annotations on a payload parameter into account.

Specified by:
  `toMessage` in interface `SmartMessageConverter`
Parameters:
  `object` - the object to convert
  `session` - the Session to use for creating a JMS Message
  `conversionHint` - an extra object passed to the `MessageConverter`, e.g. the associated `MethodParameter` (may be `null`}
Returns:
  the JMS Message
Throws:
  `JMSException` - if thrown by JMS API methods
  `MessageConversionException` - in case of conversion failure
See Also:
  `MessageConverter.toMessage(Object, Session)`

#### toMessage

    public Message toMessage(Object object,
                             Session session,
                             @Nullable
                             Class<?> jsonView)
                      throws JMSException,
                             MessageConversionException

Convert a Java object to a JMS Message using the specified json view and the supplied session to create the message object.

Parameters:
  `object` - the object to convert
  `session` - the Session to use for creating a JMS Message
  `jsonView` - the view to use to filter the content
Returns:
  the JMS Message
Throws:
  `JMSException` - if thrown by JMS API methods
  `MessageConversionException` - in case of conversion failure
Since:
  4.3

#### fromMessage

    public Object fromMessage(Message message)
                       throws JMSException,
                              MessageConversionException

Description copied from interface: `MessageConverter`
Convert from a JMS Message to a Java object.

Specified by:
  `fromMessage` in interface `MessageConverter`
Parameters:
  `message` - the message to convert
Returns:
  the converted Java object
Throws:
  `JMSException` - if thrown by JMS API methods
  `MessageConversionException` - in case of conversion failure

#### toMessage

    protected Message toMessage(Object object,
                                Session session,
                                ObjectWriter objectWriter)
                         throws JMSException,
                                MessageConversionException

Throws:
  `JMSException`
  `MessageConversionException`

#### mapToTextMessage

    protected TextMessage mapToTextMessage(Object object,
                                           Session session,
                                           ObjectWriter objectWriter)
                                    throws JMSException,
                                           IOException

Map the given object to a `TextMessage`.

Parameters:
  `object` - the object to be mapped
  `session` - current JMS session
  `objectWriter` - the writer to use
Returns:
  the resulting message
Throws:
  `JMSException` - if thrown by JMS methods
  `IOException` - in case of I/O errors
Since:
  4.3
See Also:
  `Session.createBytesMessage()`

#### mapToBytesMessage

    protected BytesMessage mapToBytesMessage(Object object,
                                             Session session,
                                             ObjectWriter objectWriter)
                                      throws JMSException,
                                             IOException

Map the given object to a `BytesMessage`.

Parameters:
  `object` - the object to be mapped
  `session` - current JMS session
  `objectWriter` - the writer to use
Returns:
  the resulting message
Throws:
  `JMSException` - if thrown by JMS methods
  `IOException` - in case of I/O errors
Since:
  4.3
See Also:
  `Session.createBytesMessage()`

#### mapToMessage

    protected Message mapToMessage(Object object,
                                   Session session,
                                   ObjectWriter objectWriter,
                                   MessageType targetType)
                            throws JMSException,
                                   IOException

Template method that allows for custom message mapping. Invoked when `setTargetType(org.springframework.jms.support.converter.MessageType)` is not `MessageType.TEXT` or `MessageType.BYTES`.

The default implementation throws an `IllegalArgumentException`.

Parameters:
  `object` - the object to marshal
  `session` - the JMS Session
  `objectWriter` - the writer to use
  `targetType` - the target message type (other than TEXT or BYTES)
Returns:
  the resulting message
Throws:
  `JMSException` - if thrown by JMS methods
  `IOException` - in case of I/O errors

#### setTypeIdOnMessage

    protected void setTypeIdOnMessage(Object object,
                                      Message message)
                               throws JMSException

Set a type id for the given payload object on the given JMS Message.

The default implementation consults the configured type id mapping and sets the resulting value (either a mapped id or the raw Java class name) into the configured type id message property.

Parameters:
  `object` - the payload object to set a type id for
  `message` - the JMS Message on which to set the type id property
Throws:
  `JMSException` - if thrown by JMS methods
See Also:
  `getJavaTypeForMessage(javax.jms.Message)`, `setTypeIdPropertyName(String)`, `setTypeIdMappings(java.util.Map)`

#### convertFromTextMessage

    protected Object convertFromTextMessage(TextMessage message,
                                            JavaType targetJavaType)
                                     throws JMSException,
                                            IOException

Convert a TextMessage to a Java Object with the specified type.

Parameters:
  `message` - the input message
  `targetJavaType` - the target type
Returns:
  the message converted to an object
Throws:
  `JMSException` - if thrown by JMS
  `IOException` - in case of I/O errors

#### convertFromBytesMessage

    protected Object convertFromBytesMessage(BytesMessage message,
                                             JavaType targetJavaType)
                                      throws JMSException,
                                             IOException

Convert a BytesMessage to a Java Object with the specified type.

Parameters:
  `message` - the input message
  `targetJavaType` - the target type
Returns:
  the message converted to an object
Throws:
  `JMSException` - if thrown by JMS
  `IOException` - in case of I/O errors

#### convertFromMessage

    protected Object convertFromMessage(Message message,
                                        JavaType targetJavaType)
                                 throws JMSException,
                                        IOException

Template method that allows for custom message mapping. Invoked when `setTargetType(org.springframework.jms.support.converter.MessageType)` is not `MessageType.TEXT` or `MessageType.BYTES`.

The default implementation throws an `IllegalArgumentException`.

Parameters:
  `message` - the input message
  `targetJavaType` - the target type
Returns:
  the message converted to an object
Throws:
  `JMSException` - if thrown by JMS
  `IOException` - in case of I/O errors

#### getJavaTypeForMessage

    protected JavaType getJavaTypeForMessage(Message message)
                                      throws JMSException

Determine a Jackson JavaType for the given JMS Message, typically parsing a type id message property.

The default implementation parses the configured type id property name and consults the configured type id mapping. This can be overridden with a different strategy, e.g. doing some heuristics based on message origin.

Parameters:
  `message` - the JMS Message from which to get the type id property
Throws:
  `JMSException` - if thrown by JMS methods
See Also:
  `setTypeIdOnMessage(Object, javax.jms.Message)`, `setTypeIdPropertyName(String)`, `setTypeIdMappings(java.util.Map)`

#### getSerializationView

    @Nullable
    protected Class<?> getSerializationView(@Nullable
                                                      Object conversionHint)

Determine a Jackson serialization view based on the given conversion hint.

Parameters:
  `conversionHint` - the conversion hint Object as passed into the converter for the current conversion attempt
Returns:
  the serialization view class, or `null` if none