Deserializers
Date: 2016-12-04

com.fasterxml.jackson.databind.deser

## Interface Deserializers

- All Known Implementing Classes:
    CoreXMLDeserializers, Deserializers.Base, SimpleDeserializers

      public interface Deserializers

  Interface that defines API for simple extensions that can provide additional deserializers for various types. Access is by a single callback method; instance is to either return a configured `JsonDeserializer` for specified type, or null to indicate that it does not support handling of the type. In latter case, further calls can be made for other providers; in former case returned deserializer is used for handling of instances of specified type.

  It is strongly recommended that implementations always extend `Deserializers.Base` and NOT just implement `Deserializers`.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface and Description
    --- | ---
    `static class` | `Deserializers.Base` Basic `Deserializers` implementation that implements all methods but provides no deserializers.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `JsonDeserializer<?>` | `findArrayDeserializer(ArrayType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)` Method called to locate serializer for specified array type.
    `JsonDeserializer<?>` | `findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)` Method called to locate deserializer for specified value type which does not belong to any other category (not an Enum, Collection, Map, Array, reference value or tree node)
    `JsonDeserializer<?>` | `findCollectionDeserializer(CollectionType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)` Method called to locate serializer for specified `Collection` (List, Set etc) type.
    `JsonDeserializer<?>` | `findCollectionLikeDeserializer(CollectionLikeType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)` Method called to locate serializer for specified "Collection-like" type (one that acts like `Collection` but does not implement it).
    `JsonDeserializer<?>` | `findEnumDeserializer(java.lang.Class<?> type, DeserializationConfig config, BeanDescription beanDesc)` Method called to locate deserializer for specified `Enum` type.
    `JsonDeserializer<?>` | `findMapDeserializer(MapType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)` Method called to locate deserializer for specified `Map` type.
    `JsonDeserializer<?>` | `findMapLikeDeserializer(MapLikeType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)` Method called to locate serializer for specified "Map-like" type (one that acts like `Map` but does not implement it).
    `JsonDeserializer<?>` | `findReferenceDeserializer(ReferenceType refType, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer contentTypeDeserializer, JsonDeserializer<?> contentDeserializer)` Method called to locate deserializer for value that is of referential type,
    `JsonDeserializer<?>` | `findTreeNodeDeserializer(java.lang.Class<? extends JsonNode> nodeType, DeserializationConfig config, BeanDescription beanDesc)` Method called to locate deserializer for specified JSON tree node type.

- - ### Method Detail

    - #### findEnumDeserializer

          JsonDeserializer<?> findEnumDeserializer(java.lang.Class<?> type,
                                                 DeserializationConfig config,
                                                 BeanDescription beanDesc)
                                                   throws JsonMappingException

      Method called to locate deserializer for specified `Enum` type.
      Parameters:
        `type` - Type of `Enum` instances to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findTreeNodeDeserializer

          JsonDeserializer<?> findTreeNodeDeserializer(java.lang.Class<? extends JsonNode> nodeType,
                                                     DeserializationConfig config,
                                                     BeanDescription beanDesc)
                                                       throws JsonMappingException

      Method called to locate deserializer for specified JSON tree node type.
      Parameters:
        `nodeType` - Specific type of JSON tree nodes to deserialize (subtype of `JsonNode`)
        `config` - Configuration in effect
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findBeanDeserializer

          JsonDeserializer<?> findBeanDeserializer(JavaType type,
                                                 DeserializationConfig config,
                                                 BeanDescription beanDesc)
                                                   throws JsonMappingException

      Method called to locate deserializer for specified value type which does not belong to any other category (not an Enum, Collection, Map, Array, reference value or tree node)
      Parameters:
        `type` - Bean type to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findReferenceDeserializer

          JsonDeserializer<?> findReferenceDeserializer(ReferenceType refType,
                                                      DeserializationConfig config,
                                                      BeanDescription beanDesc,
                                                      TypeDeserializer contentTypeDeserializer,
                                                      JsonDeserializer<?> contentDeserializer)
                                                        throws JsonMappingException

      Method called to locate deserializer for value that is of referential type,
      Parameters:
        `refType` - Specific referential type to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the reference type that contains class annotations and other information typically needed for building deserializers
        `contentTypeDeserializer` - Possible type deserializer for referenced value
        `contentDeserializer` - Value deserializer to use for referenced value, if indicated by property annotation
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`
      Since:
        2.7

    - #### findArrayDeserializer

          JsonDeserializer<?> findArrayDeserializer(ArrayType type,
                                                  DeserializationConfig config,
                                                  BeanDescription beanDesc,
                                                  TypeDeserializer elementTypeDeserializer,
                                                  JsonDeserializer<?> elementDeserializer)
                                                    throws JsonMappingException

      Method called to locate serializer for specified array type.

      Deserializer for element type may be passed, if configured explicitly at higher level (by annotations, typically), but usually are not. Type deserializer for element is passed if one is needed based on contextual information (annotations on declared element class; or on field or method type is associated with).

      Parameters:
        `type` - Type of array instances to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
        `elementTypeDeserializer` - If element type needs polymorphic type handling, this is the type information deserializer to use; should usually be used as is when constructing array deserializer.
        `elementDeserializer` - Deserializer to use for elements, if explicitly defined (by using annotations, for exmple). May be null, in which case it should be resolved here (or using `ResolvableDeserializer` callback)
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findCollectionDeserializer

          JsonDeserializer<?> findCollectionDeserializer(CollectionType type,
                                                       DeserializationConfig config,
                                                       BeanDescription beanDesc,
                                                       TypeDeserializer elementTypeDeserializer,
                                                       JsonDeserializer<?> elementDeserializer)
                                                         throws JsonMappingException

      Method called to locate serializer for specified `Collection` (List, Set etc) type.

      Deserializer for element type may be passed, if configured explicitly at higher level (by annotations, typically), but usually are not. Type deserializer for element is passed if one is needed based on contextual information (annotations on declared element class; or on field or method type is associated with).

      Parameters:
        `type` - Type of collection instances to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
        `elementTypeDeserializer` - If element type needs polymorphic type handling, this is the type information deserializer to use; should usually be used as is when constructing array deserializer.
        `elementDeserializer` - Deserializer to use for elements, if explicitly defined (by using annotations, for exmple). May be null, in which case it should be resolved here (or using `ResolvableDeserializer` callback)
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findCollectionLikeDeserializer

          JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type,
                                                           DeserializationConfig config,
                                                           BeanDescription beanDesc,
                                                           TypeDeserializer elementTypeDeserializer,
                                                           JsonDeserializer<?> elementDeserializer)
                                                             throws JsonMappingException

      Method called to locate serializer for specified "Collection-like" type (one that acts like `Collection` but does not implement it).

      Deserializer for element type may be passed, if configured explicitly at higher level (by annotations, typically), but usually are not. Type deserializer for element is passed if one is needed based on contextual information (annotations on declared element class; or on field or method type is associated with).

      Parameters:
        `type` - Type of instances to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
        `elementTypeDeserializer` - If element type needs polymorphic type handling, this is the type information deserializer to use; should usually be used as is when constructing array deserializer.
        `elementDeserializer` - Deserializer to use for elements, if explicitly defined (by using annotations, for exmple). May be null, in which case it should be resolved here (or using `ResolvableDeserializer` callback)
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findMapDeserializer

          JsonDeserializer<?> findMapDeserializer(MapType type,
                                                DeserializationConfig config,
                                                BeanDescription beanDesc,
                                                KeyDeserializer keyDeserializer,
                                                TypeDeserializer elementTypeDeserializer,
                                                JsonDeserializer<?> elementDeserializer)
                                                  throws JsonMappingException

      Method called to locate deserializer for specified `Map` type.

      Deserializer for element type may be passed, if configured explicitly at higher level (by annotations, typically), but usually are not. Type deserializer for element is passed if one is needed based on contextual information (annotations on declared element class; or on field or method type is associated with).

      Similarly, a `KeyDeserializer` may be passed, but this is only done if there is a specific configuration override (annotations) to indicate instance to use. Otherwise null is passed, and key deserializer needs to be obtained later during resolution (using `ResolvableDeserializer.resolve(com.fasterxml.jackson.databind.DeserializationContext)`).

      Parameters:
        `type` - Type of `Map` instances to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
        `keyDeserializer` - Key deserializer use, if it is defined via annotations or other configuration; null if default key deserializer for key type can be used.
        `elementTypeDeserializer` - If element type needs polymorphic type handling, this is the type information deserializer to use; should usually be used as is when constructing array deserializer.
        `elementDeserializer` - Deserializer to use for elements, if explicitly defined (by using annotations, for exmple). May be null, in which case it should be resolved here (or using `ResolvableDeserializer` callback)
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`

    - #### findMapLikeDeserializer

          JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                    DeserializationConfig config,
                                                    BeanDescription beanDesc,
                                                    KeyDeserializer keyDeserializer,
                                                    TypeDeserializer elementTypeDeserializer,
                                                    JsonDeserializer<?> elementDeserializer)
                                                      throws JsonMappingException

      Method called to locate serializer for specified "Map-like" type (one that acts like `Map` but does not implement it).

      Deserializer for element type may be passed, if configured explicitly at higher level (by annotations, typically), but usually are not. Type deserializer for element is passed if one is needed based on contextual information (annotations on declared element class; or on field or method type is associated with).

      Similarly, a `KeyDeserializer` may be passed, but this is only done if there is a specific configuration override (annotations) to indicate instance to use. Otherwise null is passed, and key deserializer needs to be obtained later during resolution (using `ResolvableDeserializer.resolve(com.fasterxml.jackson.databind.DeserializationContext)`).

      Parameters:
        `type` - Type of `Map` instances to deserialize
        `config` - Configuration in effect
        `beanDesc` - Definition of the enumeration type that contains class annotations and other information typically needed for building deserializers
        `keyDeserializer` - Key deserializer use, if it is defined via annotations or other configuration; null if default key deserializer for key type can be used.
        `elementTypeDeserializer` - If element type needs polymorphic type handling, this is the type information deserializer to use; should usually be used as is when constructing array deserializer.
        `elementDeserializer` - Deserializer to use for elements, if explicitly defined (by using annotations, for exmple). May be null, in which case it should be resolved here (or using `ResolvableDeserializer` callback)
      Returns:
        Deserializer to use for the type; or null if this provider does not know how to construct it
      Throws:
        `JsonMappingException`