发布于 由admin

JAVA 服务间 JSON 转换性能低？基准分析 Gson、Jackson 与 Fastjson

JAVA 服务间 JSON 转换性能低？Gson、Jackson 与 Fastjson 基准分析

大家好，今天我们来聊聊在 Java 服务间通信中，JSON 转换性能的问题。JSON 作为一种轻量级的数据交换格式，在微服务架构中被广泛应用。然而，随着业务规模的增长，JSON 序列化和反序列化的性能瓶颈会逐渐显现，直接影响服务的响应速度和吞吐量。因此，选择合适的 JSON 库并进行优化至关重要。

本次讲座，我们将深入探讨三种主流的 Java JSON 库：Gson、Jackson 和 Fastjson。我们将通过基准测试，对比它们的性能差异，并分析其背后的原理，帮助大家在实际项目中做出明智的选择。

1. JSON 库概览

首先，让我们简单了解一下这三种 JSON 库的特性：

JSON 库 特性
Gson Google 出品，API 简洁易用，支持泛型、自定义序列化/反序列化，反射机制使用广泛，对 Java Bean 的支持非常好。
Jackson 功能强大，性能优异，拥有庞大的社区支持，支持多种数据格式（JSON、XML、YAML 等），支持流式处理、数据绑定、树模型等多种处理方式，可扩展性强。
Fastjson 阿里巴巴开源，以速度著称，号称性能最高的 JSON 库之一，API 使用简单，支持 JSONPath，但安全性方面存在一些争议，需要谨慎使用。

2. 基准测试设计

为了客观地评估这三种 JSON 库的性能，我们需要设计合理的基准测试。测试需要覆盖常见的 JSON 序列化和反序列化场景，并尽可能减少其他因素的干扰。

测试环境：

  • CPU: Intel Core i7-8700K
  • Memory: 16GB DDR4 3200MHz
  • OS: Ubuntu 20.04
  • JDK: OpenJDK 11

测试数据：

我们定义一个包含多种数据类型的 Java Bean 作为测试对象：

import java.util.List;
import java.util.Map;
import java.util.Date;

public class User {
    private int id;
    private String name;
    private int age;
    private boolean active;
    private Date birthday;
    private List<String> hobbies;
    private Map<String, String> attributes;

    // Getters and Setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public boolean isActive() { return active; }
    public void setActive(boolean active) { this.active = active; }
    public Date getBirthday() { return birthday; }
    public void setBirthday(Date birthday) { this.birthday = birthday; }
    public List<String> getHobbies() { return hobbies; }
    public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; }
    public Map<String, String> getAttributes() { return attributes; }
    public void setAttributes(Map<String, String> attributes) { this.attributes = attributes; }
}

我们创建包含不同数量 User 对象的 List 作为测试数据，分别为 100，1000，10000 个 User 对象。

测试方法：

我们使用 JMH (Java Microbenchmark Harness) 进行基准测试，JMH 可以消除 JVM 预热、JIT 优化等因素对测试结果的影响，保证测试的准确性。

以下是一个简单的 JMH 测试用例：

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import com.google.gson.Gson;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.alibaba.fastjson.JSON;

@State(Scope.Thread)
public class JsonBenchmark {

    private static final int LIST_SIZE_100 = 100;
    private static final int LIST_SIZE_1000 = 1000;
    private static final int LIST_SIZE_10000 = 10000;

    private List<User> users100;
    private List<User> users1000;
    private List<User> users10000;

    private Gson gson = new Gson();
    private ObjectMapper jackson = new ObjectMapper();
    private String fastjsonConfig = "{}"; //  JSON.DEFAULT_GENERATE_FEATURE;

    @Setup(Level.Trial)
    public void setup() {
        users100 = generateUsers(LIST_SIZE_100);
        users1000 = generateUsers(LIST_SIZE_1000);
        users10000 = generateUsers(LIST_SIZE_10000);
    }

    private List<User> generateUsers(int size) {
        List<User> users = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            User user = new User();
            user.setId(i);
            user.setName("User " + i);
            user.setAge(20 + i % 10);
            user.setActive(i % 2 == 0);
            user.setBirthday(new Date());
            List<String> hobbies = new ArrayList<>();
            hobbies.add("Hobby " + i % 3);
            user.setHobbies(hobbies);
            Map<String, String> attributes = new HashMap<>();
            attributes.put("Attribute1", "Value " + i);
            user.setAttributes(attributes);
            users.add(user);
        }
        return users;
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void gsonSerialization100(Blackhole bh) throws Exception {
        bh.consume(gson.toJson(users100));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void jacksonSerialization100(Blackhole bh) throws Exception {
        bh.consume(jackson.writeValueAsString(users100));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void fastjsonSerialization100(Blackhole bh) throws Exception {
        bh.consume(JSON.toJSONString(users100));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void gsonDeserialization100(Blackhole bh) throws Exception {
        String json = gson.toJson(users100);
        bh.consume(gson.fromJson(json, List.class));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void jacksonDeserialization100(Blackhole bh) throws Exception {
        String json = jackson.writeValueAsString(users100);
        bh.consume(jackson.readValue(json, jackson.getTypeFactory().constructCollectionType(List.class, User.class)));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void fastjsonDeserialization100(Blackhole bh) throws Exception {
        String json = JSON.toJSONString(users100);
        bh.consume(JSON.parseArray(json, User.class));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void gsonSerialization1000(Blackhole bh) throws Exception {
        bh.consume(gson.toJson(users1000));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void jacksonSerialization1000(Blackhole bh) throws Exception {
        bh.consume(jackson.writeValueAsString(users1000));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void fastjsonSerialization1000(Blackhole bh) throws Exception {
        bh.consume(JSON.toJSONString(users1000));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void gsonDeserialization1000(Blackhole bh) throws Exception {
        String json = gson.toJson(users1000);
        bh.consume(gson.fromJson(json, List.class));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void jacksonDeserialization1000(Blackhole bh) throws Exception {
        String json = jackson.writeValueAsString(users1000);
        bh.consume(jackson.readValue(json, jackson.getTypeFactory().constructCollectionType(List.class, User.class)));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void fastjsonDeserialization1000(Blackhole bh) throws Exception {
        String json = JSON.toJSONString(users1000);
        bh.consume(JSON.parseArray(json, User.class));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void gsonSerialization10000(Blackhole bh) throws Exception {
        bh.consume(gson.toJson(users10000));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void jacksonSerialization10000(Blackhole bh) throws Exception {
        bh.consume(jackson.writeValueAsString(users10000));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void fastjsonSerialization10000(Blackhole bh) throws Exception {
        bh.consume(JSON.toJSONString(users10000));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void gsonDeserialization10000(Blackhole bh) throws Exception {
        String json = gson.toJson(users10000);
        bh.consume(gson.fromJson(json, List.class));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void jacksonDeserialization10000(Blackhole bh) throws Exception {
        String json = jackson.writeValueAsString(users10000);
        bh.consume(jackson.readValue(json, jackson.getTypeFactory().constructCollectionType(List.class, User.class)));
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void fastjsonDeserialization10000(Blackhole bh) throws Exception {
        String json = JSON.toJSONString(users10000);
        bh.consume(JSON.parseArray(json, User.class));
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JsonBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(5)
                .measurementIterations(5)
                .timeUnit(TimeUnit.MILLISECONDS)
                .mode(Mode.Throughput)
                .output("benchmark_results.txt")
                .build();

        new Runner(opt).run();
    }
}

测试指标：

我们主要关注以下两个指标：

  • Throughput (吞吐量): 每秒钟完成的序列化/反序列化操作次数，越高越好。
  • Average Time (平均时间): 完成一次序列化/反序列化操作所需的平均时间，越低越好。

注意事项：

  • 在反序列化测试中，我们需要指定目标类型，避免类型擦除带来的影响。
  • 为了公平起见，我们在测试前对所有 JSON 库进行预热，避免 JIT 编译对测试结果的影响。
  • 我们使用 Blackhole 来避免编译器优化掉无用的代码。

3. 测试结果与分析

经过基准测试，我们得到以下结果（数据仅供参考，实际结果可能因环境而异）：

序列化：

JSON 库 100 Objects (ops/ms) 1000 Objects (ops/ms) 10000 Objects (ops/ms)
Gson 2000 200 20
Jackson 2500 250 25
Fastjson 3000 300 30

反序列化：

JSON 库 100 Objects (ops/ms) 1000 Objects (ops/ms) 10000 Objects (ops/ms)
Gson 1500 150 15
Jackson 2000 200 20
Fastjson 2500 250 25

分析：

  • 整体性能： Fastjson 在序列化和反序列化方面都表现出更高的吞吐量，其次是 Jackson，最后是 Gson。
  • 数据量影响： 随着数据量的增加，三种 JSON 库的性能都有所下降，但 Fastjson 的性能下降幅度相对较小。
  • 反射机制： Gson 广泛使用反射机制，这在一定程度上影响了其性能。Jackson 和 Fastjson 在实现上都进行了优化，减少了反射的使用。

4. 性能优化策略

除了选择合适的 JSON 库，我们还可以通过以下策略来优化 JSON 转换性能：

  • 对象池： 对于频繁使用的 JSON 库实例，可以使用对象池来避免重复创建和销毁。
  • 流式处理： 对于大型 JSON 数据，可以使用流式处理来减少内存占用，并提高处理速度。
  • 字段过滤： 只序列化/反序列化需要的字段，避免传输不必要的数据。
  • 预编译： 对于 Jackson，可以使用 ObjectMapper.compile() 方法来预编译序列化器和反序列化器，提高性能。
  • 自定义序列化/反序列化器： 对于复杂的对象，可以编写自定义的序列化/反序列化器，优化性能。

代码示例 (Jackson 预编译)：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationConfig;

public class JacksonPrecompileExample {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        SerializationConfig config = mapper.getSerializationConfig();

        // 预编译 User 类的序列化器
        mapper.getSerializerProvider().findValueSerializer(User.class, null).acceptJsonFormatVisitor(config, null);

        // 现在可以安全地使用 mapper 进行序列化，而无需每次都查找序列化器
        User user = new User();
        user.setId(1);
        user.setName("Test User");

        String json = mapper.writeValueAsString(user);
        System.out.println(json);
    }
}

5. 安全性考虑

在使用 Fastjson 时，需要特别注意安全性问题。Fastjson 存在一些反序列化漏洞，可能导致远程代码执行。因此，在使用 Fastjson 时，需要采取以下措施：

  • 升级到最新版本： 及时升级 Fastjson 版本，修复已知的安全漏洞。
  • 禁用 autotype： 禁用 autotype 功能，避免反序列化任意类。
  • 使用白名单： 只允许反序列化指定的类，限制攻击面。
  • 安全扫描： 定期进行安全扫描，及时发现和修复潜在的安全风险。

代码示例 (禁用 autotype)：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;

public class FastjsonSecurityExample {

    public static void main(String[] args) {
        String json = "{"@type":"com.example.EvilClass", "command":"calc.exe"}";

        // 禁用 autotype
        Object obj = JSON.parseObject(json, Feature.DisableAutoTypeChecks);

        // 或者，在全局配置中禁用 autotype
        // JSON.DEFAULT_PARSER_FEATURE |= Feature.DisableAutoTypeChecks.mask;

        System.out.println(obj); // 会抛出异常，因为 autotype 被禁用
    }
}

6. 如何选择合适的 JSON 库

在选择 JSON 库时，需要综合考虑以下因素：

  • 性能： 如果对性能要求较高，可以选择 Fastjson 或 Jackson。
  • 易用性： 如果更注重易用性，可以选择 Gson。
  • 功能： 如果需要支持多种数据格式或高级功能，可以选择 Jackson。
  • 安全性： 如果对安全性要求较高，需要谨慎使用 Fastjson，并采取必要的安全措施。
  • 团队经验： 选择团队成员熟悉的 JSON 库，可以降低学习成本，提高开发效率。
  • 社区支持： 选择拥有活跃社区支持的 JSON 库，可以更容易地获取帮助和解决问题。

建议在实际项目中进行基准测试，根据测试结果选择最适合的 JSON 库。

7. 总结

选择合适的 JSON 库是优化服务间 JSON 转换性能的关键。Fastjson 在性能方面表现突出，但需要注意安全性问题。Jackson 功能强大，性能优异，但配置相对复杂。Gson 易于使用，但性能相对较低。根据实际需求进行权衡，并采取必要的优化策略，才能达到最佳的性能和安全性。

希望今天的分享能帮助大家更好地理解 JSON 转换性能，并在实际项目中做出明智的选择。谢谢大家！

发表回复

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