什么是 JSON 序列化？

序列化 就是将 Java 对象转换成 JSON 格式的字符串（{"name":"张三", "age":30}），这个过程也常被称为 编码 或 序列化。

反之，将 JSON 字符串转换回 Java 对象的过程，则称为 反序列化 或 解码。

为什么需要序列化？

1. 数据传输：在网络上，数据通常以文本形式传输，JSON 是一种轻量级、通用的文本格式，非常适合在不同系统（如 Java 后端和 JavaScript 前端）之间传递数据。
2. 数据持久化：可以将 Java 对象的状态保存到文件或数据库中,以便之后可以重新加载并恢复对象。
3. 配置文件：JSON 也常被用作配置文件，因为它比 XML 更简洁易读。

Java 中实现 JSON 序列化的主流方式

Java 生态中有几款非常流行的 JSON 处理库，下面我将介绍最主流的四种,并附上代码示例。

Jackson

Jackson 是目前 Java 社区最流行、性能最好的 JSON 库，被广泛用于 Spring Boot 等框架中。

Maven 依赖:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version> <!-- 使用最新版本 -->
</dependency>

核心类:

• ObjectMapper: Jackson 的核心类,负责所有序列化和反序列化的工作。

示例代码:

我们创建一个简单的 Java 对象（POJO - Plain Old Java Object）。

// User.java
public class User {
    private String name;
    private int age;
    private String[] hobbies;
    // 必须有无参构造函数，以便 Jackson 反序列化时使用
    public User() {
    }
    // 推荐：使用构造函数初始化所有字段
    public User(String name, int age, String[] hobbies) {
        this.name = name;
        this.age = age;
        this.hobbies = hobbies;
    }
    // 推荐：为每个字段提供 getter 和 setter 方法
    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 String[] getHobbies() {
        return hobbies;
    }
    public void setHobbies(String[] hobbies) {
        this.hobbies = hobbies;
    }
    // (可选) 重写 toString() 方法，方便打印对象内容
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", hobbies=" + Arrays.toString(hobbies) +
                '}';
    }
}

我们使用 Jackson 的 ObjectMapper 来序列化这个 User 对象。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonSerializationExample {
    public static void main(String[] args) {
        // 1. 创建 User 对象
        User user = new User("李四", 28, new String[]{"阅读", "编程", "旅行"});
        // 2. 创建 ObjectMapper 实例
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 3. 调用 writeValueAsString() 方法进行序列化
            // 这个方法会自动调用对象的 getter 方法
            String jsonString = objectMapper.writeValueAsString(user);
            // 4. 输出结果
            System.out.println("Jackson 序列化结果:");
            System.out.println(jsonString);
            // 其他常用方法：
            // 序列化到文件
            // objectMapper.writeValue(new File("user.json"), user);
            // 序列化到字节数组
            // byte[] jsonBytes = objectMapper.writeValueAsBytes(user);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

输出结果:

{"name":"李四","age":28,"hobbies":["阅读","编程","旅行"]}

Gson

Google 开发的 Gson 库也非常流行，以其简单易用的 API 而闻名。

Maven 依赖:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> <!-- 使用最新版本 -->
</dependency>

核心类:

• Gson: Gson 的核心类,用法非常直观。

示例代码: 同样使用上面的 User 类。

import com.google.gson.Gson;
public class GsonSerializationExample {
    public static void main(String[] args) {
        // 1. 创建 User 对象
        User user = new User("王五", 35, new String[]{"音乐", "电影"});
        // 2. 创建 Gson 实例
        Gson gson = new Gson();
        // 3. 调用 toJson() 方法进行序列化
        String jsonString = gson.toJson(user);
        // 4. 输出结果
        System.out.println("Gson 序列化结果:");
        System.out.println(jsonString);
    }
}

输出结果:

{"name":"王五","age":35,"hobbies":["音乐","电影"]}

可以看到，Gson 的 API 更加简洁,一行代码就能完成序列化。

org.json (JSON-Java)

这是一个非常轻量级的库，API 很接近标准的 JavaScript 操作。

Maven 依赖:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20251013</version> <!-- 使用最新版本 -->
</dependency>

核心类:

• JSONObject: 代表一个 JSON 对象。
• JSONArray: 代表一个 JSON 数组。

示例代码: 这种方式与前两种不同，它不是直接将 POJO 转换为 JSON，而是需要手动构建 JSONObject。

import org.json.JSONObject;
public class OrgJsonSerializationExample {
    public static void main(String[] args) {
        // 1. 创建 User 对象
        User user = new User("赵六", 42, new String[]{"游泳", "登山"});
        // 2. 创建 JSONObject 并手动将 Java 对象的属性放入其中
        // 注意：基本类型的包装类（如 Integer）比基本类型（如 int）更安全
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", user.getName());
        jsonObject.put("age", user.getAge());
        jsonObject.put("hobbies", user.getHobbies());
        // 3. 直接调用 JSONObject 的 toString() 方法
        String jsonString = jsonObject.toString();
        // 4. 输出结果
        System.out.println("org.json 序列化结果:");
        System.out.println(jsonString);
    }
}

输出结果:

{"name":"赵六","age":42,"hobbies":["游泳","登山"]}

这种方式在需要动态构建 JSON 或处理非标准结构时很有用，但对于标准的 POJO 序列化,代码量稍多。

Java 内置库 (javax.json / jakarta.json)

从 Java EE 8 开始，Java 引入了标准的 JSON API（javax.json），Jakarta EE 10 中则是 jakarta.json，它提供了一种不依赖于第三方厂商的、标准的 API。

Maven 依赖 (以 Jakarta 为例):

<dependency>
    <groupId>org.eclipse.ee4j</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>2.1.3</version>
</dependency>
<!-- 你还需要一个实现，Yasson 或 Johnzon -->
<dependency>
    <groupId>org.eclipse</groupId>
    <artifactId>yasson</artifactId>
    <version>3.0.3</version>
</dependency>

核心类:

• JsonBuilderFactory: 用于创建 JSON 构建器。
• JsonObjectBuilder: 用于构建 JsonObject。

示例代码: 同样，这种方式也是手动构建，类似于 org.json。

import jakarta.json.Json;
import jakarta.json.JsonArrayBuilder;
import jakarta.json.JsonObject;
import jakarta.json.JsonObjectBuilder;
public class JakartaJsonSerializationExample {
    public static void main(String[] args) {
        // 1. 创建 User 对象
        User user = new User("钱七", 50, new String[]{"书法", "下棋"});
        // 2. 获取 JsonBuilderFactory 和 JsonObjectBuilder
        JsonBuilderFactory jsonBuilderFactory = Json.createBuilderFactory(null);
        JsonObjectBuilder jsonObjectBuilder = jsonBuilderFactory.createObjectBuilder();
        // 3. 构建 JsonObject
        // 对于数组，需要先创建 JsonArrayBuilder
        JsonArrayBuilder hobbiesArrayBuilder = jsonBuilderFactory.createArrayBuilder();
        for (String hobby : user.getHobbies()) {
            hobbiesArrayBuilder.add(hobby);
        }
        jsonObjectBuilder.add("name", user.getName());
        jsonObjectBuilder.add("age", user.getAge());
        jsonObjectBuilder.add("hobbies", hobbiesArrayBuilder);
        // 4. 构建 JsonObject 并转换为字符串
        JsonObject jsonObject = jsonObjectBuilder.build();
        String jsonString = jsonObject.toString();
        // 5. 输出结果
        System.out.println("Jakarta JSON 序列化结果:");
        System.out.println(jsonString);
    }
}

输出结果:

{"name":"钱七","age":50,"hobbies":["书法","下棋"]}

总结与对比

如何选择？

• 新项目，特别是使用 Spring Boot：直接选择 Jackson，它是事实上的标准，与 Spring 生态系统无缝集成,功能强大且性能卓越。
• 需要快速开发，项目不依赖 Spring：选择 Gson，它的 API 非常直观，学习成本低,代码量少。
• 只需要偶尔处理一下 JSON，不想引入大型库：选择 org.json，它足够轻量,适合简单的任务。
• 项目有严格的标准合规要求，希望避免厂商锁定：选择 Jakarta JSON，虽然目前不如前三者流行,但它是未来的标准。

对于绝大多数 Java 掌握 Jackson 和 Gson 就足以应对所有日常开发需求，Jackson 因其在企业级框架中的主导地位,更值得深入学习。