Java四大常用JSON解析工具性能对比(Hutool、Fastjson2、Gson与Jackson)

更新时间：2025年05月20日 08:50:42 作者：不掉头发的阿水

JSON 是现代软件开发中常用的数据交换格式,尤其在微服务和前后端分离的架构中更是必不可少,本文将对 Java 中四大主流 JSON 解析库进行性能测试和对比分析,希望对大家有所帮助

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;
        // Hutool
        long 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);
 
        // Fastjson2
        long 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);
 
        // Gson
        Gson 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);
 
        // Jackson
        ObjectMapper 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 {
        // Hutool
        long 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);
 
        // Fastjson2
        long 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);
 
        // Gson
        Gson 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);
 
        // Jackson
        ObjectMapper 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());
        // Hutool
        long 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);
 
        // Fastjson2
        long 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);
 
        // Gson
        Gson 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);
 
        // Jackson
        ObjectMapper 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. 结论与建议

Fastjson2：

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

Hutool：

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

Jackson：

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

Gson：

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

注意事项

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

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

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

到此这篇关于Java四大常用JSON解析工具性能对比(Hutool、Fastjson2、Gson与Jackson)的文章就介绍到这了,更多相关Java解析JSON内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java实现JDK动态代理的原理详解
这篇文章主要介绍了Java实现JDK动态代理的原理详解，Java常用的动态代理模式有JDK动态代理，也有cglib动态代理，本文重点讲解JDK的动态代理，需要的小伙伴可以参考一下的相关资料
2022-07-07
gradle安装和环境配置全过程
本文介绍了如何安装和配置Gradle环境,包括下载Gradle、配置环境变量、测试Gradle以及在IntelliJ IDEA中配置Gradle
2025-01-01
每日几道java新手入门面试题,通往自由的道路
这篇文章主要为大家分享了最有价值的是几道java面试题，涵盖内容全面，包括数据结构和算法相关的题目、经典面试编程题等，对hashCode方法的设计、垃圾收集的堆和代进行剖析，感兴趣的小伙伴们可以参考一下
2021-07-07
Spring Boot如何配置yml配置文件定义集合、数组和Map
这篇文章主要介绍了Spring Boot 优雅配置yml配置文件定义集合、数组和Map,包括Spring Boot yml配置文件定义基本数据类型和引用数据类型的方式，需要的朋友可以参考下
2023-10-10
JavaWeb乱码问题的终极解决方案（推荐）
这篇文章主要给大家介绍了关于JavaWeb乱码问题的终极解决方案，文中通过示例代码介绍的非常详细，对大家学习或者使用JavaWeb具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-04-04
SpringBoot监视器的具体使用
Spring Boot监视器是一个用于监控和管理Spring Boot应用程序的工具集,本文就来介绍一下SpringBoot监视器的具体使用,感兴趣的可以了解一下
2025-01-01
SpringBoot整合EasyCaptcha实现图形验证码功能
这篇文章主要介绍了SpringBoot整合EasyCaptcha实现图形验证码功能,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2024-02-02
java通过共享变量结束run停止线程的方法示例
这篇文章主要介绍了java通过共享变量结束run停止线程的方法,大家参考使用
2013-11-11
Spring Boot分页方法定义示例
这篇文章主要为大家介绍了Spring Boot 分页方法定义,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-09-09
Java中简单实用Quartz概述
Quartz是一个开源的Java调度框架，可以用来实现在指定的时间或时间间隔触发任务执行的功能，这篇文章主要介绍了Java中简单实用Quartz,需要的朋友可以参考下
2023-02-02