You need to enable JavaScript to run this app. Java中基于Jackson如何将扁平化JSON数组转换为嵌套结构化JSON?
优惠活动
大模型
产品
解决方案
定价
更多

Java中基于Jackson如何将扁平化JSON数组转换为嵌套结构化JSON?

基于Jackson实现扁平键值结构到嵌套JSON的转换

针对你给出的key-value格式扁平输入、带1起始数组下标的场景,两种可直接落地的实现方案,完全适配你当前已经在使用的Jackson技术栈,无需引入额外第三方依赖。

方案1:自定义路径解析 + 动态构建JsonNode

这个方案可控性最高,完全匹配你当前的key格式规则,没有额外的语法兼容性要求。

核心处理逻辑

  • 遍历输入的扁平数组,逐行读取每一个key和对应的value
  • 对单个key做结构化拆分:
    • 识别普通对象层级段(以.为分隔的字符串)
    • 识别数组节点段(带[数字]格式标记的部分)
    • 注意你的输入中数组下标从1开始,构建JSON数组时需要将下标值减1,匹配JSON标准数组从0开始计数的规则
  • 沿着拆分后的路径逐层遍历根节点:
    • 遇到中间对象段时,若对应字段不存在则创建ObjectNode
    • 遇到数组段时,若对应数组字段不存在则创建ArrayNode;若数组长度不足目标下标位置,自动补占位空对象,避免下标越界
    • 走到路径最后一段时,直接将value写入对应节点

核心实现代码

项目中仅需保留已引入的Jackson databind依赖即可运行:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

转换工具类代码:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FlatToNestedConverter {
    // 匹配路径段的正则:匹配普通名称 + 可选的数组下标标记
    private static final Pattern PATH_SEGMENT_PATTERN = Pattern.compile("([^.\\[]+)(\\[(\\d+)\\])?");
    private final ObjectMapper objectMapper = new ObjectMapper();

    public JsonNode convert(String flatJsonStr) throws Exception {
        JsonNode flatInput = objectMapper.readTree(flatJsonStr);
        ObjectNode rootNode = objectMapper.createObjectNode();

        for (JsonNode item : flatInput) {
            String key = item.get("key").asText();
            JsonNode value = item.get("value");
            Matcher matcher = PATH_SEGMENT_PATTERN.matcher(key);
            ObjectNode currentParent = rootNode;

            while (matcher.find()) {
                String segName = matcher.group(1);
                String indexStr = matcher.group(3);

                if (indexStr != null) {
                    // 处理数组节点
                    int arrayIndex = Integer.parseInt(indexStr) - 1; // 适配输入的1起始下标
                    ArrayNode targetArray;
                    if (currentParent.has(segName) && currentParent.get(segName).isArray()) {
                        targetArray = (ArrayNode) currentParent.get(segName);
                    } else {
                        targetArray = objectMapper.createArrayNode();
                        currentParent.set(segName, targetArray);
                    }
                    // 数组长度不足时补占位对象
                    while (targetArray.size() <= arrayIndex) {
                        targetArray.addObject();
                    }
                    currentParent = (ObjectNode) targetArray.get(arrayIndex);
                } else {
                    // 处理普通对象节点
                    if (matcher.hitEnd()) {
                        // 最后一段,直接写入值
                        currentParent.set(segName, value);
                    } else {
                        // 中间层级,确保是对象类型
                        if (currentParent.has(segName) && currentParent.get(segName).isObject()) {
                            currentParent = (ObjectNode) currentParent.get(segName);
                        } else {
                            ObjectNode newNode = objectMapper.createObjectNode();
                            currentParent.set(segName, newNode);
                            currentParent = newNode;
                        }
                    }
                }
            }
        }
        return rootNode;
    }
}

该实现直接输入你给出的样例扁平结构,输出结果和你要求的嵌套结构完全一致。

方案2:基于Jackson原生JsonPointer能力简化实现

如果你不想手写正则做路径拆分,可以直接复用Jackson原生支持的RFC6901 JSON指针规范,只需要做简单的格式转换即可使用官方的路径操作能力,减少边界判断代码量。

核心处理逻辑

  • 将原始key转换为符合JsonPointer规范的路径:
    • 把key中的[数字]格式替换成/数字,对数字做减1的偏移适配1起始下标
    • 把key中剩余的.分隔符替换成/
    • 最终生成类似/Main1/del/0/x的标准指针路径
  • 调用Jackson内置的with方法沿着指针路径自动创建中间节点,直接写入值即可

核心代码片段

import com.fasterxml.jackson.core.JsonPointer;

// 原始key转标准JsonPointer
private String toJsonPointer(String originalKey) {
    String replaced = originalKey.replaceAll("\\[", "/").replaceAll("\\]", "");
    String[] segments = replaced.split("\\.");
    StringBuilder pointer = new StringBuilder();
    for (String seg : segments) {
        if (seg.matches("\\d+")) {
            // 原数组下标转成0起始的偏移量
            int offsetIdx = Integer.parseInt(seg) - 1;
            pointer.append("/").append(offsetIdx);
        } else {
            pointer.append("/").append(seg);
        }
    }
    return pointer.toString();
}

// 写入节点
JsonPointer pointer = JsonPointer.compile(toJsonPointer(currentKey));
// Jackson会自动沿着路径创建所有缺失的中间节点,不需要手动判断节点是否存在
rootNode.with(pointer).set(currentValue);

注意事项

  • 两种方案都不需要提前定义嵌套结构的Java POJO,最终生成的JsonNode可以直接通过Jackson的treeToValue方法映射到对应的实体类
  • 若你的key中包含带点、带方括号的转义属性名,需要在路径解析阶段增加转义符判断逻辑,避免误拆分
  • 构建数组时不要忘记做1起始下标的偏移,否则会出现数组越界、或数组首位为空元素的问题

内容的提问来源于stack exchange,提问作者Antaury

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.11.16 01:15:09