核心概念

这个过程通常称为 反序列化，即从一种格式（JSON）数据重新构建成对象。

要成功地将 JSON 转换为 Java 对象，需要满足以下基本条件：

1. 一个 Java 类：这个类的结构必须与 JSON 数据的结构相对应。
   • JSON 的 key 必须与 Java 类的 field（字段）名相匹配（或通过注解进行映射）。
   • JSON 的 value 类型必须与 Java 类 field 的类型相匹配。
2. 一个 JSON 解析库：如 Jackson 或 Gson，它们负责解析 JSON 字符串并完成数据填充。

使用 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 类（POJO - Plain Old Java Object）

创建一个与 JSON 结构匹配的 Java 类，对于如下 JSON：

{
  "name": "张三",
  "age": 30,
  "isStudent": false,
  "courses": [
    "Java",
    "Spring Boot"
  ]
}

对应的 Java 类 User.java 如下：

import java.util.List;
public class User {
    private String name;
    private int age;
    private boolean isStudent;
    private List<String> courses;
    // Jackson 反序列化需要无参构造函数
    public User() {
    }
    // 推荐：使用 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 boolean isStudent() {
        return isStudent;
    }
    public void setStudent(boolean student) {
        isStudent = student;
    }
    public List<String> getCourses() {
        return courses;
    }
    public void setCourses(List<String> courses) {
        this.courses = courses;
    }
    // (可选) 重写 toString() 方法，方便打印和调试
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isStudent=" + isStudent +
                ", courses=" + courses +
                '}';
    }
}

进行转换

创建一个工具类或直接在代码中使用 ObjectMapper 进行转换。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonJsonToObjectExample {
    public static void main(String[] args) {
        // 1. 创建 ObjectMapper 实例（它线程安全，可以全局共享）
        ObjectMapper objectMapper = new ObjectMapper();
        // 2. 定义 JSON 字符串
        String jsonString = "{\"name\":\"张三\",\"age\":30,\"isStudent\":false,\"courses\":[\"Java\",\"Spring Boot\"]}";
        try {
            // 3. 调用 readValue 方法进行转换
            // 第一个参数：JSON 字符串
            // 第二个参数：要转换成的 Java 对象的类型 (User.class)
            User user = objectMapper.readValue(jsonString, User.class);
            // 4. 验证结果
            System.out.println("转换成功！");
            System.out.println(user.getName()); // 输出: 张三
            System.out.println(user.getAge());  // 输出: 30
            System.out.println(user);          // 输出: User 对象的 toString() 结果
        } catch (JsonProcessingException e) {
            System.err.println("JSON 解析失败！");
            e.printStackTrace();
        }
    }
}

关键点：

• ObjectMapper 是 Jackson 的核心类，负责所有序列化和反序列化操作。
• objectMapper.readValue(jsonString, User.class) 是核心方法，它会将 jsonString 的内容填充到一个 User 类的新实例中。
• JSON 的 key 必须和 Java 类的 field 名完全一致（默认情况下，Jackson 是区分大小写的）。

使用 Gson

Google 的 Gson 是另一个非常受欢迎的 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 同样需要一个与 JSON 结构匹配的 Java 类。User.java 类与上面 Jackson 示例中的完全一样。

进行转换

import com.google.gson.Gson;
public class GsonJsonToObjectExample {
    public static void main(String[] args) {
        // 1. 创建 Gson 实例（它也线程安全，可以全局共享）
        Gson gson = new Gson();
        // 2. 定义 JSON 字符串
        String jsonString = "{\"name\":\"李四\",\"age\":25,\"isStudent\":true,\"courses\":[\"Python\",\"数据分析\"]}";
        // 3. 调用 fromJson 方法进行转换
        // 第一个参数：JSON 字符串
        // 第二个参数：要转换成的 Java 对象的类型
        User user = gson.fromJson(jsonString, User.class);
        // 4. 验证结果
        System.out.println("转换成功！");
        System.out.println(user.getName()); // 输出: 李四
        System.out.println(user.getAge());  // 输出: 25
        System.out.println(user);          // 输出: User 对象的 toString() 结果
    }
}

关键点：

• Gson 是 Gson 库的核心类。
• gson.fromJson(jsonString, User.class) 是核心方法，与 Jackson 的 readValue 功能相同。
• 同样,JSON 的 key 必须和 Java 类的 field 名完全一致。

进阶：处理复杂情况（字段名不匹配）

有时,JSON 中的 key 和 Java 类中的 field 名可能不一致，JSON 中是 user_name，但 Java 类中是 name，这时就需要使用注解来建立映射关系。

以 Jackson 为例：

import com.fasterxml.jackson.annotation.JsonProperty;
public class UserWithAnnotation {
    // 将 JSON 中的 "user_name" 字段映射到 Java 的 "name" 字段
    @JsonProperty("user_name")
    private String name;
    // 将 JSON 中的 "user_age" 字段映射到 Java 的 "age" 字段
    @JsonProperty("user_age")
    private int age;
    // ... getter, setter, toString ...
}

对应的 JSON：

{
  "user_name": "王五",
  "user_age": 28
}

转换代码不变,ObjectMapper 会自动识别 @JsonProperty 注解并完成正确的映射。

String json = "{\"user_name\":\"王五\",\"user_age\":28}";
UserWithAnnotation user = objectMapper.readValue(json, UserWithAnnotation.class);
System.out.println(user.getName()); // 输出: 王五

Gson 也有类似的注解 @SerializedName：

import com.google.gson.annotations.SerializedName;
public class UserWithGsonAnnotation {
    @SerializedName("user_name")
    private String name;
    @SerializedName("user_age")
    private int age;
    // ... getter, setter, toString ...
}

总结与对比

对于新项目，尤其是基于 Spring Boot 的项目，强烈推荐使用 Jackson，如果你需要一个轻量级、简单易用的库，或者项目已经在使用 Gson，Gson 也是一个非常不错的选择。