Java四大常用JSON解析性能对比：Hutool、Fastjson2、Gson与Jackson测试

1. 引言

JSON 是现代软件开发中常用的数据交换格式，尤其在微服务和前后端分离的架构中更是必不可少。
本文将对 Java 中四大主流 JSON 解析库——Hutool、Fastjson2、Gson 和 Jackson 进行性能测试和对比分析，通过实测 20 万条数据解析，揭示各库在批量和逐条处理中的表现。

测试结果仅供参考！！！ 请多次测试再抉择

---

2. 环境与依赖

2.1 环境信息

• 操作系统：Window11
• JDK 版本：jdk1.8.0_281
• CPU :  AMD Ryzen 9 7945HX
• 内存：32GB

2.2 Maven依赖

在项目的 pom.xml 文件中引入以下依赖：

      <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson --><dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.10.1</version></dependency><!-- https://mvnrepository.com/artifact/com.alibaba.fastjson2/fastjson2 --><dependency><groupId>com.alibaba.fastjson2</groupId><artifactId>fastjson2</artifactId><version>2.0.52</version></dependency><!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind --><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.14.2</version></dependency><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.8.35</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency>

---

3. 测试代码

3.1 数据模型

定义一个简单的实体对象：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;/*** @author 阿水*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Variable {private int id;private String name;private double value;private String description;private String type;
}

3.2 测试数据生成

模拟 20 万条数据用于测试：

  // 生成测试数据public static List<Variable> generateData(int size) {List<Variable> list = new ArrayList<>(size);for (int i = 0; i < size; i++) {Variable data = new Variable();data.setId(i);data.setName("Name" + i);data.setValue(Math.random() * 1000);data.setDescription(IdUtil.fastSimpleUUID());data.setType(IdUtil.fastSimpleUUID()+i);list.add(data);}return list;}

3.3 四大库序列化与反序列化测试

import cn.hutool.core.util.IdUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson2.JSON;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;/*** @description: JSON 序列化、解析性能测试* @author 阿水*/
@Slf4j
public class JsonBenchmarkTest {//数据总条数public static int dataSize = 200000;//测试次数public static  int iterations = 10;public static void main(String[] args) throws Exception {// 生成测试数据List<Variable> testData = generateData(dataSize);log.info("测试数据总条数为: {} 条", dataSize);log.info("以下测试结果均为进行 {} 次计算之后，耗费时间取平均值计算得出。", iterations);// 序列化测试String jsonString = serializationTest(testData);log.info("JSON 数据总大小为: {} 字节", jsonString.length());// 批量解析测试log.info("===== 使用批量解析 JSON（即解析集合API）=====");batchParseTest(jsonString);// 单条解析测试log.info("===== 循环遍历逐个解析 JSON API =====");singleParseTest(jsonString);// 单条解析并插入集合测试log.info("===== 循环遍历逐个解析 JSON并插入集合 API=====");singleParseAndAddListTest(jsonString);}// 生成测试数据public static List<Variable> generateData(int size) {List<Variable> list = new ArrayList<>(size);for (int i = 0; i < size; i++) {Variable data = new Variable();data.setId(i);data.setName("Name" + i);data.setValue(Math.random() * 1000);data.setDescription(IdUtil.fastSimpleUUID());data.setType(IdUtil.fastSimpleUUID()+i);list.add(data);}return list;}/*** 序列化测试*/private static String serializationTest(List<Variable> testData) throws Exception {String jsonResult = null;// Hutoollong hutoolTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();String hutoolJson = JSONUtil.toJsonStr(testData);long end = System.currentTimeMillis();hutoolTotal += (end - start);if (i == 0) jsonResult = hutoolJson; // 保存结果}log.info("HuTool 序列化平均耗时: {} ms", hutoolTotal / iterations);// Fastjson2long fastjsonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();String fastjsonJson = JSON.toJSONString(testData);long end = System.currentTimeMillis();fastjsonTotal += (end - start);}log.info("Fastjson2 序列化平均耗时: {} ms", fastjsonTotal / iterations);// GsonGson gson = new Gson();long gsonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();String gsonJson = gson.toJson(testData);long end = System.currentTimeMillis();gsonTotal += (end - start);}log.info("Gson 序列化平均耗时: {} ms", gsonTotal / iterations);// JacksonObjectMapper objectMapper = new ObjectMapper();long jacksonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();String jacksonJson = objectMapper.writeValueAsString(testData);long end = System.currentTimeMillis();jacksonTotal += (end - start);}log.info("Jackson 序列化平均耗时: {} ms", jacksonTotal / iterations);return jsonResult;}/*** 批量解析测试*/private static void batchParseTest(String jsonString) throws Exception {// Hutoollong hutoolTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();List<Variable> result = JSONUtil.toList(JSONUtil.parseArray(jsonString), Variable.class);long end = System.currentTimeMillis();hutoolTotal += (end - start);}log.info("HuTool 批量解析平均耗时: {} ms", hutoolTotal / iterations);// Fastjson2long fastjsonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();List<Variable> result = JSON.parseArray(jsonString, Variable.class);long end = System.currentTimeMillis();fastjsonTotal += (end - start);}log.info("Fastjson2 批量解析平均耗时: {} ms", fastjsonTotal / iterations);// GsonGson gson = new Gson();long gsonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();List<Variable> result = gson.fromJson(jsonString, new TypeToken<List<Variable>>() {}.getType());long end = System.currentTimeMillis();gsonTotal += (end - start);}log.info("Gson 批量解析平均耗时: {} ms", gsonTotal / iterations);// JacksonObjectMapper objectMapper = new ObjectMapper();long jacksonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();List<Variable> result = objectMapper.readValue(jsonString, new TypeReference<List<Variable>>() {});long end = System.currentTimeMillis();jacksonTotal += (end - start);}log.info("Jackson 批量解析平均耗时: {} ms", jacksonTotal / iterations);}/*** 单条解析测试*/private static void singleParseTest(String jsonString) throws Exception {List<String> messageList = JSON.parseArray(jsonString, Variable.class).stream().map(JSON::toJSONString).collect(Collectors.toList());// Hutoollong hutoolTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();for (String msg : messageList) {Variable v = JSONUtil.toBean(msg, Variable.class);}long end = System.currentTimeMillis();hutoolTotal += (end - start);}log.info("HuTool 单条解析平均耗时: {} ms", hutoolTotal / iterations);// Fastjson2long fastjsonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();for (String msg : messageList) {Variable v = JSON.parseObject(msg, Variable.class);}long end = System.currentTimeMillis();fastjsonTotal += (end - start);}log.info("Fastjson2 单条解析平均耗时: {} ms", fastjsonTotal / iterations);// GsonGson gson = new Gson();long gsonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();for (String msg : messageList) {Variable v = gson.fromJson(msg, Variable.class);}long end = System.currentTimeMillis();gsonTotal += (end - start);}log.info("Gson 单条解析平均耗时: {} ms", gsonTotal / iterations);// JacksonObjectMapper objectMapper = new ObjectMapper();long jacksonTotal = 0;for (int i = 0; i < iterations; i++) {long start = System.currentTimeMillis();for (String msg : messageList) {Variable v = objectMapper.readValue(msg, Variable.class);}long end = System.currentTimeMillis();jacksonTotal += (end - start);}log.info("Jackson 单条解析平均耗时: {} ms", jacksonTotal / iterations);}/*** 循环遍历单条解析并插入集合测试*//*** 循环遍历单条解析并插入集合测试 (平均耗时计算)*/static void singleParseAndAddListTest(String jsonString) throws Exception {// 转换为模拟 MQ 消息体List<String> messageList = JSON.parseArray(jsonString, Variable.class).stream().map(JSON::toJSONString) // 将每个对象转为 JSON 字符串模拟单条消息.collect(Collectors.toList());// 平均耗时变量定义double hutoolTotalTime = 0;double fastjsonTotalTime = 0;double gsonTotalTime = 0;double jacksonTotalTime = 0;// 循环 10 次计算平均耗时for (int i = 0; i < iterations; i++) {// 1. Hutool JSONUtil 单条解析List<Variable> hutoolList = new ArrayList<>();long hutoolStart = System.currentTimeMillis();for (String msg : messageList) {Variable v = JSONUtil.toBean(msg, Variable.class);hutoolList.add(v); // 将对象存入集合}long hutoolEnd = System.currentTimeMillis();hutoolTotalTime += (hutoolEnd - hutoolStart);// 2. Fastjson2 单条解析List<Variable> fastjsonList = new ArrayList<>();long fastjsonStart = System.currentTimeMillis();for (String msg : messageList) {Variable v = JSON.parseObject(msg, Variable.class);fastjsonList.add(v);}long fastjsonEnd = System.currentTimeMillis();fastjsonTotalTime += (fastjsonEnd - fastjsonStart);// 3. Gson 单条解析List<Variable> gsonList = new ArrayList<>();Gson gson = new Gson();long gsonStart = System.currentTimeMillis();for (String msg : messageList) {Variable v = gson.fromJson(msg, Variable.class);gsonList.add(v);}long gsonEnd = System.currentTimeMillis();gsonTotalTime += (gsonEnd - gsonStart);// 4. Jackson 单条解析List<Variable> jacksonList = new ArrayList<>();ObjectMapper objectMapper = new ObjectMapper();long jacksonStart = System.currentTimeMillis();for (String msg : messageList) {Variable v = objectMapper.readValue(msg, Variable.class);jacksonList.add(v);}long jacksonEnd = System.currentTimeMillis();jacksonTotalTime += (jacksonEnd - jacksonStart);}// 输出平均耗时结果log.info("HuTool 单条解析并存入集合平均耗时: {} ms", hutoolTotalTime / iterations);log.info("Fastjson2 单条解析并存入集合平均耗时: {} ms", fastjsonTotalTime / iterations);log.info("Gson 单条解析并存入集合平均耗时: {} ms", gsonTotalTime / iterations);log.info("Jackson 单条解析并存入集合平均耗时: {} ms", jacksonTotalTime / iterations);}}

---

4. 20W条数据、31098673字节测试结果分析（仅供参考 仅供参考 仅供参考 ！！！）

库名称	序列化+反序列化总耗时	性能排名
Fastjson2	110ms左右	🥇 第一名
Jackson	170ms左右	🥈 第二名
Gson	210ms左右	🥉 第三名
Hutool	1800ms左右	第四名

---

5. 性能分析与总结

测试结果分析

1. Fastjson2

   • 性能表现： 测试结果中，无论是批量解析、逐条解析还是逐条解析并插入集合，它的速度都是最快的（30ms、39ms、39.8ms）。
   • 特性优势： 支持复杂对象结构解析，API 设计简洁高效，并修复了旧版 Fastjson 的反序列化漏洞，安全性更高。
   • 适用场景： 高并发、大数据量处理及性能敏感型应用场景。

2. Hutool

   • 性能表现： 表现最慢，尤其在批量解析（637ms）和逐条解析（589ms）中远落后于其他库。
   • 特性优势： API 优雅轻便，开发效率高，但性能瓶颈明显，不适合超大规模数据解析。
   • 适用场景： 适合中小规模项目的快速开发，便捷性优先于性能要求的场合。

3. Jackson

   • 性能表现： 表现较优，解析速度仅次于 Fastjson2（78ms、101ms、99.8ms），兼顾性能与功能复杂性。
   • 特性优势： 支持复杂 Java 对象和自定义配置，兼容性强，适合复杂数据结构映射需求。
   • 适用场景： 企业级应用、大型复杂系统开发及对灵活性要求高的项目。

4. Gson

   • 性能表现： 性能优于 Hutool，但低于 Fastjson2 和 Jackson（93ms、119ms、119.5ms）。
   • 特性优势： API 简单直观，开发成本低，但在大数据量或高并发处理时性能表现不够理想。
   • 适用场景： 小规模数据解析需求，或对性能要求不高的任务。

---

6. 推荐选择

需求类型	推荐库	适用场景描述
性能优先	Fastjson2	在所有测试场景中速度最快，适合高性能和高并发场景，适合日志分析、大数据处理和消息队列数据解析等应用。
轻量便捷	Hutool	更适合中小规模项目的快速开发，虽然性能较低，但 API 优雅轻便，适合便捷性优先的场合。
功能复杂需求	Jackson	兼顾性能与灵活性，支持复杂数据结构和自定义配置，适合大型企业级应用或复杂对象映射需求。
简单解析需求	Gson	API 简洁易用，适合小规模数据解析任务，学习成本低，但不适合大数据和高并发需求。

---

7. 结论与建议

1. Fastjson2：

   • 性能最高，适合高并发与大数据处理需求。
   • 安全性较高，是性能敏感应用的首选。

2. Hutool：

   • 开发便捷但性能较低，适合中小规模项目。
   • 如果对开发效率要求高且数据量适中，可以选择它。

3. Jackson：

   • 性能与灵活性兼顾，适合复杂对象和企业级系统。
   • 面向需要自定义解析规则的场景表现更出色。

4. Gson：

   • 简单易用但性能低于 Fastjson2 和 Jackson。
   • 适合小型项目或对性能要求不高的场合。

---

注意事项

1. 安全性： Fastjson2 安全性最佳，其他库需关注版本更新，以避免反序列化漏洞。
2. 兼容性： Jackson 在跨平台兼容性和复杂结构处理方面表现更佳。
3. 性能评估： 项目正式使用前，应基于实际生产环境进行更大规模的性能测试和压力测试。

---

仅当前测试数据明确显示：

• Fastjson2 性能最佳，适合高性能需求。
• Hutool 性能最慢，更适合便捷开发而非大规模数据解析。
• Jackson 在性能和灵活性之间取得平衡，适合复杂应用场景。
• Gson 表现优于 Hutool，但略逊于 Fastjson2 和 Jackson，适合轻量级需求。