反序列化解析介绍（十）

诣极

2018-09-30

Fastjson源码解析

概要

fastjson核心功能包括序列化和反序列化，反序列化的含义是将跨语言的json字符串转换成java对象。遇到到反序列化章节，这里假定你已经阅读并理解了词法分析章节的内容。

反序列化的章节比序列化复杂一些，我认为通过调试小单元代码片段的方式有助于理解，我在适当的地方会给出单元测试入口，集中精力理解具体类型的实现。

现在，我们正式开始理解反序列化实现吧。

public static <T> T parseObject(String text, Class<T> clazz) {
    /** 根据指定text，返回期望的java对象类型class */
    return parseObject(text, clazz, new Feature[0]);
}

这个反序列化接口可以处理对象包含任意字段类型，但是自身不能是泛型类型，原因是java的运行时类型擦除。fastjson给出了替代方法解决：

1
2
3

String json = "[{},...]";
Type listType = new TypeReference<List<Model>>() {}.getType();
List<Model> modelList = JSON.parseObject(json, listType);

我们把关注点收回来，继续分析内部调用parseObject :

public static <T> T parseObject(String json, Class<T> clazz, Feature... features) {
    return (T) parseObject(json, (Type) clazz, ParserConfig.global, null, DEFAULT_PARSER_FEATURE, features);
}

    public static <T> T parseObject(String input, Type clazz, ParserConfig config, ParseProcess processor,
                                      int featureValues, Feature... features) {
    if (input == null) {
        return null;
    }

    /** 配置反序列化时启用的特性，比如是否允许json字符串字段不包含双引号 */
    if (features != null) {
        for (Feature feature : features) {
            featureValues |= feature.mask;
        }
    }

    /**
     *  初始化DefaultJSONParser，反序列化类型由它
     *  委托config查找具体序列化处理器处理
     */
    DefaultJSONParser parser = new DefaultJSONParser(input, config, featureValues);

    /** 添加拦截器 */
    if (processor != null) {
        if (processor instanceof ExtraTypeProvider) {
            parser.getExtraTypeProviders().add((ExtraTypeProvider) processor);
        }

        if (processor instanceof ExtraProcessor) {
            parser.getExtraProcessors().add((ExtraProcessor) processor);
        }

        if (processor instanceof FieldTypeResolver) {
            parser.setFieldTypeResolver((FieldTypeResolver) processor);
        }
    }

    /** 使用反序列化实例转换对象，查找具体序列化实例委托给config查找 */
    T value = (T) parser.parseObject(clazz, null);

    /** 处理json内部引用协议格式对象 */
    parser.handleResovleTask(value);

    parser.close();

    return (T) value;
}

最终反序列化接口定义了执行的大框架：

创建解析配置ParserConfig对象，包括初始化内部反序列化实例和特性配置等。
添加反序列化拦截器
根据具体类型查找反序列化实例，执行反序列化转换
解析对象内部引用

我们继续查看parser.parseObject(clazz, null)逻辑：

public <T> T parseObject(Type type, Object fieldName) {
    /** 获取json串第一个有效token */
    int token = lexer.token();
    if (token == JSONToken.NULL) {
        /** 如果返回时null，自动预读下一个token */
        lexer.nextToken();
        return null;
    }

    /** 判定token属于字符串 */
    if (token == JSONToken.LITERAL_STRING) {
        /** 获取byte字节数据，分为十六进制和base64编码 */
        if (type == byte[].class) {
            byte[] bytes = lexer.bytesValue();
            lexer.nextToken();
            return (T) bytes;
        }

        /** 获取字符数组, 特殊处理String内存占用 */
        if (type == char[].class) {
            String strVal = lexer.stringVal();
            lexer.nextToken();
            return (T) strVal.toCharArray();
        }
    }

    /** 委托config进行特定类型查找反序列化实例 */
    ObjectDeserializer derializer = config.getDeserializer(type);

    try {
        /** 执行反序列化 */
        return (T) derializer.deserialze(this, type, fieldName);
    } catch (JSONException e) {
        throw e;
    } catch (Throwable e) {
        throw new JSONException(e.getMessage(), e);
    }
}

反序列化核心逻辑还是在委托配置查找反序列化实例，我们具体看看是如何查找反序列化实例的，进入ParserConfig#getDeserializer(java.lang.reflect.Type)自己查看逻辑：

public ObjectDeserializer getDeserializer(Type type) {
    /** 首先从内部已经注册查找特定class的反序列化实例 */
    ObjectDeserializer derializer = this.deserializers.get(type);
    if (derializer != null) {
        return derializer;
    }

    if (type instanceof Class<?>) {
        /** 引用类型，根据特定类型再次匹配 */
        return getDeserializer((Class<?>) type, type);
    }

    if (type instanceof ParameterizedType) {
        /** 获取泛型类型原始类型 */
        Type rawType = ((ParameterizedType) type).getRawType();
        /** 泛型原始类型是引用类型，根据特定类型再次匹配 */
        if (rawType instanceof Class<?>) {
            return getDeserializer((Class<?>) rawType, type);
        } else {
            /** 递归调用反序列化查找 */
            return getDeserializer(rawType);
        }
    }

    if (type instanceof WildcardType) {
        /** 类型是通配符或者限定类型 */
        WildcardType wildcardType = (WildcardType) type;
        Type[] upperBounds = wildcardType.getUpperBounds();
        if (upperBounds.length == 1) {
            Type upperBoundType = upperBounds[0];
            /** 获取泛型上界(? extends T)，根据特定类型再次匹配 */
            return getDeserializer(upperBoundType);
        }
    }

    /** 如果无法匹配到，使用默认JavaObjectDeserializer反序列化 */
    return JavaObjectDeserializer.instance;
}

反序列化匹配getDeserializer(Type)主要特定处理了泛型类型，取出泛型类型真实类型还是委托内部ParserConfig#getDeserializer(java.lang.Class<?>, java.lang.reflect.Type)进行精确类型查找：

public ObjectDeserializer getDeserializer(Class<?> clazz, Type type) {
    /** 首先从内部已经注册查找特定type的反序列化实例 */
    ObjectDeserializer derializer = deserializers.get(type);
    if (derializer != null) {
        return derializer;
    }

    if (type == null) {
        type = clazz;
    }

    /** 再次从内部已经注册查找特定class的反序列化实例 */
    derializer = deserializers.get(type);
    if (derializer != null) {
        return derializer;
    }

    {
        JSONType annotation = TypeUtils.getAnnotation(clazz,JSONType.class);
        if (annotation != null) {
            Class<?> mappingTo = annotation.mappingTo();
            /** 根据类型注解指定的反序列化类型 */
            if (mappingTo != Void.class) {
                return getDeserializer(mappingTo, mappingTo);
            }
        }
    }

    if (type instanceof WildcardType || type instanceof TypeVariable || type instanceof ParameterizedType) {
        /** 根据泛型真实类型查找反序列化实例 */
        derializer = deserializers.get(clazz);
    }

    if (derializer != null) {
        return derializer;
    }

    /** 获取class名称，进行类型匹配(可以支持高版本jdk和三方库) */
    String className = clazz.getName();
    className = className.replace('$', '.');

    if (className.startsWith("java.awt.")
        && AwtCodec.support(clazz)) {
        /**
         *  如果class的name是"java.awt."开头 并且
         *  继承 Point、Rectangle、Font或者Color 其中之一
         */
        if (!awtError) {
            String[] names = new String[] {
                    "java.awt.Point",
                    "java.awt.Font",
                    "java.awt.Rectangle",
                    "java.awt.Color"
            };

            try {
                for (String name : names) {
                    if (name.equals(className)) {
                        /** 如果系统支持4中类型， 使用AwtCodec 反序列化 */
                        deserializers.put(Class.forName(name), derializer = AwtCodec.instance);
                        return derializer;
                    }
                }
            } catch (Throwable e) {
                // skip
                awtError = true;
            }

            derializer = AwtCodec.instance;
        }
    }

    if (!jdk8Error) {
        try {
            if (className.startsWith("java.time.")) {
                String[] names = new String[] {
                        "java.time.LocalDateTime",
                        "java.time.LocalDate",
                        "java.time.LocalTime",
                        "java.time.ZonedDateTime",
                        "java.time.OffsetDateTime",
                        "java.time.OffsetTime",
                        "java.time.ZoneOffset",
                        "java.time.ZoneRegion",
                        "java.time.ZoneId",
                        "java.time.Period",
                        "java.time.Duration",
                        "java.time.Instant"
                };

                for (String name : names) {
                    if (name.equals(className)) {
                        /** 如果系统支持JDK8中日期类型， 使用Jdk8DateCodec 反序列化 */
                        deserializers.put(Class.forName(name), derializer = Jdk8DateCodec.instance);
                        return derializer;
                    }
                }
            } else if (className.startsWith("java.util.Optional")) {
                String[] names = new String[] {
                        "java.util.Optional",
                        "java.util.OptionalDouble",
                        "java.util.OptionalInt",
                        "java.util.OptionalLong"
                };
                for (String name : names) {
                    if (name.equals(className)) {
                        /** 如果系统支持JDK8中可选类型， 使用OptionalCodec 反序列化 */
                        deserializers.put(Class.forName(name), derializer = OptionalCodec.instance);
                        return derializer;
                    }
                }
            }
        } catch (Throwable e) {
            // skip
            jdk8Error = true;
        }
    }

    if (className.equals("java.nio.file.Path")) {
        deserializers.put(clazz, derializer = MiscCodec.instance);
    }

    if (clazz == Map.Entry.class) {
        deserializers.put(clazz, derializer = MiscCodec.instance);
    }

    final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    try {
        /** 使用当前线程类加载器 查找 META-INF/services/AutowiredObjectDeserializer.class实现类 */
        for (AutowiredObjectDeserializer autowired : ServiceLoader.load(AutowiredObjectDeserializer.class,
                                                                        classLoader)) {
            for (Type forType : autowired.getAutowiredFor()) {
                deserializers.put(forType, autowired);
            }
        }
    } catch (Exception ex) {
        // skip
    }

    if (derializer == null) {
        derializer = deserializers.get(type);
    }

    if (derializer != null) {
        return derializer;
    }

    if (clazz.isEnum()) {
        Class<?> deserClass = null;
        JSONType jsonType = clazz.getAnnotation(JSONType.class);
        if (jsonType != null) {
            deserClass = jsonType.deserializer();
            try {
                /** 如果是枚举类型并使用了注解，使用注解指定的反序列化 */
                derializer = (ObjectDeserializer) deserClass.newInstance();
                deserializers.put(clazz, derializer);
                return derializer;
            } catch (Throwable error) {
                // skip
            }
        }
        /** 如果是枚举类型，使用EnumSerializer反序列化 */
        derializer = new EnumDeserializer(clazz);
    } else if (clazz.isArray()) {
        /** 如果是数组类型，使用数组对象反序列化实例 */
        derializer = ObjectArrayCodec.instance;
    } else if (clazz == Set.class || clazz == HashSet.class || clazz == Collection.class || clazz == List.class
               || clazz == ArrayList.class) {
        /** 如果class实现集合接口，使用CollectionCodec反序列化 */
        derializer = CollectionCodec.instance;
    } else if (Collection.class.isAssignableFrom(clazz)) {
        /** 如果class实现类Collection接口，使用CollectionCodec反序列化 */
        derializer = CollectionCodec.instance;
    } else if (Map.class.isAssignableFrom(clazz)) {
        /** 如果class实现Map接口，使用MapDeserializer反序列化 */
        derializer = MapDeserializer.instance;
    } else if (Throwable.class.isAssignableFrom(clazz)) {
        /** 如果class继承Throwable类，使用ThrowableDeserializer反序列化 */
        derializer = new ThrowableDeserializer(this, clazz);
    } else if (PropertyProcessable.class.isAssignableFrom(clazz)) {
        derializer = new PropertyProcessableDeserializer((Class<PropertyProcessable>)clazz);
    } else {
        /** 默认使用JavaBeanDeserializer反序列化(没有开启asm情况下) */
        derializer = createJavaBeanDeserializer(clazz, type);
    }

    /** 加入cache，避免同类型反复创建 */
    putDeserializer(type, derializer);

    return derializer;
}

其实查找反序列化和之前提到了序列化类似，根据特定类型匹配接口或者继承实现类查找的，这里指的关注一下创建通用反序列化实例 createJavaBeanDeserializer(clazz, type) ：

public ObjectDeserializer createJavaBeanDeserializer(Class<?> clazz, Type type) {
    boolean asmEnable = this.asmEnable & !this.fieldBased;

    /**
     *  ... 省略判定是否开启asm逻辑
     */

    /** 创建通用Java对象反序列化实例JavaBeanDeserializer */
    if (!asmEnable) {
        return new JavaBeanDeserializer(this, clazz, type);
    }

    /**
     *  ... 省略创建基于asm的反序列化对象
     */
}