Spring Boot中高效提取嵌套JSON数据的策略

本教程详细探讨了在spring boot应用中如何高效地从复杂嵌套json结构中提取特定数据。我们将重点介绍jackson库的两种核心方法：jackson streaming api，适用于处理大型或结构动态的json，以及jackson data binding，适用于将json映射到预定义java对象。文章将提供详细的代码示例和实现步骤，并讨论如何进一步过滤提取出的数据，例如按类别筛选。

在Spring Boot应用程序中处理来自API调用的JSON数据是常见的任务，尤其当JSON结构包含多层嵌套时，如何高效且优雅地提取所需信息成为一个关键问题。本文将深入探讨使用Jackson库来解决这一挑战的两种主要方法：Jackson Streaming API和Jackson Data Binding，并提供具体的代码示例。

1. 准备工作

在Spring Boot项目中，Jackson是默认的JSON处理库，因此通常无需额外添加依赖。但如果需要确保版本或解决特定问题，可以检查 pom.xml 中是否包含以下依赖：

    com.fasterxml.jackson.core    jackson-databind

假设我们有以下JSON数据，其中包含嵌套的 footwearList 和 clothingList：

[    {        "id": 1,        "footwearList": [            {                "id": 1,                "name": "sandals",                "category": "men"            },            {                "id": 3,                "name": "sandals",                "category": "women"            }        ],        "clothingList": [            {                "id": 1,                "name": "t-shirt",                "category": "men"            },            {                "id": 3,                "name": "tshirt",                "category": "women"            }        ]    },    {        "id": 2,        "footwearList": [            {                "id": 2,                "name": "shoes",                "category": "men"            },            {                "id": 4,                "name": "shoes",                "category": "women"            }        ],        "clothingList": [            {                "id": 2,                "name": "shirt",                "category": "men"            },            {                "id": 4,                "name": "shirt",                "category": "women"            }        ]    }]

我们的目标是从这个JSON中提取 footwearList 和 clothingList 中的 Item 对象，并可能进一步按 category 进行筛选。

2. 使用Jackson Streaming API

当JSON结构非常庞大、键名动态不固定，或者我们不希望将整个JSON完全映射为Java对象时，Jackson Streaming API提供了一种高效的迭代方式。它允许我们遍历JSON树，按需提取数据。

首先，定义一个 Item 类来表示 footwearList 和 clothingList 中的元素：

public class Item {    private int id;    private String name;    private String category;    // 无参构造函数    public Item() {}    // 带参构造函数    public Item(int id, String name, String category) {        this.id = id;        this.name = name;        this.category = category;    }    // Getters and Setters    public int getId() { return id; }    public void setId(int id) { this.id = id; }    public String getName() { return name; }    public void setName(String name) { this.name = name; }    public String getCategory() { return category; }    public void setCategory(String category) { this.category = category; }    @Override    public String toString() {        return "Item{id=" + id + ", name='" + name + "', category='" + category + "'}";    }}

接下来，我们创建一个辅助方法将 JsonNode 转换为 Item 对象：

import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;public class JsonExtractor {    private static final ObjectMapper MAPPER = new ObjectMapper();    // 辅助方法：将JsonNode转换为Item对象    public static Item nodeToItem(JsonNode node) {        try {            return MAPPER.treeToValue(node, Item.class);        } catch (com.fasterxml.jackson.core.JsonProcessingException e) {            System.err.println("Error converting JsonNode to Item: " + e.getMessage());            return null;        }    }    // ... 其他方法}

现在，我们可以编写逻辑来遍历JSON并提取嵌套列表中的 Item：

import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import java.util.List;import java.util.regex.Pattern;import java.util.function.Predicate;import java.util.stream.StreamSupport;import java.util.Collections; // 导入Collectionspublic class JsonExtractor {    private static final ObjectMapper MAPPER = new ObjectMapper();    // 定义一个正则表达式谓词，用于匹配包含"footwear"或"clothing"的字段名    public static final Predicate TARGET_LIST_PREDICATE = Pattern.compile("footwear|clothing").asPredicate();    // 辅助方法：将JsonNode转换为Item对象 (同上)    public static Item nodeToItem(JsonNode node) {        try {            return MAPPER.treeToValue(node, Item.class);        } catch (com.fasterxml.jackson.core.JsonProcessingException e) {            System.err.println("Error converting JsonNode to Item: " + e.getMessage());            return null;        }    }    public List extractNestedItems(String json) {        try {            JsonNode rootNode = MAPPER.readTree(json);            if (!rootNode.isArray()) {                System.err.println("Root JSON node is not an array.");                return Collections.emptyList();            }            return StreamSupport.stream(rootNode.spliterator(), false) // 遍历根数组的每个对象                .mapMulti((node, consumer) -> { // 对于每个对象                    node.fields().forEachRemaining(entry -> { // 遍历其所有字段                        if (TARGET_LIST_PREDICATE.test(entry.getKey()) && entry.getValue().isArray()) {                            // 如果字段名匹配且其值为数组，则将数组中的每个元素传递给consumer                            entry.getValue().forEach(consumer);                        }                    });                })                .map(JsonExtractor::nodeToItem) // 将每个JsonNode转换为Item对象                .toList(); // 收集结果        } catch (com.fasterxml.jackson.core.JsonProcessingException e) {            System.err.println("Error parsing JSON: " + e.getMessage());            return Collections.emptyList();        }    }    // 示例用法    public static void main(String[] args) {        String json = "[n" +                "    {n" +                "        "id": 1,n" +                "        "footwearList": [n" +                "            { "id": 1, "name": "sandals", "category": "men" },n" +                "            { "id": 3, "name": "sandals", "category": "women" }n" +                "        ],n" +                "        "clothingList": [n" +                "            { "id": 1, "name": "t-shirt", "category": "men" },n" +                "            { "id": 3, "name": "tshirt", "category": "women" }n" +                "        ]n" +                "    },n" +                "    {n" +                "        "id": 2,n" +                "        "footwearList": [n" +                "            { "id": 2, "name": "shoes", "category": "men" },n" +                "            { "id": 4, "name": "shoes", "category": "women" }n" +                "        ],n" +                "        "clothingList": [n" +                "            { "id": 2, "name": "shirt", "category": "men" },n" +                "            { "id": 4, "name": "shirt", "category": "women" }n" +                "        ]n" +                "    }n" +                "]";        JsonExtractor extractor = new JsonExtractor();        List allItems = extractor.extractNestedItems(json);        System.out.println("所有提取的Item:");        allItems.forEach(System.out::println);        // 进一步按类别过滤        List menItems = allItems.stream()                                      .filter(item -> "men".equals(item.getCategory()))                                      .toList();        System.out.println("n按类别'men'过滤的Item:");        menItems.forEach(System.out::println);    }}

输出示例:

所有提取的Item:Item{id=1, name='sandals', category='men'}Item{id=3, name='sandals', category='women'}Item{id=1, name='t-shirt', category='men'}Item{id=3, name='tshirt', category='women'}Item{id=2, name='shoes', category='men'}Item{id=4, name='shoes', category='women'}Item{id=2, name='shirt', category='men'}Item{id=4, name='shirt', category='women'}按类别'men'过滤的Item:Item{id=1, name='sandals', category='men'}Item{id=1, name='t-shirt', category='men'}Item{id=2, name='shoes', category='men'}Item{id=2, name='shirt', category='men'}

这种方法非常灵活，即使JSON的顶层结构或嵌套列表的键名发生变化，只要我们调整 TARGET_LIST_PREDICATE，代码仍然可以工作。

3. 使用Jackson Data Binding

对于结构相对固定且已知其模式的JSON数据，Jackson Data Binding是更推荐和简洁的方法。它允许我们将JSON直接映射到Java对象（POJO），极大地简化了数据访问。

首先，定义一个 Store 类来表示JSON中的顶层对象。由于 footwearList 和 clothingList 的键是动态的，我们可以使用 Map<String, List> 结合 @JsonAnySetter 和 @JsonAnyGetter 来处理。

import com.fasterxml.jackson.annotation.JsonAnyGetter;import com.fasterxml.jackson.annotation.JsonAnySetter;import java.util.HashMap;import java.util.List;import java.util.Map;public class Store {    private int id;    private Map<String, List> items = new HashMap(); // 用于存储动态的列表    // 无参构造函数    public Store() {}    // Getters and Setters for id    public int getId() { return id; }    public void setId(int id) { this.id = id; }    // @JsonAnySetter 用于反序列化时捕获未映射的键值对    @JsonAnySetter    public void readStore(String key, List value) {        this.items.put(key, value);    }    // @JsonAnyGetter 用于序列化时将Map中的内容作为顶级字段输出    // 注意：这里的实现是为了演示，实际序列化时可能需要更精细的控制    @JsonAnyGetter    public Map<String, List> getItems() {        return items;    }    @Override    public String toString() {        return "Store{id=" + id + ", items=" + items + '}';    }}

现在，我们可以使用 ObjectMapper 将整个JSON字符串反序列化为 List：

import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.ObjectMapper;import java.util.Collections;import java.util.List;import java.util.stream.Collectors;public class JsonDataBinder {    private static final ObjectMapper MAPPER = new ObjectMapper();    public List parseJsonToStores(String json) {        try {            return MAPPER.readValue(json, new TypeReference<List>() {});        } catch (com.fasterxml.jackson.core.JsonProcessingException e) {            System.err.println("Error parsing JSON to Store list: " + e.getMessage());            return Collections.emptyList();        }    }    public static void main(String[] args) {        String json = "[n" +                "    {n" +                "        "id": 1,n" +                "        "footwearList": [n" +                "            { "id": 1, "name": "sandals", "category": "men" },n" +                "            { "id": 3, "name": "sandals", "category": "women" }n" +                "        ],n" +                "        "clothingList": [n" +                "            { "id": 1, "name": "t-shirt", "category": "men" },n" +                "            { "id": 3, "name": "tshirt", "category": "women" }n" +                "        ]n" +                "    },n" +                "    {n" +                "        "id": 2,n" +                "        "footwearList": [n" +                "            { "id": 2, "name": "shoes", "category": "men" },n" +                "            { "id": 4, "name": "shoes", "category": "women" }n" +                "        ],n" +                "        "clothingList": [n" +                "            { "id": 2, "name": "shirt", "category": "men" },n" +                "            { "id": 4, "name": "shirt", "category": "women" }n" +                "        ]n" +                "    }n" +                "]";        JsonDataBinder binder = new JsonDataBinder();        List stores = binder.parseJsonToStores(json);        System.out.println("所有解析的Store对象:");        stores.forEach(System.out::println);        // 提取所有鞋类商品        List allFootwear = stores.stream()                                       .flatMap(store -> store.getItems().getOrDefault("footwearList", Collections.emptyList()).stream())                                       .collect(Collectors.toList());        System.out.println("n所有鞋类商品:");        allFootwear.forEach(System.out::println);        // 提取所有男士服装        List menClothing = stores.stream()                                       .flatMap(store -> store.getItems().getOrDefault("clothingList", Collections.emptyList()).stream())                                       .filter(item -> "men".equals(item.getCategory()))                                       .collect(Collectors.toList());        System.out.println("n所有男士服装:");        menClothing.forEach(System.out::println);    }}

输出示例:

所有解析的Store对象:Store{id=1, items={footwearList=[Item{id=1, name='sandals', category='men'}, Item{id=3, name='sandals', category='women'}], clothingList=[Item{id=1, name='t-shirt', category='men'}, Item{id=3, name='tshirt', category='women'}]}}Store{id=2, items={footwearList=[Item{id=2, name='shoes', category='men'}, Item{id=4, name='shoes', category='women'}], clothingList=[Item{id=2, name='shirt', category='men'}, Item{id=4, name='shirt', category='women'}]}}所有鞋类商品:Item{id=1, name='sandals', category='men'}Item{id=3, name='sandals', category='women'}Item{id=2, name='shoes', category='men'}Item{id=4, name='shoes', category='women'}所有男士服装:Item{id=1, name='t-shirt', category='men'}Item{id=2, name='shirt', category='men'}

Data Binding方法将整个JSON结构映射为强类型Java对象，使得后续的数据访问和操作（如使用Java Stream API进行过滤）变得非常直观和类型安全。

4. 注意事项与总结

选择合适的解析策略：Jackson Streaming API： 适用于JSON结构不固定、键名动态、数据量非常大（避免一次性加载所有数据到内存）的场景。它提供了更细粒度的控制，但代码相对复杂。Jackson Data Binding： 适用于JSON结构相对稳定且可以预先定义POJO的场景。它提供了更高的开发效率和代码可读性，是大多数Spring Boot应用的首选。错误处理： 在实际应用中，始终要包含 try-catch 块来处理 JsonProcessingException（或其子类 IOException），以优雅地处理JSON解析过程中可能出现的错误。性能： 对于中小型JSON，Data Binding的性能通常足够好。对于超大型JSON，Streaming API可能提供更好的内存效率。JSONPath： 虽然原问题中提到了 JsonPath，它是一个强大的JSON查询语言。但在Spring Boot的Jackson生态系统中，通常可以直接利用Jackson本身的API来实现大部分需求，而无需引入额外的 JsonPath 依赖，从而保持项目依赖的简洁性。

通过掌握Jackson Streaming API和Data Binding这两种方法，开发者可以根据具体需求，在Spring Boot中灵活高效地处理各种复杂嵌套的JSON数据。在大多数情况下，Data Binding结合 @JsonAnySetter 等注解，能够以最简洁的方式解决嵌套和动态键的问题。

以上就是Spring Boot中高效提取嵌套JSON数据的策略的详细内容，更多请关注创想鸟其它相关文章！