如何用Jackson库获取JSON响应嵌套属性并提取A/B列表的data？

嘿，这个需求用Jackson来实现其实挺 straightforward 的，我给你梳理下具体的实现思路和代码示例：

因为你的JSON结构有两种可能（包含A数组或B数组），核心是先动态判断目标数组，再遍历提取每个元素的data属性并转成Map。Jackson的JsonNode可以帮我们灵活处理这种不确定的JSON结构，不用提前硬编码所有字段。

首先确保你已经引入了Jackson的核心依赖（以Maven为例）：

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

方式一：用JsonNode动态解析（最灵活） #

这种方式适合完全不确定data子属性结构的场景，直接把data转成Map<String, Object>：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class DataExtractor {
    public static void main(String[] args) throws Exception {
        // 替换成你的实际JSON字符串/输入流
        String sampleJson = "{\"meta\": {\"someData\": \"demo\"}, \"A\": [{\"code\": 123, \"id\": \"item001\", \"data\": {\"product\": \"phone\", \"stock\": 100}}, {\"code\": 456, \"id\": \"item002\", \"data\": {\"author\": \"John\", \"title\": \"Java Guide\"}}]}";
        
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode rootNode = objectMapper.readTree(sampleJson);
        
        // 用来存储最终的data集合，这里用元素的id作为key，你也可以用索引
        Map<String, Map<String, Object>> resultMap = new HashMap<>();
        
        // 判断目标数组是A还是B
        JsonNode targetArray;
        if (rootNode.has("A")) {
            targetArray = rootNode.get("A");
        } else if (rootNode.has("B")) {
            targetArray = rootNode.get("B");
        } else {
            throw new IllegalArgumentException("JSON中未找到A或B数组");
        }
        
        // 遍历数组提取data
        for (JsonNode element : targetArray) {
            // 取出id作为key（如果不需要id，也可以用数组索引）
            String itemId = element.get("id").asText();
            // 取出data节点并转成Map
            JsonNode dataNode = element.get("data");
            Map<String, Object> dataMap = objectMapper.convertValue(dataNode, Map.class);
            
            resultMap.put(itemId, dataMap);
        }
        
        // 打印结果，格式和你期望的一致
        resultMap.forEach((id, data) -> System.out.println(id + ".data = " + data));
    }
}

方式二：用POJO结合TypeReference（更类型安全） #

如果code、id这些字段是固定的，只是data的子属性可变，可以定义一个POJO类来封装数组元素：

// 定义数组元素的POJO
class Item {
    private int code;
    private String id;
    private Map<String, Object> data;

    // 自动生成getter和setter
    public int getCode() { return code; }
    public void setCode(int code) { this.code = code; }
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public Map<String, Object> getData() { return data; }
    public void setData(Map<String, Object> data) { this.data = data; }
}

然后用TypeReference来解析数组：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PojoDataExtractor {
    public static void main(String[] args) throws Exception {
        String sampleJson = "{\"meta\": {\"someData\": \"demo\"}, \"B\": [{\"code\": 789, \"id\": \"item003\", \"data\": {\"color\": \"red\", \"size\": \"L\"}}]}";
        
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode rootNode = objectMapper.readTree(sampleJson);
        
        Map<String, Map<String, Object>> resultMap = new HashMap<>();
        
        if (rootNode.has("A")) {
            List<Item> items = objectMapper.readValue(rootNode.get("A").traverse(), new TypeReference<List<Item>>() {});
            for (Item item : items) {
                resultMap.put(item.getId(), item.getData());
            }
        } else if (rootNode.has("B")) {
            List<Item> items = objectMapper.readValue(rootNode.get("B").traverse(), new TypeReference<List<Item>>() {});
            for (Item item : items) {
                resultMap.put(item.getId(), item.getData());
            }
        }
        
        resultMap.forEach((id, data) -> System.out.println(id + ".data = " + data));
    }
}

• 如果JSON中可能存在id或data字段缺失的情况，记得添加空判断（比如element.has("id")），避免空指针异常
• 如果data的子属性有特定类型（比如数字、日期），可以指定更具体的Map类型（比如Map<String, Object>已经足够，Jackson会自动转换类型）
• 处理大JSON时，用JsonNode的方式比POJO更节省内存，因为它不需要一次性把整个对象加载到内存

内容的提问来源于stack exchange，提问作者Tejus