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/cfg/MapperConfigBase.java

    package com.fasterxml.jackson.databind.cfg;
    
    import java.text.DateFormat;
    import java.util.*;
    
    import com.fasterxml.jackson.annotation.*;
    import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
    import com.fasterxml.jackson.core.Base64Variant;
    
    import com.fasterxml.jackson.databind.*;
    import com.fasterxml.jackson.databind.introspect.ClassIntrospector;
    import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver;
    import com.fasterxml.jackson.databind.introspect.AccessorNamingStrategy;
    import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
    import com.fasterxml.jackson.databind.introspect.SimpleMixInResolver;
    import com.fasterxml.jackson.databind.introspect.VisibilityChecker;
    import com.fasterxml.jackson.databind.jsontype.SubtypeResolver;
    import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
    import com.fasterxml.jackson.databind.type.TypeFactory;
    import com.fasterxml.jackson.databind.util.RootNameLookup;
    
    @SuppressWarnings("serial")
    public abstract class MapperConfigBase<CFG extends ConfigFeature,
        T extends MapperConfigBase<CFG,T>>
        extends MapperConfig<T>
        implements java.io.Serializable
    {
        /**
         * @since 2.9
         */
        protected final static ConfigOverride EMPTY_OVERRIDE = ConfigOverride.empty();
    
        private final static int DEFAULT_MAPPER_FEATURES = collectFeatureDefaults(MapperFeature.class);
    
        /**
         * @since 2.9
         */
        private final static int AUTO_DETECT_MASK =
                MapperFeature.AUTO_DETECT_FIELDS.getMask()
                | MapperFeature.AUTO_DETECT_GETTERS.getMask()
                | MapperFeature.AUTO_DETECT_IS_GETTERS.getMask()
                | MapperFeature.AUTO_DETECT_SETTERS.getMask()
                | MapperFeature.AUTO_DETECT_CREATORS.getMask()
                ;
    
        /*
        /**********************************************************
        /* Immutable config
        /**********************************************************
         */
    
        /**
         * Mix-in annotation mappings to use, if any: immutable,
         * cannot be changed once defined.
         * 
         * @since 2.6
         */
        protected final SimpleMixInResolver _mixIns;
    
        /**
         * Registered concrete subtypes that can be used instead of (or
         * in addition to) ones declared using annotations.
         *<p>
         * Note that instances are stateful and as such may need to be copied,
         * and may NOT be demoted down to {@link BaseSettings}.
         */
        protected final SubtypeResolver _subtypeResolver;
    
        /**
         * Explicitly defined root name to use, if any; if empty
         * String, will disable root-name wrapping; if null, will
         * use defaults
         */
        protected final PropertyName _rootName;
    
        /**
         * View to use for filtering out properties to serialize
         * or deserialize.
         * Null if none (will also be assigned null if <code>Object.class</code>
         * is defined), meaning that all properties are to be included.
         */
        protected final Class<?> _view;
    
        /**
         * Contextual attributes accessible (get and set) during processing,
         * on per-call basis.
         * 
         * @since 2.3
         */
        protected final ContextAttributes _attributes;
    
        /**
         * Simple cache used for finding out possible root name for root name
         * wrapping.
         *<p>
         * Note that instances are stateful (for caching) and as such may need to be copied,
         * and may NOT be demoted down to {@link BaseSettings}.
         *
         * @since 2.6
         */
        protected final RootNameLookup _rootNames;
    
        /**
         * Configuration overrides to apply, keyed by type of property.
         *
         * @since 2.8
         */
        protected final ConfigOverrides _configOverrides;
    
        /*
        /**********************************************************
        /* Construction
        /**********************************************************
         */
    
        /**
         * Constructor used when creating a new instance (compared to
         * that of creating fluent copies)
         *
         * @since 2.8
         */
        protected MapperConfigBase(BaseSettings base,
                SubtypeResolver str, SimpleMixInResolver mixins, RootNameLookup rootNames,
                ConfigOverrides configOverrides)
        {
            super(base, DEFAULT_MAPPER_FEATURES);
            _mixIns = mixins;
            _subtypeResolver = str;
            _rootNames = rootNames;
            _rootName = null;
            _view = null;
            // default to "no attributes"
            _attributes = ContextAttributes.getEmpty();
            _configOverrides = configOverrides;
        }
    
        /**
         * Copy constructor usually called to make a copy for use by
         * ObjectMapper that is copied.
         *
         * @since 2.11.2
         */
        protected MapperConfigBase(MapperConfigBase<CFG,T> src,
                SubtypeResolver str, SimpleMixInResolver mixins, RootNameLookup rootNames,
                ConfigOverrides configOverrides)
        {
            // 18-Apr-2018, tatu: [databind#1898] need to force copying of `ClassIntrospector`
            //    (to clear its cache) to avoid leakage
            super(src, src._base.copy());
            _mixIns = mixins;
            _subtypeResolver = str;
            _rootNames = rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = configOverrides;
        }
    
        /**
         * Pass-through constructor used when no changes are needed to the
         * base class.
         */
        protected MapperConfigBase(MapperConfigBase<CFG,T> src)
        {
            super(src);
            _mixIns = src._mixIns;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
    
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, BaseSettings base)
        {
            super(src, base);
            _mixIns = src._mixIns;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
        
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, int mapperFeatures)
        {
            super(src, mapperFeatures);
            _mixIns = src._mixIns;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
    
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, SubtypeResolver str) {
            super(src);
            _mixIns = src._mixIns;
            _subtypeResolver = str;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
    
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, PropertyName rootName) {
            super(src);
            _mixIns = src._mixIns;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
    
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, Class<?> view)
        {
            super(src);
            _mixIns = src._mixIns;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
    
        /**
         * @since 2.1
         */
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, SimpleMixInResolver mixins)
        {
            super(src);
            _mixIns = mixins;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = src._attributes;
            _configOverrides = src._configOverrides;
        }
    
        /**
         * @since 2.3
         */
        protected MapperConfigBase(MapperConfigBase<CFG,T> src, ContextAttributes attr)
        {
            super(src);
            _mixIns = src._mixIns;
            _subtypeResolver = src._subtypeResolver;
            _rootNames = src._rootNames;
            _rootName = src._rootName;
            _view = src._view;
            _attributes = attr;
            _configOverrides = src._configOverrides;
        }
    
        /*
        /**********************************************************
        /* Abstract fluent factory methods to be implemented by subtypes
        /**********************************************************
         */
    
        /**
         * @since 2.9 (in this case, demoted from sub-classes)
         */
        protected abstract T _withBase(BaseSettings newBase);
    
        /**
         * @since 2.9 (in this case, demoted from sub-classes)
         */
        protected abstract T _withMapperFeatures(int mapperFeatures);
    
        /*
        /**********************************************************
        /* Additional shared fluent factory methods; features
        /**********************************************************
         */
        
        /**
         * Fluent factory method that will construct and return a new configuration
         * object instance with specified features enabled.
         */
        @SuppressWarnings("unchecked")
        @Override
        public final T with(MapperFeature... features)
        {
            int newMapperFlags = _mapperFeatures;
            for (MapperFeature f : features) {
                newMapperFlags |= f.getMask();
            }
            if (newMapperFlags == _mapperFeatures) {
                return (T) this;
            }
            return _withMapperFeatures(newMapperFlags);
        }
    
        /**
         * Fluent factory method that will construct and return a new configuration
         * object instance with specified features disabled.
         */
        @SuppressWarnings("unchecked")
        @Override
        public final T without(MapperFeature... features)
        {
            int newMapperFlags = _mapperFeatures;
            for (MapperFeature f : features) {
                 newMapperFlags &= ~f.getMask();
            }
            if (newMapperFlags == _mapperFeatures) {
                return (T) this;
            }
            return _withMapperFeatures(newMapperFlags);
        }
    
        @SuppressWarnings("unchecked")
        @Override
        public final T with(MapperFeature feature, boolean state)
        {
            int newMapperFlags;
            if (state) {
                newMapperFlags = _mapperFeatures | feature.getMask();
            } else {
                newMapperFlags = _mapperFeatures & ~feature.getMask();
            }
            if (newMapperFlags == _mapperFeatures) {
                return (T) this;
            }
            return _withMapperFeatures(newMapperFlags);
        }
    
        /*
        /**********************************************************
        /* Additional shared fluent factory methods; introspectors
        /**********************************************************
         */
        
        /**
         * Method for constructing and returning a new instance with different
         * {@link AnnotationIntrospector} to use (replacing old one).
         *<p>
         * NOTE: make sure to register new instance with <code>ObjectMapper</code>
         * if directly calling this method.
         */
        public final T with(AnnotationIntrospector ai) {
            return _withBase(_base.withAnnotationIntrospector(ai));
        }
    
        /**
         * Method for constructing and returning a new instance with additional
         * {@link AnnotationIntrospector} appended (as the lowest priority one)
         */
        public final T withAppendedAnnotationIntrospector(AnnotationIntrospector ai) {
            return _withBase(_base.withAppendedAnnotationIntrospector(ai));
        }
    
        /**
         * Method for constructing and returning a new instance with additional
         * {@link AnnotationIntrospector} inserted (as the highest priority one)
         */
        public final T withInsertedAnnotationIntrospector(AnnotationIntrospector ai) {
            return _withBase(_base.withInsertedAnnotationIntrospector(ai));
        }
        
        /**
         * Method for constructing and returning a new instance with different
         * {@link ClassIntrospector}
         * to use.
         *<p>
         * NOTE: make sure to register new instance with <code>ObjectMapper</code>
         * if directly calling this method.
         */
        public final T with(ClassIntrospector ci) {
            return _withBase(_base.withClassIntrospector(ci));
        }
    
        /*
        /**********************************************************
        /* Additional shared fluent factory methods; attributes
        /**********************************************************
         */
    
        /**
         * Method for constructing an instance that has specified
         * contextual attributes.
         * 
         * @since 2.3
         */
        public abstract T with(ContextAttributes attrs);
    
        /**
         * Method for constructing an instance that has only specified
         * attributes, removing any attributes that exist before the call.
         * 
         * @since 2.3
         */
        public T withAttributes(Map<?,?> attributes) {
            return with(getAttributes().withSharedAttributes(attributes));
        }
        
        /**
         * Method for constructing an instance that has specified
         * value for attribute for given key.
         * 
         * @since 2.3
         */
        public T withAttribute(Object key, Object value) {
            return with(getAttributes().withSharedAttribute(key, value));
        }
    
        /**
         * Method for constructing an instance that has no
         * value for attribute for given key.
         * 
         * @since 2.3
         */
        public T withoutAttribute(Object key) {
            return with(getAttributes().withoutSharedAttribute(key));
        }
    
        /*
        /**********************************************************
        /* Additional shared fluent factory methods; factories
        /**********************************************************
         */
    
        /**
         * Method for constructing and returning a new instance with different
         * {@link TypeFactory}
         * to use.
         */
        public final T with(TypeFactory tf) {
            return _withBase( _base.withTypeFactory(tf));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * {@link TypeResolverBuilder} to use.
         */
        public final T with(TypeResolverBuilder<?> trb) {
            return _withBase(_base.withTypeResolverBuilder(trb));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * {@link PropertyNamingStrategy}
         * to use.
         *<p>
         * NOTE: make sure to register new instance with <code>ObjectMapper</code>
         * if directly calling this method.
         */
        public final T with(PropertyNamingStrategy pns) {
            return _withBase(_base.withPropertyNamingStrategy(pns));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * {@link PropertyNamingStrategy}
         * to use.
         *
         * @since 2.12
         */
        public final T with(AccessorNamingStrategy.Provider p) {
            return _withBase(_base.withAccessorNaming(p));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * {@link HandlerInstantiator}
         * to use.
         *<p>
         * NOTE: make sure to register new instance with <code>ObjectMapper</code>
         * if directly calling this method.
         */
        public final T with(HandlerInstantiator hi) {
            return _withBase(_base.withHandlerInstantiator(hi));
        }
    
        /*
        /**********************************************************
        /* Additional shared fluent factory methods; other
        /**********************************************************
         */
    
        /**
         * Method for constructing and returning a new instance with different
         * default {@link Base64Variant} to use with base64-encoded binary values.
         */
        public final T with(Base64Variant base64) {
            return _withBase(_base.with(base64));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * {@link DateFormat}
         * to use.
         *<p>
         * NOTE: non-final since <code>SerializationConfig</code> needs to override this
         */
        public T with(DateFormat df) {
            return _withBase(_base.withDateFormat(df));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * default {@link java.util.Locale} to use for formatting.
         */
        public final T with(Locale l) {
            return _withBase(_base.with(l));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * default {@link java.util.TimeZone} to use for formatting of date values.
         */
        public final T with(TimeZone tz) {
            return _withBase(_base.with(tz));
        }
    
        /**
         * Method for constructing and returning a new instance with different
         * root name to use (none, if null).
         *<p>
         * Note that when a root name is set to a non-Empty String, this will automatically force use
         * of root element wrapping with given name. If empty String passed, will
         * disable root name wrapping; and if null used, will instead use
         * <code>SerializationFeature</code> to determine if to use wrapping, and annotation
         * (or default name) for actual root name to use.
         * 
         * @param rootName to use: if null, means "use default" (clear setting);
         *   if empty String ("") means that no root name wrapping is used;
         *   otherwise defines root name to use.
         *   
         * @since 2.6
         */
        public abstract T withRootName(PropertyName rootName);
    
        public T withRootName(String rootName) {
            if (rootName == null) {
                return withRootName((PropertyName) null);
            }
            return withRootName(PropertyName.construct(rootName));
        }
        
        /**
         * Method for constructing and returning a new instance with different
         * {@link SubtypeResolver}
         * to use.
         *<p>
         * NOTE: make sure to register new instance with <code>ObjectMapper</code>
         * if directly calling this method.
         */
        public abstract T with(SubtypeResolver str);
    
        /**
         * Method for constructing and returning a new instance with different
         * view to use.
         */
        public abstract T withView(Class<?> view);
    
        /*
        /**********************************************************
        /* Simple accessors
        /**********************************************************
         */
    
        /**
         * Accessor for object used for finding out all reachable subtypes
         * for supertypes; needed when a logical type name is used instead
         * of class name (or custom scheme).
         */
        @Override
        public final SubtypeResolver getSubtypeResolver() {
            return _subtypeResolver;
        }
    
        /**
         * @deprecated Since 2.6 use {@link #getFullRootName} instead.
         */
        @Deprecated // since 2.6
        public final String getRootName() {
            return (_rootName == null) ? null : _rootName.getSimpleName();
        }
    
        /**
         * @since 2.6
         */
        public final PropertyName getFullRootName() {
            return _rootName;
        }
    
        @Override
        public final Class<?> getActiveView() {
            return _view;
        }
    
        @Override
        public final ContextAttributes getAttributes() {
            return _attributes;
        }
    
        /*
        /**********************************************************
        /* Configuration access; default/overrides
        /**********************************************************
         */
    
        @Override
        public final ConfigOverride getConfigOverride(Class<?> type) {
            ConfigOverride override = _configOverrides.findOverride(type);
            return (override == null) ? EMPTY_OVERRIDE : override;
        }
    
        @Override
        public final ConfigOverride findConfigOverride(Class<?> type) {
            return _configOverrides.findOverride(type);
        }
    
        @Override
        public final JsonInclude.Value getDefaultPropertyInclusion() {
            return _configOverrides.getDefaultInclusion();
        }
    
        @Override
        public final JsonInclude.Value getDefaultPropertyInclusion(Class<?> baseType) {
            JsonInclude.Value v = getConfigOverride(baseType).getInclude();
            JsonInclude.Value def = getDefaultPropertyInclusion();
            if (def == null) {
                return v;
            }
            return def.withOverrides(v);
        }
    
        @Override
        public final JsonInclude.Value getDefaultInclusion(Class<?> baseType,
                Class<?> propertyType) {
            JsonInclude.Value v = getConfigOverride(propertyType).getIncludeAsProperty();
            JsonInclude.Value def = getDefaultPropertyInclusion(baseType);
            if (def == null) {
                return v;
            }
            return def.withOverrides(v);
        }
    
        @Override
        public final JsonFormat.Value getDefaultPropertyFormat(Class<?> type) {
            return _configOverrides.findFormatDefaults(type);
        }
    
        @Override
        public final JsonIgnoreProperties.Value getDefaultPropertyIgnorals(Class<?> type) {
            ConfigOverride overrides = _configOverrides.findOverride(type);
            if (overrides != null) {
                JsonIgnoreProperties.Value v = overrides.getIgnorals();
                if (v != null) {
                    return v;
                }
            }
            // 01-May-2015, tatu: Could return `Value.empty()` but for now `null`
            //   seems simpler as callers can avoid processing.
            return null;
        }
    
        @Override
        public final JsonIgnoreProperties.Value getDefaultPropertyIgnorals(Class<?> baseType,
                AnnotatedClass actualClass)
        {
            AnnotationIntrospector intr = getAnnotationIntrospector();
            JsonIgnoreProperties.Value base = (intr == null) ? null
                    : intr.findPropertyIgnoralByName(this, actualClass);
            JsonIgnoreProperties.Value overrides = getDefaultPropertyIgnorals(baseType);
            return JsonIgnoreProperties.Value.merge(base, overrides);
        }
    
        @Override
        public final JsonIncludeProperties.Value getDefaultPropertyInclusions(Class<?> baseType,
                AnnotatedClass actualClass)
        {
            AnnotationIntrospector intr = getAnnotationIntrospector();
            return (intr == null) ? null : intr.findPropertyInclusionByName(this, actualClass);
        }
    
        @Override
        public final VisibilityChecker<?> getDefaultVisibilityChecker()
        {
            VisibilityChecker<?> vchecker = _configOverrides.getDefaultVisibility();
            // then global overrides (disabling)
            // 05-Mar-2018, tatu: As per [databind#1947], need to see if any disabled
            if ((_mapperFeatures & AUTO_DETECT_MASK) != AUTO_DETECT_MASK) {
                if (!isEnabled(MapperFeature.AUTO_DETECT_FIELDS)) {
                    vchecker = vchecker.withFieldVisibility(Visibility.NONE);
                }
                if (!isEnabled(MapperFeature.AUTO_DETECT_GETTERS)) {
                    vchecker = vchecker.withGetterVisibility(Visibility.NONE);
                }
                if (!isEnabled(MapperFeature.AUTO_DETECT_IS_GETTERS)) {
                    vchecker = vchecker.withIsGetterVisibility(Visibility.NONE);
                }
                if (!isEnabled(MapperFeature.AUTO_DETECT_SETTERS)) {
                    vchecker = vchecker.withSetterVisibility(Visibility.NONE);
                }
                if (!isEnabled(MapperFeature.AUTO_DETECT_CREATORS)) {
                    vchecker = vchecker.withCreatorVisibility(Visibility.NONE);
                }
            }
            return vchecker;
        }
    
        @Override // since 2.9
        public final VisibilityChecker<?> getDefaultVisibilityChecker(Class<?> baseType,
                AnnotatedClass actualClass) {
            VisibilityChecker<?> vc = getDefaultVisibilityChecker();
            AnnotationIntrospector intr = getAnnotationIntrospector();
            if (intr != null) {
                vc = intr.findAutoDetectVisibility(actualClass, vc);
            }
            ConfigOverride overrides = _configOverrides.findOverride(baseType);
            if (overrides != null) {
                vc = vc.withOverrides(overrides.getVisibility()); // ok to pass null
            }
            return vc;
        }
    
        @Override
        public final JsonSetter.Value getDefaultSetterInfo() {
            return _configOverrides.getDefaultSetterInfo();
        }
    
        @Override
        public Boolean getDefaultMergeable() {
            return _configOverrides.getDefaultMergeable();
        }
    
        @Override
        public Boolean getDefaultMergeable(Class<?> baseType) {
            Boolean b;
            ConfigOverride cfg = _configOverrides.findOverride(baseType);
            if (cfg != null) {
                b = cfg.getMergeable();
                if (b != null) {
                    return b;
                }
            }
            return _configOverrides.getDefaultMergeable();
        }
    
        /*
        /**********************************************************
        /* Other config access
        /**********************************************************
         */
    
        @Override
        public PropertyName findRootName(JavaType rootType) {
            if (_rootName != null) {
                return _rootName;
            }
            return _rootNames.findRootName(rootType, this);
        }
    
        @Override
        public PropertyName findRootName(Class<?> rawRootType) {
            if (_rootName != null) {
                return _rootName;
            }
            return _rootNames.findRootName(rawRootType, this);
        }
    
        /*
        /**********************************************************
        /* ClassIntrospector.MixInResolver impl:
        /**********************************************************
         */
    
        /**
         * Method that will check if there are "mix-in" classes (with mix-in
         * annotations) for given class
         */
        @Override
        public final Class<?> findMixInClassFor(Class<?> cls) {
            return _mixIns.findMixInClassFor(cls);
        }
    
        // Not really relevant here (should not get called)
        @Override
        public MixInResolver copy() {
            throw new UnsupportedOperationException();
        }
        
        /**
         * Test-only method -- does not reflect possibly open-ended set that external
         * mix-in resolver might provide.
         */
        public final int mixInCount() {
            return _mixIns.localSize();
        }
    }
    

    com/fasterxml/jackson/databind/cfg/MapperConfigBase.java

     

    ⇒ Jackson Annotations Source Code

    ⇐ Download and Install Jackson Binary Package

    ⇑ Downloading and Reviewing jackson-*.jar

    ⇑⇑ Jackson - Java JSON library

    2022-03-29, 31925👍, 0💬