Jackson Data Binding Source Code

Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java".

  • Jackson Data Binding module allows you to converts JSON to and from POJO (Plain Old Java Object) using property accessor or using annotations.
  • Jackson Databind Source Code files are provided in the source packge (jackson-databind-2.12.4-sources.jar). You can download it at Jackson Maven Website.

    You can also browse Jackson Databind Source Code below:

    ✍: FYIcenter.com

    com/fasterxml/jackson/databind/deser/DeserializerFactory.java

    package com.fasterxml.jackson.databind.deser;
    
    import com.fasterxml.jackson.databind.*;
    import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
    import com.fasterxml.jackson.databind.type.*;
    
    /**
     * Abstract class that defines API used by {@link DeserializationContext}
     * to construct actual
     * {@link JsonDeserializer} instances (which are then cached by
     * context and/or dedicated cache).
     *<p>
     * Since there are multiple broad categories of deserializers, there are 
     * multiple factory methods:
     *<ul>
     * <li>For JSON "Array" type, we need 2 methods: one to deal with expected
     *   Java arrays ({@link #createArrayDeserializer})
     *   and the other for other Java containers like {@link java.util.List}s
     *   and {@link java.util.Set}s ({@link #createCollectionDeserializer}).
     *   Actually there is also a third method for "Collection-like" types;
     *   things like Scala collections that act like JDK collections but do not
     *   implement same interfaces.
     *  </li>
     * <li>For JSON "Object" type, we need 2 methods: one to deal with
     *   expected Java {@link java.util.Map}s
     *   ({@link #createMapDeserializer}), and another for POJOs
     *   ({@link #createBeanDeserializer}.
     *   As an additional twist there is also a callback for "Map-like" types,
     *   mostly to make it possible to support Scala Maps (which are NOT JDK
     *   Map compatible).
     *  </li>
     * <li>For Tree Model ({@link com.fasterxml.jackson.databind.JsonNode}) properties there is
     *    {@link #createTreeDeserializer}
     * <li>For enumerated types ({@link java.lang.Enum}) there is
     *    {@link #createEnumDeserializer}
     *  </li>
     * <li>For all other types, {@link #createBeanDeserializer} is used.
     * </ul>
     *<p>
     */
    public abstract class DeserializerFactory
    {
        protected final static Deserializers[] NO_DESERIALIZERS = new Deserializers[0];
    
        /*
        /********************************************************
        /* Configuration handling
        /********************************************************
         */
    
        /**
         * Convenience method for creating a new factory instance with additional deserializer
         * provider.
         */
        public abstract DeserializerFactory withAdditionalDeserializers(Deserializers additional);
    
        /**
         * Convenience method for creating a new factory instance with additional
         * {@link KeyDeserializers}.
         */
        public abstract DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional);
        
        /**
         * Convenience method for creating a new factory instance with additional
         * {@link BeanDeserializerModifier}.
         */
        public abstract DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier);
    
        /**
         * Convenience method for creating a new factory instance with additional
         * {@link AbstractTypeResolver}.
         */
        public abstract DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver);
    
        /**
         * Convenience method for creating a new factory instance with additional
         * {@link ValueInstantiators}.
         */
        public abstract DeserializerFactory withValueInstantiators(ValueInstantiators instantiators);
        
        /*
        /**********************************************************
        /* Basic DeserializerFactory API:
        /**********************************************************
         */
    
        /**
         * Method that can be called to try to resolve an abstract type
         * (interface, abstract class) into a concrete type, or at least
         * something "more concrete" (abstract class instead of interface).
         * Will either return passed type, or a more specific type.
         */
        public abstract JavaType mapAbstractType(DeserializationConfig config, JavaType type)
            throws JsonMappingException;
    
        /**
         * Method that is to find all creators (constructors, factory methods)
         * for the bean type to deserialize.
         */
        public abstract ValueInstantiator findValueInstantiator(DeserializationContext ctxt,
                BeanDescription beanDesc)
            throws JsonMappingException;
        
        /**
         * Method called to create (or, for completely immutable deserializers,
         * reuse) a deserializer that can convert JSON content into values of
         * specified Java "bean" (POJO) type.
         * At this point it is known that the type is not otherwise recognized
         * as one of structured types (array, Collection, Map) or a well-known
         * JDK type (enum, primitives/wrappers, String); this method only
         * gets called if other options are exhausted. This also means that
         * this method can be overridden to add support for custom types.
         *
         * @param type Type to be deserialized
         */
        public abstract JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ctxt,
                JavaType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        /**
         * Method called to create a deserializer that will use specified Builder
         * class for building value instances.
         */
        public abstract JsonDeserializer<Object> createBuilderBasedDeserializer(
        		DeserializationContext ctxt, JavaType type, BeanDescription beanDesc,
        		Class<?> builderClass)
            throws JsonMappingException;
    
    
        public abstract JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt,
                JavaType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        /**
         * @since 2.7
         */
        public abstract JsonDeserializer<?> createReferenceDeserializer(DeserializationContext ctxt,
                ReferenceType type, BeanDescription beanDesc)
            throws JsonMappingException;
        
        /**
         * Method called to create and return a deserializer that can construct
         * JsonNode(s) from JSON content.
         */
        public abstract JsonDeserializer<?> createTreeDeserializer(DeserializationConfig config,
                JavaType type, BeanDescription beanDesc)
            throws JsonMappingException;
        
        /**
         * Method called to create (or, for completely immutable deserializers,
         * reuse) a deserializer that can convert JSON content into values of
         * specified Java type.
         *
         * @param type Type to be deserialized
         */
        public abstract JsonDeserializer<?> createArrayDeserializer(DeserializationContext ctxt,
                ArrayType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        public abstract JsonDeserializer<?> createCollectionDeserializer(DeserializationContext ctxt,
                CollectionType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        public abstract JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext ctxt,
                CollectionLikeType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        public abstract JsonDeserializer<?> createMapDeserializer(DeserializationContext ctxt,
                MapType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        public abstract JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext ctxt,
                MapLikeType type, BeanDescription beanDesc)
            throws JsonMappingException;
    
        /**
         * Method called to find if factory knows how to create a key deserializer
         * for specified type; currently this means checking if a module has registered
         * possible deserializers.
         * 
         * @return Key deserializer to use for specified type, if one found; null if not
         *   (and default key deserializer should be used)
         */
        public abstract KeyDeserializer createKeyDeserializer(DeserializationContext ctxt,
                JavaType type)
            throws JsonMappingException;
    
        /**
         * Method called to find and create a type information deserializer for given base type,
         * if one is needed. If not needed (no polymorphic handling configured for type),
         * should return null.
         *<p>
         * Note that this method is usually only directly called for values of container (Collection,
         * array, Map) types and root values, but not for bean property values.
         *
         * @param baseType Declared base type of the value to deserializer (actual
         *    deserializer type will be this type or its subtype)
         * 
         * @return Type deserializer to use for given base type, if one is needed; null if not.
         */
        public abstract TypeDeserializer findTypeDeserializer(DeserializationConfig config,
                JavaType baseType)
            throws JsonMappingException;
    
        /**
         * Method that can be used to check if databind module has explicitly declared deserializer
         * for given (likely JDK) type, explicit meaning that there is specific deserializer for
         * given type as opposed to auto-generated "Bean" deserializer. Factory itself will check
         * for known JDK-provided types, but registered {@link com.fasterxml.jackson.databind.Module}s
         * are also called to see if they might provide explicit deserializer.
         *<p> 
         * Main use for this method is with Safe Default Typing (and generally Safe Polymorphic
         * Deserialization), during which it is good to be able to check that given raw type
         * is explicitly supported and as such "known type" (as opposed to potentially
         * dangerous "gadget type" which could be exploited).
         *<p>
         * This matches {@code Deserializers.Base.hasDeserializerFor(Class)} method, which is
         * the mechanism used to determine if a {@code Module} might provide an explicit
         * deserializer instead of core databind.
         *
         * @since 2.11
         */
        public abstract boolean hasExplicitDeserializerFor(DeserializationConfig config,
                Class<?> valueType);
    }
    

    com/fasterxml/jackson/databind/deser/DeserializerFactory.java

     

    ⇒ Jackson Annotations Source Code

    ⇐ Download and Install Jackson Binary Package

    ⇑ Downloading and Reviewing jackson-*.jar

    ⇑⇑ Jackson - Java JSON library

    2022-03-29, 31690👍, 0💬