Java中JSON数据的解析与遍历：从固定结构到通用处理

{
    "message": "Results field contain api response",
    "results": {
        "Person 1": "USA",
        "Person 2": "India",
        "Name 3": "Europe",
        "People": "Germany"
    }
}

<dependency>
    <groupId>com.googlecode.json-simple</groupId>
    <artifactId>json-simple</artifactId>
    <version>1.1.1</version>
</dependency>

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

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonTraversalExample {

    public static void main(String[] args) {
        // 假设JSON数据存储在文件 /tmp/test.json 中
        // 为方便测试，这里可以先创建一个临时文件
        String jsonFilePath = "/tmp/test.json";
        String jsonContent = "{\n" +
                             "    \"message\": \"Results field contain api response\",\n" +
                             "    \"results\": {\n" +
                             "        \"Person 1\": \"USA\",\n" +
                             "        \"Person 2\": \"India\",\n" +
                             "        \"Name 3\": \"Europe\",\n" +
                             "        \"People\": \"Germany\"\n" +
                             "    }\n" +
                             "}";

        try {
            // 将JSON内容写入临时文件
            Files.write(Paths.get(jsonFilePath), jsonContent.getBytes());
            System.out.println("JSON data written to: " + jsonFilePath);

            // 使用try-with-resources确保资源自动关闭
            try (Reader reader = new FileReader(jsonFilePath)) {
                // 创建JSONParser实例
                JSONParser parser = new JSONParser();
                // 解析JSON文件，返回根JSONObject
                JSONObject root = (JSONObject) parser.parse(reader);

                // 提取顶层"message"字段
                System.out.println("Message: " + root.get("message"));

                // 提取"results"字段，它是一个嵌套的JSONObject
                JSONObject results = (JSONObject) root.get("results");

                // 遍历"results"对象中的所有键值对
                System.out.println("\nResults Details:");
                for (Object key : results.keySet()) {
                    System.out.println(key + ": " + results.get(key));
                }

            }
        } catch (IOException | ParseException e) {
            // 捕获IO异常和解析异常
            System.err.println("Error processing JSON: " + e.getMessage());
            e.printStackTrace();
            // 实际应用中可能需要更精细的异常处理
            throw new RuntimeException("Failed to parse or read JSON.", e);
        } finally {
            // 清理临时文件 (可选)
            try {
                Files.deleteIfExists(Paths.get(jsonFilePath));
                System.out.println("Temporary JSON file deleted: " + jsonFilePath);
            } catch (IOException e) {
                System.err.println("Error deleting temporary file: " + e.getMessage());
            }
        }
    }
}

JSON data written to: /tmp/test.json
Message: Results field contain api response

Results Details:
Person 1: USA
Person 2: India
People: Germany
Name 3: Europe
Temporary JSON file deleted: /tmp/test.json

// 概念性伪代码，展示递归处理逻辑
import org.json.simple.JSONObject;
import org.json.simple.JSONArray; // 明确引入JSONArray

public class GenericJsonTraversal {

    public void traverseJsonNode(Object node) {
        if (node instanceof JSONObject) {
            JSONObject jsonObject = (JSONObject) node;
            System.out.println("Processing JSONObject...");
            for (Object keyObj : jsonObject.keySet()) {
                String key = (String) keyObj;
                Object value = jsonObject.get(key);
                System.out.println("Key: " + key + ", Value Type: " + 
                                   (value != null ? value.getClass().getSimpleName() : "null"));
                // 递归处理嵌套的JSONObject或JSONArray
                if (value instanceof JSONObject || value instanceof JSONArray) {
                    traverseJsonNode(value);
                } else {
                    // 处理基本类型值
                    System.out.println("  -> Value: " + value);
                }
            }
        } else if (node instanceof JSONArray) {
            JSONArray jsonArray = (JSONArray) node;
            System.out.println("Processing JSONArray...");
            for (Object element : jsonArray) {
                System.out.println("Element Type: " + 
                                   (element != null ? element.getClass().getSimpleName() : "null"));
                // 递归处理数组中的元素
                traverseJsonNode(element);
            }
        } else if (node != null) {
            // 处理基本类型值 (String, Number, Boolean)
            System.out.println("Processing primitive value: " + node);
        } else {
            // 处理null值
            System.out.println("Processing null value.");
        }
    }

    // 调用示例：
    // public static void main(String[] args) {
    //     String complexJson = "{ \"data\": { \"id\": 123, \"details\": [\"a\", {\"sub\": \"value\"}] }, \"status\": \"success\" }";
    //     JSONParser parser = new JSONParser();
    //     try {
    //         Object parsedJson = parser.parse(complexJson);
    //         new GenericJsonTraversal().traverseJsonNode(parsedJson);
    //     } catch (ParseException e) {
    //         e.printStackTrace();
    //     }
    // }
}