全解史上最快的JOSN解析庫 - alibaba Fastjson

阿新 • • 發佈：2018-12-03

JSON，全稱：JavaScript Object Notation，作為一個常見的輕量級的資料交換格式，應該在一個程式設計師的開發生涯中是常接觸的。簡潔和清晰的層次結構使得 JSON 成為理想的資料交換語言。易於人閱讀和編寫，同時也易於機器解析和生成，並有效地提升網路傳輸效率。

Java是面向物件的語言，所以我們更多的在專案中是以物件的形式處理業務的，但是在傳輸的時候我們卻要將物件轉換為 JSON 格式便於傳輸，而且 JSON 格式一般能解析為大多數的物件格式，而不在乎程式語言。

現在主流的物件與 JSON 互轉的工具很多，我們主要介紹今天的主角，阿里巴巴的開源庫 - Fastjson。Fastjson是一個Java庫，可用於將Java物件轉換為其JSON表示。它還可用於將JSON字串轉換為等效的Java物件。Fastjson可以處理任意Java物件，包括您沒有原始碼的預先存在的物件。

什麼是 Fastjson?

阿里官方給的定義是， fastjson 是阿里巴巴的開源JSON解析庫，它可以解析 JSON 格式的字串，支援將 Java Bean 序列化為 JSON 字串，也可以從 JSON 字串反序列化到 JavaBean。

Fastjson 的優點

速度快
fastjson相對其他JSON庫的特點是快，從2011年fastjson釋出1.1.x版本之後，其效能從未被其他Java實現的JSON庫超越。
使用廣泛
fastjson在阿里巴巴大規模使用，在數萬臺伺服器上部署，fastjson在業界被廣泛接受。在2012年被開源中國評選為最受歡迎的國產開源軟體之一。

測試完備
fastjson有非常多的testcase，在1.2.11版本中，testcase超過3321個。每次釋出都會進行迴歸測試，保證質量穩定。
使用簡單
fastjson的 API 十分簡潔。
功能完備
支援泛型，支援流處理超大文字，支援列舉，支援序列化和反序列化擴充套件。

怎麼獲得 Fastjson

你可以通過如下地方下載fastjson:

maven中央倉庫: http://central.maven.org/maven2/com/alibaba/fastjson/
Sourceforge.net : https://sourceforge.net/projects/fastjson/files/
在maven專案的pom檔案中直接配置fastjson依賴

fastjson最新版本都會發布到maven中央倉庫，你可以直接依賴。

<dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>x.x.x</version>
</dependency>

其中x.x.x是版本號，根據需要使用特定版本，建議使用最新版本。

Fastjson 主要的API

Fastjson入口類是 com.alibaba.fastjson.JSON，主要的 API 是 JSON.toJSONString 和 parseObject。

package com.alibaba.fastjson;
public abstract class JSON {
      // Java物件轉換為JSON字串
      public static final String toJSONString(Object object);
      //JSON字串轉換為Java物件
      public static final <T> T parseObject(String text, Class<T> clazz, Feature... features);
}

序列化：

String jsonString = JSON.toJSONString(obj);

反序列化：

VO vo = JSON.parseObject("...", VO.class);

泛型反序列化：

import com.alibaba.fastjson.TypeReference;

List<VO> list = JSON.parseObject("...", new TypeReference<List<VO>>() {});

Fastjson 的效能

fastjson是目前java語言中最快的json庫，比自稱最快的jackson速度還要快，第三方獨立測試結果看這裡：https://github.com/eishay/jvm-serializers/wiki。

自行做效能測試時，需關閉迴圈引用檢測的功能。

JSON.toJSONString(obj, SerializerFeature.DisableCircularReferenceDetect)
VO vo = JSON.parseObject("...", VO.class, Feature.DisableCircularReferenceDetect)

另外，Fastjson 比 Gson 快大約6倍，測試結果可以看這裡：

Checking correctness…
[done]
Pre-warmup… java-built-in hessian kryo protostuff-runtime avro-generic msgpack json/jackson/databind json/jackson/databind-strings json/jackson/db-afterburner json/google-gson/databind json/svenson-databind json/flexjson/databind json/fastjson/databind smile/jackson/databind smile/jackson/db-afterburner smile/protostuff-runtime bson/jackson/databind xml/xstream+c xml/jackson/databind-aalto
[done]
pre. create ser deser shal +deep total size +dfl
java-built-in 63 5523 27765 28084 28162 33686 889 514
hessian 64 3776 6459 6505 6690 10466 501 313
kryo 63 809 962 937 1001 1810 214 133
protostuff-runtime 62 671 903 920 957 1627 241 151
avro-generic 436 1234 1122 1416 1760 2994 221 133
msgpack 61 789 1369 1385 1449 2238 233 146
json/jackson/databind 60 1772 3089 3113 3246 5018 485 261
json/jackson/databind-strings 64 2346 3739 3791 3921 6267 485 261
json/jackson/db-afterburner 64 1482 2220 2233 2323 3805 485 261
json/google-gson/databind 64 7076 4894 4962 5000 12076 486 259
json/svenson-databind 64 5422 12387 12569 12468 17890 495 266
json/flexjson/databind 62 20923 26853 26873 27272 48195 503 273
json/fastjson/databind 63 1250 1208 1206 1247 2497 486 262
smile/jackson/databind 60 1697 2117 2290 2298 3996 338 241
smile/jackson/db-afterburner 60 1300 1614 1648 1703 3003 352 252
smile/protostuff-runtime 61 1275 1612 1638 1685 2961 335 235
bson/jackson/databind 63 5151 6729 6977 6918 12069 506 286
xml/xstreamc 62 6358 13208 13319 13516 19874 487 244
xml/jackson/databind-aalto 62 2955 5332 5465 5584 8539 683 286

Fastjson 使用示例

我們建立一個班級的物件，和一個學生物件如下：

班級物件

public class Grade {

    private Long id;
    private String name;
    private List<Student> users = new ArrayList<Student>();

    // 省略 setter、getter
    
    public void addStudent(Student student) {
        users.add(student);
    }

    @Override
    public String toString() {
        return "Grade{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", users=" + users +
                '}';
    }
}

學生物件

public class Student {

    private Long   id;
    private String name;

    // 省略 setter、getter
    
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

執行的 Main 函式

public class MainTest {

    public static void main(String[] args) {
        Grade group = new Grade();
        group.setId(0L);
        group.setName("admin");

        Student student = new Student();
        student.setId(2L);
        student.setName("guest");

        Student rootUser = new Student();
        rootUser.setId(3L);
        rootUser.setName("root");

        group.addStudent(student);
        group.addStudent(rootUser);

        // 轉換為 JSON
        String jsonString = JSON.toJSONString(group);
        System.out.println("JSON字串：" + jsonString);

        // 轉換為 物件BEAN
        Grade grade = JSON.parseObject(jsonString, Grade.class);
        System.out.println("JavaBean物件：" + grade);
    }
}

最後的執行結果如下：

JSON字串：
{"id":0,"name":"admin","users":[{"id":2,"name":"guest"},{"id":3,"name":"root"}]}

JavaBean物件：
Grade{id=0, name='admin', users=[Student{id=2, name='guest'}, Student{id=3, name='root'}]}

將物件中的空值輸出

在fastjson中，預設是不輸出空值的。無論Map中的null和物件屬性中的null，序列化的時候都會被忽略不輸出，這樣會減少產生文字的大小。但如果需要輸出空值怎麼做呢？

如果你需要輸出空值，需要使用 SerializerFeature.WriteMapNullValue

Model obj = ...;
JSON.toJSONString(obj, SerializerFeature.WriteMapNullValue);

幾種空值特別處理方式：

SerializerFeature	描述
WriteNullListAsEmpty	將Collection型別欄位的欄位空值輸出為[]
WriteNullStringAsEmpty	將字串型別欄位的空值輸出為空字串 ""
WriteNullNumberAsZero	將數值型別欄位的空值輸出為0
WriteNullBooleanAsFalse	將Boolean型別欄位的空值輸出為false

具體的示例參考如下，可以同時選擇多個：

class Model {
      public List<Objec> items;
}

Model obj = ....;

String text = JSON.toJSONString(obj, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullListAsEmpty);

Fastjson 處理日期

Fastjson 處理日期的API很簡單，例如：

JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd HH:mm:ss.SSS")

使用ISO-8601日期格式

JSON.toJSONString(obj, SerializerFeature.UseISO8601DateFormat);

全域性修改日期格式

JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd";
JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);

反序列化能夠自動識別如下日期格式：

ISO-8601日期格式
yyyy-MM-dd
yyyy-MM-dd HH:mm:ss
yyyy-MM-dd HH:mm:ss.SSS
毫秒數字
毫秒數字字串
.NET JSON日期格式
new Date(198293238)

雖然上面處理了單個的日期型別和全域性的日期型別格式的配置，但是有時候我們需要的是物件中個別的日期型別差異化，並不一定是同一種格式的。那如何處理呢？接下來介紹 Fastjson 的定製序列化。

Fastjson 定製序列化

簡介

fastjson支援多種方式定製序列化。

通過@JSONField定製序列化
通過@JSONType定製序列化
通過SerializeFilter定製序列化
通過ParseProcess定製反序列化

使用@JSONField配置

1、JSONField 註解介紹

package com.alibaba.fastjson.annotation;

public @interface JSONField {
    // 配置序列化和反序列化的順序，1.1.42版本之後才支援
    int ordinal() default 0;

     // 指定欄位的名稱
    String name() default "";

    // 指定欄位的格式，對日期格式有用
    String format() default "";

    // 是否序列化
    boolean serialize() default true;

    // 是否反序列化
    boolean deserialize() default true;
}

2、JSONField配置方式

可以把@JSONField配置在欄位或者getter/setter方法上，例如：

配置在欄位上

public class VO {
     @JSONField(name="ID")
     private int id;

     @JSONField(name="birthday",format="yyyy-MM-dd")
     public Date date;
}

配置在 Getter/Setter 上

public class VO {
    private int id;

    @JSONField(name="ID")
    public int getId() { return id;}

    @JSONField(name="ID")
    public void setId(int id) {this.id = id;}
}

注意：若屬性是私有的，必須有set*方法。否則無法反序列化。

3、使用format配置日期格式化

可以定製化配置各個日期欄位的格式化

 public class A {
      // 配置date序列化和反序列使用yyyyMMdd日期格式
      @JSONField(format="yyyyMMdd")
      public Date date;
 }

4、使用serialize/deserialize指定欄位不序列化

public class A {
      @JSONField(serialize=false)
      public Date date;
 }

 public class A {
      @JSONField(deserialize=false)
      public Date date;
 }

5、使用ordinal指定欄位的順序

預設Fastjson序列化一個java bean，是根據fieldName的字母序進行序列化的，你可以通過ordinal指定欄位的順序。這個特性需要1.1.42以上版本。

public static class VO {
    @JSONField(ordinal = 3)
    private int f0;

    @JSONField(ordinal = 2)
    private int f1;

    @JSONField(ordinal = 1)
    private int f2;
}

6、使用serializeUsing制定屬性的序列化類

在fastjson 1.2.16版本之後，JSONField支援新的定製化配置serializeUsing，可以單獨對某一個類的某個屬性定製序列化，比如：

public static class Model {
    @JSONField(serializeUsing = ModelValueSerializer.class)
    public int value;
}

public static class ModelValueSerializer implements ObjectSerializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                      int features) throws IOException {
        Integer value = (Integer) object;
        String text = value + "元";
        serializer.write(text);
    }
}

測試程式碼

Model model = new Model();
model.value = 100;
String json = JSON.toJSONString(model);
Assert.assertEquals("{\"value\":\"100元\"}", json);

使用@JSONType配置

和JSONField類似，但JSONType配置在類上，而不是field或者getter/setter方法上。

通過SerializeFilter定製序列化

1、簡介

SerializeFilter是通過程式設計擴充套件的方式定製序列化。fastjson支援6種SerializeFilter，用於不同場景的定製序列化。

PropertyPreFilter 根據PropertyName判斷是否序列化
PropertyFilter 根據PropertyName和PropertyValue來判斷是否序列化
NameFilter 修改Key，如果需要修改Key,process返回值則可
ValueFilter 修改Value
BeforeFilter 序列化時在最前新增內容
AfterFilter 序列化時在最後新增內容

2、PropertyFilter 根據PropertyName和PropertyValue來判斷是否序列化

 public interface PropertyFilter extends SerializeFilter {
    boolean apply(Object object, String propertyName, Object propertyValue);
 }

可以通過擴充套件實現根據object或者屬性名稱或者屬性值進行判斷是否需要序列化。例如：

PropertyFilter filter = new PropertyFilter() {

    public boolean apply(Object source, String name, Object value) {
        if ("id".equals(name)) {
            int id = ((Integer) value).intValue();
            return id >= 100;
        }
        return false;
    }
};

JSON.toJSONString(obj, filter); // 序列化的時候傳入filter

3、PropertyPreFilter 根據PropertyName判斷是否序列化

和PropertyFilter不同只根據object和name進行判斷，在呼叫getter之前，這樣避免了getter呼叫可能存在的異常。

 public interface PropertyPreFilter extends SerializeFilter {
      boolean apply(JSONSerializer serializer, Object object, String name);
  }

4、NameFilter 序列化時修改Key

如果需要修改Key,process返回值則可

public interface NameFilter extends SerializeFilter {
    String process(Object object, String propertyName, Object propertyValue);
}

fastjson內建一個PascalNameFilter，用於輸出將首字元大寫的Pascal風格。例如：

import com.alibaba.fastjson.serializer.PascalNameFilter;

Object obj = ...;
String jsonStr = JSON.toJSONString(obj, new PascalNameFilter());

5、ValueFilter 序列化時修改Value

public interface ValueFilter extends SerializeFilter {
  Object process(Object object, String propertyName, Object propertyValue);
}

6、BeforeFilter 序列化時在最前新增內容

在序列化物件的所有屬性之前執行某些操作,例如呼叫 writeKeyValue 新增內容

public abstract class BeforeFilter implements SerializeFilter {
   protected final void writeKeyValue(String key, Object value) { ... }
    // 需要實現的抽象方法，在實現中呼叫writeKeyValue新增內容
    public abstract void writeBefore(Object object);
}

7、AfterFilter 序列化時在最後新增內容

在序列化物件的所有屬性之後執行某些操作,例如呼叫 writeKeyValue 新增內容

 public abstract class AfterFilter implements SerializeFilter {
  protected final void writeKeyValue(String key, Object value) { ... }
    // 需要實現的抽象方法，在實現中呼叫writeKeyValue新增內容
    public abstract void writeAfter(Object object);
}

通過ParseProcess定製反序列化

1、簡介

ParseProcess是程式設計擴充套件定製反序列化的介面。fastjson支援如下ParseProcess：

ExtraProcessor 用於處理多餘的欄位
ExtraTypeProvider 用於處理多餘欄位時提供型別資訊

2、使用ExtraProcessor 處理多餘欄位

public static class VO {
    private int id;
    private Map<String, Object> attributes = new HashMap<String, Object>();
    public int getId() { return id; }
    public void setId(int id) { this.id = id;}
    public Map<String, Object> getAttributes() { return attributes;}
}
    
ExtraProcessor processor = new ExtraProcessor() {
    public void processExtra(Object object, String key, Object value) {
        VO vo = (VO) object;
        vo.getAttributes().put(key, value);
    }
};
    
VO vo = JSON.parseObject("{\"id\":123,\"name\":\"abc\"}", VO.class, processor);
Assert.assertEquals(123, vo.getId());
Assert.assertEquals("abc", vo.getAttributes().get("name"));

3、使用ExtraTypeProvider 為多餘的欄位提供型別

public static class VO {
    private int id;
    private Map<String, Object> attributes = new HashMap<String, Object>();
    public int getId() { return id; }
    public void setId(int id) { this.id = id;}
    public Map<String, Object> getAttributes() { return attributes;}
}
    
class MyExtraProcessor implements ExtraProcessor, ExtraTypeProvider {
    public void processExtra(Object object, String key, Object value) {
        VO vo = (VO) object;
        vo.getAttributes().put(key, value);
    }
    
    public Type getExtraType(Object object, String key) {
        if ("value".equals(key)) {
            return int.class;
        }
        return null;
    }
};
ExtraProcessor processor = new MyExtraProcessor();
    
VO vo = JSON.parseObject("{\"id\":123,\"value\":\"123456\"}", VO.class, processor);
Assert.assertEquals(123, vo.getId());
Assert.assertEquals(123456, vo.getAttributes().get("value")); // value本應該是字串型別的，通過getExtraType的處理變成Integer型別了。

在 Spring MVC 中整合 Fastjson

如果你使用 Spring MVC 來構建 Web 應用並對效能有較高的要求的話，可以使用 Fastjson 提供的FastJsonHttpMessageConverter 來替換 Spring MVC 預設的 HttpMessageConverter 以提高 @RestController @ResponseBody @RequestBody 註解的 JSON序列化速度。下面是配置方式，非常簡單。

XML式
如果是使用 XML 的方式配置 Spring MVC 的話，只需在 Spring MVC 的 XML 配置檔案中加入下面配置即可

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter"/>      
    </mvc:message-converters>
</mvc:annotation-driven>

通常預設配置已經可以滿足大部分使用場景，如果你想對它進行自定義配置的話，你可以新增 FastJsonConfig Bean。

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <property name="fastJsonConfig" ref="fastJsonConfig"/>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

<bean id="fastJsonConfig" class="com.alibaba.fastjson.support.config.FastJsonConfig">
    <!--   自定義配置...   -->
</bean>

程式設計式
如果是使用程式設計的方式（通常是基於 Spring Boot 專案）配置 Spring MVC 的話只需繼承 WebMvcConfigurerAdapter覆寫configureMessageConverters方法即可，就像下面這樣。

@Configuration
public class WebMvcConfigurer extends WebMvcConfigurerAdapter {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        //自定義配置...
        //FastJsonConfig config = new FastJsonConfig();
        //config.set ...
        //converter.setFastJsonConfig(config);
        converters.add(0, converter);
    }
}

注意：
1、如果你使用的 Fastjson 版本小於1.2.36的話(強烈建議使用最新版本)，在與Spring MVC 4.X 版本整合時需使用 FastJsonHttpMessageConverter4。

2、SpringBoot 2.0.1版本中載入WebMvcConfigurer的順序發生了變動，故需使用converters.add(0, converter);指定FastJsonHttpMessageConverter在converters內的順序，否則在SpringBoot 2.0.1及之後的版本中將優先使用Jackson處理。

在 Spring Data Redis 中整合 Fastjson

通常我們在 Spring 中使用 Redis 是通過 Spring Data Redis 提供的 RedisTemplate 來進行的，如果你準備使用 JSON 作為物件序列/反序列化的方式並對序列化速度有較高的要求的話，建議使用 Fastjson 提供的 GenericFastJsonRedisSerializer 或 FastJsonRedisSerializer 作為 RedisTemplate 的 RedisSerializer。下面是配置方式，非常簡單。

XML式
如果是使用 XML 的方式配置 Spring Data Redis 的話，只需將 RedisTemplate 中的 Serializer 替換為 GenericFastJsonRedisSerializer 即可。

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory" ref="jedisConnectionFactory"/>
    <property name="defaultSerializer">
        <bean class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer"/>
    </property>
</bean>

下面是完整的 Spring 整合 Redis 配置供參考。

<!-- Redis 連線池配置(可選) -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxTotal" value="${redis.pool.maxActive}"/>
    <property name="maxIdle" value="${redis.pool.maxIdle}"/>
    <property name="maxWaitMillis" value="${redis.pool.maxWait}"/>
    <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
     <!-- 更多連線池配置...-->
</bean>
<!-- Redis 連線工廠配置 -->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    <!--設定連線池配置，不設定的話會使用預設的連線池配置，若想禁用連線池可設定 usePool = false -->   
    <property name="poolConfig" ref="jedisPoolConfig" />  
    <property name="hostName" value="${host}"/>
    <property name="port" value="${port}"/>
    <property name="password" value="${password}"/>
    <property name="database" value="${database}"/>
    <!-- 更多連線工廠配置...-->
</bean>
<!-- RedisTemplate 配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <!-- 設定 Redis 連線工廠-->
    <property name="connectionFactory" ref="jedisConnectionFactory"/>
    <!-- 設定預設 Serializer ，包含 keySerializer & valueSerializer -->
    <property name="defaultSerializer">
        <bean class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer"/>
    </property>
    <!-- 單獨設定 keySerializer -->
    <property name="keySerializer">
        <bean class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer"/>
    </property>
    <!-- 單獨設定 valueSerializer -->
    <property name="valueSerializer">
        <bean class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer"/>
    </property>
</bean>

程式設計式

如果是使用程式設計的方式（通常是基於 Spring Boot 專案）配置 RedisTemplate 的話只需在你的配置類(被@Configuration註解修飾的類)中顯式建立 RedisTemplate Bean，設定 Serializer 即可。

@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate redisTemplate = new RedisTemplate();
    redisTemplate.setConnectionFactory(redisConnectionFactory);

    GenericFastJsonRedisSerializer fastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
    redisTemplate.setDefaultSerializer(fastJsonRedisSerializer);//設定預設的Serialize，包含 keySerializer & valueSerializer

    //redisTemplate.setKeySerializer(fastJsonRedisSerializer);//單獨設定keySerializer
    //redisTemplate.setValueSerializer(fastJsonRedisSerializer);//單獨設定valueSerializer
    return redisTemplate;
}

通常使用 GenericFastJsonRedisSerializer 即可滿足大部分場景，如果你想定義特定型別專用的 RedisTemplate 可以使用 FastJsonRedisSerializer來代替 GenericFastJsonRedisSerializer，配置是類似的。

參考：https://github.com/alibaba/fastjson/wiki

全解史上最快的JOSN解析庫 - alibaba Fastjson

什麼是 Fastjson?

Fastjson 的優點

怎麼獲得 Fastjson

Fastjson 主要的API

Fastjson 的效能

Fastjson 使用示例

將物件中的空值輸出

Fastjson 處理日期

Fastjson 定製序列化

簡介

使用@JSONField配置

1、JSONField 註解介紹

2、JSONField配置方式

3、使用format配置日期格式化

4、使用serialize/deserialize指定欄位不序列化

5、使用ordinal指定欄位的順序

6、使用serializeUsing制定屬性的序列化類

使用@JSONType配置

通過SerializeFilter定製序列化

1、簡介

2、PropertyFilter 根據PropertyName和PropertyValue來判斷是否序列化

3、PropertyPreFilter 根據PropertyName判斷是否序列化

4、NameFilter 序列化時修改Key

5、ValueFilter 序列化時修改Value

6、BeforeFilter 序列化時在最前新增內容

7、AfterFilter 序列化時在最後新增內容

通過ParseProcess定製反序列化

1、簡介

2、使用ExtraProcessor 處理多餘欄位

3、使用ExtraTypeProvider 為多餘的欄位提供型別

在 Spring MVC 中整合 Fastjson

在 Spring Data Redis 中整合 Fastjson

相關推薦