Jackson 和 Gson，并附上清晰的代码示例。

为什么需要 JSON 库？

• JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成。
• Java 对象 是 Java 语言中的实体，包含属性和方法。
• 转换需求：
  • 序列化 (Serialization)：将 Java 对象转换成 JSON 字符串，以便在网络传输或存储时使用。
  • 反序列化 (Deserialization)：将 JSON 字符串解析成 Java 对象，以便在程序中操作数据。

使用 Jackson (推荐)

Jackson 是目前 Java 生态中最流行、功能最强大的 JSON 处理库之一，Spring Boot 等主流框架都默认使用它。

添加依赖

如果你使用 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）

这个类的字段需要和 JSON 中的键对应。

// User.java
public class User {
    private String name;
    private int age;
    private String[] hobbies;
    // 必须有无参构造函数
    public User() {
    }
    // 推荐：使用构造函数和 getter/setter
    public User(String name, int age, String[] hobbies) {
        this.name = name;
        this.age = age;
        this.hobbies = hobbies;
    }
    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) +
                '}';
    }
}

字符串 与 JSON 对象 的互转

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class JacksonExample {
    public static void main(String[] args) {
        // 创建 Jackson 的核心对象 ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();
        // --- 场景1: Java对象 -> JSON字符串 (序列化) ---
        User user = new User("张三", 30, new String[]{"阅读", "游泳"});
        try {
            // 将 User 对象转换为 JSON 字符串
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println("Java对象 -> JSON字符串:");
            System.out.println(jsonString);
            // 输出: {"name":"张三","age":30,"hobbies":["阅读","游泳"]}
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        // --- 场景2: JSON字符串 -> Java对象 (反序列化) ---
        String jsonInput = "{\"name\":\"李四\",\"age\":25,\"hobbies\":[\"编程\",\"音乐\"]}";
        try {
            // 将 JSON 字符串转换为 User 对象
            User deserializedUser = objectMapper.readValue(jsonInput, User.class);
            System.out.println("\nJSON字符串 -> Java对象:");
            System.out.println(deserializedUser);
            // 输出: User{name='李四', age=25, hobbies=[编程, 音乐]}
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        // --- 场景3: JSON字符串 -> Map/List (处理通用JSON) ---
        String complexJson = "{\"city\":\"北京\",\"scores\":[98, 95, 89]}";
        try {
            // 转换为 Map
            Map<String, Object> dataMap = objectMapper.readValue(complexJson, new TypeReference<Map<String, Object>>() {});
            System.out.println("\nJSON字符串 -> Map:");
            System.out.println(dataMap);
            // 输出: {city=北京, scores=[98, 95, 89]}
            // 转换为 List
            String jsonArrayString = "[{\"id\":1,\"name\":\"Item1\"},{\"id\":2,\"name\":\"Item2\"}]";
            List<Map<String, Object>> dataList = objectMapper.readValue(jsonArrayString, new TypeReference<List<Map<String, Object>>>() {});
            System.out.println("\nJSON字符串 -> List:");
            System.out.println(dataList);
            // 输出: [{id=1, name=Item1}, {id=2, name=Item2}]
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

使用 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 类 (POJO)

与 Jackson 方案中的 User.java 完全相同。

字符串 与 JSON 对象 的互转

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class GsonExample {
    public static void main(String[] args) {
        // 创建 Gson 的核心对象 Gson
        Gson gson = new Gson();
        // --- 场景1: Java对象 -> JSON字符串 (序列化) ---
        User user = new User("王五", 28, new String[]{"游戏", "旅行"});
        // 将 User 对象转换为 JSON 字符串
        String jsonString = gson.toJson(user);
        System.out.println("Java对象 -> JSON字符串:");
        System.out.println(jsonString);
        // 输出: {"name":"王五","age":28,"hobbies":["游戏","旅行"]}
        // --- 场景2: JSON字符串 -> Java对象 (反序列化) ---
        String jsonInput = "{\"name\":\"赵六\",\"age\":32,\"hobbies\":[\"摄影\",\"烹饪\"]}";
        // 将 JSON 字符串转换为 User 对象
        User deserializedUser = gson.fromJson(jsonInput, User.class);
        System.out.println("\nJSON字符串 -> Java对象:");
        System.out.println(deserializedUser);
        // 输出: User{name='赵六', age=32, hobbies=[摄影, 烹饪]}
        // --- 场景3: JSON字符串 -> Map/List (处理通用JSON) ---
        String complexJson = "{\"city\":\"上海\",\"scores\":[100, 88, 92]}";
        // 转换为 Map
        Type mapType = new TypeToken<Map<String, Object>>() {}.getType();
        Map<String, Object> dataMap = gson.fromJson(complexJson, mapType);
        System.out.println("\nJSON字符串 -> Map:");
        System.out.println(dataMap);
        // 输出: {city=上海, scores=[100.0, 88.0, 92.0]} (注意Gson默认将数字转为Double)
        String jsonArrayString = "[{\"id\":1,\"name\":\"ProductA\"},{\"id\":2,\"name\":\"ProductB\"}]";
        // 转换为 List
        Type listType = new TypeToken<List<Map<String, Object>>>() {}.getType();
        List<Map<String, Object>> dataList = gson.fromJson(jsonArrayString, listType);
        System.out.println("\nJSON字符串 -> List:");
        System.out.println(dataList);
        // 输出: [{id=1, name=ProductA}, {id=2, name=ProductB}]
    }
}

Jackson vs. Gson 对比

如何选择？

• 如果你正在使用 Spring Boot，或者对 性能 有较高要求，或者需要处理非常复杂的 JSON 结构，Jackson 是首选。
• 如果你需要一个简单、稳定、可靠的库，并且不介意其稍慢一点的性能，或者你的项目已经大量使用了 Google 的其他库，Gson 是一个绝佳的选择。

1. 添加依赖：在 pom.xml 或 build.gradle 中引入 Jackson 或 Gson。
2. 创建 POJO：创建一个 Java 类，其字段与 JSON 结构对应。
3. 序列化 (Java -> JSON)：
   • Jackson: objectMapper.writeValueAsString(javaObject)
   • Gson: gson.toJson(javaObject)
4. 反序列化 (JSON -> Java)：
   • Jackson: objectMapper.readValue(jsonString, TargetClass.class)
   • Gson: gson.fromJson(jsonString, TargetClass.class)

对于处理通用的 JSON（如 Map 或 List），两者都需要使用特定的类型工具（TypeReference 或 TypeToken）来告诉库如何解析泛型。