Java 解析 JSON 全指南：从基础原理到高效实战

2026-02-08 08:46:50 0条评论 2次阅读 0人点赞

在日常的 Java 开发中，我们经常需要处理数据的传输与存储。你是否遇到过需要将一个复杂的对象结构发送给前端，或者从第三方 API 获取数据的场景？这时，JSON（JavaScript Object Notation）就派上用场了。它不仅轻量级，而且结构清晰，成为了业界事实上的数据交换标准。

虽然在 Java 9 之后，JDK 引入了轻量级的 JSON API（并在后续版本中不断改进），但在实际的企业级开发和遗留系统维护中，我们依然经常需要处理各种不同的 JSON 解析库，或者深入理解数据结构的底层逻辑。

在这篇文章中，我们将深入探讨如何在 Java 中解析和生成 JSON。为了让你透彻理解这一过程，我们不仅会介绍 JSON 的核心概念，还会通过具体的代码示例，展示如何从零开始构建 JSON 对象，以及如何将复杂的 JSON 字符串解析回 Java 对象。无论你是刚接触 Java 的新手，还是希望巩固基础的老手，我相信这篇教程都会对你有所帮助。

JSON 的核心结构

在我们开始写代码之前，让我们先快速回顾一下 JSON 的基本结构。JSON 主要由两种结构组成：

  • 对象：这是一个无序的键/值对集合。在 Java 中，它非常类似于我们的 INLINECODE49679722。对象用花括号 INLINECODEdc8db2f2 包裹。
  • 数组：这是一个有序的值列表。在 Java 中，它对应于我们的 INLINECODE27ae92c4 或数组。数组用方括号 INLINECODEc8df45a6 包裹。

一个值可以是字符串、数字、布尔值、null，甚至是嵌套的对象或数组。让我们看一个经典的 JSON 示例，这将是我们后续代码操作的目标数据。

{
  "firstName": "John",
  "lastName": "Smith",
  "age": 25,
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "New York",
    "state": "NY",
    "postalCode": 10021
  },
  "phoneNumbers": [
    { "type": "home", "number": "212 555-1234" },
    { "type": "fax", "number": "646 555-4567" }
  ]
}

在这个例子中，我们可以看到嵌套的对象（INLINECODE8167cff2）和嵌套的数组（INLINECODEb931572c）。理解这种嵌套结构对于后续的解析工作至关重要。

在 Java 中处理 JSON

在 Java 的早期版本中，标准库并没有提供内置的 JSON 支持。因此，社区诞生了大量的第三方库，如 INLINECODEe28b74b0、INLINECODEe40e60e8、Gson 等。为了演示解析的核心原理，我们将使用一个简单且直观的方式来进行操作。

我们将重点放在理解数据结构的转换上：如何将 Java 的对象（Map, List）转换为 JSON 格式，以及如何反向操作。

第一步：将 Java 对象转换为 JSON（写入文件）

让我们从“生成”开始。假设我们有一个用户数据结构存储在 Java 对象中，我们需要将其转换为 JSON 字符串并写入文件。这在数据持久化或生成配置文件时非常常见。

在这个过程中，我们将使用 INLINECODE2d5df346 和 INLINECODEb9ffbb3a 来构建数据结构，并利用 Map 来存储具体的键值对。为了让我们生成的 JSON 文件易于阅读，我们通常还需要对其进行“美化”格式化。

以下是完整的示例代码，它展示了如何构建复杂的嵌套 JSON 结构并保存为文件：

import java.io.PrintWriter;
import java.util.LinkedHashMap;
import java.util.Map;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

// 引入 Jackson 库用于美化输出（实际开发中非常推荐的做法）
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;

public class JSONWriteExample {

    public static void main(String[] args) throws Exception {
        // 1. 创建根对象，即最外层的 JSON Object
        JSONObject jo = new JSONObject();
        
        // 2. 放入基本数据类型
        jo.put("firstName", "John");
        jo.put("lastName", "Smith");
        jo.put("age", 25);

        // 3. 构建嵌套的 Address 对象
        // 这里使用 LinkedHashMap 来保证顺序（虽然 JSON 标准不保证顺序，但 Java Map 有序）
        Map address = new LinkedHashMap();
        address.put("streetAddress", "21 2nd Street");
        address.put("city", "New York");
        address.put("state", "NY");
        address.put("postalCode", 10021);

        // 将 address Map 放入根对象
        jo.put("address", address);
        
        // 4. 构建电话号码数组
        JSONArray phoneNumbers = new JSONArray();

        // 第一个电话号码对象（使用 Map 构建）
        Map phone1 = new LinkedHashMap();
        phone1.put("type", "home");
        phone1.put("number", "212 555-1234");

        // 第二个电话号码对象
        Map phone2 = new LinkedHashMap();
        phone2.put("type", "fax");
        phone2.put("number", "646 555-4567");

        // 将对象添加到数组中
        phoneNumbers.add(phone1);
        phoneNumbers.add(phone2);

        // 将数组放入根对象
        jo.put("phoneNumbers", phoneNumbers);
        
        // 5. 格式化并写入文件
        // 为了让 JSON 文件漂亮，我们使用 Jackson 的 ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();

        // 将 JSONObject 转换为格式化后的字符串
        String prettyJson = writer.writeValueAsString(jo);
        
        // 写入文件 "JSONExample.json"
        try (PrintWriter pw = new PrintWriter("JSONExample.json")) {
            pw.write(prettyJson);
        }
        
        // 控制台输出查看结果
        System.out.println("JSON 文件生成成功！内容如下：");
        System.out.println(prettyJson);
    }
}

#### 代码解析与最佳实践

在上述代码中，你可能注意到了几个关键点：

  • INLINECODE588b6d13 的使用：标准的 JSON 规范规定对象是无序的。但在 Java 中，如果我们希望生成的 JSON 在文件中具有一定的可读性（比如地址信息紧跟在姓名后面），使用 INLINECODE9d840f2c 可以帮助我们维持插入顺序。这在调试或生成配置文件时非常有用。
  • 混合使用库：我们使用了 INLINECODEf1661723 库的核心类来构建结构，同时利用 INLINECODE73a599e8 库强大的 ObjectMapper 来进行格式化输出。这展示了在实际项目中，我们往往不是只依赖一个库，而是利用各自的优势。
  • Try-with-resources：我们在 PrintWriter 的使用中隐式地建议使用 try-with-resources（或者在 finally 中 close），以确保文件句柄被正确释放，防止内存泄漏。

运行这段代码后，你将在项目根目录下得到一个 JSONExample.json 文件。内容如下所示：

{
  "firstName" : "John",
  "lastName" : "Smith",
  "age" : 25,
  "address" : {
    "streetAddress" : "21 2nd Street",
    "city" : "New York",
    "state" : "NY",
    "postalCode" : 10021
  },
  "phoneNumbers" : [ {
    "type" : "home",
    "number" : "212 555-1234"
  }, {
    "type" : "fax",
    "number" : "646 555-4567"
  } ]
}

第二步：从 JSON 解析回 Java 对象（读取文件）

现在我们已经有了 JSON 文件，接下来的任务是读取它并将其还原为 Java 可以操作的数据。这在读取配置文件或处理 API 响应时是标准操作。

解析的过程本质上是“文本 -> Java 对象”的转换。我们需要使用 JSONParser 将原始字符串解析为一个通用的 Java 对象，然后根据具体的结构类型（Object 或 Array）进行强制类型转换。

让我们看看如何读取刚才生成的文件：

import java.io.FileReader;
import java.util.Iterator;
import java.util.Map;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;

public class JSONReadExample {
    public static void main(String[] args) {
        try {
            // 1. 创建 JSONParser 实例
            JSONParser parser = new JSONParser();
            
            // 2. 使用 FileReader 读取文件并解析
            // parse() 方法返回的是一个 Object，我们需要根据实际结构转型
            Object obj = parser.parse(new FileReader("JSONExample.json"));
            
            // 3. 将根对象转换为 JSONObject
            JSONObject jo = (JSONObject) obj;

            // 4. 获取基本字段
            String firstName = (String) jo.get("firstName");
            String lastName = (String) jo.get("lastName");
            // JSON 中的数字默认解析为 long，除非特别指定
            long age = (long) jo.get("age");

            System.out.println("--- 基本信息 ---");
            System.out.println("姓名: " + firstName + " " + lastName);
            System.out.println("年龄: " + age);

            // 5. 解析嵌套的 Address 对象
            // 这里的 address 在解析后变回了 Map
            System.out.println("
--- 地址信息 ---");
            Map address = (Map) jo.get("address");
            for (Object entry : address.entrySet()) {
                Map.Entry pair = (Map.Entry) entry;
                System.out.println(pair.getKey() + " : " + pair.getValue());
            }

            // 6. 解析嵌套的 PhoneNumbers 数组
            System.out.println("
--- 电话号码 ---");
            JSONArray phoneNumbers = (JSONArray) jo.get("phoneNumbers");
            
            // 遍历数组
            for (Object phoneObj : phoneNumbers) {
                Map phone = (Map) phoneObj;
                // 这里的 phone 就是一个 Map {type=..., number=...}
                for (Object entry : phone.entrySet()) {
                    Map.Entry pair = (Map.Entry) entry;
                    System.out.println(pair.getKey() + " : " + pair.getValue());
                }
                System.out.println("---");
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

#### 解析过程中的关键细节

  • 类型转换：注意看 INLINECODEf74a54f3。即使我们在写 JSON 时觉得它是整数，INLINECODE2dc17ea6 也会默认将其解析为 INLINECODE0fb986cd 类型。如果你需要 INLINECODE0b79f6c6，必须手动强转 INLINECODEf04e7b2c。这是 Java JSON 解析中常见的“坑”，如果你直接强转 INLINECODEe9f8af72，程序会抛出 INLINECODE3d138a5a，因为 INLINECODE0cc6e6a9 和 Long 之间无法直接转换。
  • 泛型与 Map：解析出来的对象实际上是 INLINECODE423bac46 的实现类（如 INLINECODE8fed1f63 继承了 INLINECODEc35838e8）。因此，我们可以将其当作 INLINECODE1b242641 来遍历，这在处理不确定字段名的 JSON 结构时非常灵活。

进阶探讨：常见问题与最佳实践

掌握了基础的读写之后，让我们来聊聊在实际开发中可能遇到的问题以及如何优化我们的代码。

#### 1. 依赖管理的建议

在示例中，我们使用了 INLINECODEf9b94d2a 和 INLINECODEaecd28c0。在现代 Java 开发中，Jackson 和 Gson 通常比 INLINECODE359bb5dc 更受欢迎，因为它们提供了更强大的功能，比如直接将 JSON 映射到 POJO（普通 Java 对象），而不仅仅是 INLINECODE626da49f。不过，了解底层的 INLINECODEbc78715c 和 INLINECODE403217df 操作有助于你理解这些高级库的原理。

#### 2. 字符编码问题

你可能会在读取包含中文的 JSON 文件时遇到乱码。这通常是因为 INLINECODEe3726590 使用了系统的默认编码（可能是 GBK）。为了代码的健壮性，建议始终显式指定 UTF-8 编码。你可以将 INLINECODE64402999 替换为 INLINECODE90330f24 并配合 INLINECODE1af8ee43 使用：

// 推荐的读取方式，防止中文乱码
Object obj = parser.parse(new InputStreamReader(new FileInputStream("JSONExample.json"), "UTF-8"));

#### 3. 性能优化：大数据量处理

如果我们要处理几百兆甚至几个 G 的 JSON 文件，将整个文件加载到内存（INLINECODEe8aeb3b2）会导致 INLINECODE7cb4b1f1。在这种场景下，我们应该使用 流式解析。

例如，Jackson 库提供了 INLINECODEf2fd08ec 接口，允许我们像读取 XML 一样逐个 Token 读取 JSON（INLINECODEa49d50de, INLINECODE035dea3f, INLINECODEf2495d47 等），从而极大地降低内存占用。虽然代码会稍微复杂一些，但在高并发或大数据场景下是必须的。

#### 4. 安全性警告

永远不要使用 INLINECODE286b76b8 类似的方法来解析 JSON（虽然在 Java 中较少见，但在 JavaScript 环境下是巨大的安全隐患）。在 Java 中，始终使用成熟的解析器（如我们使用的 INLINECODEc73e4685 或 Jackson），因为它们会自动处理转义字符，防止恶意注入。

总结

通过这篇文章，我们不仅学习了 JSON 的结构，还亲手实现了 Java 与 JSON 之间的双向转换。我们可以看到，处理 JSON 的核心在于理解 “文本流”与“内存对象结构”之间的映射关系。

我们先是将嵌套的 Java 对象一步步构建成了 JSON 文件，然后又解析回来，处理了类型转换和嵌套遍历。这些操作是每一个 Java 后端开发者的基本功。

下一步建议：

  • 尝试引入 Jackson 或 Gson 库，体验一下如何通过 ObjectMapper.readValue(jsonString, MyObject.class) 直接将 JSON 转换为自定义的 Java 类（POJO），这会让你的代码更加简洁优雅。
  • 如果你在项目中频繁使用 Map 来存取 JSON 数据，试着定义一些实体类，利用注解来处理字段映射，提升代码的可维护性。

希望这篇指南能帮助你更好地理解和处理 Java 中的 JSON 数据！如果你在实践过程中遇到任何问题，欢迎随时交流。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/35274.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年