Java中如何遍历由quickcheck.generator生成的随机结构JSON字符串？

嘿，这个需求太常见了！别担心，Jackson完全能搞定这种未知结构的JSON盲遍历，根本不需要提前知道任何键名或者层级结构。下面给你两种实用的实现思路，都是基于Jackson的，你可以按需选择：

方案1：递归遍历JsonNode（最直观） #

Jackson的JsonNode是处理动态JSON结构的核心类，我们可以通过递归遍历它的所有节点，逐个处理键值对，最后生成新的JSON。

核心步骤： #

1. 用ObjectMapper把原始JSON字符串解析成JsonNode
2. 写递归函数，区分三种节点类型处理：
   • ObjectNode（对象）：遍历所有键值对，递归处理每个值
   • ArrayNode（数组）：遍历每个元素，递归处理
   • 叶子节点（字符串/数字/布尔等）：和指定字符串比较，执行你需要的转换逻辑

代码示例 #

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

import java.io.IOException;

public class BlindJsonProcessor {
    private static final ObjectMapper objectMapper = new ObjectMapper();
    // 这里替换成你要比较的目标字符串
    private static final String TARGET_STRING = "value1";
    // 示例：如果值匹配目标字符串，替换成这个新值
    private static final String REPLACEMENT_VALUE = "matched_and_replaced";

    public static void main(String[] args) throws IOException {
        // 模拟随机生成的JSON字符串
        String randomJson = "{ \"key1\": \"value2\", \"key3\": 1234, \"key2\": { \"key4\": true, \"key7\": \"value3\", \"key6\": \"value1\", \"key5\": 234 } }";
        
        // 解析原始JSON
        JsonNode rootNode = objectMapper.readTree(randomJson);
        // 遍历并转换JSON
        JsonNode transformedRoot = traverseAndTransform(rootNode);
        
        // 输出格式化后的新JSON
        System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(transformedRoot));
    }

    private static JsonNode traverseAndTransform(JsonNode node) {
        if (node.isObject()) {
            ObjectNode newObject = objectMapper.createObjectNode();
            // 遍历对象的所有键值对
            node.fields().forEachRemaining(entry -> {
                String key = entry.getKey();
                JsonNode value = entry.getValue();
                // 递归处理值节点，再添加到新对象中
                newObject.set(key, traverseAndTransform(value));
            });
            return newObject;
        } else if (node.isArray()) {
            ArrayNode newArray = objectMapper.createArrayNode();
            // 遍历数组的每个元素
            node.elements().forEachRemaining(element -> {
                newArray.add(traverseAndTransform(element));
            });
            return newArray;
        } else {
            // 处理叶子节点：和目标字符串比较
            if (node.isTextual() && node.asText().equals(TARGET_STRING)) {
                // 匹配成功，返回替换值
                return objectMapper.valueToTree(REPLACEMENT_VALUE);
            }
            // 不匹配则保留原节点
            return node;
        }
    }
}

代码说明 #

• 这个例子中，我们把所有值等于"value1"的节点替换成了"matched_and_replaced"，你可以根据自己的需求修改比较逻辑（比如比较键名、或者更复杂的匹配规则）。
• 递归逻辑会自动处理任意深度的嵌套结构，不管JSON有多少层都能遍历到。

方案2：带路径追踪的遍历（更灵活） #

如果你需要知道每个键值对的层级路径（比如key2.key6这种），可以在递归时添加路径参数，方便做更精细的处理。

代码示例（修改递归函数） #

import java.util.ArrayList;
import java.util.List;

// ... 其他导入和常量和方案1一致 ...

private static JsonNode traverseAndTransform(JsonNode node, List<String> currentPath) {
    if (node.isObject()) {
        ObjectNode newObject = objectMapper.createObjectNode();
        node.fields().forEachRemaining(entry -> {
            String key = entry.getKey();
            // 更新当前路径
            List<String> newPath = new ArrayList<>(currentPath);
            newPath.add(key);
            
            JsonNode value = entry.getValue();
            newObject.set(key, traverseAndTransform(value, newPath));
        });
        return newObject;
    } else if (node.isArray()) {
        ArrayNode newArray = objectMapper.createArrayNode();
        int index = 0;
        for (JsonNode element : node) {
            // 数组元素用[index]标记路径
            List<String> newPath = new ArrayList<>(currentPath);
            newPath.add("[" + index + "]");
            
            newArray.add(traverseAndTransform(element, newPath));
            index++;
        }
        return newArray;
    } else {
        // 打印当前键值对的路径和值，方便调试
        String fullPath = String.join(".", currentPath);
        System.out.printf("Path: %s, Value: %s%n", fullPath, node);
        
        // 你的比较逻辑
        if (node.isTextual() && node.asText().equals(TARGET_STRING)) {
            return objectMapper.valueToTree(REPLACEMENT_VALUE);
        }
        return node;
    }
}

调用方式 #

在main函数里调用时，传入空列表作为初始路径：

JsonNode transformedRoot = traverseAndTransform(rootNode, new ArrayList<>());

关键知识点 #

Jackson的JsonNode天生就是为动态JSON设计的，完全支持盲遍历，不需要提前定义任何POJO类。不管JSON结构怎么变，只要用上述递归方式，就能遍历到每一个键值对。

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