本篇通过 JMH 来测试一下 Java 中几种常见的 JSON 解析库的性能。每次都在网上看到别人说什么某某库性能是如何如何的好,碾压其他的库。但是百闻不如一见,只有自己亲手测试过的才是最值得相信的。

JSON 不管是在 Web 开发还是服务器开发中是相当常见的数据传输格式,一般情况我们对于 JSON 解析构造的性能并不需要过于关心,除非是在性能要求比较高的系统。

目前对于 Java 开源的 JSON 类库有很多种,下面我们取 4 个常用的 JSON 库进行性能测试对比, 同时根据测试结果分析如果根据实际应用场景选择最合适的 JSON 库。

这 4 个 JSON 类库分别为:Gson,FastJson,Jackson,Json-lib。

简单介绍

选择一个合适的 JSON 库要从多个方面进行考虑:

  • 字符串解析成 JSON 性能

  • 字符串解析成 JavaBean 性能

  • JavaBean 构造 JSON 性能

  • 集合构造 JSON 性能

  • 易用性

先简单介绍下四个类库的身份背景

Gson

项目地址:https://github.com/google/gson

Gson 是目前功能最全的 Json 解析神器,Gson 当初是为因应 Google 公司内部需求而由 Google 自行研发而来,但自从在 2008 年五月公开发布第一版后已被许多公司或用户应用。Gson 的应用主要为 toJson 与 fromJson 两个转换函数,无依赖,不需要例外额外的 jar,能够直接跑在 JDK 上。在使用这种对象转换之前,需先创建好对象的类型以及其成员才能成功的将 JSON 字符串成功转换成相对应的对象。类里面只要有 get 和 set 方法,Gson 完全可以实现复杂类型的 json 到 bean 或 bean 到 json 的转换,是 JSON 解析的神器。

FastJson

项目地址:https://github.com/alibaba/fastjson

Fastjson 是一个 Java 语言编写的高性能的 JSON 处理器,由阿里巴巴公司开发。无依赖,不需要例外额外的 jar,能够直接跑在 JDK 上。FastJson 在复杂类型的 Bean 转换 Json 上会出现一些问题,可能会出现引用的类型,导致 Json 转换出错,需要制定引用。FastJson 采用独创的算法,将 parse 的速度提升到极致,超过所有 json 库。

Jackson

项目地址:https://github.com/FasterXML/jackson

Jackson 是当前用的比较广泛的,用来序列化和反序列化 json 的 Java 开源框架。Jackson 社区相对比较活跃,更新速度也比较快, 从 Github 中的统计来看,Jackson 是最流行的 json 解析器之一,Spring MVC 的默认 json 解析器便是 Jackson。

Jackson 优点很多:

  • Jackson 所依赖的 jar 包较少,简单易用。

  • 与其他 Java 的 json 的框架 Gson 等相比,Jackson 解析大的 json 文件速度比较快。

  • Jackson 运行时占用内存比较低,性能比较好

  • Jackson 有灵活的 API,可以很容易进行扩展和定制。

目前最新版本是 2.9.4,Jackson 的核心模块由三部分组成:

  1. jackson-core 核心包,提供基于”流模式”解析的相关 API,它包括 JsonPaser 和 JsonGenerator。Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。

  2. jackson-annotations 注解包,提供标准注解功能;

  3. jackson-databind 数据绑定包,提供基于”对象绑定” 解析的相关 API( ObjectMapper )和”树模型” 解析的相关 API(JsonNode);基于”对象绑定” 解析的 API 和”树模型”解析的 API 依赖基于”流模式”解析的 API。

为什么 Jackson 的介绍这么长啊?因为它也是本人的最爱。

Json-lib

项目地址:http://json-lib.sourceforge.net/index.html

json-lib 最开始的也是应用最广泛的 json 解析工具,json-lib 不好的地方确实是依赖于很多第三方包,对于复杂类型的转换,json-lib 对于 json 转换成 bean 还有缺陷, 比如一个类里面会出现另一个类的 list 或者 map 集合,json-lib 从 json 到 bean 的转换就会出现问题。json-lib 在功能和性能上面都不能满足现在互联网化的需求。

编写性能测试

接下来开始编写这四个库的性能测试代码。

添加 maven 依赖

当然首先是添加四个库的 maven 依赖,公平起见,我全部使用它们最新的版本:

<!-- Json libs-->
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.2</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.46</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.4</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.4</version>
</dependency>

四个库的工具类

FastJsonUtil.java

public class FastJsonUtil {
    public static String bean2Json(Object obj) {
        return JSON.toJSONString(obj);
    }


    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        return JSON.parseObject(jsonStr, objClass);
    }
}

GsonUtil.java

public class GsonUtil {
    private static Gson gson = new GsonBuilder().create();


    public static String bean2Json(Object obj) {
        return gson.toJson(obj);
    }


    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        return gson.fromJson(jsonStr, objClass);
    }


    public static String jsonFormatter(String uglyJsonStr) {
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        JsonParser jp = new JsonParser();
        JsonElement je = jp.parse(uglyJsonStr);
        return gson.toJson(je);
    }
}

JacksonUtil.java

public class JacksonUtil {
    private static ObjectMapper mapper = new ObjectMapper();


    public static String bean2Json(Object obj) {
        try {
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }
    }


    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        try {
            return mapper.readValue(jsonStr, objClass);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

JsonLibUtil.java

public class JsonLibUtil {


    public static String bean2Json(Object obj) {
        JSONObject jsonObject = JSONObject.fromObject(obj);
        return jsonObject.toString();
    }


    @SuppressWarnings("unchecked")
    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        return (T) JSONObject.toBean(JSONObject.fromObject(jsonStr), objClass);
    }
}

准备 Model 类

这里我写一个简单的 Person 类,同时属性有 Date、List、Map 和自定义的类 FullName,最大程度模拟真实场景。

public class Person {
    private String name;
    private FullName fullName;
    private int age;
    private Date birthday;
    private List<String> hobbies;
    private Map<String, String> clothes;
    private List<Person> friends;


    // getter/setter省略


    @Override
    public String toString() {
        StringBuilder str = new StringBuilder("Person [name=" + name + ", fullName=" + fullName + ", age="
                + age + ", birthday=" + birthday + ", hobbies=" + hobbies
                + ", clothes=" + clothes + "]n");
        if (friends != null) {
            str.append("Friends:n");
            for (Person f : friends) {
                str.append("t").append(f);
            }
        }
        return str.toString();
    }


}

public class FullName {
    private String firstName;
    private String middleName;
    private String lastName;


    public FullName() {
    }


    public FullName(String firstName, String middleName, String lastName) {
        this.firstName = firstName;
        this.middleName = middleName;
        this.lastName = lastName;
    }


    // 省略getter和setter


    @Override
    public String toString() {
        return "[firstName=" + firstName + ", middleName="
                + middleName + ", lastName=" + lastName + "]";
    }
}

JSON 序列化性能基准测试

@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class JsonSerializeBenchmark {
    /**
     * 序列化次数参数
     */
    @Param({"1000", "10000", "100000"})
    private int count;


    private Person p;


    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
                .include(JsonSerializeBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(0)
                .build();
        Collection<RunResult> results =  new Runner(opt).run();
        ResultExporter.exportResult("JSON序列化性能", results, "count", "秒");
    }


    @Benchmark
    public void JsonLib() {
        for (int i = 0; i < count; i++) {
            JsonLibUtil.bean2Json(p);
        }
    }


    @Benchmark
    public void Gson() {
        for (int i = 0; i < count; i++) {
            GsonUtil.bean2Json(p);
        }
    }


    @Benchmark
    public void FastJson() {
        for (int i = 0; i < count; i++) {
            FastJsonUtil.bean2Json(p);
        }
    }


    @Benchmark
    public void Jackson() {
        for (int i = 0; i < count; i++) {
            JacksonUtil.bean2Json(p);
        }
    }


    @Setup
    public void prepare() {
        List<Person> friends=new ArrayList<Person>();
        friends.add(createAPerson("小明",null));
        friends.add(createAPerson("Tony",null));
        friends.add(createAPerson("陈小二",null));
        p=createAPerson("邵同学",friends);
    }


    @TearDown
    public void shutdown() {
    }


    private Person createAPerson(String name,List<Person> friends) {
        Person newPerson=new Person();
        newPerson.setName(name);
        newPerson.setFullName(new FullName("zjj_first", "zjj_middle", "zjj_last"));
        newPerson.setAge(24);
        List<String> hobbies=new ArrayList<String>();
        hobbies.add("篮球");
        hobbies.add("游泳");
        hobbies.add("coding");
        newPerson.setHobbies(hobbies);
        Map<String,String> clothes=new HashMap<String, String>();
        clothes.put("coat", "Nike");
        clothes.put("trousers", "adidas");
        clothes.put("shoes", "安踏");
        newPerson.setClothes(clothes);
        newPerson.setFriends(friends);
        return newPerson;
    }
}

说明一下,上面的代码中

ResultExporter.exportResult("JSON序列化性能", results, "count", "秒");

这个是我自己编写的将性能测试报告数据填充至 Echarts 图,然后导出 png 图片的方法。

执行后的结果图:

从上面的测试结果可以看出,反序列化的时候,Gson、Jackson 和 FastJson 区别不大,性能都很优异,而那个 Json-lib 还是来继续搞笑的。

本文文字及图片出自 InfoQ

余下全文(1/3)
分享这篇文章:

请关注我们:

《Java 常用的几个 Json 库,性能强势对比!》有14个想法

  1. admin  这篇文章, 并对这篇文章的反应是'+(44066*40206)+'
  2. admin  这篇文章
  3. admin  这篇文章
  4. admin  这篇文章
  5. admin  这篇文章
  6. admin  这篇文章
  7. admin  这篇文章
  8. admin  这篇文章
  9. admin  这篇文章
  10. admin  这篇文章
  11. admin  这篇文章
  12. admin  这篇文章
  13. admin  这篇文章
  14. admin  这篇文章

发表评论

邮箱地址不会被公开。 必填项已用*标注