Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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, 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
`protected Log` | `logger` Logger available to subclasses

Constructor Summary
`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
`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 actualy 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)`

### 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 actualy object. Invoked from `read(java.lang.Class, 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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD