org.springframework.http.converter

## Class AbstractHttpMessageConverter<T>

- java.lang.Object
- - org.springframework.http.converter.AbstractHttpMessageConverter<T>

All Implemented Interfaces:
  HttpMessageConverter<T>

Direct Known Subclasses:
  AbstractWireFeedHttpMessageConverter, AbstractXmlHttpMessageConverter, ByteArrayHttpMessageConverter, MappingJackson2HttpMessageConverter, MappingJacksonHttpMessageConverter, ObjectToStringHttpMessageConverter, ResourceHttpMessageConverter, StringHttpMessageConverter

    public abstract class AbstractHttpMessageConverter<T>
    extends Object
    implements HttpMessageConverter<T>

Abstract base class for most `HttpMessageConverter` implementations.

This base class adds support for setting supported `MediaTypes`, through the `supportedMediaTypes` bean property. It also adds support for `Content-Type` and `Content-Length` when writing to output messages.

Since:
  3.0
Author:
  Arjen Poutsma, Juergen Hoeller

### Field Summary

Fields
`protected Log` `logger` Logger available to subclasses

### Constructor Summary

Constructors
`protected` `AbstractHttpMessageConverter()` Construct an `AbstractHttpMessageConverter` with no supported media types.
`protected` `AbstractHttpMessageConverter(MediaType... supportedMediaTypes)` Construct an `AbstractHttpMessageConverter` with multiple supported media type.
`protected` `AbstractHttpMessageConverter(MediaType supportedMediaType)` Construct an `AbstractHttpMessageConverter` with one supported media type.

### Method Summary

Methods
`boolean` `canRead(Class<?> clazz, MediaType mediaType)` This implementation checks if the given class is supported, and if the supported media types include the given media type.
`protected boolean` `canRead(MediaType mediaType)` Returns true if any of the supported media types include the given media type.
`boolean` `canWrite(Class<?> clazz, MediaType mediaType)` This implementation checks if the given class is supported, and if the supported media types include the given media type.
`protected boolean` `canWrite(MediaType mediaType)` Returns `true` if the given media type includes any of the supported media types.
`protected Long` `getContentLength(T t, MediaType contentType)` Returns the content length for the given type.
`protected MediaType` `getDefaultContentType(T t)` Returns the default content type for the given type.
`List<MediaType>` `getSupportedMediaTypes()` Return the list of `MediaType` objects supported by this converter.
`T` `read(Class<? extends T> clazz, HttpInputMessage inputMessage)` This implementation simple delegates to `readInternal(Class, HttpInputMessage)`.
`protected abstract T` `readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)` Abstract template method that reads the actual object.
`void` `setSupportedMediaTypes(List<MediaType> supportedMediaTypes)` Set the list of `MediaType` objects supported by this converter.
`protected abstract boolean` `supports(Class<?> clazz)` Indicates whether the given class is supported by this converter.
`void` `write(T t, MediaType contentType, HttpOutputMessage outputMessage)` This implementation delegates to `getDefaultContentType(Object)` if a content type was not provided, calls `getContentLength(T, org.springframework.http.MediaType)`, and sets the corresponding headers on the output message.
`protected abstract void` `writeInternal(T t, HttpOutputMessage outputMessage)` Abstract template method that writes the actual body.

### 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

Logger available to subclasses

### Constructor Detail

#### AbstractHttpMessageConverter

    protected AbstractHttpMessageConverter()

Construct an `AbstractHttpMessageConverter` with no supported media types.

See Also:
  `setSupportedMediaTypes(java.util.List<org.springframework.http.MediaType>)`

#### AbstractHttpMessageConverter

    protected AbstractHttpMessageConverter(MediaType supportedMediaType)

Construct an `AbstractHttpMessageConverter` with one supported media type.

Parameters:
  `supportedMediaType` - the supported media type

#### AbstractHttpMessageConverter

    protected AbstractHttpMessageConverter(MediaType... supportedMediaTypes)

Construct an `AbstractHttpMessageConverter` with multiple supported media type.

Parameters:
  `supportedMediaTypes` - the supported media types

### Method Detail

#### setSupportedMediaTypes

    public void setSupportedMediaTypes(List<MediaType> supportedMediaTypes)

Set the list of `MediaType` objects supported by this converter.

#### getSupportedMediaTypes

    public List<MediaType> getSupportedMediaTypes()

Description copied from interface: `HttpMessageConverter`
Return the list of `MediaType` objects supported by this converter.

Specified by:
  `getSupportedMediaTypes` in interface `HttpMessageConverter<T>`
Returns:
  the list of supported media types

#### canRead

    public boolean canRead(Class<?> clazz,
                  MediaType mediaType)

This implementation checks if the given class is supported, and if the supported media types include the given media type.

Specified by:
  `canRead` in interface `HttpMessageConverter<T>`
Parameters:
  `clazz` - the class to test for readability
  `mediaType` - the media type to read, can be `null` if not specified. Typically the value of a `Content-Type` header.
Returns:
  `true` if readable; `false` otherwise

#### canRead

    protected boolean canRead(MediaType mediaType)

Returns true if any of the supported media types include the given media type.

Parameters:
  `mediaType` - the media type to read, can be `null` if not specified. Typically the value of a `Content-Type` header.
Returns:
  `true` if the supported media types include the media type, or if the media type is `null`

#### canWrite

    public boolean canWrite(Class<?> clazz,
                   MediaType mediaType)

This implementation checks if the given class is supported, and if the supported media types include the given media type.

Specified by:
  `canWrite` in interface `HttpMessageConverter<T>`
Parameters:
  `clazz` - the class to test for writability
  `mediaType` - the media type to write, can be `null` if not specified. Typically the value of an `Accept` header.
Returns:
  `true` if writable; `false` otherwise

#### canWrite

    protected boolean canWrite(MediaType mediaType)

Returns `true` if the given media type includes any of the supported media types.

Parameters:
  `mediaType` - the media type to write, can be `null` if not specified. Typically the value of an `Accept` header.
Returns:
  `true` if the supported media types are compatible with the media type, or if the media type is `null`

#### read

    public final T read(Class<? extends T> clazz,
         HttpInputMessage inputMessage)
                 throws IOException

This implementation simple delegates to `readInternal(Class, HttpInputMessage)`. Future implementations might add some default behavior, however.

Specified by:
  `read` in interface `HttpMessageConverter<T>`
Parameters:
  `clazz` - the type of object to return. This type must have previously been passed to the `canRead` method of this interface, which must have returned `true`.
  `inputMessage` - the HTTP input message to read from
Returns:
  the converted object
Throws:
  `IOException` - in case of I/O errors

#### write

    public final void write(T t,
             MediaType contentType,
             HttpOutputMessage outputMessage)
                     throws IOException,
                            HttpMessageNotWritableException

This implementation delegates to `getDefaultContentType(Object)` if a content type was not provided, calls `getContentLength(T, org.springframework.http.MediaType)`, and sets the corresponding headers on the output message. It then calls `writeInternal(T, org.springframework.http.HttpOutputMessage)`.

Specified by:
  `write` in interface `HttpMessageConverter<T>`
Parameters:
  `t` - the object to write to the output message. The type of this object must have previously been passed to the `canWrite` method of this interface, which must have returned `true`.
  `contentType` - the content type to use when writing. May be `null` to indicate that the default content type of the converter must be used. If not `null`, this media type must have previously been passed to the `canWrite` method of this interface, which must have returned `true`.
  `outputMessage` - the message to write to
Throws:
  `IOException` - in case of I/O errors
  `HttpMessageNotWritableException` - in case of conversion errors

#### getDefaultContentType

    protected MediaType getDefaultContentType(T t)
                                       throws IOException

Returns the default content type for the given type. Called when `write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage)` is invoked without a specified content type parameter.

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

Parameters:
  `t` - the type to return the content type for
Returns:
  the content type, or `null` if not known
Throws:
  `IOException`

#### getContentLength

    protected Long getContentLength(T t,
                        MediaType contentType)
                             throws IOException

Returns the content length for the given type.

By default, this returns `null`, meaning that the content length is unknown. Can be overridden in subclasses.

Parameters:
  `t` - the type to return the content length for
Returns:
  the content length, or `null` if not known
Throws:
  `IOException`

#### supports

    protected abstract boolean supports(Class<?> clazz)

Indicates whether the given class is supported by this converter.

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

#### readInternal

    protected abstract T readInternal(Class<? extends T> clazz,
                 HttpInputMessage inputMessage)
                               throws IOException,
                                      HttpMessageNotReadableException

Abstract template method that reads the actual object. Invoked from `read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage)`.

Parameters:
  `clazz` - the type of object to return
  `inputMessage` - the HTTP input message to read from
Returns:
  the converted object
Throws:
  `IOException` - in case of I/O errors
  `HttpMessageNotReadableException` - in case of conversion errors

#### writeInternal

    protected abstract void writeInternal(T t,
                     HttpOutputMessage outputMessage)
                                   throws IOException,
                                          HttpMessageNotWritableException

Abstract template method that writes the actual body. Invoked from `write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage)`.

Parameters:
  `t` - the object to write to the output message
  `outputMessage` - the message to write to
Throws:
  `IOException` - in case of I/O errors
  `HttpMessageNotWritableException` - in case of conversion errors