Fastjson源码分析—ParserConfig的作用及原理（2）

最新推荐文章于 2025-03-27 11:26:03 发布
最新推荐文章于 2025-03-27 11:26:03 发布
阅读量3k 收藏 1
点赞数 1
分类专栏： Fastjson 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45854465/article/details/121341388
版权
本文详细剖析ParserConfig的getDeserializer, createJavaBeanDeserializer和initJavaBeanDeserializers方法，揭示Fastjson如何通过这些函数实现自定义序列化过程，提升灵活性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2021SC@SDUSC
上一篇我们分析了ParserConfig的使用方法、关键变量的含义以及checkAutoType方法ConfigFromPropety方法的解析，这篇文章我们继续分析ParserConfig的另外几个关键方法，深度了解它的作用原理。

目录

getDeserializer(Type type)

该方法用于获取指定类型的反序列化器。反序列化匹配getDeserializer(Type)主要特定处理了泛型类型，取出泛型类型真实类型还是委托内部ParserConfig#getDeserializer(java.lang.Class<?>, java.lang.reflect.Type)进行精确类型查找。
先上代码：

 public ObjectDeserializer getDeserializer(Type type) {
        ObjectDeserializer deserializer = get(type);
        if (deserializer != null) {
            return deserializer;
        }

        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];
                return getDeserializer(upperBoundType);
            }
        }

        return JavaObjectDeserializer.instance;
    }

可以看到该方法的执行流程是：

  1. 首先从内部已经注册查找特定class的反序列化实例
  2. 如果是引用类型，根据特定类型再次匹配
  3. 获取泛型类型原始类型
  4. 如果泛型原始类型是引用类型，根据特定类型再次匹配
  5. 递归调用反序列化查找
  6. 如果类型是通配符或者限定类型，获取泛型上界，根据特定类型再次匹配
  7. 如果无法匹配到，使用默认JavaObjectDeserializer反序列化

createJavaBeanDeserializer

该方法用于创建特定javabean的反序列化器，先看看代码：

    public ObjectDeserializer createJavaBeanDeserializer(Class<?> clazz, Type type) {
        boolean asmEnable = this.asmEnable & !this.fieldBased;
        if (asmEnable) {
            JSONType jsonType = TypeUtils.getAnnotation(clazz,JSONType.class);

            if (jsonType != null) {
                Class<?> deserializerClass = jsonType.deserializer();
                if (deserializerClass != Void.class) {
                    try {
                        Object deseralizer = deserializerClass.newInstance();
                        if (deseralizer instanceof ObjectDeserializer) {
                            return (ObjectDeserializer) deseralizer;
                        }
                    } catch (Throwable e) {
                        // skip
                    }
                }

                asmEnable = jsonType.asm()
                        && jsonType.parseFeatures().length == 0;
            }

            if (asmEnable) {
                Class<?> superClass = JavaBeanInfo.getBuilderClass(clazz, jsonType);
                if (superClass == null) {
                    superClass = clazz;
                }

                for (;;) {
                    if (!Modifier.isPublic(superClass.getModifiers())) {
                        asmEnable = false;
                        break;
                    }

                    superClass = superClass.getSuperclass();
                    if (superClass == Object.class || superClass == null) {
                        break;
                    }
                }
            }
        }

        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) {
            if (clazz.isInterface()) {
                asmEnable = false;
            }
            JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz
                    , type
                    , propertyNamingStrategy
                    ,false
                    , TypeUtils.compatibleWithJavaBean
                    , jacksonCompatible
            );

            if (asmEnable && beanInfo.fields.length > 200) {
                asmEnable = false;
            }

            Constructor<?> defaultConstructor = beanInfo.defaultConstructor;
            if (asmEnable && defaultConstructor == null && !clazz.isInterface()) {
                asmEnable = false;
            }

            for (FieldInfo fieldInfo : beanInfo.fields) {
                if (fieldInfo.getOnly) {
                    asmEnable = false;
                    break;
                }

                Class<?> fieldClass = fieldInfo.fieldClass;
                if (!Modifier.isPublic(fieldClass.getModifiers())) {
                    asmEnable = false;
                    break;
                }

                if (fieldClass.isMemberClass() && !Modifier.isStatic(fieldClass.getModifiers())) {
                    asmEnable = false;
                    break;
                }

                if (fieldInfo.getMember() != null //
                    && !ASMUtils.checkName(fieldInfo.getMember().getName())) {
                    asmEnable = false;
                    break;
                }

                JSONField annotation = fieldInfo.getAnnotation();
                if (annotation != null //
                    && ((!ASMUtils.checkName(annotation.name())) //
                        || annotation.format().length() != 0 //
                        || annotation.deserializeUsing() != Void.class //
                        || annotation.parseFeatures().length != 0 //
                        || annotation.unwrapped())
                        || (fieldInfo.method != null && fieldInfo.method.getParameterTypes().length > 1)) {
                    asmEnable = false;
                    break;
                }

                if (fieldClass.isEnum()) { // EnumDeserializer
                    ObjectDeserializer fieldDeser = this.getDeserializer(fieldClass);
                    if (!(fieldDeser instanceof EnumDeserializer)) {
                        asmEnable = false;
                        break;
                    }
                }
            }
        }

        if (asmEnable) {
            if (clazz.isMemberClass() && !Modifier.isStatic(clazz.getModifiers())) {
                asmEnable = false;
            }
        }

        if (asmEnable) {
            if (TypeUtils.isXmlField(clazz)) {
                asmEnable = false;
            }
        }

        if (!asmEnable) {
            return new JavaBeanDeserializer(this, clazz, type);
        }

        JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz, type, propertyNamingStrategy);
        try {
            return asmFactory.createJavaBeanDeserializer(this, beanInfo);
            // } catch (VerifyError e) {
            // e.printStackTrace();
            // return new JavaBeanDeserializer(this, clazz, type);
        } 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);
        }
    }

代码比较长，其中包括许多if分支，总结下来，这个方法主要做了这些事：
先确定是否使用asm。首先对asmEnable判断，如果是true，则使用asm的方式生成特定javabean的反序列化器，否则，使用常规的set方法进行反序列化（效率低、不安全）。
在确定使用asm的前提下，先判断要反序列化的类型JSONType，如果默认的反序列化解析器库中存在相应的解析器，那么调用相应的解析器。如果没有，则生成对应的解析器：先确定json字符串有哪些属性，然后构造对应的setter、getter，使用前几篇提到的asm方法直接生成class文件。

initJavaBeanDeserializers

讲完了Java bean构造器如何动态生成，就可以看看在如何对其进行初始化了。

public void initJavaBeanDeserializers(Class<?>... classes) {
        if (classes == null) {
            return;
        }

        for (Class<?> type : classes) {
            if (type == null) {
                continue;
            }
            ObjectDeserializer deserializer = createJavaBeanDeserializer(type, type);
            putDeserializer(type, deserializer);
        }
    }

首先对传入的class对象判断是否为空，如果为空，直接返回。不为空的话，一个一个对class对象判断其type，type若为空，跳过这一轮循环进入下一轮循环。不为空，则调用createJavaBeanDeserializer为其生成反序列化器，并将对应的type和反序列化器放入一个map容器中。

总结

这两篇着重分析了ParserConfig的关键方法的作用及其实现原理。ParserConfig的存在，使得Fastjson可以实现高度定制化，调用者可以自由地对Fastjson进行配置从而达到自己的目的。

fastjson源码--进大厂的最后一脚
weixin_41563161的博客
12-24 1241
fastjson源码–进大厂的最后一脚 1.序 记得春招面试的时候的面试官问有读过什么源码没有，自己只是稍微看了一下fastjson的，并且当时最尴尬的是自己对着自己的笔记给面试官读的，然后就顺利的拿下了大厂的offer。所以源码还是值得读的。读源码会让我们有更多的思考在里面，学习的设计思想的魅力。今天就把fastjson整理一下。 2.详细 2.1 JSON 2.1.1 什么是JSON 让我们先来认识一下JSON是什么。以下是百度百科的内容。 简单来说， Json是一种轻量级的数据交换格式，采用一种“键
fastjson深度源码解析- 反序列化(一) - 反序列化解析介绍
商宗海的博客
02-05 5435
概要 fastjson核心功能包括序列化和反序列化，反序列化的含义是将跨语言的json字符串转换成java对象。遇到到反序列化章节，这里假定你已经阅读并理解了词法分析章节的内容。 反序列化的章节比序列化复杂一些，我认为通过调试小单元代码片段的方式有助于理解，我在适当的地方会给出单元测试入口，集中精力理解具体类型的实现。 现在，我们正式开始理解反序列化实现吧。 pu
FastJsonParser
05-20
FastJsonParser
Fastjson源码分析—ParserConfig的作用及原理（1）
qq_45854465的博客
11-08 9620
使用Fastjson进行反序列化时，我们总希望能够对反序列化的过程进行一个定制，有时候这种定制我们希望是临时的，有时希望是全局的。之前提到过我们可以通过feature参数对反序列化的属性进行定制，包括是否允许使用大括号、是否允许多重逗号等。今天谈一下ParserConfig类，它拥有比feature更强大的功能，从更高的角度对反序列化过程进行控制，支持全局定制，也可以进对某一次反序列化改变其默认的行为。下面开始分析。 目录ParserConfig的使用ParserConfig的变量及含义ParserConf
SpringBoot-JSON:Fastjson2-Jackson 高级功能及基础使用配置、技巧、案例
最新发布
T_TO_O－的专栏
03-27 1866
场景：从复杂 JSON 中提取特定字段。// 输出：Alice说明：类似XPath语法，支持复杂路径查询。场景：序列化时输出指定格式的日期。// 输出：2025-03-27说明：通过注册自定义序列化器。场景：处理特殊类型（如枚举、自定义对象）。@Override// 注解使用说明：通过实现自定义序列化逻辑。技巧Fastjson2Jackson自定义序列化自定义处理 null 值性能优化JSONB 二进制格式流式 API + 模块化配置动态解析JSONPath。
configparser模块用法
依の手帳
12-01 795
configparser模块是python内置的一个用于处理配置文件(.ini文件)的模块. import configparser config = configparser.ConfigParser() config['phonenum'] = {'ergou':'13344445555'} with open('example.ini', 'w') as f: config.wri...
FastJSON实现详解
poijm
09-27 2583
本篇接下来的内容是基于FastJSON 1.1.40，着重讲述其序列化、反序列化实现，最后分析FastJSON为何如此“fast”的原因。 1. 序列化 所谓序列化，就是将java各种对象转化为json串。不多说，先上图。    序列化入口 平常我们经常用到的是JSON.toJSONString()这个静态方法来实现序列化。其实JSON是一个抽象类，该类实
Python模块之configparser：文件增删改查
weixin_30681615的博客
06-22 126
configparser模块 该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节（section），每个节可以有多个参数（键=值）。 创建文件 来看一个好多软件的常见文档格式如下： [DEFAULT] ServerAliveInterval = 45 Compression = yes CompressionLevel = 9 ForwardX11 =...
FastJson源码解析：掌握Json数据处理
FastJson 的源码分析涉及到对 JSON 解析原理的理解，包括 JSON 数据结构、解析算法、以及 FastJson 自身特有的设计模式和代码实现。解析 JSON 数据的过程通常包括以下几个核心步骤： 1. 词法分析（Lexical Analysis...
Fastjson 1.2.47版本使用教程及源码解析
Fastjson 是一个广泛使用的 Java 语言编写的高性能的 JSON 库，它可以快速地将 Java 对象转换为 JSON 格式的...通过提供的示例代码和源码分析，可以更深入地理解 Fastjson 的工作机制，以便在实际项目中更好地运用。
fastjson深度源码解析- 序列化(六) - json特定序列化实现解析
商宗海的博客
02-04 3931
序列化回调接口实现分析 特定序列化实现解析 MapSerializer序列化 按照代码的顺序第一个分析到Map序列化器，内部调用write： public void write(JSONSerializer serializer , Object object , Object fieldName
深入fastjson源码命令执行调试
2201_75353421的博客
06-28 678
本文给出一份fastjson在调试命令执行时的底层过程展现。
configparser配置文件解析模块
WY_记录
08-12 734
configparser配置文件解析模块 配置文件 configparser 的基本操作 其他注意 configparser配置文件解析模块 配置文件 配置文件中包含一个或多个 section， 每个 section 有自己的 option； section 用 [sect_name] 表示，每个option是一个键值对，使用分隔符= 或: 隔开； 在 optio...
java configparser_configparser模块简介
weixin_29599033的博客
02-17 393
configparser模块简介该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节(section)，每个节可以有多个参数(键=值)。节与java原先的配置文件相同的格式看一下configparser生成的配置文件的格式[DEFAULT]ServerAliveInterval = 45Compression = yesCompressionLevel = 9Forwa...
序列化方式二——JSON之Fastjson
zhouhengzhe的博客
09-20 2777
允许用户自定义序列化器，用于控制特定类型的序列化过程。用户需要实现接口，并重写write方法。@Data// 构造方法、getter和setter省略@Override// 自定义序列化逻辑// 输出自定义序列化后的结果专门用于处理将 JSON 数据反序列化为 Java 对象的过程。不过，需要注意的是，对于大多数开发者而言，直接使用进行自定义反序列化可能不是最常见的做法，因为 Fastjson 提供了更高级别的抽象（如@JSONField注解、Feature。
【FastJson】FastJson 解析报错serializer error/deserializer error
懂得一千零一种,赋予你失败的方法！
03-12 1988
比如下面这个样子： com.alibaba.fastjson.JSONException: create asm deserializer error, com.dituwuyou.bean.User at com.alibaba.fastjson.parser.ParserConfig.createJavaBeanDeserializer(ParserConfig.java:529) at com.alibaba.fastjson.parser.ParserConfig.getDeseri
FastJSON 简单使用
u013456370的专栏
02-09 711
转载链接：http://blog.youkuaiyun.com/flysun3344/article/details/54707965需要相关jar包，如果使用maven的话，在pom.xml文件加入一下依赖：&lt;dependency&gt; &lt;groupId&gt;com.alibaba&lt;/groupId&gt; &lt;artifactId&gt;fastjson&lt...
fastjson2 反序列化包含多层泛型结构的实体类 泛型被擦除 解决方案
寂夜了无痕的博客
03-21 1750
fastjson2 反序列化包含多层泛型结构的实体类 泛型被擦除 解决方案
fastjson源码分析
05-12
下面就简单介绍一下fastjson的源码分析。 1. 核心架构 fastjson的核心架构包括JSONReader、JSONWriter、JSONLexer、JSONParser、JSONScanner、JSONSerializer、JSONDeserializer等模块。其中，JSONLexer和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值