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

## com.fasterxml.jackson.databind.deser
Class BeanDeserializerBase

    java.lang.Object
      com.fasterxml.jackson.databind.JsonDeserializer<T>
          com.fasterxml.jackson.databind.deser.std.StdDeserializer<Object>
              com.fasterxml.jackson.databind.deser.BeanDeserializerBase

All Implemented Interfaces:
  ContextualDeserializer, ResolvableDeserializer

Direct Known Subclasses:
  BeanDeserializer, BuilderBasedDeserializer

    public abstract class BeanDeserializerBase

extends StdDeserializer<Object>
implements ContextualDeserializer, ResolvableDeserializer

Base class for `BeanDeserializer`.

Nested Class Summary

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

Field Summary
`protected SettableAnyProperty` | `_anySetter` Fallback setter used for handling any properties that are not mapped to regular setters.
`protected Map<String,SettableBeanProperty>` | `_backRefs` We may also have one or more back reference fields (usually zero or one).
`protected BeanPropertyMap` | `_beanProperties` Mapping of property names to properties, built when all properties to use have been successfully resolved.
`protected JavaType` | `_beanType` Declared type of the bean this deserializer handles.
`protected Annotations` | `_classAnnotations` Annotations from the bean class: used for accessing annotations during resolution phase (see `resolve(com.fasterxml.jackson.databind.DeserializationContext)`).
`protected JsonDeserializer<Object>` | `_delegateDeserializer` Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.
`protected ExternalTypeHandler` | `_externalTypeIdHandler` Handler that we need iff any of properties uses external type id.
`protected HashSet<String>` | `_ignorableProps` In addition to properties that are set, we will also keep track of recognized but ignorable properties: these will be skipped without errors or warnings.
`protected boolean` | `_ignoreAllUnknown` Flag that can be set to ignore and skip unknown properties.
`protected ValueInjector[]` | `_injectables` List of `ValueInjector`s, if any injectable values are expected by the bean; otherwise null.
`protected boolean` | `_needViewProcesing` Flag that indicates that some aspect of deserialization depends on active view used (if any)
`protected boolean` | `_nonStandardCreation` Flag that is set to mark "non-standard" cases; where either we use one of non-default creators, or there are unwrapped values to consider.
`protected ObjectIdReader` | `_objectIdReader` If an Object Id is to be used for value handled by this deserializer, this reader is used for handling.
`protected PropertyBasedCreator` | `_propertyBasedCreator` If the bean needs to be instantiated using constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation.
`protected HashMap<ClassKey,JsonDeserializer<Object>>` | `_subDeserializers` Lazily constructed map used to contain deserializers needed for polymorphic subtypes.
`protected UnwrappedPropertyHandler` | `_unwrappedPropertyHandler` If one of properties has "unwrapped" value, we need separate helper object
`protected ValueInstantiator` | `_valueInstantiator` Object that handles details of constructing initial bean value (to which bind data to), unless instance is passed (via updateValue())
`protected boolean` | `_vanillaProcessing` Flag that indicates that no "special features" whatsoever are enabled, so the simplest processing is possible.

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

Constructor Summary
`protected` | `BeanDeserializerBase(BeanDeserializerBase src)`
`protected` | `BeanDeserializerBase(BeanDeserializerBase src, boolean ignoreAllUnknown)`
`` | `BeanDeserializerBase(BeanDeserializerBase src, HashSet<String> ignorableProps)`
`protected` | `BeanDeserializerBase(BeanDeserializerBase src, NameTransformer unwrapper)`
`` | `BeanDeserializerBase(BeanDeserializerBase src, ObjectIdReader oir)`
`protected` | `BeanDeserializerBase(BeanDeserializerBuilder builder, BeanDescription beanDesc, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, boolean hasViews)` Constructor used when initially building a deserializer instance, given a `BeanDeserializerBuilder` that contains configuration.

Method Summary
`protected JsonDeserializer<Object>` | `_findSubclassDeserializer(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens)` Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
`protected SettableBeanProperty` | `_resolveInnerClassValuedProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...
`protected SettableBeanProperty` | `_resolveManagedReferenceProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method called to see if given property is part of 'managed' property pair (managed + back reference), and if so, handle resolution details.
`protected SettableBeanProperty` | `_resolveUnwrappedProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method called to see if given property might be so-called unwrapped property: these require special handling.
`JsonDeserializer<?>` | `createContextual(DeserializationContext ctxt, BeanProperty property)` Although most of post-processing is done in resolve(), we only get access to referring property's annotations here; and this is needed to support per-property ObjectIds.
`Iterator<SettableBeanProperty>` | `creatorProperties()` Accessor for finding properties that represents values to pass through property-based creator method (constructor or factory method)
`protected Object` | `deserializeFromObjectId(com.fasterxml.jackson.core.JsonParser jp, DeserializationContext ctxt)` Method called in cases where it looks like we got an Object Id to parse and use as a reference.
`Object` | `deserializeWithType(com.fasterxml.jackson.core.JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
`SettableBeanProperty` | `findBackReference(String logicalName)` Method needed by `BeanDeserializerFactory` to properly link managed- and back-reference pairs.
`SettableBeanProperty` | `findProperty(String propertyName)` Accessor for finding the property with given name, if POJO has one.
`Class<?>` | `getBeanClass()`
`Collection<Object>` | `getKnownPropertyNames()` Method that will either return null to indicate that type being deserializers has no concept of properties; or a collection of identifiers for which `toString` will give external property name.
`ObjectIdReader` | `getObjectIdReader()` Overridden to return true for those instances that are handling value for which Object Identity handling is enabled (either via value type or referring property).
`int` | `getPropertyCount()` Accessor for checking number of deserialized properties.
`ValueInstantiator` | `getValueInstantiator()`
`JavaType` | `getValueType()` Exact structured type deserializer handles, if known.
`protected Object` | `handleUnknownProperties(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens)` Method called to handle set of one or more unknown properties, stored in their entirety in given `TokenBuffer` (as field entries, name and value).
`protected void` | `handleUnknownProperty(com.fasterxml.jackson.core.JsonParser jp, DeserializationContext ctxt, Object beanOrClass, String propName)` Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus can not be assigned.
`boolean` | `hasProperty(String propertyName)`
`boolean` | `hasViews()`
`protected void` | `injectValues(DeserializationContext ctxt, Object bean)`
`boolean` | `isCachable()` Method called to see if deserializer instance is cachable and usable for other properties of same type (type for which instance was created).
`Iterator<SettableBeanProperty>` | `properties()` Accessor for iterating over properties this deserializer uses; with the exception that properties passed via Creator methods (specifically, "property-based constructor") are not included, but can be accessed separate by calling `creatorProperties()`
`void` | `resolve(DeserializationContext ctxt)` Method called to finalize setup of this deserializer, after deserializer itself has been registered.
`abstract JsonDeserializer<Object>` | `unwrappingDeserializer(NameTransformer unwrapper)` Method that will return deserializer instance that is able to handle "unwrapped" value instances If no unwrapped instance can be constructed, will simply return this object as-is.
`abstract BeanDeserializerBase` | `withIgnorableProperties(HashSet<String> ignorableProps)`
`abstract BeanDeserializerBase` | `withObjectIdReader(ObjectIdReader oir)`
`void` | `wrapAndThrow(Throwable t, Object bean, int index, DeserializationContext ctxt)`
`void` | `wrapAndThrow(Throwable t, Object bean, String fieldName, DeserializationContext ctxt)` Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of `IOException`, or an unchecked exception.
`protected void` | `wrapInstantiationProblem(Throwable t, DeserializationContext ctxt)`

Methods inherited from class com.fasterxml.jackson.databind.deser.std.StdDeserializer
`_parseBoolean, _parseBooleanFromNumber, _parseBooleanPrimitive, _parseByte, _parseDate, _parseDouble, _parseDoublePrimitive, _parseFloat, _parseFloatPrimitive, _parseInteger, _parseIntPrimitive, _parseLong, _parseLongPrimitive, _parseShort, _parseShortPrimitive, findDeserializer, getValueClass, isDefaultDeserializer, isDefaultKeyDeserializer, parseDouble`

Methods inherited from class com.fasterxml.jackson.databind.JsonDeserializer
`deserialize, deserialize, getEmptyValue, getNullValue`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### _classAnnotations

    protected final Annotations _classAnnotations

  Annotations from the bean class: used for accessing annotations during resolution phase (see `resolve(com.fasterxml.jackson.databind.DeserializationContext)`).

### _beanType

    protected final JavaType _beanType

  Declared type of the bean this deserializer handles.

### _valueInstantiator

    protected final ValueInstantiator _valueInstantiator

  Object that handles details of constructing initial bean value (to which bind data to), unless instance is passed (via updateValue())

### _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 bean needs to be instantiated using constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation. This value gets resolved during general resolution.

### _nonStandardCreation

    protected boolean _nonStandardCreation

  Flag that is set to mark "non-standard" cases; where either we use one of non-default creators, or there are unwrapped values to consider.

### _vanillaProcessing

    protected boolean _vanillaProcessing

  Flag that indicates that no "special features" whatsoever are enabled, so the simplest processing is possible.

### _beanProperties

    protected final BeanPropertyMap _beanProperties

  Mapping of property names to properties, built when all properties to use have been successfully resolved.

### _injectables

    protected final ValueInjector[] _injectables

  List of `ValueInjector`s, if any injectable values are expected by the bean; otherwise null. This includes injectors used for injecting values via setters and fields, but not ones passed through constructor parameters.

### _anySetter

    protected SettableAnyProperty _anySetter

  Fallback setter used for handling any properties that are not mapped to regular setters. If setter is not null, it will be called once for each such property.

### _ignorableProps

    protected final HashSet<String> _ignorableProps

  In addition to properties that are set, we will also keep track of recognized but ignorable properties: these will be skipped without errors or warnings.

### _ignoreAllUnknown

    protected final boolean _ignoreAllUnknown

  Flag that can be set to ignore and skip unknown properties. If set, will not throw an exception for unknown properties.

### _needViewProcesing

    protected final boolean _needViewProcesing

  Flag that indicates that some aspect of deserialization depends on active view used (if any)

### _backRefs

    protected final Map<String,SettableBeanProperty> _backRefs

  We may also have one or more back reference fields (usually zero or one).

### _subDeserializers

    protected HashMap<ClassKey,JsonDeserializer<Object>> _subDeserializers

  Lazily constructed map used to contain deserializers needed for polymorphic subtypes. Note that this is only needed for polymorphic types, that is, when the actual type is not statically known. For other types this remains null.

### _unwrappedPropertyHandler

    protected UnwrappedPropertyHandler _unwrappedPropertyHandler

  If one of properties has "unwrapped" value, we need separate helper object

### _externalTypeIdHandler

    protected ExternalTypeHandler _externalTypeIdHandler

  Handler that we need iff any of properties uses external type id.

### _objectIdReader

    protected final ObjectIdReader _objectIdReader

  If an Object Id is to be used for value handled by this deserializer, this reader is used for handling.

Constructor Detail

### BeanDeserializerBase

    protected BeanDeserializerBase(BeanDeserializerBuilder builder,
                                   BeanDescription beanDesc,
                                   BeanPropertyMap properties,
                                   Map<String,SettableBeanProperty> backRefs,
                                   HashSet<String> ignorableProps,
                                   boolean ignoreAllUnknown,
                                   boolean hasViews)

  Constructor used when initially building a deserializer instance, given a `BeanDeserializerBuilder` that contains configuration.

### BeanDeserializerBase

    protected BeanDeserializerBase(BeanDeserializerBase src)

### BeanDeserializerBase

    protected BeanDeserializerBase(BeanDeserializerBase src,
                                   boolean ignoreAllUnknown)

### BeanDeserializerBase

    protected BeanDeserializerBase(BeanDeserializerBase src,
                                   NameTransformer unwrapper)

### BeanDeserializerBase

    public BeanDeserializerBase(BeanDeserializerBase src,
                                ObjectIdReader oir)

### BeanDeserializerBase

    public BeanDeserializerBase(BeanDeserializerBase src,
                                HashSet<String> ignorableProps)

Method Detail

### unwrappingDeserializer

    public abstract JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)

  Description copied from class: `JsonDeserializer`
  Method that will return deserializer instance that is able to handle "unwrapped" value instances If no unwrapped instance can be constructed, will simply return this object as-is.

  Default implementation just returns 'this' indicating that no unwrapped variant exists

  Overrides:
    `unwrappingDeserializer` in class `JsonDeserializer<Object>`

### withObjectIdReader

    public abstract BeanDeserializerBase withObjectIdReader(ObjectIdReader oir)

### withIgnorableProperties

    public abstract BeanDeserializerBase withIgnorableProperties(HashSet<String> ignorableProps)

### resolve

    public void resolve(DeserializationContext ctxt)
                 throws JsonMappingException

  Method called to finalize setup of this deserializer, after deserializer itself has been registered. This is needed to handle recursive and transitive dependencies.

  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

  Although most of post-processing is done in resolve(), we only get access to referring property's annotations here; and this is needed to support per-property ObjectIds.

  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 can not 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`

### _resolveManagedReferenceProperty

    protected SettableBeanProperty _resolveManagedReferenceProperty(DeserializationContext ctxt,
                                                                    SettableBeanProperty prop)

  Helper method called to see if given property is part of 'managed' property pair (managed + back reference), and if so, handle resolution details.

### _resolveUnwrappedProperty

    protected SettableBeanProperty _resolveUnwrappedProperty(DeserializationContext ctxt,
                                                             SettableBeanProperty prop)

  Helper method called to see if given property might be so-called unwrapped property: these require special handling.

### _resolveInnerClassValuedProperty

    protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext ctxt,
                                                                    SettableBeanProperty prop)

  Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...

### isCachable

    public boolean isCachable()

  Description copied from class: `JsonDeserializer`
  Method called to see if deserializer instance is cachable and usable for other properties of same type (type for which instance was created).

  Note that cached instances are still resolved on per-property basis, if instance implements `ResolvableDeserializer`: cached instance is just as the base. This means that in most cases it is safe to cache instances; however, it only makes sense to cache instances if instantiation is expensive, or if instances are heavy-weight.

  Default implementation returns false, to indicate that no caching is done.

  Overrides:
    `isCachable` in class `JsonDeserializer<Object>`

### getObjectIdReader

    public ObjectIdReader getObjectIdReader()

  Overridden to return true for those instances that are handling value for which Object Identity handling is enabled (either via value type or referring property).

  Overrides:
    `getObjectIdReader` in class `JsonDeserializer<Object>`
  Returns:
    ObjectIdReader used for resolving possible Object Identifier value, instead of full value serialization, if deserializer can do that; null if no Object Id is expected.

### hasProperty

    public boolean hasProperty(String propertyName)

### hasViews

    public boolean hasViews()

### getPropertyCount

    public int getPropertyCount()

  Accessor for checking number of deserialized properties.

### getKnownPropertyNames

    public Collection<Object> getKnownPropertyNames()

  Description copied from class: `JsonDeserializer`
  Method that will either return null to indicate that type being deserializers has no concept of properties; or a collection of identifiers for which `toString` will give external property name. This is only to be used for error reporting and diagnostics purposes (most commonly, to accompany "unknown property" exception).

  Overrides:
    `getKnownPropertyNames` in class `JsonDeserializer<Object>`

### getBeanClass

    public final Class<?> getBeanClass()

### getValueType

    public JavaType getValueType()

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

  Default implementation just returns null.

  Overrides:
    `getValueType` in class `StdDeserializer<Object>`

### properties

    public Iterator<SettableBeanProperty> properties()

  Accessor for iterating over properties this deserializer uses; with the exception that properties passed via Creator methods (specifically, "property-based constructor") are not included, but can be accessed separate by calling `creatorProperties()`

### creatorProperties

    public Iterator<SettableBeanProperty> creatorProperties()

  Accessor for finding properties that represents values to pass through property-based creator method (constructor or factory method)

  Since:
    2.0

### findProperty

    public SettableBeanProperty findProperty(String propertyName)

  Accessor for finding the property with given name, if POJO has one. Name used is the external name, i.e. name used in external data representation (JSON).

  Since:
    2.0

### findBackReference

    public SettableBeanProperty findBackReference(String logicalName)

  Method needed by `BeanDeserializerFactory` to properly link managed- and back-reference pairs.

### getValueInstantiator

    public ValueInstantiator getValueInstantiator()

### deserializeWithType

    public final Object deserializeWithType(com.fasterxml.jackson.core.JsonParser jp,
                                            DeserializationContext ctxt,
                                            TypeDeserializer typeDeserializer)
                                     throws IOException,
                                            com.fasterxml.jackson.core.JsonProcessingException

  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<Object>`
    `typeDeserializer` - Deserializer to use for handling type information
  Throws:
    `IOException`
    `com.fasterxml.jackson.core.JsonProcessingException`

### deserializeFromObjectId

    protected Object deserializeFromObjectId(com.fasterxml.jackson.core.JsonParser jp,
                                             DeserializationContext ctxt)
                                      throws IOException,
                                             com.fasterxml.jackson.core.JsonProcessingException

  Method called in cases where it looks like we got an Object Id to parse and use as a reference.

  Throws:
    `IOException`
    `com.fasterxml.jackson.core.JsonProcessingException`

### injectValues

    protected void injectValues(DeserializationContext ctxt,
                                Object bean)
                         throws IOException,
                                com.fasterxml.jackson.core.JsonProcessingException

  Throws:
    `IOException`
    `com.fasterxml.jackson.core.JsonProcessingException`

### handleUnknownProperty

    protected void handleUnknownProperty(com.fasterxml.jackson.core.JsonParser jp,
                                         DeserializationContext ctxt,
                                         Object beanOrClass,
                                         String propName)
                                  throws IOException,
                                         com.fasterxml.jackson.core.JsonProcessingException

  Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus can not be assigned.

  Overrides:
    `handleUnknownProperty` in class `StdDeserializer<Object>`
  Parameters:
    `jp` - Parser that points to value of the unknown property
    `ctxt` - Context for deserialization; allows access to the parser, error reporting functionality
    `beanOrClass` - Instance that is being populated by this deserializer, or if not known, Class that would be instantiated. If null, will assume type is what `StdDeserializer.getValueClass()` returns.
    `propName` - Name of the property that can not be mapped
  Throws:
    `IOException`
    `com.fasterxml.jackson.core.JsonProcessingException`

### handleUnknownProperties

    protected Object handleUnknownProperties(DeserializationContext ctxt,
                                             Object bean,
                                             TokenBuffer unknownTokens)
                                      throws IOException,
                                             com.fasterxml.jackson.core.JsonProcessingException

  Method called to handle set of one or more unknown properties, stored in their entirety in given `TokenBuffer` (as field entries, name and value).

  Throws:
    `IOException`
    `com.fasterxml.jackson.core.JsonProcessingException`

### _findSubclassDeserializer

    protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt,
                                                                 Object bean,
                                                                 TokenBuffer unknownTokens)
                                                          throws IOException,
                                                                 com.fasterxml.jackson.core.JsonProcessingException

  Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.

  Throws:
    `IOException`
    `com.fasterxml.jackson.core.JsonProcessingException`

### wrapAndThrow

    public void wrapAndThrow(Throwable t,
                             Object bean,
                             String fieldName,
                             DeserializationContext ctxt)
                      throws IOException

  Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of `IOException`, or an unchecked exception.

  Rules for wrapping and unwrapping are bit complicated; essentially:

  - Errors are to be passed as is (if uncovered via unwrapping)
  - "Plain" IOExceptions (ones that are not of type `JsonMappingException` are to be passed as is

  Throws:
    `IOException`

### wrapAndThrow

    public void wrapAndThrow(Throwable t,
                             Object bean,
                             int index,
                             DeserializationContext ctxt)
                      throws IOException

  Throws:
    `IOException`

### wrapInstantiationProblem

    protected void wrapInstantiationProblem(Throwable t,
                                            DeserializationContext ctxt)
                                     throws IOException

  Throws:
    `IOException`

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

Copyright © 2012 fasterxml.com. All Rights Reserved.