org.springframework.http.converter

## Class ResourceRegionHttpMessageConverter

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

- All Implemented Interfaces:
    GenericHttpMessageConverter<Object>, HttpMessageConverter<Object>

      public class ResourceRegionHttpMessageConverter
      extends AbstractGenericHttpMessageConverter<Object>

  Implementation of `HttpMessageConverter` that can write a single `ResourceRegion` or Collections of `ResourceRegions`.
  Since:
    4.3
  Author:
    Brian Clozel, Juergen Hoeller

- - ### Field Summary

    - ### Fields inherited from class org.springframework.http.converter.AbstractHttpMessageConverter

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ResourceRegionHttpMessageConverter()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `boolean` | `canRead(Type type, Class<?> contextClass, MediaType mediaType)` Indicates whether the given type can be read by this converter.
    `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.
    `boolean` | `canWrite(Type type, Class<?> clazz, MediaType mediaType)` Indicates whether the given class can be written by this converter.
    `protected MediaType` | `getDefaultContentType(Object object)` Returns the default content type for the given type.
    `Object` | `read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)` Read an object of the given type form the given input message, and returns it.
    `protected ResourceRegion` | `readInternal(Class<?> clazz, HttpInputMessage inputMessage)` Abstract template method that reads the actual object.
    `protected void` | `writeInternal(Object object, Type type, HttpOutputMessage outputMessage)` Abstract template method that writes the actual body.
    `protected void` | `writeResourceRegion(ResourceRegion region, HttpOutputMessage outputMessage)`

    - ### Methods inherited from class org.springframework.http.converter.AbstractGenericHttpMessageConverter

      `supports, write, writeInternal`

    - ### Methods inherited from class org.springframework.http.converter.AbstractHttpMessageConverter

      `addDefaultHeaders, canRead, canWrite, getContentLength, getDefaultCharset, getSupportedMediaTypes, read, setDefaultCharset, setSupportedMediaTypes, write`

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

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

    - ### Methods inherited from interface org.springframework.http.converter.HttpMessageConverter

      `getSupportedMediaTypes, getSupportedMediaTypes, read, write`

- - ### Constructor Detail

    - #### ResourceRegionHttpMessageConverter

          public ResourceRegionHttpMessageConverter()

  - ### Method Detail

    - #### canRead

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

      Description copied from class: `AbstractHttpMessageConverter`
      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<Object>`
      Overrides:
        `canRead` in class `AbstractHttpMessageConverter<Object>`
      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

          public boolean canRead(Type type,
                                 @Nullable
                                 Class<?> contextClass,
                                 @Nullable
                                 MediaType mediaType)

      Description copied from interface: `GenericHttpMessageConverter`
      Indicates whether the given type can be read by this converter. This method should perform the same checks as `HttpMessageConverter.canRead(Class, MediaType)` with additional ones related to the generic type.
      Specified by:
        `canRead` in interface `GenericHttpMessageConverter<Object>`
      Overrides:
        `canRead` in class `AbstractGenericHttpMessageConverter<Object>`
      Parameters:
        `type` - the (potentially generic) type to test for readability
        `contextClass` - a context class for the target type, for example a class in which the target type appears in a method signature (can be `null`)
        `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

    - #### read

          public Object read(Type type,
                             @Nullable
                             Class<?> contextClass,
                             HttpInputMessage inputMessage)
                      throws IOException,
                             HttpMessageNotReadableException

      Description copied from interface: `GenericHttpMessageConverter`
      Read an object of the given type form the given input message, and returns it.
      Parameters:
        `type` - the (potentially generic) type of object to return. This type must have previously been passed to the `canRead` method of this interface, which must have returned `true`.
        `contextClass` - a context class for the target type, for example a class in which the target type appears in a method signature (can be `null`)
        `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

    - #### readInternal

          protected ResourceRegion readInternal(Class<?> clazz,
                                                HttpInputMessage inputMessage)
                                         throws IOException,
                                                HttpMessageNotReadableException

      Description copied from class: `AbstractHttpMessageConverter`
      Abstract template method that reads the actual object. Invoked from `AbstractHttpMessageConverter.read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage)`.
      Specified by:
        `readInternal` in class `AbstractHttpMessageConverter<Object>`
      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

    - #### canWrite

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

      Description copied from class: `AbstractHttpMessageConverter`
      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<Object>`
      Overrides:
        `canWrite` in class `AbstractHttpMessageConverter<Object>`
      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

          public boolean canWrite(@Nullable
                                  Type type,
                                  @Nullable
                                  Class<?> clazz,
                                  @Nullable
                                  MediaType mediaType)

      Description copied from interface: `GenericHttpMessageConverter`
      Indicates whether the given class can be written by this converter.

      This method should perform the same checks as `HttpMessageConverter.canWrite(Class, MediaType)` with additional ones related to the generic type.

      Specified by:
        `canWrite` in interface `GenericHttpMessageConverter<Object>`
      Overrides:
        `canWrite` in class `AbstractGenericHttpMessageConverter<Object>`
      Parameters:
        `type` - the (potentially generic) type to test for writability (can be `null` if not specified)
        `clazz` - the source object 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

    - #### writeInternal

          protected void writeInternal(Object object,
                                       @Nullable
                                       Type type,
                                       HttpOutputMessage outputMessage)
                                throws IOException,
                                       HttpMessageNotWritableException

      Description copied from class: `AbstractGenericHttpMessageConverter`
      Abstract template method that writes the actual body. Invoked from `AbstractGenericHttpMessageConverter.write(T, java.lang.reflect.Type, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage)`.
      Specified by:
        `writeInternal` in class `AbstractGenericHttpMessageConverter<Object>`
      Parameters:
        `object` - the object to write to the output message
        `type` - the type of object to write (may be `null`)
        `outputMessage` - the HTTP output message to write to
      Throws:
        `IOException` - in case of I/O errors
        `HttpMessageNotWritableException` - in case of conversion errors

    - #### getDefaultContentType

          protected MediaType getDefaultContentType(Object object)

      Description copied from class: `AbstractHttpMessageConverter`
      Returns the default content type for the given type. Called when `AbstractHttpMessageConverter.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.

      Overrides:
        `getDefaultContentType` in class `AbstractHttpMessageConverter<Object>`
      Parameters:
        `object` - the type to return the content type for
      Returns:
        the content type, or `null` if not known

    - #### writeResourceRegion

          protected void writeResourceRegion(ResourceRegion region,
                                             HttpOutputMessage outputMessage)
                                      throws IOException

      Throws:
        `IOException`