关于java:用了几年的-Fastjson我最终替换成了Jackson

作者：larva-zhh\
起源：www.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/…，成果尚待察看。

替换 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：

public static JSONObject parseObject(String text);

public static JSONObject parseObject(String text, Feature... features);

public static <T> T parseObject(String text, Class<T> clazz);

public static <T> T parseObject(String text, Class<T> clazz, Feature... features);

public static <T> T parseObject(String text, TypeReference<T> type, Feature... features);

public static JSONArray parseArray(String text);

public static <T> List<T> parseArray(String text, Class<T> clazz);

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

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

   // featureValues 作为基准解析个性开关值
   // 入参 features 和 featureValues 取并集失去最终的解析个性
   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;

}

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

static {
        int features = 0;
        features |= Feature.AutoCloseSource.getMask();
        features |= Feature.InternFieldNames.getMask();
        features |= Feature.UseBigDecimal.getMask();
        features |= Feature.AllowUnQuotedFieldNames.getMask();
        features |= Feature.AllowSingleQuotes.getMask();
        features |= Feature.AllowArbitraryCommas.getMask();
        features |= Feature.SortFeidFastMatch.getMask();
        features |= Feature.IgnoreNotMatch.getMask();
        DEFAULT_PARSER_FEATURE = features;
}

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

@Test
public void printFastJsonDefaultParserFeature() {for (Feature feature : Feature.values()) {if (Feature.isEnabled(JSON.DEFAULT_PARSER_FEATURE, feature)) {System.out.println(feature);
        }
    }
}

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

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

Serialization

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

public static String toJSONString(Object object);

public static String toJSONString(Object object, SerializerFeature... features);

public static String toJSONStringWithDateFormat(Object object, String dateFormat, SerializerFeature... features);

public static String toJSONString(Object object, boolean prettyFormat);

public static void writeJSONString(Writer writer, Object object, SerializerFeature... features);

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

 public static String toJSONString(Object object, SerializeConfig config, SerializeFilter[] filters, String dateFormat, int defaultFeatures, SerializerFeature... features) {SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);

   try {JSONSerializer serializer = new JSONSerializer(out, config);

       if (dateFormat != null && dateFormat.length() != 0) {serializer.setDateFormat(dateFormat);
           serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
       }

       if (filters != null) {for (SerializeFilter filter : filters) {serializer.addFilter(filter);
           }
       }

       serializer.write(object);

       return out.toString();} finally {out.close();
   }
}

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

static {
    int features = 0;
    features |= SerializerFeature.QuoteFieldNames.getMask();
    features |= SerializerFeature.SkipTransientField.getMask();
    features |= SerializerFeature.WriteEnumUsingName.getMask();
    features |= SerializerFeature.SortField.getMask();

    DEFAULT_GENERATE_FEATURE = features;

    config(IOUtils.DEFAULT_PROPERTIES);
}

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

@Test
public void printFastJsonDefaultGenerateFeature() {for (SerializerFeature feature : SerializerFeature.values()) {if (SerializerFeature.isEnabled(JSON.DEFAULT_GENERATE_FEATURE, feature)) {System.out.println(feature);
        }
    }
}

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。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
public @interface JSONField {// 序列化和反序列化时的字段程序，等价于 jackson 的 @JsonProperty.index()
    int ordinal() default 0;

    // 序列化和反序列化时的字段名称映射，等价于 jackson 的 @JsonProperty.value()
    String name() default "";

    // 序列化和反序列化时的数据格式（日期格局、16 进制等等），等价于 jackson 的 @JsonFormat.shape() + @JsonFormat.pattern()
    String format() default "";

    // 字段是否序列化，等价于 jackson 的 @JsonProperty.access()
    boolean serialize() default true;

    // 字段是否反序列化，等价于 jackson 的 @JsonProperty.access()
    boolean deserialize() default true;

    // 序列化个性，等价于 jackson 的 @JsonProperty.with()
    SerializerFeature[] serialzeFeatures() default {};

    // 反序列化个性，等价于 jackson 的 @JsonFormat.with()
    Feature[] parseFeatures() default {};

    // 对属性进行打标，便于在序列化时进行 exclude 或 include，等价于 jackson 的 @JsonView
    String label() default "";

    // 序列化时将字段内容间接输入，不通过本义，等价于 jackson 的 @JsonRawValue
    boolean jsonDirect() default false;

    // 指定序列化时应用的 Serializer Class，等价于 jackson 的 @JsonSerialize
    Class<?> serializeUsing() default Void.class;

    // 指定反序列化时应用的 Deserializer Class，等价于 jackson 的 @JsonDeserialize
    Class<?> deserializeUsing() default Void.class;

    // 指定反序列化时应用的字段别名，等价于 jackson 的 @JsonAlias
    String[] alternateNames() default {};

    // 将字段的子属性映射到父节点上，等价于 jackson 的 @JsonUnwrapped
    boolean unwrapped() default false;

    // 指定序列化时字段为 null 时应用的默认值，等价于 jackson 的 @JsonProperty.defaultValue()
    String defaultValue() default "";}

unwrapped的用法能够参考 AnnotationUseJacksonReplaceFastJsonTest.java 中的testJSONFieldUnwrapped。

@JSONType

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

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface JSONType {

    // 是否应用 asm 优化，jackson 无对应个性
    boolean asm() default true;

    // 序列化和反序列化时的 field 排序，等价于 jackson 的 @JsonPropertyOrder.value()
    String[] orders() default {};

    // 序列化和反序列化时蕴含的 field，等价于 jackson 的
    String[] includes() default {};

    // 序列化和反序列化时疏忽的 field，等价于 jackson 的 @JsonIgnoreProperties
    String[] ignores() default {};

    // 序列化个性，等价于 jackson 的 @JsonProperty.with()
    SerializerFeature[] serialzeFeatures() default {};

    // 反序列化个性，等价于 jackson 的 @JsonFormat.with()
    Feature[] parseFeatures() default {};

    // 序列化时是否根据 field 字母程序排序，等价于 jackson 的 @JsonPropertyOrder.alphabetic()
    boolean alphabetic() default true;

    // 反序列化多态类型时，如果依据其余 typeName 等形式无奈找到正确的子类时，默认应用的子类，等价于 jackson 的 @JsonTypeInfo.defaultImpl()
    Class<?> mappingTo() default Void.class;

    // 反序列化时指定 java bean builder 类(必须是 @JSONPOJOBuilder 注解的类)，等价于 jackson 的 @JsonDeserialize.builder()
    Class<?> builder() default Void.class;

    // 申明这个类型的别名，反序列化多态类型时应用，等价于 jackson 的 @JsonTypeName
    String typeName() default "";

    // 反序列化某个接口或抽象类或父类的子类时指定依据哪个字段的值和子类的 typeName 相等来决定具体实现类，等价于 jackson 的 @JsonTypeInfo.use() = Id.CUSTOM + @JsonTypeInfo.property()
    String typeKey() default "";

    // 反序列化某个接口或抽象类或父类的子类时指定能够反序列化的子类类型，等价于 jackson 的 @JsonSubTypes
    Class<?>[] seeAlso() default{};

    // 指定序列化时应用的 Serializer Class，等价于 jackson 的 @JsonSerialize
    Class<?> serializer() default Void.class;

    // 指定反序列化时应用的 Deserializer Class，等价于 jackson 的 @JsonDeserialize
    Class<?> deserializer() default Void.class;

    // 序列化时，如果 filed 是枚举类型，则和一般的 java bean 一样输入枚举的 filed，而不是通常应用的 Enum.name()值，jackson 没有对应个性
    boolean serializeEnumAsJavaBean() default false;

    // 指定 json 和 Java bean 之间的字段名称映射策略，等价于 jackson 的 @JsonNaming
    PropertyNamingStrategy naming() default PropertyNamingStrategy.CamelCase;

    // 指定序列化时应用的 Serialize filter，等价于 jackson 的 @JsonFilter
    Class<? extends SerializeFilter>[] serialzeFilters() default {};}

JSONObject & JSONArray

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

public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {

    private final Map<String, Object> map;
    ...
}
public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {

    private static final long  serialVersionUID = 1L;
    private final List<Object> list;
    protected transient Object relatedArray;
    protected transient Type   componentType;
    ...
}

从源码就能够发现，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。

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。

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2021 最新版)

2. 终于靠开源我的项目弄到 IntelliJ IDEA 激活码了，真香！

3. 阿里 Mock 工具正式开源，干掉市面上所有 Mock 工具！

4.Spring Cloud 2020.0.0 正式公布，全新颠覆性版本！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！