序列化与反序列化——FastJSON、Jackson、Gson性能测试

背景

起因是公司原先用的是阿里开源的FastJSON，大家用的也比较顺手，但是在出现了两次严重的漏洞后，公司决定放弃FastJSON，使用其他序列化/反序列化工具。考虑大家常用的无非就是FastJSON、Jackson和Gson这三种，因此领导让我调研一下到底是使用Gson还是Jackson。

关于漏洞这里我多说一句，建议大家还真得把这个事情当一个事情。我之前就被漏洞坑了一把，在一台linux服务器上部署了6.5版本的confluence，后来阿里云也发紧急通知了，告知赶紧升级，然而我并没有当一回事，过了没两天我就中招了，这台机器被挖矿了，什么都干不了，只能是初始化系统，好一顿折腾～

秉持着严谨且负责的精神，这个事情还是要好好做一下子的～

测试结果预告

前置准备工作

为了营造一个相对准确、互不影响的测试环境，我们需要有以下限制（要求）：

MacBook Pro (16-inch, 2019) 
处理器 2.3 GHz 八核Intel Core i9 
内存16 GB 2667 MHz DDR4
硬盘 1T

#JDK版本
jdk1.8.0_151
#运行参数
-Xms4g -Xmx4g -XX:+UseG1GC

• 三种JSON引擎版本:

com.fasterxml.jackson.core.jackson:2.11.1
com.google.code.gson:2.8.6
com.alibaba.fastjson:1.2.72

序列化与反序列化

搞事情之前，我们先来复习一下什么是序列化与反序列化：

序列化：把Java对象转换为字节序列的过程。

反序列化：把字节序列恢复为Java对象的过程。

对象的序列化主要有两种用途：

持久化对象：把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

网络传输对象：在网络上传送对象的字节序列。

代码测试

创建一个对象，包含Boolean、Integer、Long、Double、Date、String、ArrayList、HashMap等数据类型，构造方法即初始化好对象，方便后面使用：

package com.performance.json.bean;
import com.performance.json.DataBuilder;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
 * 数据对象
 * @author java架构设计
 * @date 2020/7/17 5:19 下午
 **/
@Data
public class DataBean implements Serializable {
    private static final long serialVersionUID = 6453520211539229613L;
    private Boolean aBoolean;
    private Integer integer;
    private Long aLong;
    private Double aDouble;
    private Date date;
    private String string;
    private List<String> list;
    private Map<String, Object> objectMap;
    public DataBean() {
        Random random = new Random();
        this.aBoolean = random.nextBoolean();
        this.integer = random.nextInt();
        this.aLong = random.nextLong();
        this.aDouble = random.nextDouble();
        this.date = new Date();
        this.string = DataBuilder.randomString();
        this.list = DataBuilder.randomList();
        this.objectMap = DataBuilder.randomMap();
    }
}

其中randomString()、randomList()、randomMap()方法如下：

package com.performance.json;
import java.util.*;
/**
 * 数据构造器
 *
 * @author java架构设计
 * @date 2020/7/17 5:30 下午
 **/
public class DataBuilder {
    private static final String[] chars = new String[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b",
            "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w",
            "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
            "S", "T", "U", "V", "W", "X", "Y", "Z" };
    private static final Random random = new Random();

    /**
     * 生成100以内随机长度的字符串
     * @return String
     */
    public static String randomString(){
        int len = random.nextInt(100);
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            sb.append(chars[random.nextInt(62)]);
        }
        return sb.toString();
    }

    /**
     * 生成100以内的字符串集合
     * @return List<String>
     */
    public static List<String> randomList() {
        int len = random.nextInt(100);
        ArrayList<String> list = new ArrayList<>(len);
        for (int i = 0; i < len; i++) {
            list.add(randomString());
        }
        return list;
    }

		/**
     * 生成100以内的Map
     * @return Map<String, Object>
     */
    public static Map<String, Object> randomMap() {
        int len = random.nextInt(100);
        Map<String, Object> map = new HashMap<>(len);
        for (int i = 0; i < len; i++) {
            switch (i % 6) {
                case 0:
                    map.put("key" + i, random.nextBoolean());
                    break;
                case 1:
                    map.put("key" + i, random.nextInt());
                    break;
                case 2:
                    map.put("key" + i, random.nextLong());
                    break;
                case 3:
                    map.put("key" + i, random.nextDouble());
                    break;
                case 4:
                    map.put("key" + i, new Date());
                    break;
                case 5:
                    map.put("key" + i, randomString());
                    break;
                default:
                    break;
            }
        }
        return map;
    }
}

序列化测试代码：

测试对象数分别为1、100、1000、10000、100000个，对象都是预先生成好，然后再依次执行三种JSON引擎执行序列化操作，输出结果：

#1个对象
FastJSON耗时：84ms
Gson耗时：13ms
Jackson耗时：51ms

#10个对象
FastJSON耗时：87ms
Gson耗时：21ms
Jackson耗时：54ms

#100个对象
FastJSON耗时：110ms
Gson耗时：43ms
Jackson耗时：69ms

#1000个对象
FastJSON耗时：138ms
Gson耗时：114ms
Jackson耗时：98ms

#10000个对象
FastJSON耗时：290ms
Gson耗时：467ms
Jackson耗时：230ms

#10000个对象
FastJSON耗时：1657ms
Gson耗时：3340ms
Jackson耗时：1456ms

生成条形图：

从上图来分析，可以知道的是，在数据量较少（1、10、100）的时候，Gson的性能最优，且优势较明显，当对象数量在1000的时候，Jackson的性能开始上来了，因此在对象数量在1～1000的时候，性能比拼：Gson>Jackson>FastJSON。

但是当数量达到10000、100000级别的时候，Gson的性能下降的比较厉害，而FastJson和Jackson依旧保持着它们的快，性能比较：Jackson>FastJSON>Gson。

反序列化测试代码：

public static void main(String[] args) {
        testDeSerialize(1);
//        testDeSerialize(10);
//        testDeSerialize(100);
//        testDeSerialize(1000);
//        testDeSerialize(10000);
//        testDeSerialize(100000);
}

测试对象数分别为1、100、1000、10000、100000个，对象都是预先序列化好，然后再依次执行三种JSON引擎执行反序列化操作，输出结果：

#1次
FastJSON耗时：20ms
Gson耗时：5ms
Jackson耗时：28ms

#10次
FastJSON耗时：29ms
Gson耗时：15ms
Jackson耗时：34ms

#100次
FastJSON耗时：48ms
Gson耗时：46ms
Jackson耗时：51ms

#1000次
FastJSON耗时：131ms
Gson耗时：214ms
Jackson耗时：146ms

#10000次
FastJSON耗时：652ms
Gson耗时：893ms
Jackson耗时：720ms

#100000次
FastJSON耗时：5985ms
Gson耗时：7357ms
Jackson耗时：5232ms

生成条形图：

反序列化性能测试，

在对象数量为1、10、100的时候，Gson的性能最好，Jackson次之，性能排序为：Gson>Jackson>FastJson；

在对象数量为1000、10000的时候，Gson的性能下降比较明显，这个量级下性能排序为：FastJson>Jackson>Gson。

在对象数量为10w的时候，Jackson反超FastJson，性能排序为：Jackson>FastJson>Gson。

总结

在做这个性能测试之前，也是在网上查找了一下大家是怎么做这个性能测试的，有的很复杂，有的却也简单，最终我还是选择了一种简单的测试方式，在尽可能的规避其他因素的影响，比如：提前生成好数据、三种引擎测试的样本数据一致、1～10w次的次数测试的时候都是重新运行main方法，尽量避免虚拟机的影响。

最终得出的性能测试结果与网上参考文章的测试结果一致。

如果您觉得上述测试过程有问题，欢迎在评论区指正～