使用 Jackson (推荐)

Jackson 是目前 Java 生态中最流行、性能最高的 JSON 处理库，Spring Boot 默认就集成了它。

步骤 1: 添加 Maven 依赖

在你的 pom.xml 文件中添加 Jackson 的核心依赖：

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

步骤 2: 准备 Java 类 (POJO)

你需要一个 Java 类（Plain Old Java Object）来与 JSON 字符串的结构对应，JSON 的键名需要与 Java 类的属性名一致（可以通过注解 @JsonProperty 进行自定义）。

示例 JSON 字符串:

{
  "name": "张三",
  "age": 30,
  "isStudent": false,
  "courses": [
    "Java",
    "Spring Boot"
  ],
  "address": {
    "city": "北京",
    "street": "中关村大街1号"
  }
}

对应的 Java 类:

import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;
import java.util.Map;
public class User {
    private String name;
    private int age;
    private boolean isStudent;
    @JsonProperty("courses") // JSON 键和 Java 属性名不同，使用此注解
    private List<String> courseList;
    private Address address;
    // 内部类，用于表示嵌套的 JSON 对象
    public static class Address {
        private String city;
        private String street;
        // Getters and Setters (省略 getter/setter 会导致解析失败)
        public String getCity() { return city; }
        public void setCity(String city) { this.city = city; }
        public String getStreet() { return street; }
        public void setStreet(String street) { this.street = street; }
        @Override
        public String toString() {
            return "Address{" + "city='" + city + '\'' + ", street='" + street + '\'' + '}';
        }
    }
    // Getters and Setters
    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> getCourseList() { return courseList; }
    public void setCourseList(List<String> courseList) { this.courseList = courseList; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isStudent=" + isStudent +
                ", courseList=" + courseList +
                ", address=" + address +
                '}';
    }
}

步骤 3: 进行解析

使用 ObjectMapper 类的 readValue() 方法进行解析。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonJsonParser {
    public static void main(String[] args) {
        String jsonString = "{\n" +
                "  \"name\": \"张三\",\n" +
                "  \"age\": 30,\n" +
                "  \"isStudent\": false,\n" +
                "  \"courses\": [\n" +
                "    \"Java\",\n" +
                "    \"Spring Boot\"\n" +
                "  ],\n" +
                "  \"address\": {\n" +
                "    \"city\": \"北京\",\n" +
                "    \"street\": \"中关村大街1号\"\n" +
                "  }\n" +
                "}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 将 JSON 字符串解析为 User 对象
            User user = objectMapper.readValue(jsonString, User.class);
            // 打印解析结果
            System.out.println("解析成功！");
            System.out.println(user);
            System.out.println("城市: " + user.getAddress().getCity());
        } catch (JsonProcessingException e) {
            System.err.println("JSON 解析失败！");
            e.printStackTrace();
        }
    }
}

使用 Google Gson

Gson 是 Google 开发的另一个非常流行的 JSON 库，使用简单直观。

步骤 1: 添加 Maven 依赖

在 pom.xml 中添加 Gson 依赖：

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

步骤 2: 准备 Java 类 (POJO)

Java 类与 Jackson 示例中的 User 和 Address 类完全相同。 你不需要做任何修改。

步骤 3: 进行解析

使用 Gson 类的 fromJson() 方法。

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
public class GsonJsonParser {
    public static void main(String[] args) {
        String jsonString = "{\n" +
                "  \"name\": \"张三\",\n" +
                "  \"age\": 30,\n" +
                "  \"isStudent\": false,\n" +
                "  \"courses\": [\n" +
                "    \"Java\",\n" +
                "    \"Spring Boot\"\n" +
                "  ],\n" +
                "  \"address\": {\n" +
                "    \"city\": \"北京\",\n" +
                "    \"street\": \"中关村大街1号\"\n" +
                "  }\n" +
                "}";
        Gson gson = new Gson();
        try {
            // 直接解析为 User 对象
            User user = gson.fromJson(jsonString, User.class);
            System.out.println("解析成功！");
            System.out.println(user);
            System.out.println("城市: " + user.getAddress().getCity());
        } catch (Exception e) {
            System.err.println("JSON 解析失败！");
            e.printStackTrace();
        }
    }
}

Gson 解析 List 的特殊用法： JSON 是一个数组，你需要使用 TypeToken 来指定泛型类型。

// 假设 jsonString 是一个 JSON 数组: "[{\"name\":\"李四\"}, {\"name\":\"王五\"}]"
String jsonArrayString = "[{\"name\":\"李四\"}, {\"name\":\"王五\"}]";
// 使用 TypeToken 来告诉 Gson 这是一个 List<User>
Type userListType = new TypeToken<List<User>>(){}.getType();
List<User> userList = gson.fromJson(jsonArrayString, userListType);
System.out.println(userList);

其他方式 (不推荐，仅作了解)

a) org.json

这是 Java 标准库之外的一个轻量级库，但使用起来比较繁琐，需要手动处理每个字段。

Maven 依赖:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20251013</version>
</dependency>

示例代码:

import org.json.JSONObject;
import org.json.JSONArray;
public class OrgJsonParser {
    public static void main(String[] args) {
        String jsonString = "{\n" +
                "  \"name\": \"张三\",\n" +
                "  \"age\": 30,\n" +
                "  \"isStudent\": false,\n" +
                "  \"courses\": [\"Java\", \"Spring Boot\"],\n" +
                "  \"address\": {\n" +
                "    \"city\": \"北京\",\n" +
                "    \"street\": \"中关村大街1号\"\n" +
                "  }\n" +
                "}";
        JSONObject jsonObject = new JSONObject(jsonString);
        // 手动获取和转换每个字段
        String name = jsonObject.getString("name");
        int age = jsonObject.getInt("age");
        boolean isStudent = jsonObject.getBoolean("isStudent");
        JSONArray coursesArray = jsonObject.getJSONArray("courses");
        String course1 = coursesArray.getString(0);
        JSONObject addressObj = jsonObject.getJSONObject("address");
        String city = addressObj.getString("city");
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("City: " + city);
    }
}

缺点: 代码冗长，容易出错，没有类型安全。

b) Java 内置库 (JDK 11+)

从 Java 11 开始，标准库中包含了 javax.json API (也称为 JSON-P)。

Maven 依赖 (如果使用 JDK < 11):

<dependency>
    <groupId>javax.json</groupId>
    <artifactId>javax.json-api</artifactId>
    <version>1.1.4</version>
</dependency>
<!-- 还需要一个实现，如 org.glassfish -->
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.json</artifactId>
    <version>1.1.4</version>
</dependency>

缺点: API 设计比较底层，使用起来比 Jackson 和 Gson 复杂，且在 JDK 11 之前需要额外依赖。

总结与对比

最终建议

对于绝大多数 Java 项目，首选 Jackson，如果你已经在使用 Spring Boot，那 Jackson 已经为你准备好了，无需额外配置，如果你需要一个独立、轻量且极易上手的库，Gson 是绝佳的选择，尽量避免使用 org.json，除非你的项目有特殊的轻量级或无依赖要求。