Java JSON 处理库全面指南：Jackson、Gson、JSON-B 与 Fastjson 深度解析

在现代 Java 开发中，JSON（JavaScript Object Notation）已成为 RESTful API 数据交换、微服务通信以及配置文件存储的事实标准。高效、稳定地进行 JSON 序列化与反序列化是构建高性能 Java 应用的核心环节。本文深度解析 Java 生态系统中的四大主流 JSON 处理库——Jackson、Gson、JSON-B 与 Fastjson，涵盖核心特性、代码实践、安全合规及架构选型策略，助力开发者在不同业务场景下做出最优技术决策。

7.5 Java JSON 处理库核心解析

7.5.1 主流 JSON 处理库对比与选型

Java 生态系统中存在多种 JSON 处理库，各有其设计哲学与适用场景。以下为核心库的综合对比：

7.5.2 Jackson：高性能与高扩展性实践

Jackson 被广泛认为是 Java 中最流行且功能最强大的 JSON 处理库。它提供了高性能的数据绑定（Data Binding）、流式处理（Streaming API）以及树模型（Tree Model），能够满足从简单对象映射到复杂流式解析的各类需求。

1. 引入 Jackson 依赖

在 Maven 或 Gradle 项目中添加 jackson-databind 依赖，该模块会自动引入 jackson-core 和 jackson-annotations。

Maven:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>
​

Gradle:

dependencies {
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.0'
}
​

2. 基础序列化与反序列化

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class JacksonExample {
    public static void main(String[] args) throws IOException {
        // 实例化 ObjectMapper（建议作为全局单例复用，线程安全）
        ObjectMapper objectMapper = new ObjectMapper();

        // 序列化：Java 对象转换为 JSON 字符串
        User user = new User("John Doe", 30);
        String jsonString = objectMapper.writeValueAsString(user);
        System.out.println("JSON String: " + jsonString);

        // 反序列化：JSON 字符串转换为 Java 对象
        String json = "{\"name\":\"Jane Doe\",\"age\":25}";
        User newUser = objectMapper.readValue(json, User.class);
        System.out.println("User Object: " + newUser);
    }

    static class User {
        public String name;
        public int age;

        // Jackson 反序列化必须依赖无参构造函数
        public User() {} 

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{name='" + name + "', age=" + age + "}";
        }
    }
}
​

核心机制解析：

• ObjectMapper 是 Jackson 的核心入口类，负责协调所有的序列化与反序列化操作。
• writeValueAsString() 与 readValue() 是最常用的数据绑定方法。
• 关键约束：目标类必须提供默认的无参构造函数，否则反序列化过程将抛出异常。

3. 高级特性与注解控制

Jackson 提供了丰富的注解体系以精确控制 JSON 结构的映射行为。

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class JacksonJsonPropertyExample {
    public static void main(String[] args) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();

        Person person = new Person("Alice", 28, "alice@example.com");
        String jsonString = objectMapper.writeValueAsString(person);
        System.out.println("JSON String: " + jsonString);

        String json = "{\"email_address\":\"bob@example.com\", \"person_name\":\"Bob\", \"age\":35}";
        Person newPerson = objectMapper.readValue(json, Person.class);
        System.out.println("Person Object: " + newPerson);
    }

    static class Person {
        @JsonProperty("person_name")
        public String name;
        
        public int age;
        
        @JsonProperty("email_address")
        public String email;

        public Person() {}

        public Person(String name, int age, String email) {
            this.name = name;
            this.age = age;
            this.email = email;
        }
    }
}
​

通过 @JsonProperty 注解，实现了 Java 属性名与 JSON 字段名的解耦。此外，@JsonIgnore 可用于排除敏感字段，@JsonFormat 则常用于统一日期时间格式。

7.5.3 Gson：简洁易用的轻量级方案

由 Google 开发的 Gson 以其极简的 API 设计著称，无需繁琐的配置即可完成大多数常规的 JSON 处理任务。

1. 引入 Gson 依赖

Maven:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
</dependency>
​

Gradle:

dependencies {
    implementation 'com.google.code.gson:gson:2.8.9'
}
​

2. 基础用法与核心 API

import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {
        Gson gson = new Gson();

        Dog dog = new Dog("Buddy", "Golden Retriever");
        String jsonString = gson.toJson(dog);
        System.out.println("JSON String: " + jsonString);

        String json = "{\"name\":\"Bella\",\"breed\":\"Labrador\"}";
        Dog newDog = gson.fromJson(json, Dog.class);
        System.out.println("Dog Object: " + newDog);
    }

    static class Dog {
        public String name;
        public String breed;

        public Dog() {}

        public Dog(String name, String breed) {
            this.name = name;
            this.breed = breed;
        }
    }
}
​

Gson 的 toJson() 和 fromJson() 方法语义清晰，且对无参构造函数的要求相对宽松（在较新版本中可通过内部机制绕过）。

3. 字段过滤与重命名

import com.google.gson.Gson;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class GsonAnnotationExample {
    public static void main(String[] args) {
        // 需配合 ExclusionStrategy 或使用 new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()
        Gson gson = new Gson(); 
        
        Product product = new Product("Laptop", 1200.0, false);
        String jsonString = gson.toJson(product);
        System.out.println("JSON String: " + jsonString);
    }

    static class Product {
        @Expose
        @SerializedName("product_name")
        public String name;
        
        @Expose
        public double price;
        
        @Expose(serialize = false) // 仅参与反序列化，不参与序列化
        public boolean available;

        public Product() {}

        public Product(String name, double price, boolean available) {
            this.name = name;
            this.price = price;
            this.available = available;
        }
    }
}
​

@Expose 注解结合 GsonBuilder 可实现细粒度的字段暴露控制，@SerializedName 则负责字段重命名。

7.5.4 JSON-B：Java EE 标准化绑定 API

JSON-B（Jakarta JSON Binding）是 Jakarta EE 规范的一部分，旨在提供标准化的 JSON 映射 API，减少不同框架间的切换成本。Eclipse Yasson 是其官方参考实现。

1. 引入 JSON-B 依赖

Maven:

<dependency>
    <groupId>org.eclipse</groupId>
    <artifactId>yasson</artifactId>
    <version>2.0.3</version>
</dependency>
<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>2.0.1</version>
</dependency>
​

2. 标准化操作实践

import jakarta.json.bind.Jsonb;
import jakarta.json.bind.JsonbBuilder;

public class JsonbExample {
    public static void main(String[] args) {
        // 创建 Jsonb 实例
        Jsonb jsonb = JsonbBuilder.create();

        Address address = new Address("123 Main St", "Anytown");
        String jsonString = jsonb.toJson(address);
        System.out.println("JSON String: " + jsonString);

        String json = "{\"street\":\"456 Oak Ave\",\"city\":\"Someville\"}";
        Address newAddress = jsonb.fromJson(json, Address.class);
        System.out.println("Address Object: " + newAddress);

        // 释放底层资源
        jsonb.close(); 
    }

    static class Address {
        public String street;
        public String city;

        public Address() {}

        public Address(String street, String city) {
            this.street = street;
            this.city = city;
        }
    }
}
​

规范要点：使用完毕后必须调用 close() 方法释放 Jsonb 实例占用的资源。通过 @JsonbProperty 和 @JsonbTransient 注解，可实现与 Jackson 类似的字段映射与忽略逻辑。

7.5.5 Fastjson：极致性能与安全合规指南

Fastjson 凭借极高的解析速度在国内市场占据重要地位。然而，其历史上的 AutoType 机制曾引发多起严重的反序列化安全漏洞。

安全合规最佳实践：

1. 升级版本：务必使用 Fastjson2 或 Fastjson 1.2.83 及以上版本。
2. 开启 SafeMode：在应用启动初期，通过代码或 JVM 参数全局关闭 AutoType 功能。

   ParserConfig.getGlobalInstance().setSafeMode(true);
   ​

3. 避免不可信输入：严禁将来自外部不可信来源的 JSON 字符串直接反序列化为复杂的 Java 对象（尤其是包含 @type 字段的 payload）。

7.5.6 架构视角：JSON 处理库的生态关系

下图展示了 Java 应用程序与不同 JSON 处理库及底层数据格式之间的交互拓扑：

在微服务架构中，JSON 处理库通常被深度集成于 HTTP 客户端（如 Feign、RestTemplate）与 Web 框架（如 Spring MVC）的底层消息转换器（HttpMessageConverter）中，对开发者保持透明。

7.6 总结与最佳实践建议

JSON 处理库是 Java 数据交换链路中的基础设施。掌握其核心机制与选型策略，对提升系统吞吐量与保障数据安全至关重要。

架构选型与优化建议：

1. 默认首选 Jackson：对于绝大多数 Spring Boot 项目及企业级微服务，Jackson 是兼顾性能、功能与生态的最佳选择。
2. 警惕 Fastjson 安全风险：若因历史包袱必须使用 Fastjson，需严格执行安全加固策略，并规划向 Fastjson2 或 Jackson 迁移的路线图。
3. 大文件流式处理：在处理 GB 级别的 JSON 日志或数据导出时，应摒弃全量内存加载的 Data Binding 模式，转而使用 Jackson 的 JsonParser 或 Gson 的 JsonReader 进行流式（Streaming）解析，以避免 OOM（内存溢出）风险。
4. 单例模式复用：ObjectMapper、Gson 和 Jsonb 实例的创建成本较高且具备线程安全性，应在应用中作为全局单例（Singleton）复用，避免在循环或高并发请求中频繁实例化。