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

心已赠人 2022-10-16 14:29 323阅读 0赞

![0D5F937FE12312312D81F17F.jpg][]

程序员的成长之路

互联网/程序员/技术/资料共享

[关注][Link 1]

阅读本文大概需要 15 分钟。

作者：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

![d6a2c0a2350514de6049f703a78928ad.png][]

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

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的反序列化特性对照表 ##

<table> 
 <thead> 
  <tr> 
   <th>fastjson特性说明</th> 
   <th>fastjson枚举</th> 
   <th>fastjson默认状态</th> 
   <th>jackson枚举</th> 
   <th>jackson默认状态</th> 
   <th>jackson特性说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Parser close时自动关闭为创建Parser实例而创建的底层InputStream以及Reader等输入流</td> 
   <td>Feature.AutoCloseSource</td> 
   <td>开启</td> 
   <td>JsonParser.Feature.AUTO_CLOSE_SOURCE</td> 
   <td>开启</td> 
   <td>保持开启</td> 
  </tr> 
  <tr> 
   <td>允许json字符串中带注释</td> 
   <td>Feature.AllowComment</td> 
   <td>关闭</td> 
   <td>JsonParser.Feature.ALLOW_COMMENTS</td> 
   <td>关闭</td> 
   <td>根据系统的json数据情况开启</td> 
  </tr> 
  <tr> 
   <td>允许json字段名不被引号包括起来</td> 
   <td>Feature.AllowUnQuotedFieldNames</td> 
   <td>开启</td> 
   <td>JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES</td> 
   <td>关闭</td> 
   <td>根据系统的json数据情况开启</td> 
  </tr> 
  <tr> 
   <td>允许json字段名使用单引号包括起来</td> 
   <td>Feature.AllowSingleQuotes</td> 
   <td>开启</td> 
   <td>JsonParser.Feature.ALLOW_SINGLE_QUOTES</td> 
   <td>关闭</td> 
   <td>根据系统的json数据情况开启</td> 
  </tr> 
  <tr> 
   <td>将json字段名作为字面量缓存起来，即<code>fieldName.intern()</code></td> 
   <td>Feature.InternFieldNames</td> 
   <td>开启</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson默认使用<code>InternCache</code>缓存了PropertyName</td> 
  </tr> 
  <tr> 
   <td>识别ISO8601格式的日期字符串，例如：<code>2018-05-31T19:13:42.000Z</code>或<code>2018-05-31T19:13:42.000+07:00</code></td> 
   <td>Feature.AllowISO8601DateFormat</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson默认支持ISO8601格式日期字符串的解析，并且也可以通过<code>ObjectMapper.setDateFormat</code>指定解析格式</td> 
  </tr> 
  <tr> 
   <td>忽略json中包含的连续的多个逗号，非标准特性</td> 
   <td>Feature.AllowArbitraryCommas</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson不支持该特性，且该特性是非标准特性，因此可以忽略</td> 
  </tr> 
  <tr> 
   <td>将json中的浮点数解析成BigDecimal对象，禁用后会解析成Double对象</td> 
   <td>Feature.UseBigDecimal</td> 
   <td>开启</td> 
   <td>DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS</td> 
   <td>关闭</td> 
   <td>建议开启</td> 
  </tr> 
  <tr> 
   <td>解析时忽略未知的字段继续完成解析</td> 
   <td>Feature.IgnoreNotMatch</td> 
   <td>开启</td> 
   <td>DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES</td> 
   <td>开启</td> 
   <td>jackson默认开启遇到未知属性需要抛异常，因此如要和fastjson保持一致则需要关闭该特性</td> 
  </tr> 
  <tr> 
   <td>如果你用fastjson序列化的文本，输出的结果是按照fieldName排序输出的，parser时也能利用这个顺序进行优化读取。这种情况下，parser能够获得非常好的性能</td> 
   <td>Feature.SortFeidFastMatch</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>fastjson内部处理逻辑，jackson不支持该特性，不影响功能</td> 
  </tr> 
  <tr> 
   <td>禁用ASM</td> 
   <td>Feature.DisableASM</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>fastjson内部处理逻辑，jackson不支持该特性，不影响功能</td> 
  </tr> 
  <tr> 
   <td>禁用循环引用检测</td> 
   <td>Feature.DisableCircularReferenceDetect</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>fastjson内部处理逻辑，jackson不支持该特性，不影响功能</td> 
  </tr> 
  <tr> 
   <td>对于没有值的字符串属性设置为空串</td> 
   <td>Feature.InitStringFieldAsEmpty</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson不支持该特性，但是可以通过<code>@JsonSetter</code>的<code>nulls()</code>和<code>contentNulls()</code>分别设置Bean以及Array/Collection的元素对<code>null</code>的处理方式。例如<code>Nulls.AS_EMPTY</code>就会将<code>null</code>设置为<code>JsonDeserializer.getEmptyValue</code></td> 
  </tr> 
  <tr> 
   <td>非标准特性，允许将数组按照字段顺序解析成Java Bean，例如<code>"[1001,\"xx\",33]"</code>可以等价为<code>"{\"id\": 10001, \"name\": \"xx\", \"age\": 33}"</code></td> 
   <td>Feature.SupportArrayToBean</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>非标准特性，且使用场景较少，jackson不支持该特性</td> 
  </tr> 
  <tr> 
   <td>解析后属性保持原来的顺序</td> 
   <td>Feature.OrderedField</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>禁用特殊字符检查</td> 
   <td>Feature.DisableSpecialKeyDetect</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>使用对象数组而不是集合</td> 
   <td>Feature.UseObjectArray</td> 
   <td>关闭</td> 
   <td>DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY</td> 
   <td>关闭</td> 
   <td>保持关闭</td> 
  </tr> 
  <tr> 
   <td>支持解析没有setter方法的非public属性</td> 
   <td>Feature.SupportNonPublicField</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jaskson可以通过<code>ObjectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY)</code>来达到相同的目的</td> 
  </tr> 
  <tr> 
   <td>禁用fastjson的AUTOTYPE特性，即不按照json字符串中的<code>@type</code>自动选择反序列化类</td> 
   <td>Feature.IgnoreAutoType</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson的PolymorphicDeserialization默认是支持<code>Object.class</code>、<code>abstract classes</code>、<code>interfaces</code>属性的AUTO Type，但是该特性容易导致安全漏洞，强烈建议使用<code>ObjectMapper.disableDefaultTyping()</code>设置为只允许<code>@JsonTypeInfo</code>生效</td> 
  </tr> 
  <tr> 
   <td>禁用属性智能匹配，例如下划线自动匹配驼峰等</td> 
   <td>Feature.DisableFieldSmartMatch</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过<code>ObjectMapper.setPropertyNamingStrategy()</code>达到相同的目的，但这种是针对一个json串的统一策略，如果要在一个json串中使用不同的策略则可以使用<code>@JsonProperty.value()</code>指定字段名</td> 
  </tr> 
  <tr> 
   <td>启用fastjson的autotype功能，即根据json字符串中的<code>@type</code>自动选择反序列化的类</td> 
   <td>Feature.SupportAutoType</td> 
   <td>关闭</td> 
   <td>ObjectMapper.DefaultTyping.*</td> 
   <td>开启</td> 
   <td>jackson的PolymorphicDeserialization支持不同级别的AUTO TYPE，但是这个功能容易导致安全漏洞，强烈建议使用<code>ObjectMapper.disableDefaultTyping()</code>设置为只允许<code>@JsonTypeInfo</code>生效</td> 
  </tr> 
  <tr> 
   <td>解析时将未用引号包含的json字段名作为String类型存储，否则只能用原始类型获取key的值。例如<code>String text="{123:\"abc\"}"</code>在启用了<code>NonStringKeyAsString</code>后可以通过<code>JSON.parseObject(text).getString("123")</code>的方式获取到<code>"abc"</code>，而在不启用<code>NonStringKeyAsString</code>时，<code>JSON.parseObject(text).getString("123")</code>只能得到<code>null</code>，必须通过<code>JSON.parseObject(text).get(123)</code>的方式才能获取到<code>"abc"</code>。</td> 
   <td>Feature.NonStringKeyAsString</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>非标准特性，jackson并不支持</td> 
  </tr> 
  <tr> 
   <td>自定义<code>"{\"key\":value}"</code>解析成<code>Map</code>实例，否则解析为<code>JSONObject</code></td> 
   <td>Feature.CustomMapDeserializer</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson没有相应的全局特性，但是可以通过<code>TypeReference</code>达到相同的效果</td> 
  </tr> 
  <tr> 
   <td>枚举未匹配到时抛出异常，否则解析为<code>null</code></td> 
   <td>Feature.ErrorOnEnumNotMatch</td> 
   <td>关闭</td> 
   <td>DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL</td> 
   <td>关闭</td> 
   <td>fastjson默认解析为<code>null</code>，jackson则相反，默认会抛异常，建议采用jackson默认行为</td> 
  </tr> 
 </tbody> 
</table>

反序列化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的序列化特性对照表 ##

<table> 
 <thead> 
  <tr> 
   <th>fastjson特性说明</th> 
   <th>fastjson枚举</th> 
   <th>fastjson默认状态</th> 
   <th>jackson枚举</th> 
   <th>jackson默认状态</th> 
   <th>jackson特性说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>输出的json字段名被引号包含</td> 
   <td>SerializerFeature.QuoteFieldNames</td> 
   <td>开启</td> 
   <td>JsonGenerator.Feature.QUOTE_FIELD_NAMES</td> 
   <td>开启</td> 
   <td>保持开启</td> 
  </tr> 
  <tr> 
   <td>序列化时使用单引号，而不是使用双引号</td> 
   <td>SerializerFeature.UseSingleQuotes</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson不支持该特性</td> 
  </tr> 
  <tr> 
   <td>序列化时，value为<code>null</code>的key或field也输出</td> 
   <td>SerializerFeature.WriteMapNullValue</td> 
   <td>关闭</td> 
   <td>JsonInclude.Include.ALWAYS</td> 
   <td>开启</td> 
   <td>建议按需选择。注意<code>SerializationFeature.WRITE_NULL_MAP_VALUES</code>从2.9已废弃，且会被<code>JsonInclude.Include</code>给覆盖</td> 
  </tr> 
  <tr> 
   <td>序列化枚举时使用枚举类型的<code>toString()</code>方法，和<code>SerializerFeature.WriteEnumUsingName</code>互斥</td> 
   <td>SerializerFeature.WriteEnumUsingToString</td> 
   <td>关闭</td> 
   <td>SerializationFeature.WRITE_ENUMS_USING_TO_STRING</td> 
   <td>关闭</td> 
   <td>建议关闭，或者和反序列化的<code>DeserializationFeature.READ_ENUMS_USING_TO_STRING</code>保持一致</td> 
  </tr> 
  <tr> 
   <td>序列化枚举时使用枚举类型的<code>name()</code>方法，和<code>SerializerFeature.WriteEnumUsingToString</code>互斥</td> 
   <td>SerializerFeature.WriteEnumUsingName</td> 
   <td>开启</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson的默认行为，无需配置</td> 
  </tr> 
  <tr> 
   <td>序列化时对Date、Calendar等类型使用ISO8601格式进行格式化，否则以timestamp形式输出Long数字</td> 
   <td>SerializerFeature.UseISO8601DateFormat</td> 
   <td>关闭</td> 
   <td>SerializationFeature.WRITE_DATES_AS_TIMESTAMPS</td> 
   <td>开启</td> 
   <td>jackson和fastjson的默认行为都是将Date数据输出为Long，建议根据不同的场景选择是否需要格式化日期</td> 
  </tr> 
  <tr> 
   <td>序列化List类型数据时将<code>null</code>输出为<code>"[]"</code></td> 
   <td>SerializerFeature.WriteNullListAsEmpty</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>可以通过<code>PropertyFilter</code>/<code>SerializerFactory.withSerializerModifier(BeanSerializerModifier)</code>任一一种方式达到相同效果，推荐使用<code>PropertyFilter</code></td> 
  </tr> 
  <tr> 
   <td>序列化String类型的field时将<code>null</code>输出为<code>""</code></td> 
   <td>SerializerFeature.WriteNullStringAsEmpty</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>可以通过<code>PropertyFilter</code>/<code>SerializerFactory.withSerializerModifier(BeanSerializerModifier)</code>任一一种方式达到相同效果，推荐使用<code>PropertyFilter</code></td> 
  </tr> 
  <tr> 
   <td>序列化Number类型的field时将<code>null</code>输出为<code>0</code></td> 
   <td>SerializerFeature.WriteNullNumberAsZero</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>可以通过<code>PropertyFilter</code>/<code>SerializerFactory.withSerializerModifier(BeanSerializerModifier)</code>任一一种方式达到相同效果，推荐使用<code>PropertyFilter</code></td> 
  </tr> 
  <tr> 
   <td>序列化Boolean类型的field时将<code>null</code>输出为<code>false</code></td> 
   <td>SerializerFeature.WriteNullBooleanAsFalse</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>可以通过<code>PropertyFilter</code>/<code>SerializerFactory.withSerializerModifier(BeanSerializerModifier)</code>任一一种方式达到相同效果，推荐使用<code>PropertyFilter</code></td> 
  </tr> 
  <tr> 
   <td>序列化时忽略<code>transient</code>修饰的field</td> 
   <td>SerializerFeature.SkipTransientField</td> 
   <td>开启</td> 
   <td>MapperFeature.PROPAGATE_TRANSIENT_MARKER</td> 
   <td>关闭</td> 
   <td>建议保持关闭，通过<code>@JsonIgnore</code>或者<code>FilterProvider</code>来指定忽略的属性</td> 
  </tr> 
  <tr> 
   <td>序列化时，如果未指定<code>order</code>，则将field按照<code>getter</code>方法的字典顺序排序</td> 
   <td>SerializerFeature.SortField</td> 
   <td>开启</td> 
   <td>MapperFeature.SORT_PROPERTIES_ALPHABETICALLY</td> 
   <td>关闭</td> 
   <td>建议关闭，排序会影响序列化性能（fastjson在反序列化时支持按照field顺序读取解析，因此排序后的json串有利于提高fastjson的解析性能，但jackson并没有该特性）</td> 
  </tr> 
  <tr> 
   <td>把<code>\t</code>做转义输出，<strong>已废弃，即使开启也无效</strong></td> 
   <td>SerializerFeature.WriteTabAsSpecial</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>格式化json输出</td> 
   <td>SerializerFeature.PrettyFormat</td> 
   <td>关闭</td> 
   <td>SerializationFeature.INDENT_OUTPUT</td> 
   <td>关闭</td> 
   <td>建议保持关闭，格式化可以交给前端完成</td> 
  </tr> 
  <tr> 
   <td>序列化时把类型名称写入json</td> 
   <td>SerializerFeature.WriteClassName</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过<code>@JsonTypeInfo</code>达到类似的效果，参见Jackson Annotation Examples</td> 
  </tr> 
  <tr> 
   <td>序列化时消除对同一对象循环引用的问题</td> 
   <td>SerializerFeature.DisableCircularReferenceDetect</td> 
   <td>关闭</td> 
   <td>SerializationFeature.FAIL_ON_SELF_REFERENCES</td> 
   <td>开启</td> 
   <td>保持开启，避免循环引用</td> 
  </tr> 
  <tr> 
   <td>对斜杠'/'进行转义</td> 
   <td>SerializerFeature.WriteSlashAsSpecial</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过自定义<code>Serializer</code>实现相同效果，按需设置</td> 
  </tr> 
  <tr> 
   <td>将中文都会序列化为<code>\uXXXX</code>格式，字节数会多一些，但是能兼容IE 6</td> 
   <td>SerializerFeature.BrowserCompatible</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过自定义<code>Serializer</code>实现相同效果，按需设置</td> 
  </tr> 
  <tr> 
   <td>全局修改日期格式，默认使用<code>JSON.DEFFAULT_DATE_FORMAT</code></td> 
   <td>SerializerFeature.WriteDateUseDateFormat</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过<code>@JsonFormat.pattern()</code>、<code>ObjectMapper.setDateFormat()</code>等方式实现相同效果</td> 
  </tr> 
  <tr> 
   <td>序列化时不把最外层的类型名称写入json</td> 
   <td>SerializerFeature.NotWriteRootClassName</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过<code>@JsonRootName</code>达到类似的效果，参见Jackson Annotation Examples</td> 
  </tr> 
  <tr> 
   <td>不转义特殊字符，<strong>已废弃，即使开启也无效</strong></td> 
   <td>SerializerFeature.DisableCheckSpecialChar</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>将Bean序列化时将field值按顺序当成json数组输出，而不是json object，同时不会输出fieldName，例如：<code>{"id":123,"name":"xxx"}</code>会输出成<code>[123,"xxx"]</code></td> 
   <td>SerializerFeature.BeanToArray</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>非标准特性，jackson并不支持</td> 
  </tr> 
  <tr> 
   <td>序列化Map时将非String类型的key作为String类型输出，例如：<code>{123:231}</code>会输出成<code>{"123":231}</code></td> 
   <td>SerializerFeature.WriteNonStringKeyAsString</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>非标准特性，jackson并不支持</td> 
  </tr> 
  <tr> 
   <td>序列化<code>Byte、Short、Integer、Long、Float、Double、Boolean</code>及其对应原始类型field时，如果属性值为各自类型的默认值（如<code>0、0F、0L</code>），则不会输出该属性</td> 
   <td>SerializerFeature.NotWriteDefaultValue</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>非标准特性，jackson并不支持</td> 
  </tr> 
  <tr> 
   <td>序列化时将<code>(</code>、<code>)</code>、<code>&gt;</code>、<code>&lt;</code>以unicode编码输出</td> 
   <td>SerializerFeature.BrowserSecure</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson可以通过自定义<code>Serializer</code>实现相同效果，按需设置，通常可以交给前端处理</td> 
  </tr> 
  <tr> 
   <td>序列化时忽略没有实际属性对应的getter方法</td> 
   <td>SerializerFeature.IgnoreNonFieldGetter</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>序列化时把非String类型数据当作String类型输出</td> 
   <td>SerializerFeature.WriteNonStringValueAsString</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>jackson有一个类似的特性<code>JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS</code>可以将数字作为字符串输出，但没有覆盖所有非String类型</td> 
  </tr> 
  <tr> 
   <td>序列化时忽略会抛异常的getter方法</td> 
   <td>SerializerFeature.IgnoreErrorGetter</td> 
   <td>关闭</td> 
   <td>-</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>序列化时将BigDecimal使用toPlainString()输出</td> 
   <td>SerializerFeature.WriteBigDecimalAsPlain</td> 
   <td>关闭</td> 
   <td>JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN</td> 
   <td>关闭</td> 
   <td>按需开启</td> 
  </tr> 
  <tr> 
   <td>序列化时对Map按照Key进行排序</td> 
   <td>SerializerFeature.MapSortField</td> 
   <td>关闭</td> 
   <td>SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS</td> 
   <td>关闭</td> 
   <td>建议关闭，开启会影响性能</td> 
  </tr> 
 </tbody> 
</table>

序列化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`。

<END>

**推荐阅读：**

[虚拟货币，太坑爹了！][Link 2]

[Java这个高级特性，很多人还没用过！][Java]

最近面试BAT，整理一份面试资料《Java面试BATJ通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。

**获取方式：点个「****在看****」，点击上方小卡片，进入公众号后回复「****面试题****」领取，更多内容陆续奉上。**

朕已阅 ![274a1ffe42a66c0e9126b4fbb03aa4da.gif][]

[0D5F937FE12312312D81F17F.jpg]: /images/20221014/10d240d5111240a7b4196513986c6fbc.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa24f0bacd5379ac93d74ffebac826d2401fd494f82e900e5102a8bf968f108e4ec72a4ad548&idx=3&lang=zh_CN&mid=2247487442&scene=21&sn=61e758d4bf9f15a3419fd028146469a3&token=1854383306#wechat_redirect
[d6a2c0a2350514de6049f703a78928ad.png]: /images/20221014/c0b4a20c0d3b4027a9dc057da424a8cb.png
[jackson1_cheshire_json-simple_fastjson_jackson2_gson_org.json_org.json_usage_jackson2_jackson_jackson2_gson_org.json]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw%3D%3D&chksm=eb50e470dc276d6676c923b597cbd28cf29e7a31393f1f03afedaf22f6aaf9e0e5517b9bdb32&idx=3&mid=2247524678&scene=21&sn=a153fd4fae16c357d55414e067d7bf25#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa272063cd50a975a6557cca3e2d685e7457313044d53b0be41418db931f5806916698fc6d13&idx=1&mid=2247507723&scene=21&sn=96a32fa40e0080ad5b98c07fc72ab593#wechat_redirect
[Java]: http://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa272063cd50a975f8a1429b0e8ce733f2fd9875ea6e18d53ab49356fbc18679c5da2757c823&idx=2&mid=2247507723&scene=21&sn=c42a8e32c2a4b8ee663c21e9024dba49#wechat_redirect
[274a1ffe42a66c0e9126b4fbb03aa4da.gif]: /images/20221014/f30c7e28903647c9bce9ae2c3d397dae.png