fastjson改造，fastjson转jackson（真实项目案例，主要提供思路）_jackson fastjson

背景

1. fastjson太过于侧重性能，对于部分高级特性支持不够，而且部分自定义特性完全偏离了json和js规范导致和其他框架不兼容；
2. fastjson文档缺失较多，部分Feature甚至没有文档，而且代码缺少注释较为晦涩；
3. fastjson的CVE bug监测较弱，很多CVE数据库网站上有关fastjson的CVE寥寥无几，例如近期的AutoType导致的高危漏洞，虽然和Jackson的PolymorphicDeserialization是同样的bug，但是CVE网站上几乎没有fastjson的bug报告。

jackson和gson的使用数量遥遥领先，但是jackson有更多现成的类库兼容支持例如jackson-datatype-commons-lang3，以及更丰富的输出数据格式支持例如jackson-dataformat-yaml，而且spring框架默认使用jackson，因此最终我选择使用jackson。（其实是公司要求）

声明一下，本文主要讲述改造思路，并没有粘贴源码（怕），但是保证看完之后能对fastjson和jackson的基本结构有更多认识，对fastjson改造有一定的思路。我们组的项目就是这么改的，历史两周，已开发自测完成。

fastjson和jackson对比

想要改造好，必须先了解二者的基本结构，对两个框架的功能非常了解。接下来先介绍一下fastjson和jackson。

fastjson的基本结构

目前项目中大量的代码均使用了fastjson和json-lib两种框架（主要是fastjson），总计超过200个类中使用了这两种框架，且fastjson的代码api和jackson的相差较大，逐一改造十分困难，改造量巨大，想要改造的话需要先熟悉一下这两种框架，下面是二者的对比。

项目中主要使用的是fastjson的三个类或接口，分别是JSON,JSONObject,JSONObject我们先来看一下fastjson的基本结构。

不难发现，JSON作为JSONObject和JSONArray的父类，包含了绝大多数JSONObject和JSONArray的功能方法，包括最常用的toJSONString，parseObject，parseArray，主要用来进行 json字符串 与 具体的业务对象 与 json对象（即框架定义的包装Json的对象，比如JSONObject和JSONArray）之间的转化。

而JSONObject和JSONArray主要的作用是用来存储数据。JSONObject用来存储对象类型的json，并且实现了Map<String,Object>接口，并有一个 Map<String,Object> 类型的属性来存储数据。JSONArray用来存储数组类型的json，实现了List<Object>接口，有一个List<Object> 类型的属性来存储数据。

fastjson的结构还是非常简单的，总结一下，JSON集成了所有功能型的方法。JSONObject 和 JSONArray 都实现了JSON 接口，分别用来存储对象和数组。

简单的结构应该是fastjson快速的原因之一，或许也是频繁发生安全漏洞的原因。

jackson的基本结构

而jackson的结构就要复杂很多了。

jackson同样有包装json对象和json数组的类，分别为ObjectNode和ArrayNode，分别和fastjson的JSONObject和JSONArray对应。ObjectNode 和 ArrayNode同样有一个共同的父类 “JsonNode”，不过不同的是，这个JsonNode并不像fastjson的JSON一样，他并不包含功能类方法，只包含一些基本的操作数据的方法，比如isEmpty、isObject、asText 这种方法。并没有将 json字符串与具体对象与json对象之间转化的功能。

那么jackson框架如何进行转化操作的呢？他是通过一个叫做ObjectMapper的类进行的格式转化的功能，而且方法名和fastjson相差确实很多。

如果只是这样的话，看起来差距也没有这么大，应该比较容易就能进行格式转化才对，但是最大的问题并不是这里。
最大的问题是fastjson和jackson的数据存储逻辑也有很大的不同。

首先就是jackson的ObjectNode和ArrayNode并没有实现Map接口和List接口，意味着在使用fastjson时直接用JSONObject和JSONArray作为Map和List进行参数传递是不行的。

其次，虽然两者都使用Map或者List来存储数据，但是两者Map或者List中可存储的数据类型不同，即Map和List的泛型参数不同，比如说，前面提到过，fastjson的JSONObject使用 Map<String,Object> 进行存储对象的键值对，JSONArray使用List<Object>来存储数组元素。而jackson的ObjectNode使用Map<String,JsonNode>来存储数据，ArrayNode使用List<JsonNode> 进行存储。这就意味着在fastjson中，对象键值对的value可以是任何类型，而ObjectNode的value只能是JsonNode，任何想要存进来的数据都需要转化成JsonNode才行。数组也是同理。

由于jackson对于存储到ObjectNode和ArrayNode中数据的类型进行了类型的限制。所以，所有基本类型和String类型在jackson都有对应的 JsonNode 的实现类。比如String的实现类 TextNode，boolean的实现类 BooleanNode等，甚至连null值都有对应的实现类 NullNode。

总结一下，jackson 对于所有基本类型和对象都有包装类，包括存储对象的ObjectNode，存储数组的ArrayNode，存储整形数字的IntNode，存储String的TextNode等。而且ObjectNode中用来存储键值对的Map，其value只能是JsonNode或其实现类。ArrayNode中数组的元素也只能存储JsonNode或其实现类。并且他们两个都没有实现Map接口。ObjectMapper是用来进行格式转化的工具类。下面是对应的一些类图。

改造思路

介绍完两者的不同，接下来介绍一下到底如何改造，具体的改造思路如何。即如何重写JSON，JSONObject和JSONArray三个类。

由于项目中使用到JSONObject，JSONArray，JSON等类的次数过多，并且fastjson和jackson的api差距过大，如果想要修改最少的代码，可以重写JSONObject，JSONArray，JSON这三个类，并且 JSONObject继承ObjectNode类，JSONArray继承ArrayNode类，然后按照fastjson框架中对应的方法名实现对应的方法，直接全局替换包名就可以了。

JSON重写

首先需要重写JSON类，这个类主要是作为一个工具类，后面重写的JSONObject和JSONArray都要在方法中调用JSON工具类中的方法。那为什么不像fastjson那样用继承的方式呢？Java只支持单继承，JSONObject和JSONArray已经继承了ObjectNode和ArrayNode了。

因为fastjson和jackson默认的序列化规则可能，比如fastjson默认是支持json字符串的字段名使用单引号括起来，jackson不支持，fastjson默认支持json字符串末尾多一个逗号，jackson不支持等。而且这些不同都是可以通过添加配置来修改的，只需要将所需要的配置添加到ObjectMapper这个mapper中即可。所以需要先配置一个默认的ObjectMapper，使其和fastjson的默认序列化规则相同，即下面类中的 OBJECT_MAPPER常量，并用createMapper配置了一些序列化和反序列化规则，至于最后的filter到后面再说。

配置好默认的mapper了，就可以开始重写fastjson中的方法了，JSON的主要功能是进行数据之间的格式转化，即json字符串、具体的业务对象、json对象（JsonNode及其实现类）这三种数据之间的转化，其中json字符串和具体业务对象之间的转化比较简单，ObjectMapper中都有相应的方法。

而涉及到转化为JsonNode等json对象时会比较复杂。总共包括两种情况，即将json字符串转化为json对象和将业务对象转化为json对象。

这里以将json字符串转化为json对象举例，用ObjectMapper的默认方法最多将json字符串转化为ObjectNode或者ArrayNode等实现类，怎么将ObjectNode或者ArrayNode再转化为JSONObject和JSONArray呢？

其实，真实存储数据的是ObjectNode中的map和ArrayNode中的List，我们只需要将map和list中的数据转移过去就好。如果要将ObjectNode转化为JSONObject的话，只要new出一个JSONObject来，将ObjectNode中的map取出并放到新创建的JSONObject中即可，ArrayNode也是同理。这里重写了一个JSONObject的构造方法，接收的参数是ObjectNode，方法中遍历ObjectNode中map的键值对然后插入到新的JSONObject中。注意，这里新创建的JSONObject中map和原来ObjectNode中的map不是一个，并且map中的value也不是同一个对象，只是值相同而已，原因是 Map的put方法应该就是创建了一个新的对象然后再把值放进去（值拷贝）。

这里需要注意，如果json字符串中的json对象有多层，也就是对象中有对象或者对象中有数组，那么为了使每一层ArrayNode和ObjectNode都能被转化为JSONArray和JSONObject的话，需要递归进行上述操作。也就是这里的fromNode方法。

public static JsonNode fromNode(JsonNode jsonNode){  
    if (jsonNode != null) {  
       try {  
          if(jsonNode.isObject()){  
             JSONObject jsonObject = new JSONObject((ObjectNode) jsonNode);  
             Iterator<Map.Entry<String, JsonNode>> fields = jsonObject.fields();  
             while(fields.hasNext()){  
                Map.Entry<String, JsonNode> next = fields.next();  
                String key = next.getKey();  
                JsonNode value = next.getValue();  
                value = fromNode(value);  
                jsonObject.put(key,value);  
             }  
             return jsonObject;  
          }else if(jsonNode.isArray()){  
             JSONArray jsonArray = new JSONArray((ArrayNode) jsonNode);  
             for(int i=0;i<jsonArray.size();i++){  
                JsonNode value = jsonArray.get(i);  
                value = fromNode(value);  
                jsonArray.set(i,value);  
             }  
             return jsonArray;  
          }else{  
             return jsonNode;  
          }       } catch (Exception e) {  
          logger.error("对象转化为JsonNode失败");  
          throw new MdmRuntimeException("对象转化为JsonNode失败", e);  
       }  
    }  
    return null;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

经过上述操作，已经完成了fastjson中JSON的大部分功能，即进行数据格式的转化，剩下就是对JSONObject和JSONArray进行重写了。

JSONObject和JSONArray重写

JSONObject和JSONArray的大部分的方法就是对内部的数据进行获取或者添加，大部分是比较容易编写的，需要注意的包括几点：

1. 自定义的JSONObject的value只能是JsonNode，而fastjson的JSONObject可以的value可以是任何对象。这点在上文提到过，这就要求在往里塞数据时需要多转化一步，包括null值。JSONArray也是同理。

2. JSONObject的getJSONObject方法使用了强转的方式，将拿到的ObjectNode直接强转成JSONObject后返回，因为前面的反序列化方法等已经将内部所有层的ObjectNode全都转化为JSONObject了，而所有的JSONObject都是通过反序列化得到的，所以可以直接强转。
   这里需要注意的是，不能通过get到ObjectNode后通过上面讲述的fromNode方法进行转化，上文提到过，转化后的JSONObject和之前的ObjectNode中的map不是一个，里面的value也不是同一个对象。

这样就完成了所有的基本功能，即数据之间的转化和对象的基本操作。其余就剩一些特殊情况的处理，比如特殊的序列化规则和反序列化的规则（比如字段过滤等）、对JSONObject和JSONArray的遍历（fastjson的实现了Map或者List，能使用Map和List的遍历方式，jackson的不行），将JSONObject当作map进行参数传递等等，这些特殊情况都需要单独处理了。

特别注意

修改完成之后两条常见的问题。

1. 如果将JSONObject或者JSONArray直接作为controller接受的参数，或者接受的对象中有JSONObject和JSONArray作为属性，需要注意，会产生类型转化错误，会报错”不能将ObjectNode转化为JSONObject“，这时需要编写一个JSONObject的反序列化器，使用前面将ObjectNode对JSONObject转化的方法进行转化，然后将反序列器通过注释（@JsonDeserialize(using = JSONObjectDeserializer.class) 加到JSONObject类和JSONObject属性上。JSONArray同理。

2. 如果想从JSONObject或者JSONArray中获取字符串类型的元素的话，注意，get拿到的元素为TextNode类型，此时不能调用toString方法，需要调用asText方法，如果使用toString的话，会导致拿到的字符串多一对双引号。

序列化和反序列化规则

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);
1
2
3
4
5
6
7
8
9
10
11
12
13

从方法入参就能猜到，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;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

通过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;
}
1
2
3
4
5
6
7
8
9
10
11
12

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);
        }
    }
}
1
2
3
4
5
6
7
8

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

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);
1
2
3
4
5
6
7
8
9

从方法入参也能看出，在序列化时，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();
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

通过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);
}
1
2
3
4
5
6
7
8
9
10
11

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);
        }
    }
}
1
2
3
4
5
6
7
8

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

convertValue方法

Jackson的 convertValue 方法主常用于在不同类型的Java对象之间进行转换。这个方法属于 ObjectMapper 类，是Jackson库提供的一个非常强大的功能，可以让你轻松地在各种复杂的数据类型之间进行转换，包括从Java对象到Map、从Map到Java对象、甚至是从一种Java对象转换为另一种Java对象。

原理

convertValue 方法的工作原理基于Jackson的序列化和反序列化能力。当你调用这个方法时，Jackson实际上执行了两个步骤：

1. 序列化：首先，将源对象序列化为中间形式（通常是JSON字符串）。这一步涉及到根据Java对象的类型信息，将其转换为一种中间表示形式，这个过程中会考虑到对象内部的各种注解、类型信息等，以确保转换的准确性。
2. 反序列化：然后，将这个中间形式（JSON字符串）反序列化为目标类型的对象。在这一步，Jackson根据目标类型的信息，将中间形式转换为最终的Java对象，这个过程同样会考虑到目标对象类型的注解、构造函数、设值方法等信息，以确保对象能正确并完整地被构建。

使用场景

convertValue 方法非常适合在以下场景中使用：

• 当你需要将一个复杂的Java对象转换为一个Map，以便于访问其内部属性时。
• 当你需要将一个Map转换为一个具体的Java对象时，这在处理动态数据或者不太规范的JSON数据时非常有用。
• 当你需要将一个Java对象转换为另一个Java对象时，特别是这两个对象有着相似的结构但不完全相同，或者它们来自不同的类层次结构。

注意事项

虽然 convertValue 方法非常强大和灵活，但在使用时也需要注意以下几点：

• 性能考虑：由于转换过程实际上涉及到了序列化和反序列化，所以在性能敏感的场景下要谨慎使用。
• 类型安全：由于 convertValue 方法在编译时不会检查类型安全，因此在运行时可能会遇到类型不匹配的问题。使用时应确保目标类型与源对象是兼容的。
• 数据丢失：在从一个类型转换为另一个类型的过程中，如果两个类型不是完全匹配的，可能会发生数据丢失的情况。因此，确保目标类型能够承载源对象的所有重要信息是非常关键的。