niubility!即使JavaBean没有默认无参构造器,fastjson也可以反序列化。- - - - 阿里Fastjson反序列化源码分析

简介: 本文详细分析了 Fastjson 反序列化对象的源码(版本 fastjson-1.2.60),揭示了即使 JavaBean 沲有默认无参构造器,Fastjson 仍能正常反序列化的技术内幕。文章通过案例展示了 Fastjson 在不同构造器情况下的行为,并深入探讨了 `ParserConfig#getDeserializer` 方法的核心逻辑。此外,还介绍了 ASM 字节码技术的应用及其在反序列化过程中的角色。

niubility!即使JavaBean没有默认无参构造器,fastjson也可以反序列化。 看下面示例代码,User这个JavaBean不包含默认无参构造器。执行这段代码不仅不会像Jackson那样抛出“没有无参构造器”的异常,还能正常反序列化。

@Test
public void testFastjsonCoDec() {
    String jsonString = JSON.toJSONString(new User(1L, "Eric"));
    System.out.println(JSON.parseObject(jsonString, User.class));
}
@Data
@AllArgsConstructor
public static class User {
    private Long id;
    private String name;
}

本文我们来分析Fastjson反序列化对象的源码(Fastjson反序列化源码),我使用的版本是fastjson-1.2.60。从中,你会了解到其中蕴藏的技术内幕。

Fastjson反序列化-相关组件类(部分)及调用链路

JSON#
parseObject
DefaultJSONParser#
parseObject
ParserConfig#
getDeserializer
ParserConfig#
createJavaBeanDeserializer
ASMDeserializerFactory#
createJavaBeanDeserializer
JavaBeanDeserializer#
JavaBeanDeserializer
JavaBeanDeserializer#
deserialize




源码走起来。↓



§1. 入口 com.alibaba.fastjson.JSON

// com.alibaba.fastjson.JSON
public static <T> T parseObject(String text, Class<T> clazz) {
    return parseObject(text, clazz, new Feature[0]);
}
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);
}

注意第2个parseObject重载,其中指定的ParserConfig.globalcom.alibaba.fastjson.parser.ParserConfig类的静态单例对象(饿汉式),Fastjson反序列化的重点就是这个对象的getDeserializer(java.lang.reflect.Type)方法。暂且按下不表,我们先追踪调用到这个方法所经过的链路。

顺着上面的parseObject重载,我们继续往下探索,就到了另一个parseObject重载:

// com.alibaba.fastjson.JSON
public static <T> T parseObject(String input, Type clazz, ParserConfig config, ParseProcess processor,
       int featureValues, Feature... features) {
    if (input == null) {
        return null;
    }
    if (features != null) {
        for (Feature feature : features) {
            featureValues |= feature.mask;
        }
    }
    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);
        }
    }
    T value = (T) parser.parseObject(clazz, null);
    parser.handleResovleTask(value);
    parser.close();
    return (T) value;
}

可见这个方法返回了最终的反序列化的结果。那么,我们就要死抠它的每一行代码了。敏感的嗅觉提醒我们注意其中所调用的 com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.lang.reflect.Type, java.lang.Object)。我们看看这个方法的源码。

// com.alibaba.fastjson.parser.DefaultJSONParser
public <T> T parseObject(Type type, Object fieldName) {
    ...
    ObjectDeserializer deserializer = config.getDeserializer(type);
    try {
        if (deserializer.getClass() == JavaBeanDeserializer.class) {
            ...
            return (T) ((JavaBeanDeserializer) deserializer).deserialze(this, type, fieldName, 0);
        } else {
            return (T) deserializer.deserialze(this, type, fieldName);
        }
    } catch (JSONException e) {
        throw e;
    } catch (Throwable e) {
        throw new JSONException(e.getMessage(), e);
    }
}

看到了吧,这里调用了上面提到的ParserConfig#getDeserializer。程序就是根据它返回的 ObjectDeserializer实例,进行deserialze。

依然暂且把ParserConfig#getDeserializer当做一个黑盒。我们先看看debug出来的都是什么ObjectDeserializer。

CASE1: Java类 有 默认无参构造器

先上图。

从名字FastjsonASMDeserializer_1_User@1352可知,此时的ObjectDeserializer是一个“临时”反序列化器————阿里Fastjson库利用字节码技术动态生成的Java类反序列化器。

CASE2: Java类 没有 默认无参构造器

此时的ObjectDeserializer实例是一个JavaBeanDeserializer。

至此,一切谜团就都在ParserConfig#getDeserializer(java.lang.reflect.Type)上了。



§2. ParserConfig#getDeserializer源码分析

ParserConfig#getDeserializer(java.lang.reflect.Type)方法里重点是调用了这个类的createJavaBeanDeserializer方法。该方法作用正是创建所需的反序列化器。

这个方法里有一个局部变量asmEnable,它首先使用到当前对象的asmEnable标志。asmEnable表示是否开启ASM,默认在java环境中自动开启ASM。然后,方法里会针对各种分支逻辑,来更改局部变量asmEnable的值,决定如何生成反序列化器实例。

CASE1: Java类 有 默认无参构造器

先说ASM是什么东东?

ASM: a very small and fast Java bytecode manipulation framework.

ASM 是一个 Java 字节码操作框架,全称为 "ASM"(全称为:Abstract Syntax Model)。ASM 框架由法国电信(France Telecom)的研究员 Eric Bruneton 及其团队开发,而后被移交给 OW2 组织进行维护。ASM 允许开发者直接操作 Java 字节码,可以用于生成、转换和分析 Java 类文件。它在许多开源项目和框架中被使用,如 Spring Framework、Hibernate、JUnit 等。同样,阿里巴巴Fastjson也使用了ASM。ASM 的优势在于其轻量级和高性能。相比于其他 Java 字节码操作框架,ASM 更加灵活,并且由于其直接操作字节码的特性,通常比反射等方式更加高效。

在此”Java类 有 默认无参构造器“CASE下,我们来分析createJavaBeanDeserializer方法代码。可以看到,程序经过对目标class、目标class的fields的一顿判断后,变量asmEnable依然是true。最后调用 JavaBeanInfo.build(clazz, type, propertyNamingStrategy),并基于构建的beanInfo对象,利用字节码技术动态生成ObjectDeserializer实例。

利用字节码技术动态生成ObjectDeserializer实例,参见com.alibaba.fastjson.parser.deserializer.ASMDeserializerFactory#createJavaBeanDeserializer。阅读这段源码可以明白上面debug代码中的FastjsonASMDeserializer_1_User@1352的来源。

// com.alibaba.fastjson.parser.deserializer.ASMDeserializerFactory
public ObjectDeserializer createJavaBeanDeserializer(ParserConfig config, JavaBeanInfo beanInfo) throws Exception {
    Class<?> clazz = beanInfo.clazz;
    if (clazz.isPrimitive()) {
        throw new IllegalArgumentException("not support type :" + clazz.getName());
    }
    String className = "FastjsonASMDeserializer_" + seed.incrementAndGet() + "_" + clazz.getSimpleName();
    String classNameType;
    String classNameFull;
    Package pkg = ASMDeserializerFactory.class.getPackage();
    if (pkg != null) {
        String packageName = pkg.getName();
        classNameType = packageName.replace('.', '/') + "/" + className;
        classNameFull = packageName + "." + className;
    } else {
        classNameType = className;
        classNameFull = className;
    }
    ClassWriter cw = new ClassWriter();
    cw.visit(V1_5, ACC_PUBLIC + ACC_SUPER, classNameType, type(JavaBeanDeserializer.class), null);
    _init(cw, new Context(classNameType, config, beanInfo, 3));
    _createInstance(cw, new Context(classNameType, config, beanInfo, 3));
    _deserialze(cw, new Context(classNameType, config, beanInfo, 5));
    _deserialzeArrayMapping(cw, new Context(classNameType, config, beanInfo, 4));
    byte[] code = cw.toByteArray();
    Class<?> deserClass = classLoader.defineClassPublic(classNameFull, code, 0, code.length);
    Constructor<?> constructor = deserClass.getConstructor(ParserConfig.class, JavaBeanInfo.class);
    Object instance = constructor.newInstance(config, beanInfo);
    return (ObjectDeserializer) instance;
}

debug程序时Debugger里Frames Tab 和 Thread Dump 截图如下

CASE2: Java类 没有 默认无参构造器

同样,我们来分析createJavaBeanDeserializer方法代码。可以看到,在 JavaBean 没有默认构造器时,程序就不再使用ASM了(变量asmEnable值是false),而是直接实例化一个JavaBeanDeserializer。

下面是createJavaBeanDeserializer源码,结合程序debug,我添加了注释文字,辅助理解。

// com.alibaba.fastjson.parser.ParserConfig
public ObjectDeserializer createJavaBeanDeserializer(Class<?> clazz, Type type) {
    boolean asmEnable = this.asmEnable & !this.fieldBased; //注释:关于this.asmEnable:java环境下为true(为了区别于Android环境)
    if (asmEnable) {
        JSONType jsonType = TypeUtils.getAnnotation(clazz,JSONType.class);
        ...
    }
    if (clazz.getTypeParameters().length != 0) {
        asmEnable = false;
    }
    if (asmEnable && asmFactory != null && asmFactory.classLoader.isExternalClass(clazz)) {
        asmEnable = false;
    }
    if (asmEnable) {
        asmEnable = ASMUtils.checkName(clazz.getSimpleName());
    }
    if (asmEnable) {
        ...
        JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz
                , type
                , propertyNamingStrategy
                ,false
                , TypeUtils.compatibleWithJavaBean
                , jacksonCompatible
        );
        ...
        Constructor<?> defaultConstructor = beanInfo.defaultConstructor; //注释:因JavaBean没有无参构造器,这里的 defaultConstructor=null
        if (asmEnable && defaultConstructor == null && !clazz.isInterface()) { //注释: 走到这里时,asmEnable 依然是 true
            asmEnable = false;
        }
        for (FieldInfo fieldInfo : beanInfo.fields) {
            ...
        
        } //注释:敲黑板!for循环结束后,变量 asmEnable 的值变成了 false
    }
    ...
    if (!asmEnable) { //注释:JavaBean没有无参构造器时,走这儿,直接实例化JavaBeanDeserializer
        return new JavaBeanDeserializer(this, clazz, type);
    }
     //注释:下面逻辑是 JavaBean有默认构造器 时,利用字节码技术框架(ASM)快速生成反序列化器
    JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz, type, propertyNamingStrategy);
    try {
        return asmFactory.createJavaBeanDeserializer(this, beanInfo);
    } catch (NoSuchMethodException ex) {
        return new JavaBeanDeserializer(this, clazz, type);
    } catch (JSONException asmError) {
        return new JavaBeanDeserializer(this, beanInfo);
    } catch (Exception e) {
        throw new JSONException("create asm deserializer error, " + clazz.getName(), e);
    }
}

*JavaBeanDeserializer源码分析

JavaBeanDeserializer 这个组件就是用来解析 JSON 数据,并将其映射到 Java Bean 对象的相应属性上,完成数据的转换和处理操作。???

com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer 实现 com.alibaba.fastjson.parser.deserializer.ObjectDeserializer 接口。 它主要为 JavaBean的每个field定义了FieldDeserializer,同时,它实现了deserialze方法的具体逻辑。

上面代码中调用的构造器 JavaBeanDeserializer(this, clazz, type)里,初始化了一个类型为JavaBeanInfo名为beanInfo的field。debug有参构造器的User时,它长这样:

然后,我们看看 JavaBeanDeserializer#deserialze 方法的关键代码。结合程序debug有参构造器的User,我添加了注释文字,辅助理解。其实主要是获取构造器参数值,然后利用java.lang.reflect反射机制通过构造器创建JavaBean对象。

// com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer
protected <T> T deserialze(DefaultJSONParser parser, // 
                           Type type, // 
                           Object fieldName, // 
                           Object object, // 入参 object 是null
                           int features, //
                           int[] setFlags) {
    if (type == JSON.class || type == JSONObject.class) { // 注释:原数据是JSON/JSONObject,直接parse
        return (T) parser.parse();
    }
    //...
    //...
    if (object == null) {
        String[] paramNames = beanInfo.creatorConstructorParameters;  // 注释:null
        final Object[] params;  // 注释:构造器的参数值(多个)
        if (paramNames != null) {
            //...
        } else {
            FieldInfo[] fieldInfoList = beanInfo.fields;
            int size = fieldInfoList.length;
            params = new Object[size];
            for (int i = 0; i < size; ++i) {
                FieldInfo fieldInfo = fieldInfoList[i];
                Object param = fieldValues.get(fieldInfo.name);
                if (param == null) {//注释:为null时,获取基本类型的默认值
                    Type fieldType = fieldInfo.fieldType;
                    param = //...
                }
                params[i] = param;
            }
        }
        if (beanInfo.creatorConstructor != null) {
            //...
            // 注释:利用反射创建对象(rt.jar里java.lang.reflect.Constructor#newInstance)
            object = beanInfo.creatorConstructor.newInstance(params);
            //...
        }
    }
    Method buildMethod = beanInfo.buildMethod;
    if (buildMethod == null) {
        return (T) object; // 返回结果
    }
    //...
}

上面获取基本类型的默认值,比较简单,见下方。

if (fieldType == byte.class) param = (byte) 0;
else if (fieldType == short.class) param = (short) 0;
else if (fieldType == int.class) param = 0;
else if (fieldType == long.class) param = 0L;
else if (fieldType == float.class) param = 0F;
else if (fieldType == double.class) param = 0D;
else if (fieldType == boolean.class) param = Boolean.FALSE;
else if (fieldType == String.class && (...) != 0) param = "";



§3. 至此,本文告一段落。

不过,通过测试,发现一个问题,就是 当上面的User的有参构造器不是全参构造器时,反序列化只会把构造器参数包含的field赋值,其余field则是null。

即,下方代码的返回值是 FastJsonTest.User(id=123, name=null)

public void testFastjsonCoDec() {
        User object = new User(123L);
        object.setName("Eric");
        String jsonString = JSON.toJSONString(object);
        System.out.println(JSON.parseObject(jsonString, User.class));
    }
    @Data
    public static class User {
        private Long id;
        private String name;
        
        public User(Long id) {
            this.id = id;
        }
    }

个中缘由,择日再分析。

目录
相关文章
|
10天前
|
JSON 数据格式 索引
Python中序列化/反序列化JSON格式的数据
【11月更文挑战第4天】本文介绍了 Python 中使用 `json` 模块进行序列化和反序列化的操作。序列化是指将 Python 对象(如字典、列表)转换为 JSON 字符串,主要使用 `json.dumps` 方法。示例包括基本的字典和列表序列化,以及自定义类的序列化。反序列化则是将 JSON 字符串转换回 Python 对象,使用 `json.loads` 方法。文中还提供了具体的代码示例,展示了如何处理不同类型的 Python 对象。
|
15天前
|
存储 JSON fastjson
再也不用心惊胆战地使用FastJSON了——序列化篇
本篇将主要介绍json序列化的详细流程。本文阅读的FastJSON源码版本为2.0.31。
|
20天前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里,对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化,并探讨其背后的原理。通过实际代码示例,我们将一步步展示如何将复杂数据结构转换为字节流,以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题,以确保你的应用程序既高效又安全。
|
1月前
|
存储 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第9天】在Java的世界里,对象序列化是连接数据持久化与网络通信的桥梁。本文将深入探讨Java对象序列化的机制、实践方法及反序列化过程,通过代码示例揭示其背后的原理。从基础概念到高级应用,我们将一步步揭开序列化技术的神秘面纱,让读者能够掌握这一强大工具,以应对数据存储和传输的挑战。
|
1月前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第3天】在Java编程的世界里,对象序列化与反序列化是实现数据持久化和网络传输的关键技术。本文将深入探讨Java序列化的原理、应用场景以及如何通过代码示例实现对象的序列化与反序列化过程。从基础概念到实践操作,我们将一步步揭示这一技术的魅力所在。
|
20天前
|
存储 缓存 NoSQL
一篇搞懂!Java对象序列化与反序列化的底层逻辑
本文介绍了Java中的序列化与反序列化,包括基本概念、应用场景、实现方式及注意事项。序列化是将对象转换为字节流,便于存储和传输;反序列化则是将字节流还原为对象。文中详细讲解了实现序列化的步骤,以及常见的反序列化失败原因和最佳实践。通过实例和代码示例,帮助读者更好地理解和应用这一重要技术。
18 0
|
2月前
|
存储 XML JSON
用示例说明序列化和反序列化
用示例说明序列化和反序列化
|
2月前
|
JSON 安全 编译器
扩展类实例的序列化和反序列化
扩展类实例的序列化和反序列化
34 0
|
2月前
|
XML Dubbo Java
分布式-序列化,反序列化
分布式-序列化,反序列化
|
3月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输,之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。