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/type/TypeParser.java

    package com.fasterxml.jackson.databind.type;
    
    import java.util.*;
    
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.util.ClassUtil;
    
    /**
     * Simple recursive-descent parser for parsing canonical {@link JavaType}
     * representations and constructing type instances.
     */
    public class TypeParser
        implements java.io.Serializable
    {
        private static final long serialVersionUID = 1L;
    
        protected final TypeFactory _factory;
            
        public TypeParser(TypeFactory f) {
            _factory = f;
        }
    
        /**
         * @since 2.6.2
         */
        public TypeParser withFactory(TypeFactory f) {
            return (f == _factory) ? this : new TypeParser(f);
        }
    
        public JavaType parse(String canonical) throws IllegalArgumentException
        {
            MyTokenizer tokens = new MyTokenizer(canonical.trim());
            JavaType type = parseType(tokens);
            // must be end, now
            if (tokens.hasMoreTokens()) {
                throw _problem(tokens, "Unexpected tokens after complete type");
            }
            return type;
        }
    
        protected JavaType parseType(MyTokenizer tokens)
            throws IllegalArgumentException
        {
            if (!tokens.hasMoreTokens()) {
                throw _problem(tokens, "Unexpected end-of-string");
            }
            Class<?> base = findClass(tokens.nextToken(), tokens);
    
            // either end (ok, non generic type), or generics
            if (tokens.hasMoreTokens()) {
                String token = tokens.nextToken();
                if ("<".equals(token)) {
                    List<JavaType> parameterTypes = parseTypes(tokens);
                    TypeBindings b = TypeBindings.create(base, parameterTypes);
                    return _factory._fromClass(null, base, b);
                }
                // can be comma that separates types, or closing '>'
                tokens.pushBack(token);
            }
            return _factory._fromClass(null, base, TypeBindings.emptyBindings());
        }
    
        protected List<JavaType> parseTypes(MyTokenizer tokens)
            throws IllegalArgumentException
        {
            ArrayList<JavaType> types = new ArrayList<JavaType>();
            while (tokens.hasMoreTokens()) {
                types.add(parseType(tokens));
                if (!tokens.hasMoreTokens()) break;
                String token = tokens.nextToken();
                if (">".equals(token)) return types;
                if (!",".equals(token)) {
                    throw _problem(tokens, "Unexpected token '"+token+"', expected ',' or '>')");
                }
            }
            throw _problem(tokens, "Unexpected end-of-string");
        }
    
        protected Class<?> findClass(String className, MyTokenizer tokens)
        {
            try {
                return _factory.findClass(className);
            } catch (Exception e) {
                ClassUtil.throwIfRTE(e);
                throw _problem(tokens, "Cannot locate class '"+className+"', problem: "+e.getMessage());
            }
        }
    
        protected IllegalArgumentException _problem(MyTokenizer tokens, String msg)
        {
            return new IllegalArgumentException(String.format("Failed to parse type '%s' (remaining: '%s'): %s",
                    tokens.getAllInput(), tokens.getRemainingInput(), msg));
        }
    
        final static class MyTokenizer extends StringTokenizer
        {
            protected final String _input;
    
            protected int _index;
    
            protected String _pushbackToken;
    
            public MyTokenizer(String str) {            
                super(str, "<,>", true);
                _input = str;
            }
    
            @Override
            public boolean hasMoreTokens() {
                return (_pushbackToken != null) || super.hasMoreTokens();
            }
            
            @Override
            public String nextToken() {
                String token;
                if (_pushbackToken != null) {
                    token = _pushbackToken;
                    _pushbackToken = null;
                } else {
                    token = super.nextToken();
                    _index += token.length();
                    token = token.trim();
                }
                return token;
            }
    
            public void pushBack(String token) {
                _pushbackToken = token;
                // let's NOT change index for now, since token may have been trim()ed
            }
    
            public String getAllInput() { return _input; }
    //        public String getUsedInput() { return _input.substring(0, _index); }
            public String getRemainingInput() { return _input.substring(_index); }
        }
    }
    

    com/fasterxml/jackson/databind/type/TypeParser.java

     

    ⇒ Jackson Annotations Source Code

    ⇐ Download and Install Jackson Binary Package

    ⇑ Downloading and Reviewing jackson-*.jar

    ⇑⇑ Jackson - Java JSON library

    2022-03-29, 32308👍, 0💬