org.springframework.http.converter.json

## Class AbstractJackson2HttpMessageConverter

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

- All Implemented Interfaces:
    GenericHttpMessageConverter<Object>, HttpMessageConverter<Object>
  Direct Known Subclasses:
    MappingJackson2CborHttpMessageConverter, MappingJackson2HttpMessageConverter, MappingJackson2SmileHttpMessageConverter, MappingJackson2XmlHttpMessageConverter

      public abstract class AbstractJackson2HttpMessageConverter
      extends AbstractGenericHttpMessageConverter<Object>

  Abstract base class for Jackson based and content type independent `HttpMessageConverter` implementations.

  Compatible with Jackson 2.9 to 2.12, as of Spring 5.3.

  Since:
    4.1
  Author:
    Arjen Poutsma, Keith Donald, Rossen Stoyanchev, Juergen Hoeller, Sebastien Deleuze
  See Also:
    `MappingJackson2HttpMessageConverter`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static Charset` | `DEFAULT_CHARSET` Deprecated.
    `protected ObjectMapper` | `defaultObjectMapper`

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

      `logger`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper)`
    `protected` | `AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType... supportedMediaTypes)`
    `protected` | `AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType supportedMediaType)`

  - ### 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.
    `protected Charset` | `getCharset(MediaType contentType)` Determine the charset to use for JSON input.
    `protected Long` | `getContentLength(Object object, MediaType contentType)` Returns the content length for the given type.
    `protected MediaType` | `getDefaultContentType(Object object)` Returns the default content type for the given type.
    `protected JavaType` | `getJavaType(Type type, Class<?> contextClass)` Return the Jackson `JavaType` for the specified type and context class.
    `protected JsonEncoding` | `getJsonEncoding(MediaType contentType)` Determine the JSON encoding to use for the given content type.
    `ObjectMapper` | `getObjectMapper()` Return the main `ObjectMapper` in use.
    `Map<MediaType,ObjectMapper>` | `getObjectMappersForType(Class<?> clazz)` Return ObjectMapper registrations for the given class, if any.
    `List<MediaType>` | `getSupportedMediaTypes(Class<?> clazz)` Return the list of media types supported by this converter for the given class.
    `protected void` | `logWarningIfNecessary(Type type, Throwable cause)` Determine whether to log the given exception coming from a `ObjectMapper.canDeserialize(com.fasterxml.jackson.databind.JavaType)` / `ObjectMapper.canSerialize(java.lang.Class<?>)` check.
    `Object` | `read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)` Read an object of the given type form the given input message, and returns it.
    `protected Object` | `readInternal(Class<?> clazz, HttpInputMessage inputMessage)` Abstract template method that reads the actual object.
    `void` | `registerObjectMappersForType(Class<?> clazz, Consumer<Map<MediaType,ObjectMapper>> registrar)` Configure the `ObjectMapper` instances to use for the given `Class`.
    `void` | `setObjectMapper(ObjectMapper objectMapper)` Configure the main `ObjectMapper` to use for Object conversion.
    `void` | `setPrettyPrint(boolean prettyPrint)` Whether to use the `DefaultPrettyPrinter` when writing JSON.
    `protected void` | `writeInternal(Object object, Type type, HttpOutputMessage outputMessage)` Abstract template method that writes the actual body.
    `protected void` | `writePrefix(JsonGenerator generator, Object object)` Write a prefix before the main content.
    `protected void` | `writeSuffix(JsonGenerator generator, Object object)` Write a suffix after the main content.

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

      `canWrite, supports, write, writeInternal`

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

      `addDefaultHeaders, canRead, canWrite, 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, read, write`

- - ### Field Detail

    - #### DEFAULT_CHARSET

          @Nullable
           @Deprecated
          public static final Charset DEFAULT_CHARSET

      Deprecated.
      The default charset used by the converter.

    - #### defaultObjectMapper

          protected ObjectMapper defaultObjectMapper

  - ### Constructor Detail

    - #### AbstractJackson2HttpMessageConverter

          protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper)

    - #### AbstractJackson2HttpMessageConverter

          protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper,
                                                         MediaType supportedMediaType)

    - #### AbstractJackson2HttpMessageConverter

          protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper,
                                                         MediaType... supportedMediaTypes)

  - ### Method Detail

    - #### setObjectMapper

          public void setObjectMapper(ObjectMapper objectMapper)

      Configure the main `ObjectMapper` to use for Object conversion. If not set, a default `ObjectMapper` instance is created.

      Setting a custom-configured `ObjectMapper` is one way to take further control of the JSON serialization process. For example, an extended `SerializerFactory` can be configured that provides custom serializers for specific types. Another option for refining the serialization process is to use Jackson's provided annotations on the types to be serialized, in which case a custom-configured ObjectMapper is unnecessary.

      See Also:
        `registerObjectMappersForType(Class, Consumer)`

    - #### getObjectMapper

          public ObjectMapper getObjectMapper()

      Return the main `ObjectMapper` in use.

    - #### registerObjectMappersForType

          public void registerObjectMappersForType(Class<?> clazz,
                                                   Consumer<Map<MediaType,ObjectMapper>> registrar)

      Configure the `ObjectMapper` instances to use for the given `Class`. This is useful when you want to deviate from the `default` ObjectMapper or have the `ObjectMapper` vary by `MediaType`.

      Note: Use of this method effectively turns off use of the default `ObjectMapper` and `supportedMediaTypes` for the given class. Therefore it is important for the mappings configured here to `include` every MediaType that must be supported for the given class.

      Parameters:
        `clazz` - the type of Object to register ObjectMapper instances for
        `registrar` - a consumer to populate or otherwise update the MediaType-to-ObjectMapper associations for the given Class
      Since:
        5.3.4

    - #### getObjectMappersForType

          @Nullable
          public Map<MediaType,ObjectMapper> getObjectMappersForType(Class<?> clazz)

      Return ObjectMapper registrations for the given class, if any.
      Parameters:
        `clazz` - the class to look up for registrations for
      Returns:
        a map with registered MediaType-to-ObjectMapper registrations, or empty if in case of no registrations for the given class.
      Since:
        5.3.4

    - #### getSupportedMediaTypes

          public List<MediaType> getSupportedMediaTypes(Class<?> clazz)

      Description copied from interface: `HttpMessageConverter`
      Return the list of media types supported by this converter for the given class. The list may differ from `HttpMessageConverter.getSupportedMediaTypes()` if the converter does not support the given Class or if it supports it only for a subset of media types.
      Parameters:
        `clazz` - the type of class to check
      Returns:
        the list of media types supported for the given class

    - #### setPrettyPrint

          public void setPrettyPrint(boolean prettyPrint)

      Whether to use the `DefaultPrettyPrinter` when writing JSON. This is a shortcut for setting up an `ObjectMapper` as follows:

           ObjectMapper mapper = new ObjectMapper();
           mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
           converter.setObjectMapper(mapper);

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

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

    - #### logWarningIfNecessary

          protected void logWarningIfNecessary(Type type,
                                               @Nullable
                                               Throwable cause)

      Determine whether to log the given exception coming from a `ObjectMapper.canDeserialize(com.fasterxml.jackson.databind.JavaType)` / `ObjectMapper.canSerialize(java.lang.Class<?>)` check.
      Parameters:
        `type` - the class that Jackson tested for (de-)serializability
        `cause` - the Jackson-thrown exception to evaluate (typically a `JsonMappingException`)
      Since:
        4.3

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

    - #### getCharset

          protected Charset getCharset(@Nullable
                                       MediaType contentType)

      Determine the charset to use for JSON input.

      By default this is either the charset from the input `MediaType` or otherwise falling back on `UTF-8`. Can be overridden in subclasses.

      Parameters:
        `contentType` - the content type of the HTTP input message
      Returns:
        the charset to use
      Since:
        5.1.18

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

    - #### writePrefix

          protected void writePrefix(JsonGenerator generator,
                                     Object object)
                              throws IOException

      Write a prefix before the main content.
      Parameters:
        `generator` - the generator to use for writing content.
        `object` - the object to write to the output message.
      Throws:
        `IOException`

    - #### writeSuffix

          protected void writeSuffix(JsonGenerator generator,
                                     Object object)
                              throws IOException

      Write a suffix after the main content.
      Parameters:
        `generator` - the generator to use for writing content.
        `object` - the object to write to the output message.
      Throws:
        `IOException`

    - #### getJavaType

          protected JavaType getJavaType(Type type,
                                         @Nullable
                                         Class<?> contextClass)

      Return the Jackson `JavaType` for the specified type and context class.
      Parameters:
        `type` - the generic type to return the Jackson JavaType for
        `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`)
      Returns:
        the Jackson JavaType

    - #### getJsonEncoding

          protected JsonEncoding getJsonEncoding(@Nullable
                                                 MediaType contentType)

      Determine the JSON encoding to use for the given content type.
      Parameters:
        `contentType` - the media type as requested by the caller
      Returns:
        the JSON encoding to use (never `null`)

    - #### getDefaultContentType

          @Nullable
          protected MediaType getDefaultContentType(Object object)
                                                       throws IOException

      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
      Throws:
        `IOException`

    - #### getContentLength

          @Nullable
          protected Long getContentLength(Object object,
                                                    @Nullable
                                                    MediaType contentType)
                                             throws IOException

      Description copied from class: `AbstractHttpMessageConverter`
      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.

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