devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用了几年的 Fastjson，我最终替换成了Jackson！

作者：运维做开发 | 2024-08-20 05:51:36

赞

踩

fastjson替换成jackson

来源：cnblogs.com/larva-zhh/p/11544317.html

为什么要替换fastjson

工程里大量使用了fastjson作为序列化和反序列化框架，甚至ORM在处理部分字段也依赖fastjson进行序列化和反序列化。那么作为大量使用的基础框架，为什么还要进行替换呢？

原因有以下几点：

  1. fastjson太过于侧重性能，对于部分高级特性支持不够，而且部分自定义特性完全偏离了json和js规范导致和其他框架不兼容；

  2. fastjson文档缺失较多，部分Feature甚至没有文档，而且代码缺少注释较为晦涩；

  3. fastjson的CVE bug监测较弱，很多CVE数据库网站上有关fastjson的CVE寥寥无几，例如近期的AutoType导致的高危漏洞，虽然和Jackson的PolymorphicDeserialization是同样的bug，但是CVE网站上几乎没有fastjson的bug报告。

框架选型

参考mvnrepository json libraries，根据流行度排序后前十名框架：

  • jackson2(com.fasterxml.jackson)

  • gson

  • org.json

  • jackson1(com.codehuas.jackson)

  • fastjson

  • cheshire

  • json-simple

jackson1是已经过时的框架，因此可以忽略，cheshire和json-simple排名尚且不如fastjson，也忽略，剩余jackson2、gson以及org.json，其中org.json的使用量(usage)远小于jackson2(方便起见，下文均以jackson均指代jackson2)和gson，因此org.json也可以排除了。

关于jackson和gson的比较文章有很多，stackoverflow上自行搜索，下面仅推荐几篇blog：

  • jackson vs gson

  • JSON in Java

  • the ultimate json library json-simple vs gson vs jackson vs json

在功能特性支持、稳定性、可扩展性、易用性以及社区活跃度上 jackson 和 gson 差不多，入门教程可以分别参考baeldung jackson系列 以及 baeldung gson系列。但是jackson有更多现成的类库兼容支持例如jackson-datatype-commons-lang3，以及更丰富的输出数据格式支持例如jackson-dataformat-yaml，而且spring框架默认使用jackson，因此最终我选择使用jackson。

PS: Jackson 2.10.0开始尝试基于新的API使用白名单机制来避免RCE漏洞，详见https://github.com/FasterXML/jackson-databind/issues/2195，效果尚待观察。

替换fastjson

fastjson常见的使用场景就是序列化和反序列化，偶尔会有JSONObject和JSONArray实例的相关操作。

以下步骤的源码分析基于以下版本：

  • fastjson v1.2.60

  • jackson-core v2.9.9

  • jackson-annotations v2.9.0

  • jackson-databind v2.9.9.3

Deserialization

fastjson将json字符串反序列化成Java Bean通常使用com.alibaba.fastjson.JSON的静态方法(JSONObject和JSONArray的静态方法也是来自于JSON)，常用的有以下几个API：

  1. public static JSONObject parseObject(String text);
  2.  
  3. public static JSONObject parseObject(String text, Feature... features);
  4.  
  5. public static <T> T parseObject(String text, Class<T> clazz);
  6.  
  7. public static <T> T parseObject(String text, Class<T> clazz, Feature... features);
  8.  
  9. public static <T> T parseObject(String text, TypeReference<T> type, Feature... features);
  10.  
  11. public static JSONArray parseArray(String text);
  12.  
  13. public static <T> List<T> parseArray(String text, Class<T> clazz);

从方法入参就能猜到，fastjson在执行反序列化时的Parse行为由com.alibaba.fastjson.parser.Feature指定。研究parseObject的源码后，发现底层最终都是使用的以下方法：

  1. public static <T> T parseObject(String input, Type clazz, ParserConfig config, ParseProcess processor, int featureValues, Feature... features) {
  2.         if (input == null) {
  3.             return null;
  4.         }
  5.  
  6.         // featureValues作为基准解析特性开关值
  7.         // 入参features和featureValues取并集得到最终的解析特性
  8.         if (features != null) {
  9.             for (Feature feature : features) {
  10.                 featureValues |= feature.mask;
  11.             }
  12.         }
  13.  
  14.         DefaultJSONParser parser = new DefaultJSONParser(input, config, featureValues);
  15.  
  16.         if (processor != null) {
  17.             if (processor instanceof ExtraTypeProvider) {
  18.                 parser.getExtraTypeProviders().add((ExtraTypeProvider) processor);
  19.             }
  20.  
  21.             if (processor instanceof ExtraProcessor) {
  22.                 parser.getExtraProcessors().add((ExtraProcessor) processor);
  23.             }
  24.  
  25.             if (processor instanceof FieldTypeResolver) {
  26.                 parser.setFieldTypeResolver((FieldTypeResolver) processor);
  27.             }
  28.         }
  29.  
  30.         T value = (T) parser.parseObject(clazz, null);
  31.  
  32.         parser.handleResovleTask(value);
  33.  
  34.         parser.close();
  35.  
  36.         return (T) value;
  37.     }

通过IDE搜索usage后，发现当没有作为基准解析特性开关的featureValues入参时，都是使用的DEFAULT_PARSE_FEATURE作为基准解析特性开关，以下是JSON.DEFAULT_PARSE_FEATURE的实例化代码：

  1. static {
  2.         int features = 0;
  3.         features |= Feature.AutoCloseSource.getMask();
  4.         features |= Feature.InternFieldNames.getMask();
  5.         features |= Feature.UseBigDecimal.getMask();
  6.         features |= Feature.AllowUnQuotedFieldNames.getMask();
  7.         features |= Feature.AllowSingleQuotes.getMask();
  8.         features |= Feature.AllowArbitraryCommas.getMask();
  9.         features |= Feature.SortFeidFastMatch.getMask();
  10.         features |= Feature.IgnoreNotMatch.getMask();
  11.         DEFAULT_PARSER_FEATURE = features;
  12. }

fastjson还会从环境变量中读取配置来修改DEFAULT_PARSER_FEATURE(虽然很少会有人这么做)，但最好还是通过实际运行一下程序来确认你的环境中的实际解析特性开关。

  1. @Test
  2. public void printFastJsonDefaultParserFeature() {
  3.     for (Feature feature : Feature.values()) {
  4.         if (Feature.isEnabled(JSON.DEFAULT_PARSER_FEATURE, feature)) {
  5.             System.out.println(feature);
  6.         }
  7.     }
  8. }

fastjson 和 jackson的反序列化特性对照表

反序列化fastjson和jackson的特性TestCase见DeserializationUseJacksonReplaceFastJsonTest.java

Serialization

fastjson将Java Bean序列化成json字符串通常也是使用com.alibaba.fastjson.JSON的静态方法(JSONObject和JSONArray的静态方法也是来自于JSON)，常用的有以下几个API：

  1. public static String toJSONString(Object object);
  2.  
  3. public static String toJSONString(Object object, SerializerFeature... features);
  4.  
  5. public static String toJSONStringWithDateFormat(Object object, String dateFormat, SerializerFeature... features);
  6.  
  7. public static String toJSONString(Object object, boolean prettyFormat);
  8.  
  9. public static void writeJSONString(Writer writer, Object object, SerializerFeature... features);

从方法入参也能看出，在序列化时，fastjson的特性由SerializerFeature控制，研究toJSONString的源码后，发现最终都会调用以下方法：

  1. public static String toJSONString(Object object, SerializeConfig config, SerializeFilter[] filters, String dateFormat, int defaultFeatures, SerializerFeature... features) {
  2.          SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);
  3.  
  4.          try {
  5.              JSONSerializer serializer = new JSONSerializer(out, config);
  6.              
  7.              if (dateFormat != null && dateFormat.length() != 0) {
  8.                  serializer.setDateFormat(dateFormat);
  9.                  serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
  10.              }
  11.  
  12.              if (filters != null) {
  13.                  for (SerializeFilter filter : filters) {
  14.                      serializer.addFilter(filter);
  15.                  }
  16.              }
  17.  
  18.              serializer.write(object);
  19.  
  20.              return out.toString();
  21.          } finally {
  22.              out.close();
  23.          }
  24.      }

通过IDE搜索usage后，发现当没有作为基准解析特性开关的defaultFeatures入参时，都是使用的DEFAULT_GENERATE_FEATURE作为基准解析特性开关，以下是JSON.DEFAULT_GENERATE_FEATURE的实例化代码：

  1. static {
  2.         int features = 0;
  3.         features |= SerializerFeature.QuoteFieldNames.getMask();
  4.         features |= SerializerFeature.SkipTransientField.getMask();
  5.         features |= SerializerFeature.WriteEnumUsingName.getMask();
  6.         features |= SerializerFeature.SortField.getMask();
  7.  
  8.         DEFAULT_GENERATE_FEATURE = features;
  9.  
  10.         config(IOUtils.DEFAULT_PROPERTIES);
  11.     }

fastjson还会从环境变量中读取配置来修改DEFAULT_GENERATE_FEATURE(虽然很少会有人这么做)，但最好还是通过实际运行一下程序来确认你的环境中的实际解析特性开关。

  1. @Test
  2. public void printFastJsonDefaultGenerateFeature() {
  3.     for (SerializerFeature feature : SerializerFeature.values()) {
  4.         if (SerializerFeature.isEnabled(JSON.DEFAULT_GENERATE_FEATURE, feature)) {
  5.             System.out.println(feature);
  6.         }
  7.     }
  8. }

fastjson 和 jackson的序列化特性对照表

序列化fastjson和jackson的特性TestCase见SerializationUseJacksonReplaceFastJsonTest.java

Annotation

fastjsonzhu相对于jackson来说注解的功能划分的并没有那么细，因此fastjson的一个注解可能等价于jackson多个注解的组合。

@JSONPOJOBuilder

指定反序列化时创建java对象使用的build方法，对应jackson的@JsonPOJOBuilder。

@JSONCreator

指定反序列化时创建java对象使用的构造方法，对应jackson的@JsonCreator。

@JSONField

指定序列化和反序列化field时的行为。反序列化时，等价于@JsonProperty + @JsonDeserialize + @JsonUnwrapped + @JsonFormat+ @JsonAlias；

序列化时，等价于@JsonProperty + @JsonSerialize + @JsonUnwrapped + @JsonFormat + @JsonRawValue + @JsonView。

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({ ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER })
  3. public @interface JSONField {
  4.     // 序列化和反序列化时的字段顺序，等价于jackson的@JsonProperty.index()
  5.     int ordinal() default 0;
  6.  
  7.     // 序列化和反序列化时的字段名称映射，等价于jackson的@JsonProperty.value()
  8.     String name() default "";
  9.  
  10.     // 序列化和反序列化时的数据格式（日期格式、16进制等等），等价于jackson的@JsonFormat.shape() + @JsonFormat.pattern()
  11.     String format() default "";
  12.  
  13.     // 字段是否序列化，等价于jackson的@JsonProperty.access()
  14.     boolean serialize() default true;
  15.  
  16.     // 字段是否反序列化，等价于jackson的@JsonProperty.access()
  17.     boolean deserialize() default true;
  18.  
  19.     // 序列化特性，等价于jackson的@JsonProperty.with()
  20.     SerializerFeature[] serialzeFeatures() default {};
  21.  
  22.     // 反序列化特性，等价于jackson的@JsonFormat.with()
  23.     Feature[] parseFeatures() default {};
  24.     
  25.     // 对属性进行打标，便于在序列化时进行exclude或include，等价于jackson的@JsonView
  26.     String label() default "";
  27.     
  28.     // 序列化时将字段内容直接输出，不经过转义，等价于jackson的@JsonRawValue
  29.     boolean jsonDirect() default false;
  30.     
  31.     // 指定序列化时使用的Serializer Class，等价于jackson的@JsonSerialize
  32.     Class<?> serializeUsing() default Void.class;
  33.     
  34.     // 指定反序列化时使用的Deserializer Class，等价于jackson的@JsonDeserialize
  35.     Class<?> deserializeUsing() default Void.class;
  36.  
  37.     // 指定反序列化时使用的字段别名，等价于jackson的@JsonAlias
  38.     String[] alternateNames() default {};
  39.  
  40.     // 将字段的子属性映射到父节点上，等价于jackson的@JsonUnwrapped
  41.     boolean unwrapped() default false;
  42.     
  43.     // 指定序列化时字段为null时使用的默认值，等价于jackson的@JsonProperty.defaultValue()
  44.     String defaultValue() default "";
  45. }

unwrapped的用法可以参考AnnotationUseJacksonReplaceFastJsonTest.java中的testJSONFieldUnwrapped。

@JSONType

指定序列化和反序列化一个Java Bean时的行为。

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({ ElementType.TYPE })
  3. public @interface JSONType {
  4.  
  5.     // 是否使用asm优化，jackson无对应特性
  6.     boolean asm() default true;
  7.  
  8.     // 序列化和反序列化时的field排序，等价于jackson的@JsonPropertyOrder.value()
  9.     String[] orders() default {};
  10.  
  11.     // 序列化和反序列化时包含的field，等价于jackson的
  12.     String[] includes() default {};
  13.  
  14.     // 序列化和反序列化时忽略的field，等价于jackson的@JsonIgnoreProperties
  15.     String[] ignores() default {};
  16.  
  17.     // 序列化特性，等价于jackson的@JsonProperty.with()
  18.     SerializerFeature[] serialzeFeatures() default {};
  19.     
  20.     // 反序列化特性，等价于jackson的@JsonFormat.with()
  21.     Feature[] parseFeatures() default {};
  22.     
  23.     // 序列化时是否依据field字母顺序排序，等价于jackson的@JsonPropertyOrder.alphabetic()
  24.     boolean alphabetic() default true;
  25.     
  26.     // 反序列化多态类型时，如果根据其他typeName等方式无法找到正确的子类时，默认使用的子类，等价于jackson的@JsonTypeInfo.defaultImpl()
  27.     Class<?> mappingTo() default Void.class;
  28.     
  29.     // 反序列化时指定java bean builder类(必须是@JSONPOJOBuilder注解的类)，等价于jackson的@JsonDeserialize.builder()
  30.     Class<?> builder() default Void.class;
  31.     
  32.     // 声明这个类型的别名，反序列化多态类型时使用，等价于jackson的@JsonTypeName
  33.     String typeName() default "";
  34.  
  35.     // 反序列化某个接口或抽象类或父类的子类时指定根据哪个字段的值和子类的typeName相等来决定具体实现类，等价于jackson的@JsonTypeInfo.use() = Id.CUSTOM + @JsonTypeInfo.property()
  36.     String typeKey() default "";
  37.     
  38.     // 反序列化某个接口或抽象类或父类的子类时指定可以反序列化的子类类型，等价于jackson的@JsonSubTypes
  39.     Class<?>[] seeAlso() default{};
  40.     
  41.     // 指定序列化时使用的Serializer Class，等价于jackson的@JsonSerialize
  42.     Class<?> serializer() default Void.class;
  43.     
  44.     // 指定反序列化时使用的Deserializer Class，等价于jackson的@JsonDeserialize
  45.     Class<?> deserializer() default Void.class;
  46.  
  47.     // 序列化时，如果filed是枚举类型，则和普通的java bean一样输出枚举的filed，而不是通常使用的Enum.name()值，jackson没有对应特性
  48.     boolean serializeEnumAsJavaBean() default false;
  49.  
  50.     // 指定json和Java bean之间的字段名称映射策略，等价于jackson的@JsonNaming
  51.     PropertyNamingStrategy naming() default PropertyNamingStrategy.CamelCase;
  52.  
  53.     // 指定序列化时使用的Serialize filter，等价于jackson的@JsonFilter
  54.     Class<? extends SerializeFilter>[] serialzeFilters() default {};
  55. }

JSONObject & JSONArray

首先来看看fastjon中JSONObject和JSONArray的源码：

  1. public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
  2.  
  3.     private final Map<String, Object> map;
  4.     ...
  5. }
  1. public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {
  2.  
  3.     private static final long  serialVersionUID = 1L;
  4.     private final List<Object> list;
  5.     protected transient Object relatedArray;
  6.     protected transient Type   componentType;
  7.     ...
  8. }

从源码就可以发现，JSONObject实际是一个Map<String, Object>，而JSONArray实际是一个List<JSONObject>。因此可以将JSONObject类型改为Map<String, Object>，而JSONArray类型改为List<Object>。
但是这种方式就会导致上层API出现大量修改，因为缺少了JSONObject和JSONArray提供的多种便利的类型转换方法。如果想要暂时保留JSONObject和JSONArray，此时可以采取一种取巧的方法。

暂时保留JSONObject & JSONArray的过渡方法#

jackson官方提供了对org.json库的数据类型支持jackson-datatype-json-org，因此可以将com.alibaba.fastjson.JSONObject替换为org.json.JSONObject，
com.alibaba.fastjson.JSONArray替换为org.json.JSONArray，这两个类库的对象API大致相同，当然一些细小的改动还是避免不了的。
如果想完全不改上层代码，那也可以参考jackson-datatype-json-org和
jackson-datatype-json-lib自己实现jackson对fastjson的数据类型的binder。

larva-zhang/jackson-datatype-fastjson欢迎大家使用或提issues。

https://github.com/larva-zhang/jackson-datatype-fastjson

JSONPath#

使用json-path/JsonPath就能轻松替换fastjson的JSONPath，而且功能比fastjson更强大。

只需参考JsonProvider SPI使用JacksonJsonProvider替代json-path/JsonPath默认的JsonSmartJsonProvider即可。

自定义扩展

自定义Deserializer

fastjson中实现自定义Deserializer的方法通常是实现ObjectDeserializer接口的deserialze方法

<T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName);

在jackson中实现自定义Serializer的方法则通常是继承StdDeserializer抽象类，重写deserialize方法

public abstract T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException;

自定义Serializer

fastjson中实现自定义Serializer的方法通常是实现ObjectSerializer接口的write方法

void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException;

在jackson中实现自定义Serializer的方法则通常是继承StdSerializer抽象类，重写serialize方法

public abstract void serialize(T value, JsonGenerator gen, SerializerProvider serializers) throws IOException;

自定义Serialize Filter

fastjson中提供了6种SerializeFilter，详见fastjson/wiki/SerializeFilter。
而在jackson中则是建议继承SimpleBeanPropertyFilter。

https://github.com/alibaba/fastjson/wiki/SerializeFilter

参考文档

  • alibaba/fastjson

  • FasterXML/jackson

  • Jackson快速替换Fastjson之道

  • fastjson Features 说明

  • fastjson SerializerFeatures 说明

  • fastjson JSONField 说明

  • Jackson – Decide What Fields Get Serialized/Deserialized

推荐好文

强大，10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程！

分享一套基于SpringBoot和Vue的企业级中后台开源项目，代码很规范！

能挣钱的，开源 SpringBoot 商城系统，功能超全，超漂亮

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/1005517
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号