1. 引言：嵌套JSON数据过滤的挑战
在现代应用开发中，处理嵌套的JSON数据是常见的任务。当我们需要从复杂的JSON结构中提取或过滤特定信息，同时又希望保留其原始的层次结构时，会面临一些挑战。例如，从一个包含多层电影分类的JSON文件中，筛选出所有“热门”电影，并保持其所属的类型和国家分类不变。
考虑以下电影数据的JSON结构：
{
"Bollywood": {
"Romance": {
"hit": false,
"name": "Prithvi Raj"
},
"Action": {
"hit": true,
"name": "3 Idiots"
}
},
"Hollywood": {
"Romance": {
"hit": false,
"name": "Intimacy"
},
"Action": {
"hit": true,
"name": "Seven Samurai"
}
}
}我们的目标是过滤掉所有"hit": false的电影，最终得到如下结构：
{
"Bollywood": {
"Action": {
"hit": true,
"name": "3 Idiots"
}
},
"Hollywood": {
"Action": {
"hit": true,
"name": "Seven Samurai"
}
}
}使用Jackson库将JSON文件解析为Java的Map对象是常见的做法。然而，当使用像Map, ?>这样的不确定泛型类型时，深入嵌套结构进行操作会遇到类型安全问题。
2. 问题分析：Map, ?>与类型擦除
当Jackson将JSON解析为Map.class时，通常会得到一个Map
error: cannot find symbol
.entrySet()
^
symbol: method entrySet()
location: class Object这是因为Java的泛型在运行时会被擦除，Map, ?>在运行时实际上是Map
3. 解决方案一：通过显式类型转换进行流式过滤
为了在不破坏外部Map结构的情况下过滤嵌套数据，我们需要对每一层进行适当的类型转换，以便可以调用相应的方法（如entrySet()）并访问内部属性。
以下是使用Java Stream API和显式类型转换实现过滤的示例代码：
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.nio.file.Paths;
import java.util.Map;
import java.util.stream.Collectors;
public class JsonMovieFilter {
public static void main(String[] args) {
try {
// 确保 movie.json 文件存在于项目根目录或指定路径
// 创建一个示例 movie.json 文件
String jsonContent = "{\n" +
" \"Bollywood\": {\n" +
" \"Romance\": {\n" +
" \"hit\": false,\n" +
" \"name\": \"Prithvi Raj\"\n" +
" },\n" +
" \"Action\": {\n" +
" \"hit\": true,\n" +
" \"name\": \"3 Idiots\"\n" +
" }\n" +
" },\n" +
"\n" +
"\"Hollywood\": {\n" +
" \"Romance\": {\n" +
" \"hit\": false,\n" +
" \"name\": \"Intimacy\"\n" +
" },\n" +
" \"Action\": {\n" +
" \"hit\": true,\n" +
" \"name\": \"Seven Samurai\"\n" +
" }\n" +
" }\n" +
"}";
// 将JSON内容写入文件，以便ObjectMapper读取
// Files.write(Paths.get("movie.json"), jsonContent.getBytes()); // 如果需要实际创建文件
ObjectMapper mapper = new ObjectMapper();
// 直接从字符串读取，避免文件IO，方便测试
Map originalMap = mapper.readValue(jsonContent, Map.class);
// 使用Stream API进行嵌套过滤
Map> filteredMap = originalMap.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey, // 保留顶层键 (e.g., "Bollywood", "Hollywood")
entry -> {
// 将顶层值（Object类型）强制转换为 Map
Map innerGenreMap = (Map) entry.getValue();
// 对内层Map进行过滤
Map filteredGenreMap = innerGenreMap.entrySet().stream()
.filter(subEntry -> {
// 将内层值（Object类型，即电影详情Map）强制转换为 Map
Map movieDetails = (Map) subEntry.getValue();
// 检查 "hit" 属性是否存在且为 true
return Boolean.TRUE.equals(movieDetails.get("hit"));
})
.collect(Collectors.toMap(
Map.Entry::getKey, // 保留电影类型键 (e.g., "Action")
Map.Entry::getValue // 保留过滤后的电影详情Map
));
return filteredGenreMap;
}
))
// 过滤掉所有值为空Map的顶层条目 (即没有热门电影的分类)
.entrySet().stream()
.filter(entry -> !((Map) entry.getValue()).isEmpty())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
// 打印过滤后的结果
System.out.println("Filtered Map:\n" + mapper.writerWithDefaultPrettyPrinter().writeValueAsString(filteredMap));
} catch (Exception ex) {
ex.printStackTrace();
}
}
} 代码解释：
- originalMap.entrySet().stream(): 获取顶层Map的键值对流，例如 ("Bollywood", {...})。
-
外层 Collectors.toMap: 用于构建新的顶层Map。
- Map.Entry::getKey: 直接使用原始的顶层键（如 "Bollywood"）。
- entry -> {...}: 对每个顶层值（即{"Romance": {...}, "Action": {...}}这个Map）进行处理。
-
Map
innerGenreMap = (Map : 这里是关键。由于entry.getValue()的类型是Object，我们必须将其强制转换为Map) entry.getValue(); 才能调用其entrySet()方法。 - innerGenreMap.entrySet().stream(): 获取内层Map的键值对流，例如 ("Romance", {"hit": false, ...})。
-
filter(subEntry -> {...}): 对内层流进行过滤。
- Map
movieDetails = (Map ) subEntry.getValue();: 再次进行类型转换，将电影详情（Object类型）转换为Map 。 - Boolean.TRUE.equals(movieDetails.get("hit")): 检查电影详情Map中"hit"键的值是否为true。使用Boolean.TRUE.equals()可以避免NullPointerException，即使get("hit")返回null也不会报错。
- Map
- 内层 Collectors.toMap: 构建过滤后的内层Map，只包含符合条件的电影条目。
- 后续过滤 (.entrySet().stream().filter(...)): 在外层Collectors.toMap完成后，我们可能得到一些空的内层Map（例如，某个电影分类下没有热门电影）。这一步用于移除这些空的分类，使最终输出更整洁。
注意事项： 这种基于Map, ?>和显式类型转换的方法虽然可以工作，但在处理更复杂或结构不确定的JSON时，会变得繁琐且容易出错。每次访问深层数据都需要进行类型转换，如果类型不匹配，会在运行时抛出ClassCastException。
4. 解决方案二：利用Jackson JsonNode API 实现健壮过滤
Jackson库提供了JsonNode API，它提供了一种更健壮、类型安全的方式来遍历和操作JSON数据，而无需频繁进行Java类型转换。JsonNode代表JSON结构中的一个节点，可以轻松地访问其子节点、属性和值。
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.File;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.Map;
public class JsonMovieFilterWithJsonNode {
public static void main(String[] args) {
try {
String jsonContent = "{\n" +
" \"Bollywood\": {\n" +
" \"Romance\": {\n" +
" \"hit\": false,\n" +
" \"name\": \"Prithvi Raj\"\n" +
" },\n" +
" \"Action\": {\n" +
" \"hit\": true,\n" +
" \"name\": \"3 Idiots\"\n" +
" }\n" +
" },\n" +
"\n" +
"\"Hollywood\": {\n" +
" \"Romance\": {\n" +
" \"hit\": false,\n" +
" \"name\": \"Intimacy\"\n" +
" },\n" +
" \"Action\": {\n" +
" \"hit\": true,\n" +
" \"name\": \"Seven Samurai\"\n" +
" }\n" +
" }\n" +
"}";
ObjectMapper mapper = new ObjectMapper();
// 将JSON字符串解析为JsonNode
JsonNode rootNode = mapper.readTree(jsonContent);
// 创建一个用于存储过滤结果的ObjectNode
ObjectNode filteredRoot = mapper.createObjectNode();
// 遍历顶层节点 (e.g., "Bollywood", "Hollywood")
Iterator> genres = rootNode.fields();
while (genres.hasNext()) {
Map.Entry genreEntry = genres.next();
String genreKey = genreEntry.getKey();
JsonNode genreNode = genreEntry.getValue(); // e.g., {"Romance": {...}, "Action": {...}}
ObjectNode filteredGenre = mapper.createObjectNode();
// 遍历电影类型节点 (e.g., "Romance", "Action")
Iterator> movieTypes = genreNode.fields();
while (movieTypes.hasNext()) {
Map.Entry movieTypeEntry = movieTypes.next();
String movieTypeKey = movieTypeEntry.getKey();
JsonNode movieDetailsNode = movieTypeEntry.getValue(); // e.g., {"hit": false, "name": "Prithvi Raj"}
// 检查 "hit" 属性是否存在且为 true
if (movieDetailsNode.has("hit") && movieDetailsNode.get("hit").asBoolean()) {
filteredGenre.set(movieTypeKey, movieDetailsNode);
}
}
// 如果该电影分类下有热门电影，则添加到结果中
if (filteredGenre.size() > 0) {
filteredRoot.set(genreKey, filteredGenre);
}
}
// 打印过滤后的结果
System.out.println("Filtered JsonNode:\n" + mapper.writerWithDefaultPrettyPrinter().writeValueAsString(filteredRoot));
} catch (Exception ex) {
ex.printStackTrace();
}
}
} 代码解释：
- mapper.readTree(jsonContent): 将JSON内容直接解析为JsonNode对象，这是一个树形结构，代表了整个JSON。
- mapper.createObjectNode(): 创建一个新的ObjectNode（JsonNode的子类，代表JSON对象），用于构建过滤后的结果。
- rootNode.fields(): 获取顶层JSON对象的所有字段（键值对）的迭代器。每个值都是一个JsonNode。
- genreNode.fields(): 同样地，获取每个电影分类（如 "Bollywood"）下的所有电影类型字段的迭代器。
- movieDetailsNode.has("hit"): 安全地检查当前电影详情节点是否包含名为"hit"的字段。
- movieDetailsNode.get("hit").asBoolean(): 获取"hit"字段的值并将其转换为布尔类型。JsonNode提供了asBoolean(), asText(), asInt()等方法，可以安全地获取不同类型的值，如果节点不存在或类型不匹配，通常会返回默认值（如false、null、0），而不是抛出异常。
- filteredGenre.set(movieTypeKey, movieDetailsNode): 如果电影符合过滤条件，将其添加到构建中的filteredGenre ObjectNode中。
- filteredRoot.set(genreKey, filteredGenre): 如果某个电影分类下有符合条件的电影，则将其添加到最终的filteredRoot ObjectNode中。
5. 最佳实践与考量
- 类型安全与可读性: JsonNode方法通常比Map, ?>加大量类型转换更具类型安全性和可读性，尤其是在处理深层嵌套结构时。它避免了运行时ClassCastException的风险。
- 性能: 对于非常大的JSON文件，Jackson还提供了Streaming API (JsonParser, JsonGenerator)，可以逐个令牌地
