使用 Jackson (推荐)

Jackson 是目前 Java 生态中最流行、功能最强大的 JSON 处理库，它性能优异，功能全面，并且是 Spring Boot 等框架的默认选择。

添加依赖

你需要在你的项目中添加 Jackson 的核心库依赖。

Maven (pom.xml):

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

Gradle (build.gradle):

implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2' // 建议使用最新版本

创建 Java 对象

假设我们有一个 User 类。

// User.java
public class User {
    private String name;
    private int age;
    private String email;
    // Jackson 在进行序列化时，需要通过反射调用无参构造函数
    public User() {
    }
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    // 为了方便打印和查看，建议重写 toString() 方法
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
    // 提供Getter方法，Jackson通过反射调用它们来获取属性值
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
    // 提供Setter方法（反序列化时会用到）
    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }
    public void setEmail(String email) { this.email = email; }
}

进行转换

使用 ObjectMapper 类来完成转换。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
    public static void main(String[] args) {
        // 1. 创建 User 对象
        User user = new User("张三", 30, "zhangsan@example.com");
        // 2. 创建 ObjectMapper 实例（它是一个线程安全的类，可以复用）
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 3. 调用 writeValueAsString() 方法将对象转为 JSON 字符串
            String jsonString = objectMapper.writeValueAsString(user);
            // 4. 输出结果
            System.out.println(jsonString);
            // 输出: {"name":"张三","age":30,"email":"zhangsan@example.com"}
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

Jackson 常用配置

你可以通过 ObjectMapper 进行一些高级配置，

ObjectMapper mapper = new ObjectMapper();
// 美化输出（格式化，增加缩进和换行）
mapper.enable(SerializationFeature.INDENT_OUTPUT);
// 忽略 null 值的属性
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// 处理日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 忽略未知属性（反序列化时，如果JSON中有Java对象中没有的属性，不会报错）
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

使用 Google Gson

Gson 是 Google 开发的另一个非常流行的 JSON 库，以其简洁易用而著称。

添加依赖

Maven (pom.xml):

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

Gradle (build.gradle):

implementation 'com.google.code.gson:gson:2.10.1' // 建议使用最新版本

创建 Java 对象

Gson 对 Java 对象的要求和 Jackson 类似，需要有默认的无参构造函数，并提供 Getter 方法。

进行转换

使用 Gson 类的 toJson() 方法。

import com.google.gson.Gson;
public class GsonExample {
    public static void main(String[] args) {
        // 1. 创建 User 对象
        User user = new User("李四", 25, "lisi@example.com");
        // 2. 创建 Gson 实例（它也是一个线程安全的类，可以复用）
        Gson gson = new Gson();
        // 3. 调用 toJson() 方法将对象转为 JSON 字符串
        String jsonString = gson.toJson(user);
        // 4. 输出结果
        System.out.println(jsonString);
        // 输出: {"name":"李四","age":25,"email":"lisi@example.com"}
    }
}

Gson 常用配置

Gson 提供了一个 GsonBuilder 来进行配置。

Gson gson = new GsonBuilder()
    // 美化输出
    .setPrettyPrinting()
    // 忽略 null 值
    .serializeNulls()
    // 设置日期格式
    .setDateFormat("yyyy-MM-dd")
    // 创建 Gson 实例
    .create();

对比与选择

如何选择？

• 新项目，尤其是基于 Spring Boot 的项目：强烈推荐 Jackson，它是默认选择，无缝集成，性能最好。
• 需要快速实现，或项目与 Spring 无关：Gson 是一个非常好的选择，它的 API 非常直观，简单易用。
• 性能要求极高的应用：优先考虑 Jackson。

处理复杂对象（嵌套对象、List）

无论是 Jackson 还是 Gson，处理嵌套对象、List 或 Map 都非常简单，只要确保嵌套的对象也是可以被序列化的即可。

示例：List<User>

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import java.util.Arrays;
import java.util.List;
public class ComplexObjectExample {
    public static void main(String[] args) {
        // 创建一个用户列表
        List<User> userList = Arrays.asList(
            new User("张三", 30, "zhangsan@example.com"),
            new User("李四", 25, "lisi@example.com")
        );
        // --- 使用 Jackson ---
        ObjectMapper jacksonMapper = new ObjectMapper();
        try {
            String jacksonJson = jacksonMapper.writeValueAsString(userList);
            System.out.println("--- Jackson ---");
            System.out.println(jacksonJson);
            // 输出: [{"name":"张三","age":30,"email":"zhangsan@example.com"},{"name":"李四","age":25,"email":"lisi@example.com"}]
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        // --- 使用 Gson ---
        Gson gson = new Gson();
        String gsonJson = gson.toJson(userList);
        System.out.println("\n--- Gson ---");
        System.out.println(gsonJson);
        // 输出: [{"name":"张三","age":30,"email":"zhangsan@example.com"},{"name":"李四","age":25,"email":"lisi@example.com"}]
    }
}

要将 Java 对象转为 JSON 字符串，核心步骤如下：

1. 选择库：在 Jackson 和 Gson 之间做出选择。
2. 添加依赖：在 pom.xml 或 build.gradle 中添加相应库的依赖。
3. 准备对象：确保你的 Java 类有无参构造函数和 Getter 方法。
4. 调用 API：
   • Jackson: new ObjectMapper().writeValueAsString(object)
   • Gson: new Gson().toJson(object)
5. 处理异常：JsonProcessingException (Jackson) 或 JsonSyntaxException (Gson)。

对于绝大多数现代 Java 项目，Jackson 是更推荐的选择。