如何在Java中解析包含多层嵌套criteria对象的JSON结构

问题核心 #

你现有代码的问题集中在两点：

1. 当JSONObject本身就包含要找的criteria key时，没有做任何处理逻辑直接跳过
2. 遍历condition数组的每个条件对象时，没有检查该对象下是否嵌套了criteria字段，递归链路没有覆盖这个场景，所以深层嵌套的criteria无法被识别解析

代码调整步骤 #

1. 补全匹配到criteria后的处理逻辑 #

如果当前JSONObject已经包含目标key（也就是criteria），直接取出该criteria对象，执行你原有的Groups、condition解析逻辑

2. 新增condition节点的criteria递归检查 #

遍历每个condition的JSON对象时，先判断是否包含criteria字段，如果有就递归调用解析方法处理嵌套结构

3. 修复异常吞掉的问题 #

空的catch块会导致所有报错被隐藏，排查问题时很难定位，建议至少保留异常打印

调整后的完整代码示例 #

// 递归检索并解析所有嵌套的criteria对象
public static void getKey(JSONObject json, String key) {
    Boolean exists = json.has(key);
    Iterator<?> keys;
    String nextKeys;

    try {
        // 匹配到criteria，直接处理当前criteria对象
        if (exists) {
            JSONObject criteria = json.getJSONObject(key);
            parseCriteria(criteria);
            return;
        }

        keys = json.keys();
        while (keys.hasNext()) {
            nextKeys = (String) keys.next();
            Object value = json.get(nextKeys);
            if (value instanceof JSONObject) {
                // 递归遍历子JSONObject
                getKey((JSONObject) value, key);
            } else if (value instanceof JSONArray) {
                JSONArray jsonArray = (JSONArray) value;
                for (int i = 0; i < jsonArray.length(); i++) {
                    Object arrayItem = jsonArray.get(i);
                    if (arrayItem instanceof JSONObject) {
                        // 递归遍历数组内的JSONObject
                        getKey((JSONObject) arrayItem, key);
                    }
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

// 单独抽离criteria解析逻辑，避免代码冗余
private static void parseCriteria(JSONObject criteria) {
    String outerLo = criteria.optString("LogicalOperator");
    System.out.println("当前层级逻辑运算符：" + outerLo);
    JSONArray groups = criteria.optJSONArray("Groups");
    if (groups == null) {
        return;
    }
    List<CustomerPojo> customerList = getCustomerData();
    
    for (int i = 0; i < groups.length(); i++) {
        JSONObject group = groups.optJSONObject(i);
        if (group == null) {
            continue;
        }
        String groupLo = group.optString("LogicalOperator");
        JSONArray conditionArr = group.optJSONArray("condition");
        if (conditionArr == null) {
            continue;
        }
        List<Object> objList = new ArrayList<>();
        System.out.println("分组逻辑运算符：" + groupLo);
        
        for (int j = 0; j < conditionArr.length(); j++) {
            JSONObject condition = conditionArr.optJSONObject(j);
            if (condition == null) {
                continue;
            }
            // 检查当前条件是否嵌套了criteria，有就递归解析
            if (condition.has("criteria")) {
                getKey(condition, "criteria");
            }
            // 执行原有的过滤逻辑
            if ("AND".equals(groupLo)) {
                conditionAND(objList, customerList, condition);
            } else if ("OR".equals(groupLo)) {
                conditionOR(objList, customerList, condition);
            }
        }
        
        // OR条件去重
        if ("OR".equals(groupLo)) {
            filteringOrConditon(objList);
        }
    }
}

额外注意事项 #

• 代码中全部使用optXXX系列方法替代getXXX，避免字段不存在时直接抛出异常打断流程
• 将criteria解析逻辑单独抽离成方法，递归调用时不需要重复写解析代码，维护更方便
• 如果业务上嵌套层级极深，可以考虑把递归改成迭代的方式避免栈溢出，常规业务场景下递归足够使用

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