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.14.0-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/impl/JavaUtilCollectionsDeserializers.java

    package com.fasterxml.jackson.databind.deser.impl;
    
    import java.util.*;
    
    import com.fasterxml.jackson.databind.*;
    import com.fasterxml.jackson.databind.deser.std.StdDelegatingDeserializer;
    import com.fasterxml.jackson.databind.type.TypeFactory;
    import com.fasterxml.jackson.databind.util.Converter;
    
    /**
     * Helper class used to contain logic for deserializing "special" containers
     * from {@code java.util.Collections} and {@code java.util.Arrays}. This is needed
     * because they do not have usable no-arguments constructor: however, are easy enough
     * to deserialize using delegating deserializer.
     *
     * @since 2.9.4
     */
    public abstract class JavaUtilCollectionsDeserializers
    {
        private final static int TYPE_SINGLETON_SET = 1;
        private final static int TYPE_SINGLETON_LIST = 2;
        private final static int TYPE_SINGLETON_MAP = 3;
    
        private final static int TYPE_UNMODIFIABLE_SET = 4;
        private final static int TYPE_UNMODIFIABLE_LIST = 5;
        private final static int TYPE_UNMODIFIABLE_MAP = 6;
    
        // 2.12.1
        private final static int TYPE_SYNC_SET = 7;
        private final static int TYPE_SYNC_COLLECTION = 8;
        private final static int TYPE_SYNC_LIST = 9;
        private final static int TYPE_SYNC_MAP = 10;
    
        public final static int TYPE_AS_LIST = 11;
    
        private final static String PREFIX_JAVA_UTIL_COLLECTIONS = "java.util.Collections$";
        private final static String PREFIX_JAVA_UTIL_ARRAYS = "java.util.Arrays$";
        // for Java 11+ List.of(), Map.of() stuff
        private final static String PREFIX_JAVA_UTIL_IMMUTABLE_COLL = "java.util.ImmutableCollections$";
    
        public static JsonDeserializer<?> findForCollection(DeserializationContext ctxt,
                JavaType type)
            throws JsonMappingException
        {
            final String clsName = type.getRawClass().getName();
            if (!clsName.startsWith("java.util.")) {
                return null;
            }
            // 10-Jan-2017, tatu: Some types from `java.util.Collections`/`java.util.Arrays`
            //    need a bit of help...
            String localName = _findUtilCollectionsTypeName(clsName);
            if (localName != null) {
                JavaUtilCollectionsConverter conv = null;
                String name;
        
                if ((name = _findUnmodifiableTypeName(localName)) != null) {
                    if (name.endsWith("Set")) {
                        conv = converter(TYPE_UNMODIFIABLE_SET, type, Set.class);
                    } else if (name.endsWith("List")) {
                        conv = converter(TYPE_UNMODIFIABLE_LIST, type, List.class);
                    }
                } else if ((name = _findSingletonTypeName(localName)) != null) {
                    if (name.endsWith("Set")) {
                        conv = converter(TYPE_SINGLETON_SET, type, Set.class);
                    } else if (name.endsWith("List")) {
                        conv = converter(TYPE_SINGLETON_LIST, type, List.class);
                    }
                } else if ((name = _findSyncTypeName(localName)) != null) {
                    // [databind#3009]: synchronized, too
                    if (name.endsWith("Set")) {
                        conv = converter(TYPE_SYNC_SET, type, Set.class);
                    } else if (name.endsWith("List")) {
                        conv = converter(TYPE_SYNC_LIST, type, List.class);
                    } else if (name.endsWith("Collection")) {
                        conv = converter(TYPE_SYNC_COLLECTION, type, Collection.class);
                    }
                }
        
                return (conv == null) ? null : new StdDelegatingDeserializer<Object>(conv);
            }
            if ((localName = _findUtilArrayTypeName(clsName)) != null) {
                // Typically ends with "List" but let's just look for it
                if (localName.contains("List")) {
                    // 21-Aug-2022, tatu: [databind#3565] Let's try avoid making "Arrays.asList()"
                    //    unmodifiable tho. Could either match "ArrayList" or just, well,
                    //    default to "any" modifiable List:
                    return new StdDelegatingDeserializer<Object>(
                            converter(TYPE_AS_LIST, type, List.class));
                }
                return null;
            }
    
            if ((localName = _findUtilCollectionsImmutableTypeName(clsName)) != null) {
                // NOTE: names are "List12" and "ListN" but... let's just look for "List"
                if (localName.contains("List")) {
                    return new StdDelegatingDeserializer<Object>(
                            converter(TYPE_AS_LIST, type, List.class));
                }
                if (localName.contains("Set")) {
                    return new StdDelegatingDeserializer<Object>(
                            converter(TYPE_UNMODIFIABLE_SET, type, Set.class));
                }
                return null;
            }
    
            return null;
        }
    
        public static JsonDeserializer<?> findForMap(DeserializationContext ctxt,
                JavaType type)
            throws JsonMappingException
        {
            final String clsName = type.getRawClass().getName();
            String localName;
            JavaUtilCollectionsConverter conv = null;
    
            if ((localName = _findUtilCollectionsTypeName(clsName)) != null) {
                String name;
            
                if ((name = _findUnmodifiableTypeName(localName)) != null) {
                    if (name.contains("Map")) {
                        conv = converter(TYPE_UNMODIFIABLE_MAP, type, Map.class);
                    }
                } else if ((name = _findSingletonTypeName(localName)) != null) {
                    if (name.contains("Map")) {
                        conv = converter(TYPE_SINGLETON_MAP, type, Map.class);
                    }
                } else if ((name = _findSyncTypeName(localName)) != null) {
                    // [databind#3009]: synchronized, too
                    if (name.contains("Map")) {
                        conv = converter(TYPE_SYNC_MAP, type, Map.class);
                    }
                }
            } else if ((localName = _findUtilCollectionsImmutableTypeName(clsName)) != null) {
                if (localName.contains("Map")) {
                    conv = converter(TYPE_UNMODIFIABLE_MAP, type, Map.class);
                }
            }
            return (conv == null) ? null : new StdDelegatingDeserializer<Object>(conv);
        }
    
        static JavaUtilCollectionsConverter converter(int kind,
                JavaType concreteType, Class<?> rawSuper)
        {
            return new JavaUtilCollectionsConverter(kind, concreteType.findSuperType(rawSuper));
        }
    
        private static String _findUtilArrayTypeName(String clsName) {
            if (clsName.startsWith(PREFIX_JAVA_UTIL_ARRAYS)) {
                return clsName.substring(PREFIX_JAVA_UTIL_ARRAYS.length());
            }
            return null;
        }
    
        private static String _findUtilCollectionsTypeName(String clsName) {
            if (clsName.startsWith(PREFIX_JAVA_UTIL_COLLECTIONS)) {
                return clsName.substring(PREFIX_JAVA_UTIL_COLLECTIONS.length());
            }
            return null;
        }
    
        private static String _findUtilCollectionsImmutableTypeName(String clsName) {
            if (clsName.startsWith(PREFIX_JAVA_UTIL_IMMUTABLE_COLL)) {
                return clsName.substring(PREFIX_JAVA_UTIL_IMMUTABLE_COLL.length());
            }
            return null;
        }
    
        private static String _findSingletonTypeName(String localName) {
            return localName.startsWith("Singleton") ? localName.substring(9): null;
        }
    
        private static String _findSyncTypeName(String localName) {
            return localName.startsWith("Synchronized") ? localName.substring(12): null;
        }
    
        private static String _findUnmodifiableTypeName(String localName) {
            return localName.startsWith("Unmodifiable") ? localName.substring(12): null;
        }
        
        /**
         * Implementation used for converting from various generic container
         * types ({@link java.util.Set}, {@link java.util.List}, {@link java.util.Map})
         * into more specific implementations accessible via {@code java.util.Collections}.
         */
        private static class JavaUtilCollectionsConverter implements Converter<Object,Object>
        {
            private final JavaType _inputType;
    
            private final int _kind;
    
            JavaUtilCollectionsConverter(int kind, JavaType inputType) {
                _inputType = inputType;
                _kind = kind;
            }
            
            @Override
            public Object convert(Object value) {
                if (value == null) { // is this legal to get?
                    return null;
                }
                
                switch (_kind) {
                case TYPE_SINGLETON_SET:
                    {
                        Set<?> set = (Set<?>) value;
                        _checkSingleton(set.size());
                        return Collections.singleton(set.iterator().next());
                    }
                case TYPE_SINGLETON_LIST:
                    {
                        List<?> list = (List<?>) value;
                        _checkSingleton(list.size());
                        return Collections.singletonList(list.get(0));
                    }
                case TYPE_SINGLETON_MAP:
                    {
                        Map<?,?> map = (Map<?,?>) value;
                        _checkSingleton(map.size());
                        Map.Entry<?,?> entry = map.entrySet().iterator().next();
                        return Collections.singletonMap(entry.getKey(), entry.getValue());
                    }
    
                case TYPE_UNMODIFIABLE_SET:
                    return Collections.unmodifiableSet((Set<?>) value);
                case TYPE_UNMODIFIABLE_LIST:
                    return Collections.unmodifiableList((List<?>) value);
                case TYPE_UNMODIFIABLE_MAP:
                    return Collections.unmodifiableMap((Map<?,?>) value);
    
                case TYPE_SYNC_SET:
                    return Collections.synchronizedSet((Set<?>) value);
                case TYPE_SYNC_LIST:
                    return Collections.synchronizedList((List<?>) value);
                case TYPE_SYNC_COLLECTION:
                    return Collections.synchronizedCollection((Collection<?>) value);
                case TYPE_SYNC_MAP:
                    return Collections.synchronizedMap((Map<?,?>) value);
                    
                case TYPE_AS_LIST:
                default:
                    // Here we do not actually care about impl type, just return List as-is:
                    return value;
                }
            }
    
            @Override
            public JavaType getInputType(TypeFactory typeFactory) {
                return _inputType;
            }
    
            @Override
            public JavaType getOutputType(TypeFactory typeFactory) {
                // we don't actually care, so:
                return _inputType;
            }
    
            private void _checkSingleton(int size) {
                if (size != 1) {
                    // not the best error ever but... has to do
                    throw new IllegalArgumentException("Can not deserialize Singleton container from "+size+" entries");
                }
            }
        }
    }
    

    com/fasterxml/jackson/databind/deser/impl/JavaUtilCollectionsDeserializers.java

     

    Or download all of them as a single archive file:

    File name: jackson-databind-2.14.0-sources.jar
    File size: 1187952 bytes
    Release date: 2022-11-05
    Download 
    

     

    Jackson Annotations Source Code

    Download and Install Jackson Binary Package

    Downloading and Reviewing jackson-*.jar

    ⇑⇑ Jackson - Java JSON library

    2022-03-29, 82967👍, 0💬