com.fasterxml.jackson.databind.deser.std

## Class MapDeserializer

- java.lang.Object
- - com.fasterxml.jackson.databind.JsonDeserializer<T>
  - - com.fasterxml.jackson.databind.deser.std.StdDeserializer<T>
    - - com.fasterxml.jackson.databind.deser.std.ContainerDeserializerBase<Map<Object,Object>>
      - - com.fasterxml.jackson.databind.deser.std.MapDeserializer

All Implemented Interfaces:
  ContextualDeserializer, NullValueProvider, ResolvableDeserializer, ValueInstantiator.Gettable, Serializable

    public class MapDeserializer
    extends ContainerDeserializerBase<Map<Object,Object>>
    implements ContextualDeserializer, ResolvableDeserializer

Basic serializer that can take JSON "Object" structure and construct a `Map` instance, with typed contents.

Note: for untyped content (one indicated by passing Object.class as the type), `UntypedObjectDeserializer` is used instead. It can also construct `Map`s, but not with specific POJO types, only other containers and primitives/wrappers.

See Also:
  Serialized Form

### Nested Class Summary

### Nested classes/interfaces inherited from class com.fasterxml.jackson.databind.JsonDeserializer

`JsonDeserializer.None`

### Field Summary

Fields
`protected JsonDeserializer<Object>` `_delegateDeserializer` Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.
`protected boolean` `_hasDefaultCreator`
`protected Set<String>` `_ignorableProperties`
`protected KeyDeserializer` `_keyDeserializer` Key deserializer to use; either passed via constructor (when indicated by annotations), or resolved when `resolve(com.fasterxml.jackson.databind.DeserializationContext)` is called;
`protected PropertyBasedCreator` `_propertyBasedCreator` If the Map is to be instantiated using non-default constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation.
`protected boolean` `_standardStringKey` Flag set to indicate that the key type is `String` (or `Object`, for which String is acceptable), and that the default Jackson key deserializer would be used.
`protected JsonDeserializer<Object>` `_valueDeserializer` Value deserializer.
`protected ValueInstantiator` `_valueInstantiator`
`protected TypeDeserializer` `_valueTypeDeserializer` If value instances have polymorphic type information, this is the type deserializer that can handle it

### Fields inherited from class com.fasterxml.jackson.databind.deser.std.ContainerDeserializerBase

`_containerType, _nullProvider, _skipNullValues, _unwrapSingle`

### Fields inherited from class com.fasterxml.jackson.databind.deser.std.StdDeserializer

`_valueClass, _valueType, F_MASK_ACCEPT_ARRAYS, F_MASK_INT_COERCIONS`

### Constructor Summary

Constructors
`` `MapDeserializer(JavaType mapType, ValueInstantiator valueInstantiator, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser)`
`protected` `MapDeserializer(MapDeserializer src)` Copy-constructor that can be used by sub-classes to allow copy-on-write styling copying of settings of an existing instance.
`protected` `MapDeserializer(MapDeserializer src, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, NullValueProvider nuller, Set<String> ignorable)`

### Method Summary

All Methods Instance Methods Concrete Methods
`Map<Object,Object>` `_deserializeUsingCreator(JsonParser p, DeserializationContext ctxt)`
`protected boolean` `_isStdKeyDeser(JavaType mapType, KeyDeserializer keyDeser)` Helper method used to check whether we can just use the default key deserialization, where JSON String becomes Java String.
`protected void` `_readAndBind(JsonParser p, DeserializationContext ctxt, Map<Object,Object> result)`
`protected void` `_readAndBindStringKeyMap(JsonParser p, DeserializationContext ctxt, Map<Object,Object> result)` Optimized method used when keys can be deserialized as plain old `String`s, and there is no custom deserialized specified.
`protected void` `_readAndUpdate(JsonParser p, DeserializationContext ctxt, Map<Object,Object> result)`
`protected void` `_readAndUpdateStringKeyMap(JsonParser p, DeserializationContext ctxt, Map<Object,Object> result)` Optimized method used when keys can be deserialized as plain old `String`s, and there is no custom deserializer specified.
`JsonDeserializer<?>` `createContextual(DeserializationContext ctxt, BeanProperty property)` Method called to finalize setup of this deserializer, when it is known for which property deserializer is needed for.
`Map<Object,Object>` `deserialize(JsonParser p, DeserializationContext ctxt)` Method that can be called to ask implementation to deserialize JSON content into the value type this serializer handles.
`Map<Object,Object>` `deserialize(JsonParser p, DeserializationContext ctxt, Map<Object,Object> result)` Alternate deserialization method (compared to the most commonly used, `JsonDeserializer.deserialize(JsonParser, DeserializationContext)`), which takes in initialized value instance, to be configured and/or populated by deserializer.
`Object` `deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
`JsonDeserializer<Object>` `getContentDeserializer()` Accesor for deserializer use for deserializing content values.
`Class<?>` `getMapClass()`
`ValueInstantiator` `getValueInstantiator()`
`JavaType` `getValueType()` Exact structured type this deserializer handles, if known.
`boolean` `isCachable()` Turns out that these are expensive enough to create so that caching does make sense.
`void` `resolve(DeserializationContext ctxt)` Method called after deserializer instance has been constructed (and registered as necessary by provider objects), but before it has returned it to the caller.
`void` `setIgnorableProperties(Set<String> ignorable)`
`void` `setIgnorableProperties(String[] ignorable)`
`protected MapDeserializer` `withResolved(KeyDeserializer keyDeser, TypeDeserializer valueTypeDeser, JsonDeserializer<?> valueDeser, NullValueProvider nuller, Set<String> ignorable)` Fluent factory method used to create a copy with slightly different settings.

### Methods inherited from class com.fasterxml.jackson.databind.deser.std.ContainerDeserializerBase

`findBackReference, getContentType, getEmptyAccessPattern, getEmptyValue, supportsUpdate, wrapAndThrow`

### Methods inherited from class com.fasterxml.jackson.databind.deser.std.StdDeserializer

`_byteOverflow, _coercedTypeDesc, _coerceEmptyString, _coerceIntegral, _coerceNullToken, _coerceTextualNull, _deserializeFromArray, _deserializeFromEmpty, _deserializeWrappedValue, _failDoubleToIntCoercion, _findNullProvider, _hasTextualNull, _intOverflow, _isEmptyOrTextualNull, _isIntNumber, _isNaN, _isNegInf, _isPosInf, _neitherNull, _nonNullNumber, _parseBooleanFromInt, _parseBooleanPrimitive, _parseBooleanPrimitive, _parseBytePrimitive, _parseDate, _parseDate, _parseDateFromArray, _parseDoublePrimitive, _parseDoublePrimitive, _parseFloatPrimitive, _parseFloatPrimitive, _parseIntPrimitive, _parseIntPrimitive, _parseLongPrimitive, _parseLongPrimitive, _parseShortPrimitive, _parseString, _reportFailedNullCoerce, _shortOverflow, _verifyEndArrayForSingle, _verifyNullForPrimitive, _verifyNullForPrimitiveCoercion, _verifyNullForScalarCoercion, _verifyNumberForScalarCoercion, _verifyStringForScalarCoercion, findContentNullProvider, findContentNullStyle, findConvertingContentDeserializer, findDeserializer, findFormatFeature, findFormatOverrides, findValueNullProvider, getValueClass, getValueType, handledType, handleMissingEndArrayForSingle, handleUnknownProperty, isDefaultDeserializer, isDefaultKeyDeserializer, parseDouble`

### Methods inherited from class com.fasterxml.jackson.databind.JsonDeserializer

`deserializeWithType, getDelegatee, getEmptyValue, getKnownPropertyNames, getNullAccessPattern, getNullValue, getNullValue, getObjectIdReader, replaceDelegatee, unwrappingDeserializer`

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

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

### Field Detail

#### _keyDeserializer

    protected final KeyDeserializer _keyDeserializer

Key deserializer to use; either passed via constructor (when indicated by annotations), or resolved when `resolve(com.fasterxml.jackson.databind.DeserializationContext)` is called;

#### _standardStringKey

    protected boolean _standardStringKey

Flag set to indicate that the key type is `String` (or `Object`, for which String is acceptable), and that the default Jackson key deserializer would be used. If both are true, can optimize handling.

#### _valueDeserializer

    protected final JsonDeserializer<Object> _valueDeserializer

Value deserializer.

#### _valueTypeDeserializer

    protected final TypeDeserializer _valueTypeDeserializer

If value instances have polymorphic type information, this is the type deserializer that can handle it

#### _valueInstantiator

    protected final ValueInstantiator _valueInstantiator

#### _delegateDeserializer

    protected JsonDeserializer<Object> _delegateDeserializer

Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.

#### _propertyBasedCreator

    protected PropertyBasedCreator _propertyBasedCreator

If the Map is to be instantiated using non-default constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation.

#### _hasDefaultCreator

    protected final boolean _hasDefaultCreator

#### _ignorableProperties

    protected Set<String> _ignorableProperties

### Constructor Detail

#### MapDeserializer

    public MapDeserializer(JavaType mapType,
                           ValueInstantiator valueInstantiator,
                           KeyDeserializer keyDeser,
                           JsonDeserializer<Object> valueDeser,
                           TypeDeserializer valueTypeDeser)

#### MapDeserializer

    protected MapDeserializer(MapDeserializer src)

Copy-constructor that can be used by sub-classes to allow copy-on-write styling copying of settings of an existing instance.

#### MapDeserializer

    protected MapDeserializer(MapDeserializer src,
                              KeyDeserializer keyDeser,
                              JsonDeserializer<Object> valueDeser,
                              TypeDeserializer valueTypeDeser,
                              NullValueProvider nuller,
                              Set<String> ignorable)

### Method Detail

#### withResolved

    protected MapDeserializer withResolved(KeyDeserializer keyDeser,
                                           TypeDeserializer valueTypeDeser,
                                           JsonDeserializer<?> valueDeser,
                                           NullValueProvider nuller,
                                           Set<String> ignorable)

Fluent factory method used to create a copy with slightly different settings. When sub-classing, MUST be overridden.

#### _isStdKeyDeser

    protected final boolean _isStdKeyDeser(JavaType mapType,
                                           KeyDeserializer keyDeser)

Helper method used to check whether we can just use the default key deserialization, where JSON String becomes Java String.

#### setIgnorableProperties

    public void setIgnorableProperties(String[] ignorable)

#### setIgnorableProperties

    public void setIgnorableProperties(Set<String> ignorable)

#### resolve

    public void resolve(DeserializationContext ctxt)
                 throws JsonMappingException

Description copied from interface: `ResolvableDeserializer`
Method called after deserializer instance has been constructed (and registered as necessary by provider objects), but before it has returned it to the caller. Called object can then resolve its dependencies to other types, including self-references (direct or indirect).

Specified by:
  `resolve` in interface `ResolvableDeserializer`
Parameters:
  `ctxt` - Context to use for accessing configuration, resolving secondary deserializers
Throws:
  `JsonMappingException`

#### createContextual

    public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
                                                BeanProperty property)
                                         throws JsonMappingException

Method called to finalize setup of this deserializer, when it is known for which property deserializer is needed for.

Specified by:
  `createContextual` in interface `ContextualDeserializer`
Parameters:
  `ctxt` - Deserialization context to access configuration, additional deserializers that may be needed by this deserializer
  `property` - Method, field or constructor parameter that represents the property (and is used to assign deserialized value). Should be available; but there may be cases where caller cannot provide it and null is passed instead (in which case impls usually pass 'this' deserializer as is)
Returns:
  Deserializer to use for deserializing values of specified property; may be this instance or a new instance.
Throws:
  `JsonMappingException`

#### getContentDeserializer

    public JsonDeserializer<Object> getContentDeserializer()

Description copied from class: `ContainerDeserializerBase`
Accesor for deserializer use for deserializing content values.

Specified by:
  `getContentDeserializer` in class `ContainerDeserializerBase<Map<Object,Object>>`

#### getValueInstantiator

    public ValueInstantiator getValueInstantiator()

Specified by:
  `getValueInstantiator` in interface `ValueInstantiator.Gettable`
Overrides:
  `getValueInstantiator` in class `ContainerDeserializerBase<Map<Object,Object>>`

#### isCachable

    public boolean isCachable()

Turns out that these are expensive enough to create so that caching does make sense.

IMPORTANT: but, note, that instances CAN NOT BE CACHED if there is a value type deserializer; this caused an issue with 2.4.4 of JAXB Annotations (failing a test). It is also possible that some other settings could make deserializers un-cacheable; but on the other hand, caching can make a big positive difference with performance... so it's a hard choice.

Overrides:
  `isCachable` in class `JsonDeserializer<Map<Object,Object>>`
Since:
  2.4.4

#### deserialize

    public Map<Object,Object> deserialize(JsonParser p,
                                          DeserializationContext ctxt)
                                   throws IOException

Description copied from class: `JsonDeserializer`
Method that can be called to ask implementation to deserialize JSON content into the value type this serializer handles. Returned instance is to be constructed by method itself.

Pre-condition for this method is that the parser points to the first event that is part of value to deserializer (and which is never JSON 'null' literal, more on this below): for simple types it may be the only value; and for structured types the Object start marker or a FIELD_NAME.

The two possible input conditions for structured types result from polymorphism via fields. In the ordinary case, Jackson calls this method when it has encountered an OBJECT_START, and the method implementation must advance to the next token to see the first field name. If the application configures polymorphism via a field, then the object looks like the following.

          {
              "@class": "class name",
              ...
          }

Jackson consumes the two tokens (the `@class` field name and its value) in order to learn the class and select the deserializer. Thus, the stream is pointing to the FIELD_NAME for the first field after the @class. Thus, if you want your method to work correctly both with and without polymorphism, you must begin your method with:

           if (p.currentToken() == JsonToken.START_OBJECT) {
             p.nextToken();
           }

This results in the stream pointing to the field name, so that the two conditions align.

Post-condition is that the parser will point to the last event that is part of deserialized value (or in case deserialization fails, event that was not recognized or usable, which may be the same event as the one it pointed to upon call).

Note that this method is never called for JSON null literal, and thus deserializers need (and should) not check for it.

Specified by:
  `deserialize` in class `JsonDeserializer<Map<Object,Object>>`
Parameters:
  `p` - Parsed used for reading JSON content
  `ctxt` - Context that can be used to access information about this deserialization activity.
Returns:
  Deserialized value
Throws:
  `IOException`

#### deserialize

    public Map<Object,Object> deserialize(JsonParser p,
                                          DeserializationContext ctxt,
                                          Map<Object,Object> result)
                                   throws IOException

Description copied from class: `JsonDeserializer`
Alternate deserialization method (compared to the most commonly used, `JsonDeserializer.deserialize(JsonParser, DeserializationContext)`), which takes in initialized value instance, to be configured and/or populated by deserializer. Method is not necessarily used (or supported) by all types (it will not work for immutable types, for obvious reasons): most commonly it is used for Collections and Maps. It may be used both with "updating readers" (for POJOs) and when Collections and Maps use "getter as setter".

Default implementation just throws `UnsupportedOperationException`, to indicate that types that do not explicitly add support do not necessarily support update-existing-value operation (esp. immutable types)

Overrides:
  `deserialize` in class `JsonDeserializer<Map<Object,Object>>`
Throws:
  `IOException`

#### deserializeWithType

    public Object deserializeWithType(JsonParser p,
                                      DeserializationContext ctxt,
                                      TypeDeserializer typeDeserializer)
                               throws IOException

Description copied from class: `StdDeserializer`
Base implementation that does not assume specific type inclusion mechanism. Sub-classes are expected to override this method if they are to handle type information.

Overrides:
  `deserializeWithType` in class `StdDeserializer<Map<Object,Object>>`
  `typeDeserializer` - Deserializer to use for handling type information
Throws:
  `IOException`

#### getMapClass

    public final Class<?> getMapClass()

#### getValueType

    public JavaType getValueType()

Description copied from class: `StdDeserializer`
Exact structured type this deserializer handles, if known.

Overrides:
  `getValueType` in class `ContainerDeserializerBase<Map<Object,Object>>`

#### _readAndBind

    protected final void _readAndBind(JsonParser p,
                                      DeserializationContext ctxt,
                                      Map<Object,Object> result)
                               throws IOException

Throws:
  `IOException`

#### _readAndBindStringKeyMap

    protected final void _readAndBindStringKeyMap(JsonParser p,
                                                  DeserializationContext ctxt,
                                                  Map<Object,Object> result)
                                           throws IOException

Optimized method used when keys can be deserialized as plain old `String`s, and there is no custom deserialized specified.

Throws:
  `IOException`

#### _deserializeUsingCreator

    public Map<Object,Object> _deserializeUsingCreator(JsonParser p,
                                                       DeserializationContext ctxt)
                                                throws IOException

Throws:
  `IOException`

#### _readAndUpdate

    protected final void _readAndUpdate(JsonParser p,
                                        DeserializationContext ctxt,
                                        Map<Object,Object> result)
                                 throws IOException

Throws:
  `IOException`
Since:
  2.9

#### _readAndUpdateStringKeyMap

    protected final void _readAndUpdateStringKeyMap(JsonParser p,
                                                    DeserializationContext ctxt,
                                                    Map<Object,Object> result)
                                             throws IOException

Optimized method used when keys can be deserialized as plain old `String`s, and there is no custom deserializer specified.

Throws:
  `IOException`
Since:
  2.9