org.springframework.messaging.converter

## Class AbstractMessageConverter

- java.lang.Object
- - org.springframework.messaging.converter.AbstractMessageConverter

All Implemented Interfaces:
  MessageConverter, SmartMessageConverter

Direct Known Subclasses:
  ByteArrayMessageConverter, MappingJackson2MessageConverter, MarshallingMessageConverter, ProtobufMessageConverter, StringMessageConverter

    public abstract class AbstractMessageConverter
    extends Object
    implements SmartMessageConverter

Abstract base class for `SmartMessageConverter` implementations including support for common properties and a partial implementation of the conversion methods, mainly to check if the converter supports the conversion based on the payload class and MIME type.

Since:
  4.0
Author:
  Rossen Stoyanchev, Sebastien Deleuze, Juergen Hoeller

### Field Summary

Fields
`protected Log` `logger`

### Constructor Summary

Constructors
`protected` `AbstractMessageConverter(Collection<org.springframework.util.MimeType> supportedMimeTypes)` Constructor with a Collection of MIME types.
`protected` `AbstractMessageConverter(org.springframework.util.MimeType... supportedMimeTypes)` Constructor with one or more MIME types via vararg.
`protected` `AbstractMessageConverter(org.springframework.util.MimeType supportedMimeType)` Constructor with a single MIME type.

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`protected void` `addSupportedMimeTypes(org.springframework.util.MimeType... supportedMimeTypes)` Allows subclasses to add more supported mime types.
`protected boolean` `canConvertFrom(Message<?> message, Class<?> targetClass)`
`protected boolean` `canConvertTo(Object payload, MessageHeaders headers)`
`protected Object` `convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)` Convert the message payload from serialized form to an Object.
`protected Object` `convertToInternal(Object payload, MessageHeaders headers, Object conversionHint)` Convert the payload object to serialized form.
`Object` `fromMessage(Message<?> message, Class<?> targetClass)` Convert the payload of a `Message` from a serialized form to a typed Object of the specified target class.
`Object` `fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint)` A variant of `MessageConverter.fromMessage(Message, Class)` which takes an extra conversion context as an argument, allowing to take e.g.
`ContentTypeResolver` `getContentTypeResolver()` Return the configured `ContentTypeResolver`.
`protected org.springframework.util.MimeType` `getDefaultContentType(Object payload)` Return the default content type for the payload.
`protected org.springframework.util.MimeType` `getMimeType(MessageHeaders headers)`
`Class<?>` `getSerializedPayloadClass()` Return the configured preferred serialization payload class.
`List<org.springframework.util.MimeType>` `getSupportedMimeTypes()` Return the supported MIME types.
`boolean` `isStrictContentTypeMatch()` Whether content type resolution must produce a value that matches one of the supported MIME types.
`void` `setContentTypeResolver(ContentTypeResolver resolver)` Configure the `ContentTypeResolver` to use to resolve the content type of an input message.
`void` `setSerializedPayloadClass(Class<?> payloadClass)` Configure the preferred serialization class to use (byte[] or String) when converting an Object payload to a `Message`.
`void` `setStrictContentTypeMatch(boolean strictContentTypeMatch)` Whether this converter should convert messages for which no content type could be resolved through the configured `ContentTypeResolver`.
`protected abstract boolean` `supports(Class<?> clazz)` Whether the given class is supported by this converter.
`protected boolean` `supportsMimeType(MessageHeaders headers)`
`Message<?>` `toMessage(Object payload, MessageHeaders headers)` Create a `Message` whose payload is the result of converting the given payload Object to serialized form.
`Message<?>` `toMessage(Object payload, MessageHeaders headers, Object conversionHint)` A variant of `MessageConverter.toMessage(Object, MessageHeaders)` which takes an extra conversion context as an argument, allowing to take e.g.

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

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

### Field Detail

#### logger

    protected final Log logger

### Constructor Detail

#### AbstractMessageConverter

    protected AbstractMessageConverter(org.springframework.util.MimeType supportedMimeType)

Constructor with a single MIME type.

Parameters:
  `supportedMimeType` - the supported MIME type

#### AbstractMessageConverter

    protected AbstractMessageConverter(org.springframework.util.MimeType... supportedMimeTypes)

Constructor with one or more MIME types via vararg.

Parameters:
  `supportedMimeTypes` - the supported MIME types
Since:
  5.2.2

#### AbstractMessageConverter

    protected AbstractMessageConverter(Collection<org.springframework.util.MimeType> supportedMimeTypes)

Constructor with a Collection of MIME types.

Parameters:
  `supportedMimeTypes` - the supported MIME types

### Method Detail

#### getSupportedMimeTypes

    public List<org.springframework.util.MimeType> getSupportedMimeTypes()

Return the supported MIME types.

#### addSupportedMimeTypes

    protected void addSupportedMimeTypes(org.springframework.util.MimeType... supportedMimeTypes)

Allows subclasses to add more supported mime types.

Since:
  5.2.2

#### setContentTypeResolver

    public void setContentTypeResolver(@Nullable
                                       ContentTypeResolver resolver)

Configure the `ContentTypeResolver` to use to resolve the content type of an input message.

Note that if no resolver is configured, then `strictContentTypeMatch` should be left as `false` (the default) or otherwise this converter will ignore all messages.

By default, a `DefaultContentTypeResolver` instance is used.

#### getContentTypeResolver

    @Nullable
    public ContentTypeResolver getContentTypeResolver()

Return the configured `ContentTypeResolver`.

#### setStrictContentTypeMatch

    public void setStrictContentTypeMatch(boolean strictContentTypeMatch)

Whether this converter should convert messages for which no content type could be resolved through the configured `ContentTypeResolver`.

A converter can configured to be strict only when a `contentTypeResolver` is configured and the list of `supportedMimeTypes` is not be empty.

When this flag is set to `true`, `supportsMimeType(MessageHeaders)` will return `false` if the `contentTypeResolver` is not defined or if no content-type header is present.

#### isStrictContentTypeMatch

    public boolean isStrictContentTypeMatch()

Whether content type resolution must produce a value that matches one of the supported MIME types.

#### setSerializedPayloadClass

    public void setSerializedPayloadClass(Class<?> payloadClass)

Configure the preferred serialization class to use (byte[] or String) when converting an Object payload to a `Message`.

The default value is byte[].

Parameters:
  `payloadClass` - either byte[] or String

#### getSerializedPayloadClass

    public Class<?> getSerializedPayloadClass()

Return the configured preferred serialization payload class.

#### fromMessage

    @Nullable
    public final Object fromMessage(Message<?> message,
                                              Class<?> targetClass)

Description copied from interface: `MessageConverter`
Convert the payload of a `Message` from a serialized form to a typed Object of the specified target class. The `MessageHeaders.CONTENT_TYPE` header should indicate the MIME type to convert from.

If the converter does not support the specified media type or cannot perform the conversion, it should return `null`.

Specified by:
  `fromMessage` in interface `MessageConverter`
Parameters:
  `message` - the input message
  `targetClass` - the target class for the conversion
Returns:
  the result of the conversion, or `null` if the converter cannot perform the conversion

#### fromMessage

    @Nullable
    public final Object fromMessage(Message<?> message,
                                              Class<?> targetClass,
                                              @Nullable
                                              Object conversionHint)

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

Specified by:
  `fromMessage` in interface `SmartMessageConverter`
Parameters:
  `message` - the input message
  `targetClass` - the target class for the conversion
  `conversionHint` - an extra object passed to the `MessageConverter`, e.g. the associated `MethodParameter` (may be `null`}
Returns:
  the result of the conversion, or `null` if the converter cannot perform the conversion
See Also:
  `MessageConverter.fromMessage(Message, Class)`

#### toMessage

    @Nullable
    public final Message<?> toMessage(Object payload,
                                                @Nullable
                                                MessageHeaders headers)

Description copied from interface: `MessageConverter`
Create a `Message` whose payload is the result of converting the given payload Object to serialized form. The optional `MessageHeaders` parameter may contain a `MessageHeaders.CONTENT_TYPE` header to specify the target media type for the conversion and it may contain additional headers to be added to the message.

If the converter does not support the specified media type or cannot perform the conversion, it should return `null`.

Specified by:
  `toMessage` in interface `MessageConverter`
Parameters:
  `payload` - the Object to convert
  `headers` - optional headers for the message (may be `null`)
Returns:
  the new message, or `null` if the converter does not support the Object type or the target media type

#### toMessage

    @Nullable
    public final Message<?> toMessage(Object payload,
                                                @Nullable
                                                MessageHeaders headers,
                                                @Nullable
                                                Object conversionHint)

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

Specified by:
  `toMessage` in interface `SmartMessageConverter`
Parameters:
  `payload` - the Object to convert
  `headers` - optional headers for the message (may be `null`)
  `conversionHint` - an extra object passed to the `MessageConverter`, e.g. the associated `MethodParameter` (may be `null`}
Returns:
  the new message, or `null` if the converter does not support the Object type or the target media type
See Also:
  `MessageConverter.toMessage(Object, MessageHeaders)`

#### canConvertFrom

    protected boolean canConvertFrom(Message<?> message,
                                     Class<?> targetClass)

#### canConvertTo

    protected boolean canConvertTo(Object payload,
                                   @Nullable
                                   MessageHeaders headers)

#### supportsMimeType

    protected boolean supportsMimeType(@Nullable
                                       MessageHeaders headers)

#### getMimeType

    @Nullable
    protected org.springframework.util.MimeType getMimeType(@Nullable
                                                                      MessageHeaders headers)

#### getDefaultContentType

    @Nullable
    protected org.springframework.util.MimeType getDefaultContentType(Object payload)

Return the default content type for the payload. Called when `toMessage(Object, MessageHeaders)` is invoked without message headers or without a content type header.

By default, this returns the first element of the `supportedMimeTypes`, if any. Can be overridden in subclasses.

Parameters:
  `payload` - the payload being converted to a message
Returns:
  the content type, or `null` if not known

#### supports

    protected abstract boolean supports(Class<?> clazz)

Whether the given class is supported by this converter.

Parameters:
  `clazz` - the class to test for support
Returns:
  `true` if supported; `false` otherwise

#### convertFromInternal

    @Nullable
    protected Object convertFromInternal(Message<?> message,
                                                   Class<?> targetClass,
                                                   @Nullable
                                                   Object conversionHint)

Convert the message payload from serialized form to an Object.

Parameters:
  `message` - the input message
  `targetClass` - the target class for the conversion
  `conversionHint` - an extra object passed to the `MessageConverter`, e.g. the associated `MethodParameter` (may be `null`}
Returns:
  the result of the conversion, or `null` if the converter cannot perform the conversion
Since:
  4.2

#### convertToInternal

    @Nullable
    protected Object convertToInternal(Object payload,
                                                 @Nullable
                                                 MessageHeaders headers,
                                                 @Nullable
                                                 Object conversionHint)

Convert the payload object to serialized form.

Parameters:
  `payload` - the Object to convert
  `headers` - optional headers for the message (may be `null`)
  `conversionHint` - an extra object passed to the `MessageConverter`, e.g. the associated `MethodParameter` (may be `null`}
Returns:
  the resulting payload for the message, or `null` if the converter cannot perform the conversion
Since:
  4.2