fastjson 字符串转map_序列化与反序列化——FastJSON、Jackson、Gson性能测试

背景

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

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

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

测试结果预告

FastJSON、Gson、Jackson序列化性能比较.png

FastJSON、Gson、Jackson反序列化性能比较.png

前置准备工作

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

同一台机器，即我的mac：

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

JVM相关参数配置：

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

• 三种JSON引擎版本:

com.fasterxml.jackson.core.jackson:2.11.1com.google.code.gson:2.8.6com.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 下午 **/@Datapublic 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 list;    private Map 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     */    public static List randomList() {        int len = random.nextInt(100);        ArrayList list = new ArrayList<>(len);        for (int i = 0; i < len; i++) {            list.add(randomString());        }        return list;    }/**     * 生成100以内的Map     * @return Map     */    public static Map randomMap() {        int len = random.nextInt(100);        Map 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耗时：84msGson耗时：13msJackson耗时：51ms#10个对象FastJSON耗时：87msGson耗时：21msJackson耗时：54ms#100个对象FastJSON耗时：110msGson耗时：43msJackson耗时：69ms#1000个对象FastJSON耗时：138msGson耗时：114msJackson耗时：98ms#10000个对象FastJSON耗时：290msGson耗时：467msJackson耗时：230ms#10000个对象FastJSON耗时：1657msGson耗时：3340msJackson耗时：1456ms

生成条形图：

FastJSON、Gson、Jackson序列化性能比较.png

从上图来分析，可以知道的是，在数据量较少(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耗时：20msGson耗时：5msJackson耗时：28ms#10次FastJSON耗时：29msGson耗时：15msJackson耗时：34ms#100次FastJSON耗时：48msGson耗时：46msJackson耗时：51ms#1000次FastJSON耗时：131msGson耗时：214msJackson耗时：146ms#10000次FastJSON耗时：652msGson耗时：893msJackson耗时：720ms#100000次FastJSON耗时：5985msGson耗时：7357msJackson耗时：5232ms

生成条形图：

FastJSON、Gson、Jackson反序列化性能比较.png

反序列化性能测试，

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

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

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

总结

当数据量较小的时候(1～100)，建议使用 Gson；当数据量较大的时候，建议使用Jackson；在大数据量的时候，虽然FastJson优势上来了，但是因为有漏洞，不得不放弃。

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

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

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