fastjson深度源码解析- 序列化(四) - json序列化实现解析

转x33g5p2x  于2021-12-25 转载在 其他  
字(12.8k)|赞(0)|评价(0)|浏览(800)

概要

fastjson序列化主要使用入口就是在JSON.java类中，它提供非常简便和友好的api将java对象转换成json字符串。

JSON成员函数

  1. /** * 便捷序列化java对象，序列化对象可以包含任意泛型属性字段，但是不适用本身是泛型的对象。 * 默认序列化返回字符串，可以使用writeJSONString(Writer, Object, SerializerFeature[]) * 将序列化字符串输出到指定输出器中 */
  2.     public static String toJSONString(Object object) {
  3.         /** * 直接调用重载方法，将指定object序列化成json字符串，忽略序列化filter */
  4.         return toJSONString(object, emptyFilters);
  5.     }

使用便捷接口toJSONString方法，可以将任意java对象序列化为json字符串，内部调用toJSONString(Object, SerializeFilter[], SerializerFeature... ) :

  1. public static String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features) {
  2.         return toJSONString(object, SerializeConfig.globalInstance, filters, null, DEFAULT_GENERATE_FEATURE, features);
  3.     }

继续跟踪方法调用到toJSONString(Object, SerializeConfig ,SerializeFilter[], String, int, SerializerFeature... ) :

  1. public static String toJSONString(Object object,                   /** 序列化对象    */
  2.                                       SerializeConfig config,          /** 全局序列化配置 */
  3.                                       SerializeFilter[] filters,       /** 序列化拦截器   */
  4.                                       String dateFormat,               /** 序列化日期格式 */
  5.                                       int defaultFeatures,             /** 默认序列化特性 */
  6.                                       SerializerFeature... features) { /** 自定义序列化特性 */
  7.         /** 初始化序列化writer，用features覆盖defaultFeatures配置 */
  8.         SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);
  10.         try {
  12.             /** * 初始化JSONSerializer，序列化类型由它委托config查找具体 * 序列化处理器处理，序列化结果写入out的buffer中 */
  13.             JSONSerializer serializer = new JSONSerializer(out, config);
  15.             if (dateFormat != null && dateFormat.length() != 0) {
  16.                 serializer.setDateFormat(dateFormat);
  17.                 /** 调用out 重新配置属性 并且打开WriteDateUseDateFormat特性 */
  18.                 serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
  19.             }
  21.             if (filters != null) {
  22.                 for (SerializeFilter filter : filters) {
  23.                     /** 添加拦截器 */
  24.                     serializer.addFilter(filter);
  25.                 }
  26.             }
  28.             /** 使用序列化实例转换对象，查找具体序列化实例委托给config查找 */
  29.             serializer.write(object);
  31.             return out.toString();
  32.         } finally {
  33.             out.close();
  34.         }
  35.     }

这个序列化方法实际并不是真正执行序列化操作，首先做序列化特性配置，然后追加序列化拦截器，开始执行序列化对象操作委托给了config对象查找。

我们继续进入serializer.write(object) 查看：

  1. public final void write(Object object) {
  2.         if (object == null) {
  3.             /** 如果对象为空，直接输出 "null" 字符串 */
  4.             out.writeNull();
  5.             return;
  6.         }
  8.         Class<?> clazz = object.getClass();
  9.         /** 根据对象的Class类型查找具体序列化实例 */
  10.         ObjectSerializer writer = getObjectWriter(clazz);
  12.         try {
  13.             /** 使用具体serializer实例处理对象 */
  14.             writer.write(this, object, null, null, 0);
  15.         } catch (IOException e) {
  16.             throw new JSONException(e.getMessage(), e);
  17.         }
  18.     }

序列化回调接口

ObjectSerializer序列化接口

我们发现真正序列化对象的时候是由具体ObjectSerializer实例完成，我们首先查看一下接口定义：

  1. void write(JSONSerializer serializer, /** json序列化实例 */
  2.                Object object,       /** 待序列化的对象*/
  3.                Object fieldName,    /** 待序列化字段*/
  4.                Type fieldType,      /** 待序列化字段类型 */
  5.                int features) throws IOException;

当fastjson序列化特定的字段时会回调这个方法。

我们继续跟踪writer.write(this, object, null, null, 0) :

  1. public final void write(Object object) {
  2.         if (object == null) {
  3.             /** 如果对象为空，直接输出 "null" 字符串 */
  4.             out.writeNull();
  5.             return;
  6.         }
  8.         Class<?> clazz = object.getClass();
  9.         /** 根据对象的Class类型查找具体序列化实例 */
  10.         ObjectSerializer writer = getObjectWriter(clazz);
  12.         try {
  13.             /** 使用具体serializer实例处理对象 */
  14.             writer.write(this, object, null, null, 0);
  15.         } catch (IOException e) {
  16.             throw new JSONException(e.getMessage(), e);
  17.         }
  18.     }

我们发现在方法内部调用getObjectWriter(clazz)根据具体类型查找序列化实例，方法内部只有一行调用 config.getObjectWriter(clazz)，让我们更进一步查看委托实现细节com.alibaba.fastjson.serializer.SerializeConfig#getObjectWriter(java.lang.Class<?>):

  1. public ObjectSerializer getObjectWriter(Class<?> clazz) {
  2.         return getObjectWriter(clazz, true);
  3.     }

内部又调用com.alibaba.fastjson.serializer.SerializeConfig#getObjectWriter(java.lang.Class<?>, boolean)，这个类实现相对复杂了一些，我会按照代码顺序梳理所有序列化实例的要点 :

  1. private ObjectSerializer getObjectWriter(Class<?> clazz, boolean create) {
  2.         /** 首先从内部已经注册查找特定class的序列化实例 */
  3.         ObjectSerializer writer = serializers.get(clazz);
  5.         if (writer == null) {
  6.             try {
  7.                 final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  8.                 /** 使用当前线程类加载器 查找 META-INF/services/AutowiredObjectSerializer.class实现类 */
  9.                 for (Object o : ServiceLoader.load(AutowiredObjectSerializer.class, classLoader)) {
  10.                     if (!(o instanceof AutowiredObjectSerializer)) {
  11.                         continue;
  12.                     }
  14.                     AutowiredObjectSerializer autowired = (AutowiredObjectSerializer) o;
  15.                     for (Type forType : autowired.getAutowiredFor()) {
  16.                         /** 如果存在，注册到内部serializers缓存中 */
  17.                         put(forType, autowired);
  18.                     }
  19.                 }
  20.             } catch (ClassCastException ex) {
  21.                 // skip
  22.             }
  24.             /** 尝试在已注册缓存找到特定class的序列化实例 */
  25.             writer = serializers.get(clazz);
  26.         }
  28.         if (writer == null) {
  29.             /** 使用加载JSON类的加载器 查找 META-INF/services/AutowiredObjectSerializer.class实现类 */
  30.             final ClassLoader classLoader = JSON.class.getClassLoader();
  31.             if (classLoader != Thread.currentThread().getContextClassLoader()) {
  32.                 try {
  33.                     for (Object o : ServiceLoader.load(AutowiredObjectSerializer.class, classLoader)) {
  35.                         if (!(o instanceof AutowiredObjectSerializer)) {
  36.                             continue;
  37.                         }
  39.                         AutowiredObjectSerializer autowired = (AutowiredObjectSerializer) o;
  40.                         for (Type forType : autowired.getAutowiredFor()) {
  41.                             /** 如果存在，注册到内部serializers缓存中 */
  42.                             put(forType, autowired);
  43.                         }
  44.                     }
  45.                 } catch (ClassCastException ex) {
  46.                     // skip
  47.                 }
  49.                 /** 尝试在已注册缓存找到特定class的序列化实例 */
  50.                 writer = serializers.get(clazz);
  51.             }
  52.         }
  54.         if (writer == null) {
  55.             String className = clazz.getName();
  56.             Class<?> superClass;
  58.             if (Map.class.isAssignableFrom(clazz)) {
  59.                 /** 如果class实现类Map接口，使用MapSerializer序列化 */
  60.                 put(clazz, writer = MapSerializer.instance);
  61.             } else if (List.class.isAssignableFrom(clazz)) {
  62.                 /** 如果class实现类List接口，使用ListSerializer序列化 */
  63.                 put(clazz, writer = ListSerializer.instance);
  64.             } else if (Collection.class.isAssignableFrom(clazz)) {
  65.                 /** 如果class实现类Collection接口，使用CollectionCodec序列化 */
  66.                 put(clazz, writer = CollectionCodec.instance);
  67.             } else if (Date.class.isAssignableFrom(clazz)) {
  68.                 /** 如果class继承Date，使用DateCodec序列化 */
  69.                 put(clazz, writer = DateCodec.instance);
  70.             } else if (JSONAware.class.isAssignableFrom(clazz)) {
  71.                 /** 如果class实现类JSONAware接口，使用JSONAwareSerializer序列化 */
  72.                 put(clazz, writer = JSONAwareSerializer.instance);
  73.             } else if (JSONSerializable.class.isAssignableFrom(clazz)) {
  74.                 /** 如果class实现类JSONSerializable接口，使用JSONSerializableSerializer序列化 */
  75.                 put(clazz, writer = JSONSerializableSerializer.instance);
  76.             } else if (JSONStreamAware.class.isAssignableFrom(clazz)) {
  77.                 /** 如果class实现类JSONStreamAware接口，使用MiscCodecr序列化 */
  78.                 put(clazz, writer = MiscCodec.instance);
  79.             } else if (clazz.isEnum()) {
  80.                 JSONType jsonType = TypeUtils.getAnnotation(clazz, JSONType.class);
  81.                 if (jsonType != null && jsonType.serializeEnumAsJavaBean()) {
  82.                     /** 如果是枚举类型，并且启用特性 serializeEnumAsJavaBean * 使用JavaBeanSerializer序列化(假设没有启用asm) */
  83.                     put(clazz, writer = createJavaBeanSerializer(clazz));
  84.                 } else {
  85.                     /** 如果是枚举类型，没有启用特性 serializeEnumAsJavaBean * 使用EnumSerializer序列化 */
  86.                     put(clazz, writer = EnumSerializer.instance);
  87.                 }
  88.             } else if ((superClass = clazz.getSuperclass()) != null && superClass.isEnum()) {
  89.                 JSONType jsonType = TypeUtils.getAnnotation(superClass, JSONType.class);
  90.                 if (jsonType != null && jsonType.serializeEnumAsJavaBean()) {
  91.                     /** 如果父类是枚举类型，并且启用特性 serializeEnumAsJavaBean * 使用JavaBeanSerializer序列化(假设没有启用asm) */
  92.                     put(clazz, writer = createJavaBeanSerializer(clazz));
  93.                 } else {
  94.                     /** 如果父类是枚举类型，没有启用特性 serializeEnumAsJavaBean * 使用EnumSerializer序列化 */
  95.                     put(clazz, writer = EnumSerializer.instance);
  96.                 }
  97.             } else if (clazz.isArray()) {
  98.                 Class<?> componentType = clazz.getComponentType();
  99.                 /** 如果是数组类型，根据数组实际类型查找序列化实例 */
  100.                 ObjectSerializer compObjectSerializer = getObjectWriter(componentType);
  101.                 put(clazz, writer = new ArraySerializer(componentType, compObjectSerializer));
  102.             } else if (Throwable.class.isAssignableFrom(clazz)) {
  103.                 /** 注册通用JavaBeanSerializer序列化处理 Throwable */
  104.                 SerializeBeanInfo beanInfo = TypeUtils.buildBeanInfo(clazz, null, propertyNamingStrategy);
  105.                 beanInfo.features |= SerializerFeature.WriteClassName.mask;
  106.                 put(clazz, writer = new JavaBeanSerializer(beanInfo));
  107.             } else if (TimeZone.class.isAssignableFrom(clazz) || Map.Entry.class.isAssignableFrom(clazz)) {
  108.                 /** 如果class实现Map.Entry接口或者继承类TimeZone，使用MiscCodecr序列化 */
  109.                 put(clazz, writer = MiscCodec.instance);
  110.             } else if (Appendable.class.isAssignableFrom(clazz)) {
  111.                 /** 如果class实现Appendable接口，使用AppendableSerializer序列化 */
  112.                 put(clazz, writer = AppendableSerializer.instance);
  113.             } else if (Charset.class.isAssignableFrom(clazz)) {
  114.                 /** 如果class继承Charset抽象类，使用ToStringSerializer序列化 */
  115.                 put(clazz, writer = ToStringSerializer.instance);
  116.             } else if (Enumeration.class.isAssignableFrom(clazz)) {
  117.                 /** 如果class实现Enumeration接口，使用EnumerationSerializer序列化 */
  118.                 put(clazz, writer = EnumerationSerializer.instance);
  119.             } else if (Calendar.class.isAssignableFrom(clazz)
  120.                     || XMLGregorianCalendar.class.isAssignableFrom(clazz)) {
  121.                 /** 如果class继承类Calendar或者XMLGregorianCalendar，使用CalendarCodec序列化 */
  122.                 put(clazz, writer = CalendarCodec.instance);
  123.             } else if (Clob.class.isAssignableFrom(clazz)) {
  124.                 /** 如果class实现Clob接口，使用ClobSeriliazer序列化 */
  125.                 put(clazz, writer = ClobSeriliazer.instance);
  126.             } else if (TypeUtils.isPath(clazz)) {
  127.                 /** 如果class实现java.nio.file.Path接口，使用ToStringSerializer序列化 */
  128.                 put(clazz, writer = ToStringSerializer.instance);
  129.             } else if (Iterator.class.isAssignableFrom(clazz)) {
  130.                 /** 如果class实现Iterator接口，使用MiscCodec序列化 */
  131.                 put(clazz, writer = MiscCodec.instance);
  132.             } else {
  133.                 /** * 如果class的name是"java.awt."开头 并且 * 继承 Point、Rectangle、Font或者Color 其中之一 */
  134.                 if (className.startsWith("java.awt.")
  135.                     && AwtCodec.support(clazz)
  136.                 ) {
  137.                     // awt
  138.                     if (!awtError) {
  139.                         try {
  140.                             String[] names = new String[]{
  141.                                     "java.awt.Color",
  142.                                     "java.awt.Font",
  143.                                     "java.awt.Point",
  144.                                     "java.awt.Rectangle"
  145.                             };
  146.                             for (String name : names) {
  147.                                 if (name.equals(className)) {
  148.                                     /** 如果系统支持4中类型， 使用AwtCodec 序列化 */
  149.                                     put(Class.forName(name), writer = AwtCodec.instance);
  150.                                     return writer;
  151.                                 }
  152.                             }
  153.                         } catch (Throwable e) {
  154.                             awtError = true;
  155.                             // skip
  156.                         }
  157.                     }
  158.                 }
  160.                 // jdk8
  161.                 if ((!jdk8Error) //
  162.                     && (className.startsWith("java.time.") //
  163.                         || className.startsWith("java.util.Optional") //
  164.                         || className.equals("java.util.concurrent.atomic.LongAdder")
  165.                         || className.equals("java.util.concurrent.atomic.DoubleAdder")
  166.                     )) {
  167.                     try {
  168.                         {
  169.                             String[] names = new String[]{
  170.                                     "java.time.LocalDateTime",
  171.                                     "java.time.LocalDate",
  172.                                     "java.time.LocalTime",
  173.                                     "java.time.ZonedDateTime",
  174.                                     "java.time.OffsetDateTime",
  175.                                     "java.time.OffsetTime",
  176.                                     "java.time.ZoneOffset",
  177.                                     "java.time.ZoneRegion",
  178.                                     "java.time.Period",
  179.                                     "java.time.Duration",
  180.                                     "java.time.Instant"
  181.                             };
  182.                             for (String name : names) {
  183.                                 if (name.equals(className)) {
  184.                                     /** 如果系统支持JDK8中日期类型， 使用Jdk8DateCodec 序列化 */
  185.                                     put(Class.forName(name), writer = Jdk8DateCodec.instance);
  186.                                     return writer;
  187.                                 }
  188.                             }
  189.                         }
  190.                         {
  191.                             String[] names = new String[]{
  192.                                     "java.util.Optional",
  193.                                     "java.util.OptionalDouble",
  194.                                     "java.util.OptionalInt",
  195.                                     "java.util.OptionalLong"
  196.                             };
  197.                             for (String name : names) {
  198.                                 if (name.equals(className)) {
  199.                                     /** 如果系统支持JDK8中可选类型， 使用OptionalCodec 序列化 */
  200.                                     put(Class.forName(name), writer = OptionalCodec.instance);
  201.                                     return writer;
  202.                                 }
  203.                             }
  204.                         }
  205.                         {
  206.                             String[] names = new String[]{
  207.                                     "java.util.concurrent.atomic.LongAdder",
  208.                                     "java.util.concurrent.atomic.DoubleAdder"
  209.                             };
  210.                             for (String name : names) {
  211.                                 if (name.equals(className)) {
  212.                                     /** 如果系统支持JDK8中原子类型， 使用AdderSerializer 序列化 */
  213.                                     put(Class.forName(name), writer = AdderSerializer.instance);
  214.                                     return writer;
  215.                                 }
  216.                             }
  217.                         }
  218.                     } catch (Throwable e) {
  219.                         // skip
  220.                         jdk8Error = true;
  221.                     }
  222.                 }
  224.                 if ((!oracleJdbcError) //
  225.                     && className.startsWith("oracle.sql.")) {
  226.                     try {
  227.                         String[] names = new String[] {
  228.                                 "oracle.sql.DATE",
  229.                                 "oracle.sql.TIMESTAMP"
  230.                         };
  232.                         for (String name : names) {
  233.                             if (name.equals(className)) {
  234.                                 /** 如果系统支持oralcle驱动中日期类型， 使用DateCodec 序列化 */
  235.                                 put(Class.forName(name), writer = DateCodec.instance);
  236.                                 return writer;
  237.                             }
  238.                         }
  239.                     } catch (Throwable e) {
  240.                         // skip
  241.                         oracleJdbcError = true;
  242.                     }
  243.                 }
  245.                 if ((!springfoxError) //
  246.                     && className.equals("springfox.documentation.spring.web.json.Json")) {
  247.                     try {
  248.                         /** 如果系统支持springfox-spring-web框架中Json类型， 使用SwaggerJsonSerializer 序列化 */
  249.                         put(Class.forName("springfox.documentation.spring.web.json.Json"),
  250.                                 writer = SwaggerJsonSerializer.instance);
  251.                         return writer;
  252.                     } catch (ClassNotFoundException e) {
  253.                         // skip
  254.                         springfoxError = true;
  255.                     }
  256.                 }
  258.                 if ((!guavaError) //
  259.                         && className.startsWith("com.google.common.collect.")) {
  260.                     try {
  261.                         String[] names = new String[] {
  262.                                 "com.google.common.collect.HashMultimap",
  263.                                 "com.google.common.collect.LinkedListMultimap",
  264.                                 "com.google.common.collect.ArrayListMultimap",
  265.                                 "com.google.common.collect.TreeMultimap"
  266.                         };
  268.                         for (String name : names) {
  269.                             if (name.equals(className)) {
  270.                                 /** 如果系统支持guava框架中日期类型， 使用GuavaCodec 序列化 */
  271.                                 put(Class.forName(name), writer = GuavaCodec.instance);
  272.                                 return writer;
  273.                             }
  274.                         }
  275.                     } catch (ClassNotFoundException e) {
  276.                         // skip
  277.                         guavaError = true;
  278.                     }
  279.                 }
  281.                 if ((!jsonnullError) && className.equals("net.sf.json.JSONNull")) {
  282.                     try {
  283.                         /** 如果系统支持json-lib框架中JSONNull类型， 使用MiscCodec 序列化 */
  284.                         put(Class.forName("net.sf.json.JSONNull"), writer = MiscCodec.instance);
  285.                         return writer;
  286.                     } catch (ClassNotFoundException e) {
  287.                         // skip
  288.                         jsonnullError = true;
  289.                     }
  290.                 }
  292.                 Class[] interfaces = clazz.getInterfaces();
  293.                 /** 如果class只实现唯一接口，并且接口包含注解，使用AnnotationSerializer 序列化 */
  294.                 if (interfaces.length == 1 && interfaces[0].isAnnotation()) {
  295.                     return AnnotationSerializer.instance;
  296.                 }
  298.                 /** 如果使用了cglib或者javassist动态代理 */
  299.                 if (TypeUtils.isProxy(clazz)) {
  300.                     Class<?> superClazz = clazz.getSuperclass();
  302.                     /** 通过父类型查找序列化，父类是真实的类型 */
  303.                     ObjectSerializer superWriter = getObjectWriter(superClazz);
  304.                     put(clazz, superWriter);
  305.                     return superWriter;
  306.                 }
  308.                 /** 如果使用了jdk动态代理 */
  309.                 if (Proxy.isProxyClass(clazz)) {
  310.                     Class handlerClass = null;
  312.                     if (interfaces.length == 2) {
  313.                         handlerClass = interfaces[1];
  314.                     } else {
  315.                         for (Class proxiedInterface : interfaces) {
  316.                             if (proxiedInterface.getName().startsWith("org.springframework.aop.")) {
  317.                                 continue;
  318.                             }
  319.                             if (handlerClass != null) {
  320.                                 handlerClass = null; // multi-matched
  321.                                 break;
  322.                             }
  323.                             handlerClass = proxiedInterface;
  324.                         }
  325.                     }
  327.                     if (handlerClass != null) {
  328.                         /** 根据class实现接口类型查找序列化 */
  329.                         ObjectSerializer superWriter = getObjectWriter(handlerClass);
  330.                         put(clazz, superWriter);
  331.                         return superWriter;
  332.                     }
  333.                 }
  335.                 if (create) {
  336.                     /** 没有精确匹配，使用通用JavaBeanSerializer 序列化(假设不启用asm) */
  337.                     writer = createJavaBeanSerializer(clazz);
  338.                     put(clazz, writer);
  339.                 }
  340.             }
  342.             if (writer == null) {
  343.                 /** 尝试在已注册缓存找到特定class的序列化实例 */
  344.                 writer = serializers.get(clazz);
  345.             }
  346.         }
  347.         return writer;
  348.     }

查找具体序列化实例，查找方法基本思想根据class类型或者实现接口类型进行匹配查找。接下来针对逐个序列化实现依次分析。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/shangzonghai/article/details/79253263

内容来源于网络，如有侵权，请联系作者删除！

Javafastjson源码解析

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com