CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-com-fasterxml-jackson-core--jackson-databind

General data-binding functionality for Jackson: works on core streaming API

—

Pending
Overview
Eval results
Files

deserialization.mddocs/

Deserialization

Jackson's deserialization framework provides a flexible and extensible system for converting JSON to Java objects. The framework is built around JsonDeserializer implementations, DeserializationContext for processing context, and various factory and configuration classes that control the deserialization process.

JsonDeserializer

JsonDeserializer is the abstract base class for all deserializers that convert JSON to Java objects.

public abstract class JsonDeserializer<T> {
    // Core deserialization method
    public abstract T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException;
    
    // Type-aware deserialization (for polymorphic types)
    public T deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException;
    
    // Null and empty value handling
    public T getNullValue(DeserializationContext ctxt) throws JsonMappingException;
    public T getEmptyValue(DeserializationContext ctxt) throws JsonMappingException;
    public AccessPattern getNullAccessPattern();
    public AccessPattern getEmptyAccessPattern();
    
    // Missing value handling (for creator parameters)
    public Object getAbsentValue(DeserializationContext ctxt) throws JsonMappingException;
    
    // Metadata methods
    public Class<?> handledType();
    public LogicalType logicalType();
    public boolean isCachable();
    public JsonDeserializer<?> getDelegatee();
    public Collection<Object> getKnownPropertyNames();
    
    // Object identity support
    public ObjectIdReader getObjectIdReader();
    
    // Contextual deserialization
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
    
    // Resolution support
    public void resolve(DeserializationContext ctxt) throws JsonMappingException;
    
    // Replacement support
    public JsonDeserializer<?> replaceDelegatee(JsonDeserializer<?> delegatee);
    
    // Unwrapping support (for @JsonUnwrapped)
    public boolean isUnwrappingDeserializer();
    public JsonDeserializer<T> unwrappingDeserializer(NameTransformer unwrapper);
    
    // Update support (for merging/updating existing objects)
    public SettableBeanProperty findBackReference(String refName);
    public Boolean supportsUpdate(DeserializationConfig config);
    
    // Marker classes for None values
    public static abstract class None extends JsonDeserializer<Object> { }
}

DeserializationContext

DeserializationContext provides context and utility methods for deserializers during the deserialization process.

public abstract class DeserializationContext extends DatabindContext {
    // Value reading
    public abstract Object readValue(JsonParser p, JavaType valueType) throws IOException;
    public abstract Object readValue(JsonParser p, Class<?> valueType) throws IOException;
    public abstract Object readPropertyValue(JsonParser p, BeanProperty prop, JavaType valueType) throws IOException;
    public abstract Object readPropertyValue(JsonParser p, BeanProperty prop, Class<?> valueType) throws IOException;
    
    // Deserializer lookup
    public abstract JsonDeserializer<Object> findContextualValueDeserializer(JavaType type, BeanProperty prop) throws JsonMappingException;
    public abstract JsonDeserializer<Object> findKeyDeserializer(JavaType keyType, BeanProperty prop) throws JsonMappingException;
    public final JsonDeserializer<Object> findRootValueDeserializer(JavaType valueType) throws JsonMappingException;
    
    // Null value providers
    public abstract JsonDeserializer<Object> findNullValueDeserializer(BeanProperty prop) throws JsonMappingException;
    
    // Object construction
    public abstract Object leaseObjectBuffer();
    public abstract void returnObjectBuffer(Object buf);
    public abstract Object[] leaseObjectBuffer(int minSize);
    public abstract void returnObjectBuffer(Object[] buf);
    
    // Parser utilities
    public JsonParser getParser();
    public final JsonLocation getCurrentLocation();
    public final JsonToken getCurrentToken();
    public final JsonStreamContext getParsingContext();
    
    // Problem handling
    public abstract void reportWrongTokenException(JavaType targetType, JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException;
    public abstract void reportMissingContent(String msg, Object... msgArgs) throws JsonMappingException;
    public abstract Object reportInputMismatch(BeanProperty prop, String msg, Object... msgArgs) throws JsonMappingException;
    public abstract Object reportInputMismatch(Class<?> targetType, String msg, Object... msgArgs) throws JsonMappingException;
    public abstract Object reportInputMismatch(JavaType targetType, String msg, Object... msgArgs) throws JsonMappingException;
    public abstract Object reportBadCoercion(JsonDeserializer<?> src, Class<?> targetType, Object inputValue, String msg, Object... msgArgs) throws JsonMappingException;
    public abstract JsonMappingException wrongTokenException(JsonParser p, JavaType targetType, JsonToken expToken, String extra) throws JsonMappingException;
    public abstract JsonMappingException weirdStringException(String value, Class<?> instClass, String msgFormat, Object... msgArgs) throws JsonMappingException;
    public abstract JsonMappingException weirdNumberException(Number value, Class<?> instClass, String msg) throws JsonMappingException;
    public abstract JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue, String msg) throws JsonMappingException;
    public abstract JsonMappingException instantiationException(Class<?> instClass, Throwable cause) throws JsonMappingException;
    public abstract JsonMappingException instantiationException(Class<?> instClass, String msg) throws JsonMappingException;
    public abstract JsonMappingException invalidTypeIdException(JavaType baseType, String typeId, String extraDesc) throws JsonMappingException;
    public abstract JsonMappingException missingTypeIdException(JavaType baseType, String extraDesc) throws JsonMappingException;
    
    // Unknown property handling
    public abstract boolean handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser, Object instanceOrClass, String propName) throws IOException;
    
    // Ignorable types
    public abstract boolean isEnabled(DeserializationFeature feat);
    public final boolean isEnabled(MapperFeature feat);
    public final boolean isEnabled(JsonParser.Feature feat);
    
    // Configuration access
    public abstract DeserializationConfig getConfig();
    
    // View support
    public final Class<?> getActiveView();
    
    // Locale and timezone
    public final Locale getLocale();
    public final TimeZone getTimeZone();
    
    // Date format
    public final DateFormat getDateFormat();
    
    // Attributes
    public abstract Object getAttribute(Object key);
    public abstract DeserializationContext setAttribute(Object key, Object value);
    
    // Type factory
    public final TypeFactory getTypeFactory();
    
    // Object construction utilities  
    public Class<?> findClass(String className) throws ClassNotFoundException;
    
    // Coercion
    public CoercionAction findCoercionAction(LogicalType logicalType, Class<?> rawTargetType, CoercionInputShape inputShape);
    public CoercionAction findCoercionFromBlankString(LogicalType logicalType, Class<?> rawTargetType, CoercionAction actionIfBlankNotAllowed);
    
    // Array handling
    public final boolean hasSomeOfFeatures(int featureMask);
    
    // Object identity
    public abstract ReadableObjectId findObjectId(Object id, ObjectIdGenerator<?> generator, ObjectIdResolver resolver);
    public abstract void checkUnresolvedObjectId() throws UnresolvedForwardReference;
    
    // Buffer management for arrays  
    public final ObjectBuffer leaseObjectBuffer();
    public final void returnObjectBuffer(ObjectBuffer buf);
    
    // String building
    public StringBuilder constructStringBuilder();
    public String constructString();
    
    // Number parsing
    public final int extractScalarFromObject(JsonParser p, JsonDeserializer<?> deser, Class<?> scalarType) throws IOException;
}

Standard Deserializers

Jackson provides standard deserializers for common Java types.

StdDeserializer

public abstract class StdDeserializer<T> extends JsonDeserializer<T> implements Serializable {
    // Construction
    protected StdDeserializer(Class<?> vc);
    protected StdDeserializer(JavaType valueType);
    protected StdDeserializer(StdDeserializer<?> src);
    
    // Type information
    public Class<?> handledType();
    public JavaType getValueType();
    public JavaType getValueType(DeserializationContext ctxt);
    
    // Value extraction utilities
    protected final boolean _parseBooleanPrimitive(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Boolean _parseBoolean(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Boolean _parseBoolean(JsonParser p, DeserializationContext ctxt, Class<?> targetType) throws IOException;
    protected final int _parseIntPrimitive(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Integer _parseInteger(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Integer _parseInteger(JsonParser p, DeserializationContext ctxt, Class<?> targetType) throws IOException;
    protected final long _parseLongPrimitive(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Long _parseLong(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Long _parseLong(JsonParser p, DeserializationContext ctxt, Class<?> targetType) throws IOException;
    protected final float _parseFloatPrimitive(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Float _parseFloat(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final double _parseDoublePrimitive(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Double _parseDouble(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Date _parseDate(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final String _parseString(JsonParser p, DeserializationContext ctxt) throws IOException;
    
    // String coercion utilities
    protected T _deserializeFromString(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected T _deserializeFromArray(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected T _deserializeWrappedValue(JsonParser p, DeserializationContext ctxt) throws IOException;
    
    // Exception handling utilities
    protected JsonMappingException wrapAndThrow(Throwable t, Object ref, String fieldName) throws JsonMappingException;
    protected JsonMappingException wrapAndThrow(Throwable t, Object ref, int index) throws JsonMappingException;
    
    // Null handling
    protected void handleUnknownProperty(JsonParser p, DeserializationContext ctxt, Object instanceOrClass, String propName) throws IOException;
    protected void handleMissingEndArrayForSingle(JsonParser p, DeserializationContext ctxt) throws IOException;
    
    // Type checking
    protected final boolean _hasTextualNull(String value);
    protected final boolean _isEmptyOrTextualNull(String value);
    protected final boolean _isNegInf(String text);
    protected final boolean _isPosInf(String text);
    protected final boolean _isNaN(String text);
    
    // Coercion support
    protected Object _coerceEmptyString(DeserializationContext ctxt, boolean isEmpty) throws JsonMappingException;
    protected Object _coerceTextualNull(DeserializationContext ctxt, boolean isPrimitive) throws JsonMappingException;
    protected Object _coerceIntegral(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected Object _coerceTextualNull(DeserializationContext ctxt, boolean isPrimitive) throws JsonMappingException;
    
    // Logging
    protected void _reportFailedNullCoerce(DeserializationContext ctxt, boolean state, Enum<?> feature, String inputDesc) throws JsonMappingException;
}

// Scalar deserializers
public abstract class StdScalarDeserializer<T> extends StdDeserializer<T> {
    protected StdScalarDeserializer(Class<?> vc);
    protected StdScalarDeserializer(JavaType valueType);
    protected StdScalarDeserializer(StdScalarDeserializer<?> src);
    
    public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException;
    public abstract LogicalType logicalType();
}

Container Deserializers

// Collection deserializer
public class CollectionDeserializer extends ContainerDeserializerBase<Collection<Object>> implements ContextualDeserializer {
    // Construction
    public CollectionDeserializer(JavaType collectionType, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator);
    public CollectionDeserializer(JavaType collectionType, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator, JsonDeserializer<Object> delegateDeser);
    
    // Contextualization
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
    
    // Deserialization
    public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException;
    public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt, Collection<Object> result) throws IOException;
    
    // Value instantiation
    public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException;
    
    // Type information
    public JavaType getContentType();
    public JsonDeserializer<Object> getContentDeserializer();
    
    // Logical type
    public LogicalType logicalType();
    
    // Null/empty handling
    public boolean isCachable();
    
    // Support methods
    public Collection<Object> handleNonArray(JsonParser p, DeserializationContext ctxt, Collection<Object> result) throws IOException;
}

// Array deserializer  
public class ObjectArrayDeserializer extends ContainerDeserializerBase<Object[]> implements ContextualDeserializer {
    // Construction
    public ObjectArrayDeserializer(JavaType arrayType, JsonDeserializer<Object> elemDeser, TypeDeserializer elemTypeDeser);
    
    // Contextualization  
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
    
    // Deserialization
    public Object[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException;
    public Object[] deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException;
    
    // Content type
    public JavaType getContentType();
    public JsonDeserializer<Object> getContentDeserializer();
    
    // Logical type  
    public LogicalType logicalType();
}

// Map deserializer
public class MapDeserializer extends ContainerDeserializerBase<Map<Object, Object>> implements ContextualDeserializer, ResolvableDeserializer {
    // Construction
    public MapDeserializer(JavaType mapType, ValueInstantiator valueInstantiator, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser);
    
    // Contextualization
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
    
    // Resolution
    public void resolve(DeserializationContext ctxt) throws JsonMappingException;
    
    // Deserialization
    public Map<Object, Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException;
    public Map<Object, Object> deserialize(JsonParser p, DeserializationContext ctxt, Map<Object, Object> result) throws IOException;
    public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException;
    
    // Content information
    public JavaType getContentType();
    public JsonDeserializer<Object> getContentDeserializer();
    
    // Key information  
    public KeyDeserializer getKeyDeserializer();
    
    // Logical type
    public LogicalType logicalType();
    
    // Support methods
    protected void wrapAndThrow(Throwable t, Object ref, String fieldName) throws JsonMappingException;
}

Bean Deserialization

BeanDeserializer

public class BeanDeserializer extends BeanDeserializerBase implements Serializable {
    // Construction
    public BeanDeserializer(BeanDeserializerBuilder builder, BeanDescription beanDesc, BeanPropertyMap properties, Map<String, SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, Set<String> includableProps, boolean hasViews);
    protected BeanDeserializer(BeanDeserializerBase src);
    protected BeanDeserializer(BeanDeserializerBase src, boolean ignoreAllUnknown);
    protected BeanDeserializer(BeanDeserializerBase src, NameTransformer unwrapper);
    protected BeanDeserializer(BeanDeserializerBase src, ObjectIdReader oir);
    protected BeanDeserializerBase(BeanDeserializerBase src, Set<String> ignorableProps);
    protected BeanDeserializer(BeanDeserializerBase src, BeanPropertyMap props);
    
    // Deserialization
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException;
    public Object deserialize(JsonParser p, DeserializationContext ctxt, Object bean) throws IOException;
    
    // Deserialization from different structures
    protected Object _deserializeUsingPropertyBased(JsonParser p, DeserializationContext ctxt) throws IOException;
    public Object deserializeFromObject(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected Object _deserializeFromArray(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected final Object _deserializeFromString(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected Object _deserializeFromNumber(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected Object _deserializeOther(JsonParser p, DeserializationContext ctxt, JsonToken t) throws IOException;
    
    // Unwrapping support
    public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper);
    
    // Replacement
    public BeanDeserializer withObjectIdReader(ObjectIdReader oir);
    public BeanDeserializer withByNameInclusion(Set<String> ignorableProps, Set<String> includableProps);
    public BeanDeserializerBase withIgnoreAllUnknown(boolean ignoreUnknown);
    public BeanDeserializerBase withBeanProperties(BeanPropertyMap props);
    
    // Support methods
    protected Object deserializeWithView(JsonParser p, DeserializationContext ctxt, Object bean, Class<?> activeView) throws IOException;
    protected Object deserializeWithExternalTypeId(JsonParser p, DeserializationContext ctxt) throws IOException;
    protected Object deserializeWithExternalTypeId(JsonParser p, DeserializationContext ctxt, Object bean) throws IOException;
}

public abstract class BeanDeserializerBase extends StdDeserializer<Object> implements ContextualDeserializer, ResolvableDeserializer, Serializable {
    // Bean metadata
    protected final JavaType _beanType;
    protected final BeanPropertyMap _beanProperties;
    protected final ValueInstantiator _valueInstantiator;
    
    // Special properties
    protected JsonDeserializer<Object> _delegateDeserializer;
    protected JsonDeserializer<Object> _arrayDelegateDeserializer;
    protected PropertyBasedCreator _propertyBasedCreator;
    protected boolean _nonStandardCreation;
    protected boolean _vanillaProcessing;
    
    // Ignored and external properties
    protected final Set<String> _ignorableProps;
    protected final boolean _ignoreAllUnknown;
    protected final Set<String> _includableProps;
    protected SettableAnyProperty _anySetter;
    protected final Map<String, SettableBeanProperty> _backRefs;
    
    // View support
    protected final boolean _hasViews;
    
    // Object identity
    protected final ObjectIdReader _objectIdReader;
    
    // External type handling
    protected ExternalTypeHandler _externalTypeIdHandler;
    
    // Deserialization methods
    public abstract Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException;
    public abstract Object deserialize(JsonParser p, DeserializationContext ctxt, Object bean) throws IOException;
    public abstract Object deserializeFromObject(JsonParser p, DeserializationContext ctxt) throws IOException;
    
    // Metadata access
    public Class<?> getBeanClass();
    public JavaType getValueType();
    public Iterator<SettableBeanProperty> properties();
    public boolean hasProperty(String propertyName);
    public SettableBeanProperty findProperty(String propertyName);
    public SettableBeanProperty findProperty(int propertyIndex);
    
    // Replacement methods
    public abstract JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper);
    public abstract BeanDeserializerBase withObjectIdReader(ObjectIdReader oir);
    public abstract BeanDeserializerBase withIgnoreAllUnknown(boolean ignoreUnknown);
    public abstract BeanDeserializerBase withBeanProperties(BeanPropertyMap props);
    public abstract BeanDeserializerBase withByNameInclusion(Set<String> ignorableProps, Set<String> includableProps);
    
    // Contextualization and resolution
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
    public void resolve(DeserializationContext ctxt) throws JsonMappingException;
    
    // Unknown property handling
    protected void handleUnknownProperty(JsonParser p, DeserializationContext ctxt, Object beanOrClass, String propName) throws IOException;
    protected void handleUnknownVanilla(JsonParser p, DeserializationContext ctxt, Object bean, String propName) throws IOException;
    protected void handleUnknownProperties(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws IOException;
    
    // Ignored properties
    protected void handleIgnoredProperty(JsonParser p, DeserializationContext ctxt, Object beanOrClass, String propName) throws IOException;
    
    // Type information
    public LogicalType logicalType();
    public boolean isCachable();
    public Boolean supportsUpdate(DeserializationConfig config);
    
    // Back reference support
    public SettableBeanProperty findBackReference(String logicalName);
    
    // Object identity
    public ObjectIdReader getObjectIdReader();
    
    // Exception creation
    protected JsonMappingException wrapAndThrow(Throwable t, Object ref, String fieldName, DeserializationContext ctxt) throws JsonMappingException;
    protected JsonMappingException wrapAndThrow(Throwable t, Object ref, int index, DeserializationContext ctxt) throws JsonMappingException;
}

SettableBeanProperty

public abstract class SettableBeanProperty implements BeanProperty {
    // Property metadata
    protected final PropertyName _propName;
    protected final JavaType _type;
    protected final PropertyName _wrapperName;
    protected final AnnotatedMember _member;
    protected final Annotations _contextAnnotations;
    
    // Deserialization
    protected JsonDeserializer<Object> _valueDeserializer;
    protected TypeDeserializer _valueTypeDeserializer;
    protected NullValueProvider _nullProvider;
    
    // Property index for faster access
    protected final int _propertyIndex;
    protected final int _creatorIndex;
    
    // Views
    protected Class<?>[] _includeInViews;
    
    // Construction
    protected SettableBeanProperty(BeanPropertyDefinition propDef, JavaType type, TypeDeserializer typeDeser, Annotations contextAnnotations);
    protected SettableBeanProperty(PropertyName propName, JavaType type, PropertyName wrapperName, TypeDeserializer typeDeser, Annotations contextAnnotations, PropertyMetadata metadata);
    protected SettableBeanProperty(SettableBeanProperty src, JsonDeserializer<?> deser);
    protected SettableBeanProperty(SettableBeanProperty src, PropertyName newName);
    
    // Abstract methods
    public abstract void deserializeAndSet(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException;
    public abstract Object deserializeSetAndReturn(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException;
    public abstract void set(Object instance, Object value) throws IOException;
    public abstract Object setAndReturn(Object instance, Object value) throws IOException;
    
    // Replacement methods
    public abstract SettableBeanProperty withName(PropertyName newName);
    public abstract SettableBeanProperty withValueDeserializer(JsonDeserializer<?> deser);
    public abstract SettableBeanProperty withNullProvider(NullValueProvider nva);
    
    // Assignment
    public void assignIndex(int index);
    public void setViews(Class<?>[] views);
    public void fixAccess(DeserializationConfig config);
    
    // Metadata access
    public final String getName();
    public PropertyName getFullName();
    public JavaType getType();
    public PropertyName getWrapperName();
    public AnnotatedMember getMember();
    public <A extends Annotation> A getAnnotation(Class<A> acls);
    public <A extends Annotation> A getContextAnnotation(Class<A> acls);
    
    // Deserialization access
    public JsonDeserializer<Object> getValueDeserializer();
    public TypeDeserializer getValueTypeDeserializer();
    
    // View support
    public boolean visibleInView(Class<?> activeView);
    public boolean hasViews();
    
    // Property index
    public int getPropertyIndex();
    public int getCreatorIndex();
    
    // Metadata
    public PropertyMetadata getMetadata();
    public boolean isRequired();
    public boolean isInjectionOnly();
    
    // Value providers
    public NullValueProvider getNullValueProvider();
    
    // String representation
    public String toString();
}

Deserializer Factory

DeserializerFactory

public abstract class DeserializerFactory {
    // Deserializer creation
    public abstract JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException;
    public abstract JsonDeserializer<Object> createBuilderBasedDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc, Class<?> builderClass) throws JsonMappingException;
    
    // Array deserializers
    public abstract JsonDeserializer<?> createArrayDeserializer(DeserializationContext ctxt, ArrayType type, BeanDescription beanDesc) throws JsonMappingException;
    
    // Collection deserializers  
    public abstract JsonDeserializer<?> createCollectionDeserializer(DeserializationContext ctxt, CollectionType type, BeanDescription beanDesc) throws JsonMappingException;
    public abstract JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext ctxt, CollectionLikeType type, BeanDescription beanDesc) throws JsonMappingException;
    
    // Map deserializers
    public abstract JsonDeserializer<?> createMapDeserializer(DeserializationContext ctxt, MapType type, BeanDescription beanDesc) throws JsonMappingException;
    public abstract JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext ctxt, MapLikeType type, BeanDescription beanDesc) throws JsonMappingException;
    
    // Enum deserializers
    public abstract JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException;
    
    // Tree deserializer
    public abstract JsonDeserializer<?> createTreeDeserializer(DeserializationConfig config, JavaType nodeType, BeanDescription beanDesc) throws JsonMappingException;
    
    // Reference type deserializers
    public abstract JsonDeserializer<?> createReferenceDeserializer(DeserializationContext ctxt, ReferenceType type, BeanDescription beanDesc) throws JsonMappingException;
    
    // Type deserializers  
    public abstract TypeDeserializer findTypeDeserializer(DeserializationConfig config, JavaType baseType) throws JsonMappingException;
    
    // Key deserializers
    public abstract KeyDeserializer createKeyDeserializer(DeserializationContext ctxt, JavaType type) throws JsonMappingException;
    
    // Configuration
    public abstract DeserializerFactory withAdditionalDeserializers(Deserializers additional);
    public abstract DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional);
    public abstract DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier);
    public abstract DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver);
    public abstract DeserializerFactory withValueInstantiators(ValueInstantiators instantiators);
    public abstract DeserializerFactory withConfig(DeserializationConfig config);
}

public class BeanDeserializerFactory extends BasicDeserializerFactory implements Serializable {
    // Singleton instance
    public static final BeanDeserializerFactory instance;
    
    // Construction
    public BeanDeserializerFactory(DeserializerFactoryConfig config);
    
    // Factory methods
    public DeserializerFactory withConfig(DeserializationConfig config);
    public DeserializerFactory withAdditionalDeserializers(Deserializers additional);
    public DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional);
    public DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier);
    public DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver);
    public DeserializerFactory withValueInstantiators(ValueInstantiators instantiators);
    
    // Bean deserializer creation
    public JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException;
    public JsonDeserializer<Object> buildBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException;
    protected JsonDeserializer<Object> constructBeanDeserializer(DeserializationContext ctxt, BeanDescription beanDesc) throws JsonMappingException;
    
    // Builder-based deserializers
    public JsonDeserializer<Object> createBuilderBasedDeserializer(DeserializationContext ctxt, JavaType valueType, BeanDescription beanDesc, Class<?> builderClass) throws JsonMappingException;
    
    // Property handling
    protected void addBeanProps(DeserializationContext ctxt, BeanDescription beanDesc, BeanDeserializerBuilder builder) throws JsonMappingException;
    protected List<SettableBeanProperty> filterBeanProps(DeserializationContext ctxt, BeanDescription beanDesc, BeanDeserializerBuilder builder, List<BeanPropertyDefinition> propDefs, Set<String> ignored) throws JsonMappingException;
    protected SettableBeanProperty constructSettableProperty(DeserializationContext ctxt, BeanDescription beanDesc, BeanPropertyDefinition propDef, JavaType propType0) throws JsonMappingException;
    protected SettableBeanProperty constructSetterlessProperty(DeserializationContext ctxt, BeanDescription beanDesc, BeanPropertyDefinition propDef) throws JsonMappingException;
    
    // Creator handling  
    protected void addObjectIdReader(DeserializationContext ctxt, BeanDescription beanDesc, BeanDeserializerBuilder builder) throws JsonMappingException;
    protected PropertyBasedCreator _constructPropertyBasedCreator(DeserializationContext ctxt, BeanDescription beanDesc, boolean visibilityForCreators, AnnotationIntrospector intr, CreatorCollector creators) throws JsonMappingException;
}

Usage Examples

Custom Deserializers

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;

// Custom deserializer for Person class
public class PersonDeserializer extends StdDeserializer<Person> {
    
    public PersonDeserializer() {
        this(null);
    }
    
    public PersonDeserializer(Class<?> vc) {
        super(vc);
    }
    
    @Override
    public Person deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        JsonToken token = p.getCurrentToken();
        
        if (token == JsonToken.START_OBJECT) {
            String firstName = null;
            String lastName = null;
            Integer age = null;
            Date birthDate = null;
            
            while (p.nextToken() != JsonToken.END_OBJECT) {
                String fieldName = p.getCurrentName();
                p.nextToken();
                
                switch (fieldName) {
                    case "fullName":
                        // Handle "John Doe" format
                        String fullName = p.getText();
                        String[] parts = fullName.split(" ", 2);
                        firstName = parts[0];
                        lastName = parts.length > 1 ? parts[1] : "";
                        break;
                    case "firstName":
                        firstName = p.getText();
                        break;
                    case "lastName":  
                        lastName = p.getText();
                        break;
                    case "age":
                        age = p.getIntValue();
                        break;
                    case "birthDate":
                        // Custom date parsing
                        String dateStr = p.getText();
                        try {
                            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                            birthDate = sdf.parse(dateStr);
                        } catch (ParseException e) {
                            throw new JsonProcessingException("Invalid date format: " + dateStr, p.getCurrentLocation(), e);
                        }
                        break;
                    default:
                        // Skip unknown properties or handle them
                        p.skipChildren();
                        break;
                }
            }
            
            // Validation
            if (firstName == null) {
                throw new JsonMappingException(p, "firstName is required");
            }
            
            return new Person(firstName, lastName, age, birthDate);
            
        } else if (token == JsonToken.VALUE_STRING) {
            // Handle string format like "John Doe,30"
            String value = p.getText();
            String[] parts = value.split(",");
            if (parts.length >= 1) {
                String[] nameParts = parts[0].split(" ", 2);
                String firstName = nameParts[0];
                String lastName = nameParts.length > 1 ? nameParts[1] : "";
                Integer age = parts.length > 1 ? Integer.parseInt(parts[1].trim()) : null;
                return new Person(firstName, lastName, age, null);
            }
        }
        
        throw new JsonMappingException(p, "Cannot deserialize Person from " + token);
    }
    
    // Handle type information for polymorphic deserialization
    @Override
    public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {
        return typeDeserializer.deserializeTypedFromObject(p, ctxt);
    }
    
    // Provide null value
    @Override
    public Person getNullValue(DeserializationContext ctxt) {
        return new Person("Unknown", "", 0, null);
    }
}

// Register with ObjectMapper  
ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addDeserializer(Person.class, new PersonDeserializer());
mapper.registerModule(module);

// Use
String json = "{\"fullName\":\"John Doe\",\"age\":30}";
Person person = mapper.readValue(json, Person.class);

Contextual Deserializers

// Contextual deserializer that adapts based on annotations
public class ConfigurableStringDeserializer extends StdDeserializer<String> implements ContextualDeserializer {
    
    private final boolean upperCase;
    private final boolean trim;
    private final String defaultValue;
    
    public ConfigurableStringDeserializer() {
        this(false, false, null);
    }
    
    private ConfigurableStringDeserializer(boolean upperCase, boolean trim, String defaultValue) {
        super(String.class);
        this.upperCase = upperCase;
        this.trim = trim;
        this.defaultValue = defaultValue;
    }
    
    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
        if (property != null) {
            StringFormat ann = property.getAnnotation(StringFormat.class);
            if (ann != null) {
                return new ConfigurableStringDeserializer(
                    ann.upperCase(), 
                    ann.trim(), 
                    ann.defaultValue().isEmpty() ? null : ann.defaultValue()
                );
            }
        }
        return this;
    }
    
    @Override
    public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        String value = p.getValueAsString();
        
        if (value == null || value.isEmpty()) {
            return defaultValue;
        }
        
        if (trim) {
            value = value.trim();
        }
        
        if (upperCase) {
            value = value.toUpperCase();
        }
        
        return value;
    }
    
    @Override
    public String getNullValue(DeserializationContext ctxt) {
        return defaultValue;
    }
}

// Custom annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface StringFormat {
    boolean upperCase() default false;
    boolean trim() default true;
    String defaultValue() default "";
}

// Usage in POJO
public class UserData {
    @StringFormat(upperCase = true, trim = true)
    private String username;
    
    @StringFormat(trim = true, defaultValue = "Unknown")
    private String displayName;
    
    // getters/setters
}

Collection and Map Deserializers

// Custom collection deserializer
public class DelimitedStringListDeserializer extends StdDeserializer<List<String>> {
    
    private final String delimiter;
    
    public DelimitedStringListDeserializer(String delimiter) {
        super(List.class);
        this.delimiter = delimiter;
    }
    
    @Override
    public List<String> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        JsonToken token = p.getCurrentToken();
        
        if (token == JsonToken.VALUE_STRING) {
            // Parse delimited string
            String value = p.getText();
            if (value == null || value.isEmpty()) {
                return new ArrayList<>();
            }
            return Arrays.asList(value.split(Pattern.quote(delimiter)));
            
        } else if (token == JsonToken.START_ARRAY) {
            // Standard array parsing
            List<String> result = new ArrayList<>();
            while (p.nextToken() != JsonToken.END_ARRAY) {
                result.add(p.getValueAsString());
            }
            return result;
        }
        
        throw new JsonMappingException(p, "Expected string or array for delimited list");
    }
    
    @Override
    public List<String> getNullValue(DeserializationContext ctxt) {
        return new ArrayList<>();
    }
}

// Custom map deserializer that handles both object and array formats
public class FlexibleMapDeserializer extends StdDeserializer<Map<String, Object>> {
    
    public FlexibleMapDeserializer() {
        super(Map.class);
    }
    
    @Override
    public Map<String, Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        JsonToken token = p.getCurrentToken();
        
        if (token == JsonToken.START_OBJECT) {
            // Standard object format
            Map<String, Object> result = new LinkedHashMap<>();
            while (p.nextToken() != JsonToken.END_OBJECT) {
                String key = p.getCurrentName();
                p.nextToken();
                Object value = ctxt.readValue(p, Object.class);
                result.put(key, value);
            }
            return result;
            
        } else if (token == JsonToken.START_ARRAY) {
            // Array of key-value pairs: [["key1", "value1"], ["key2", "value2"]]
            Map<String, Object> result = new LinkedHashMap<>();
            while (p.nextToken() != JsonToken.END_ARRAY) {
                if (p.getCurrentToken() == JsonToken.START_ARRAY) {
                    p.nextToken(); // key
                    String key = p.getValueAsString();
                    p.nextToken(); // value
                    Object value = ctxt.readValue(p, Object.class);
                    p.nextToken(); // END_ARRAY
                    result.put(key, value);
                }
            }
            return result;
        }
        
        throw new JsonMappingException(p, "Expected object or array for flexible map");
    }
}

Bean Deserialization with Custom Properties

// Custom settable property for computed fields
public class ComputedSettableBeanProperty extends SettableBeanProperty {
    
    private final BiConsumer<Object, Object> setter;
    private final Function<String, Object> valueConverter;
    
    public ComputedSettableBeanProperty(BeanPropertyDefinition propDef, JavaType type,
                                      BiConsumer<Object, Object> setter,
                                      Function<String, Object> valueConverter) {
        super(propDef, type, null, null, null);
        this.setter = setter;
        this.valueConverter = valueConverter;
    }
    
    @Override
    public void deserializeAndSet(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException {
        Object value = deserialize(p, ctxt);
        if (value != null) {
            setter.accept(instance, value);
        }
    }
    
    @Override
    public Object deserializeSetAndReturn(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException {
        deserializeAndSet(p, ctxt, instance);
        return instance;
    }
    
    @Override
    public void set(Object instance, Object value) throws IOException {
        setter.accept(instance, value);
    }
    
    @Override
    public Object setAndReturn(Object instance, Object value) throws IOException {
        set(instance, value);
        return instance;
    }
    
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        String stringValue = p.getValueAsString();
        return valueConverter != null ? valueConverter.apply(stringValue) : stringValue;
    }
    
    @Override
    public SettableBeanProperty withName(PropertyName newName) {
        return this; // Immutable for simplicity
    }
    
    @Override
    public SettableBeanProperty withValueDeserializer(JsonDeserializer<?> deser) {
        return this; // Ignore for computed properties
    }
    
    @Override
    public SettableBeanProperty withNullProvider(NullValueProvider nva) {
        return this;
    }
}

// Bean deserializer modifier to add computed properties
public class ComputedPropertiesDeserializerModifier extends BeanDeserializerModifier {
    
    @Override
    public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) {
        Class<?> beanClass = beanDesc.getBeanClass();
        
        if (beanClass == Person.class) {
            // Add computed age from birthDate property
            SimpleBeanPropertyDefinition ageFromBirthDate = SimpleBeanPropertyDefinition.construct(
                config, null, new PropertyName("ageFromBirthDate"));
            
            ComputedSettableBeanProperty computedProp = new ComputedSettableBeanProperty(
                ageFromBirthDate,
                config.getTypeFactory().constructType(Integer.class),
                (person, dateStr) -> {
                    try {
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                        Date birthDate = sdf.parse((String) dateStr);
                        long ageInMillis = System.currentTimeMillis() - birthDate.getTime();
                        int years = (int) (ageInMillis / (365.25 * 24 * 60 * 60 * 1000));
                        ((Person) person).setAge(years);
                    } catch (Exception e) {
                        // Handle parsing errors
                    }
                },
                null // No conversion needed, handled in setter
            );
            
            builder.addProperty(computedProp);
        }
        
        return builder;
    }
}

Error Handling and Validation

// Deserializer with validation
public class ValidatedEmailDeserializer extends StdDeserializer<String> {
    
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");
    
    public ValidatedEmailDeserializer() {
        super(String.class);
    }
    
    @Override
    public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        String email = p.getValueAsString();
        
        if (email == null || email.isEmpty()) {
            throw new JsonMappingException(p, "Email cannot be null or empty");
        }
        
        if (!EMAIL_PATTERN.matcher(email).matches()) {
            throw new JsonMappingException(p, "Invalid email format: " + email);
        }
        
        return email.toLowerCase(); // Normalize
    }
    
    @Override
    public String getNullValue(DeserializationContext ctxt) throws JsonMappingException {
        throw new JsonMappingException(ctxt.getParser(), "Email cannot be null");
    }
}

// Problem handler for graceful error handling  
public class LoggingDeserializationProblemHandler extends DeserializationProblemHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingDeserializationProblemHandler.class);
    
    @Override
    public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser p, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException {
        logger.warn("Unknown property '{}' in {}, skipping", propertyName, beanOrClass.getClass().getSimpleName());
        p.skipChildren(); // Skip the value
        return true; // Handled
    }
    
    @Override
    public Object handleInstantiationProblem(DeserializationContext ctxt, Class<?> instClass, Object argument, Throwable t) throws IOException {
        logger.error("Failed to instantiate {}", instClass.getSimpleName(), t);
        
        // Return default instances for known types
        if (instClass == Person.class) {
            return new Person("Unknown", "", 0, null);
        }
        
        // Re-throw for unknown types  
        return NOT_HANDLED;
    }
    
    @Override
    public Object handleMissingInstantiator(DeserializationContext ctxt, Class<?> instClass, ValueInstantiator valueInst, JsonParser p, String msg) throws IOException {
        logger.warn("Missing instantiator for {}: {}", instClass.getSimpleName(), msg);
        
        // Provide default constructor logic
        try {
            return instClass.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            return NOT_HANDLED;
        }
    }
}

// Usage
ObjectMapper mapper = new ObjectMapper();
mapper.addHandler(new LoggingDeserializationProblemHandler());

// Configure to be lenient with unknown properties
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Deserialization Features Configuration

ObjectMapper mapper = new ObjectMapper();

// Configure deserialization features
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
mapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);
mapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);

// Multiple features at once
mapper.enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY,
              DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);

mapper.disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES,
               DeserializationFeature.FAIL_ON_INVALID_SUBTYPE);

// Check feature status
boolean lenient = !mapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
boolean bigDecimals = mapper.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);

// Configure through ObjectReader
ObjectReader reader = mapper.reader()
    .without(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
    .with(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);

Person person = reader.readValue(jsonWithUnknownProps, Person.class);

Types

// Deserializer interfaces
public interface ContextualDeserializer {
    JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
}

public interface ResolvableDeserializer {
    void resolve(DeserializationContext ctxt) throws JsonMappingException;
}

// Key deserializer base
public abstract class KeyDeserializer {
    public abstract Object deserializeKey(String key, DeserializationContext ctxt) throws IOException;
    
    public static abstract class None extends KeyDeserializer { }
}

// Null value provider interface
public interface NullValueProvider {
    Object getNullValue(DeserializationContext ctxt) throws JsonMappingException;
    Object getAbsentValue(DeserializationContext ctxt) throws JsonMappingException;
    AccessPattern getNullAccessPattern();
}

// Value instantiator for object creation
public abstract class ValueInstantiator {
    // Default instantiation
    public boolean canCreateUsingDefault();
    public Object createUsingDefault(DeserializationContext ctxt) throws IOException;
    
    // Delegate instantiation  
    public boolean canCreateUsingDelegate();
    public Object createUsingDelegate(DeserializationContext ctxt, Object delegate) throws IOException;
    public JavaType getDelegateType(DeserializationConfig config);
    
    // Array delegate instantiation
    public boolean canCreateUsingArrayDelegate();
    public Object createUsingArrayDelegate(DeserializationContext ctxt, Object delegate) throws IOException;
    public JavaType getArrayDelegateType(DeserializationConfig config);
    
    // Scalar instantiation
    public boolean canCreateFromString();
    public Object createFromString(DeserializationContext ctxt, String value) throws IOException;
    public boolean canCreateFromInt();
    public Object createFromInt(DeserializationContext ctxt, int value) throws IOException;
    public boolean canCreateFromLong();
    public Object createFromLong(DeserializationContext ctxt, long value) throws IOException;
    public boolean canCreateFromDouble();
    public Object createFromDouble(DeserializationContext ctxt, double value) throws IOException;
    public boolean canCreateFromBoolean();
    public Object createFromBoolean(DeserializationContext ctxt, boolean value) throws IOException;
    
    // Properties-based instantiation
    public boolean canCreateFromObjectWith();
    public Object createFromObjectWith(DeserializationContext ctxt, Object[] args) throws IOException;
    public SettableBeanProperty[] getFromObjectArguments(DeserializationConfig config);
    
    // Metadata
    public String getValueTypeDesc();
}

// Deserializer registration interface
public interface Deserializers {
    JsonDeserializer<?> findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException;
    JsonDeserializer<?> findReferenceDeserializer(ReferenceType refType, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer contentTypeDeserializer, JsonDeserializer<?> contentDeserializer) throws JsonMappingException;
    JsonDeserializer<?> findArrayDeserializer(ArrayType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException;
    JsonDeserializer<?> findCollectionDeserializer(CollectionType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException;
    JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException;
    JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException;
    JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException;
    JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException;
    JsonDeserializer<?> findTreeNodeDeserializer(Class<? extends JsonNode> nodeType, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException;
    
    public static abstract class Base implements Deserializers {
        // Default implementations returning null
    }
}

// Bean deserializer modifier
public abstract class BeanDeserializerModifier {
    public List<BeanPropertyDefinition> updateProperties(DeserializationConfig config, BeanDescription beanDesc, List<BeanPropertyDefinition> propDefs);
    public List<SettableBeanProperty> updateProperties(DeserializationConfig config, BeanDescription beanDesc, List<SettableBeanProperty> propDefs);
    public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder);
    public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyArrayDeserializer(DeserializationConfig config, ArrayType valueType, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyCollectionDeserializer(DeserializationConfig config, CollectionType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyCollectionLikeDeserializer(DeserializationConfig config, CollectionLikeType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyMapDeserializer(DeserializationConfig config, MapType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyMapLikeDeserializer(DeserializationConfig config, MapLikeType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config, JavaType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer);
    public JsonDeserializer<?> modifyKeyDeserializer(DeserializationConfig config, JavaType type, JsonDeserializer<?> deserializer);
}

// Problem handler for deserialization issues
public abstract class DeserializationProblemHandler {
    public static final Object NOT_HANDLED = new Object();
    
    public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser p, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException;
    public Object handleInstantiationProblem(DeserializationContext ctxt, Class<?> instClass, Object argument, Throwable t) throws IOException;
    public Object handleMissingInstantiator(DeserializationContext ctxt, Class<?> instClass, ValueInstantiator valueInst, JsonParser p, String msg) throws IOException;
    public Object handleMissingTypeId(DeserializationContext ctxt, JavaType baseType, TypeIdResolver idResolver, String failureMsg) throws IOException;
    public JavaType handleUnknownTypeId(DeserializationContext ctxt, JavaType baseType, String subTypeId, TypeIdResolver idResolver, String failureMsg) throws IOException;
    public JavaType handleMissingTypeId(DeserializationContext ctxt, JavaType baseType, TypeIdResolver idResolver, String failureMsg) throws IOException;
}

<function_calls> <invoke name="TodoWrite"> <parameter name="todos">[{"content": "Create entry-point document (index.md) with overview and key API snippets", "status": "completed", "activeForm": "Creating entry-point document"}, {"content": "Create object-mapping.md sub-document covering ObjectMapper, ObjectReader, ObjectWriter", "status": "completed", "activeForm": "Creating object-mapping.md"}, {"content": "Create json-tree-model.md sub-document covering JsonNode hierarchy and tree manipulation", "status": "completed", "activeForm": "Creating json-tree-model.md"}, {"content": "Create type-system.md sub-document covering JavaType and type handling", "status": "completed", "activeForm": "Creating type-system.md"}, {"content": "Create serialization.md sub-document covering JsonSerializer and serialization framework", "status": "completed", "activeForm": "Creating serialization.md"}, {"content": "Create deserialization.md sub-document covering JsonDeserializer and deserialization framework", "status": "completed", "activeForm": "Creating deserialization.md"}, {"content": "Create configuration.md sub-document covering features, settings, and configuration", "status": "in_progress", "activeForm": "Creating configuration.md"}, {"content": "Create annotations.md sub-document covering Jackson databind annotations", "status": "pending", "activeForm": "Creating annotations.md"}, {"content": "Create modules.md sub-document covering Module system and extensibility", "status": "pending", "activeForm": "Creating modules.md"}, {"content": "Create advanced-features.md sub-document covering polymorphism, custom handlers, etc.", "status": "pending", "activeForm": "Creating advanced-features.md"}]

Install with Tessl CLI

npx tessl i tessl/maven-com-fasterxml-jackson-core--jackson-databind

docs

advanced-features.md

annotations.md

configuration.md

deserialization.md

index.md

json-tree-model.md

modules.md

object-mapping.md

serialization.md

type-system.md

tile.json