本文介绍如何将形如 `"employee1.address.street": "main street"` 的扁平化 json 键，动态还原为标准嵌套 json 结构，支持任意深度路径解析，并提供基于 `org.json` 的健壮、可扩展实现方案。

在实际开发中，我们常遇到上游系统以“点分路径”（dot-notation）方式将嵌套结构扁平化为单层键值对的 JSON 数据，例如 "employee1.address.tempAddress.city": "Beijing"。这种格式虽便于序列化传输或存储，但严重破坏了 JSON 的天然层次语义，给下游解析和业务处理带来困难。本文提供一种通用、可扩展的 Java 解决方案，将此类扁平键 JSON 自动重建为符合直觉的嵌套对象结构。

核心思路是：逐级解析键路径，按需创建中间 JSONObject，并最终将值挂载到最深层节点。以下为完整实现（基于 JSON-Java 库，Maven 坐标：org.json:json:20250303）：

import org.json.*;

public class JsonPathFlattener {

    /**
     * 将扁平化 JSON 数组（每个元素含唯一 key-value）转换为嵌套结构
     */
    public static JSONObject flattenArrayToNested(JSONArray inputArray) {
        JSONObject result = new JSONObject();
        for (int i = 0; i < inputArray.length(); i++) {
            Object item = inputArray.get(i);
            if (!(item instanceof JSONObject)) {
                throw new IllegalArgumentException("Array item must be JSONObject, got: " + item.getClass().getSimpleName());
            }
            JSONObject entry = (JSONObject) item;
            if (entry.length() != 1) {
                throw new IllegalArgumentException("Each object must contain exactly one key-value pair, got: " + entry.length());
            }
            String key = entry.keys().next();
            Object value = entry.get(key);
            setJsonPath(result, key, value);
        }
        return result;
    }

    /**
     * 将 key.path.value 形式的键递归写入 target JSONObject
     */
    private static void setJsonPath(JSONObject target, String key, Object value) {
        String[] parts = key.split("\\.");
        if (parts.length == 0) return;

        JSONObject current = target;
        // 遍历除最后一个部分外的所有层级
        for (int i = 0; i < parts.length - 1; i++) {
            String part = parts[i];
            if (!current.has(part)) {
                current.put(part, new JSONObject());
            }
            Object next = current.get(part);
            if (!(next instanceof JSONObject)) {
                throw new IllegalStateException(
                    String.format("Conflict at path '%s': expected JSONObject at '%s', but found %s",
                        key, String.join(".", parts, 0, i + 1), next.getClass().getSimpleName())
                );
            }
            current = (JSONObject) next;
        }
        // 写入最终叶子节点（自动覆盖同名键，可根据需求改为抛异常）
        current.put(parts[parts.length - 1], value);
    }
}

使用示例：

public class Demo {
    public static void main(String[] args) {
        String inputJson = """
            {
                "Employee": [
                  {"employee1.id": 1},
                  {"employee1.name": "John"},
                  {"employee1.address.street": "main street"},
                  {"employee1.address.pin": "123456"},
                  {"employee2.id": 2},
                  {"employee2.name": "Mike"},
                  {"employee2.address.street": "51 street"},
                  {"employee2.address.pin": "234543"},
                  {"employee1.address.tempAddress.city": "Shanghai"},
                  {"employee1.address.permanentAddress.city": "Beijing"}
                ]
            }""";

        JSONObject root = new JSONObject(inputJson);
        JSONArray employeeArray = root.getJSONArray("Employee");

        JSONObject transformed = JsonPathFlattener.flattenArrayToNested(employeeArray);
        System.out.println(transformed.toString(2)); // 格式化输出，缩进为2
    }
}

✅ 关键特性说明：

• ✅ 任意深度支持："a.b.c.d.e.f" 可自动创建五层嵌套；
• ✅ 冲突检测：当某路径中途已存在非 JSONObject 类型值（如字符串）时，明确抛出 IllegalStateException，避免静默覆盖；
• ✅ 健壮性增强：相比原始示例，本实现增加了输入校验（数组项数量、单键约束）、类型安全断言与清晰错误提示；
• ✅ 无第三方依赖*：仅依赖轻量级 org.json，不引入 Jackson 或 Gson 等重量级框架，适合嵌入式或受限环境。

⚠️ 注意事项：

• 若输入中存在重复键（如两个 "employee1

  

  .id"），后出现的值将覆盖前者。如需严格校验重复，可在 setJsonPath 中添加 if (current.has(lastPart)) { throw ... }；
• 该转换是无状态的纯函数式操作，不修改原始数据；
• 对于超大规模数据（万级键），建议配合流式解析（如 JsonReader）优化内存占用，本方案适用于中等规模配置类场景。

综上，该方案以简洁、可控、可维护的方式解决了 JSON 扁平键 → 嵌套结构的核心难题，既满足当前需求，也具备面向未来路径扩展（如 tempAddress, permanentAddress）的天然兼容性。