JOLT JSON转换：将数组中的多个独立对象合并为单个对象

本文详细介绍了如何使用jolt转换规范，将json数组中原本独立的多个对象合并为一个单一对象。通过在`shift`操作中使用共同的数组索引`[0]`，可以有效消除不必要的嵌套层级，从而实现更紧凑、符合预期的输出结构。文章提供了具体的jolt配置示例和解释，帮助读者掌握此类复杂数据重塑技巧。

JOLT中的数组对象合并问题解析

在使用JOLT进行JSON数据转换时，一个常见的需求是将源JSON中的多个字段映射到目标JSON数组中的一个单一对象内。然而，如果不正确地构造JOLT shift 规范，可能会导致每个源字段在目标数组中生成一个独立的子对象，而非预期的合并结构。

考虑以下输入JSON结构，其中包含了一系列资产相关的信息：

输入 JSON 示例:

{
  "AssetID": "1",
  "AssetNumber": "2",
  "AssetMaterial": "Cisco MDS 9706",
  "RackUnits": "9.0",
  "MaterialType": "Chassis",
  "AssetName": "Cisco-MDS-9706_1",
  "CustRID": "A001",
  "SerialNumber": "OU812",
  "Room": "ROOM5",
  "Datacenter": "DC69",
  "UMountingID": "86",
  "CabinetAssetID": "181",
  "CabinetName": "CAB666"
}

如果使用如下的JOLT shift 规范：

[
  {
    "operation": "shift",
    "spec": {
      "AssetID": "data[].6.value",
      "AssetNumber": "data[].7.value",
      "AssetMaterial": "data[].8.value",
      "AssetName": "data[].9.value",
      "CustRID": "data[].10.value",
      "SerialNumber": "data[].11.value",
      "Room": "data[].12.value",
      "Datacenter": "data[].13.value",
      "UMountingID": "data[].14.value",
      "CabinetAssetID": "data[].15.value",
      "CabinetName": "data[].16.value"
    }
  }
]

上述规范会产生以下输出，其中 data 数组的每个元素都是一个独立的JSON对象，包含了源JSON中的一个字段：

当前输出 JSON 示例:

{
  "data": [
    { "6": { "value": "1" } },
    { "7": { "value": "2" } },
    { "8": { "value": "Cisco MDS 9706" } },
    { "9": { "value": "Cisco-MDS-9706_1" } },
    { "10": { "value": "A001" } },
    { "11": { "value": "OU812" } },
    { "12": { "value": "ROOM5" } },
    { "13": { "value": "DC69" } },
    { "14": { "value": "86" } },
    { "15": { "value": "181" } },
    { "16": { "value": "CAB666" } }
  ]
}

然而，我们期望的输出是将所有这些字段合并到 data 数组中的一个单一对象内，结构如下：

期望输出 JSON 示例:

{
  "data" : [
    {
        "6" : { "value" : "1" },
        "7" : { "value" : "2" },
        "8" : { "value" : "Cisco MDS 9706" },
        "9" : { "value" : "Cisco-MDS-9706_1" },
        "10" : { "value" : "A001" },
        "11" : { "value" : "OU812" },
        "12" : { "value" : "ROOM5" },
        "13" : { "value" : "DC69" },
        "14" : { "value" : "86" },
        "15" : { "value" : "181" },
        "16" : { "value" : "CAB666" }
    }
   ],
  "to" : "table1",
  "fieldsToReturn" : [ 6, 7, 8, 9, 10, 11, 12 ]
}

解决方案：利用共同的数组索引

问题的核心在于 data[].key.value 中的 [] 操作符。当JOLT遇到 [] 时，它会为每个匹配的源路径在目标数组中创建一个新的元素。为了将所有字段合并到数组的同一个元素中，我们需要指定一个共同的数组索引。最简单且常用的方法是使用 [0]。

将 data[].key.value 修改为 data[0].key.value 即可实现这一目标。这意味着所有转换后的字段都将被放置到 data 数组的第一个元素（索引为0）所代表的对象中。

宣小二

宣小二：媒体发稿平台，自媒体发稿平台，短视频矩阵发布平台，基于AI驱动的企业自助式投放平台。

下载

此外，原始JOLT规范中包含了一个冗余的 default 操作来添加 "to": "table1"。这个操作可以直接集成到 shift 规范中，通过使用 # 语法将常量值映射到目标路径。

优化后的 JOLT 转换规范

以下是经过优化和修正的JOLT规范，它将实现期望的输出结构：

[
  {
    "operation": "shift",
    "spec": {
      "AssetID": "data[0].6.value",
      "AssetNumber": "data[0].7.value",
      "AssetMaterial": "data[0].8.value",
      "AssetName": "data[0].9.value",
      "CustRID": "data[0].10.value",
      "SerialNumber": "data[0].11.value",
      "Room": "data[0].12.value",
      "Datacenter": "data[0].13.value",
      "UMountingID": "data[0].14.value",
      "CabinetAssetID": "data[0].15.value",
      "CabinetName": "data[0].16.value",
      // 将常量值 "table1" 映射到目标路径 "to"
      "#table1": "to" 
    }
  },
  {
    "operation": "default",
    "spec": {
      // 添加 fieldsToReturn 数组
      "fieldsToReturn": [6, 7, 8, 9, 10, 11, 12]
    }
  },
  {
    "operation": "sort" // 可选操作，用于确保输出对象的键有序
  }
]

规范说明:

1. shift 操作:

   • "AssetID": "data[0].6.value": 这里的关键是 data[0]。它指示JOLT将 AssetID 的值放置到 data 数组的第一个元素（索引为0）内部，并以 6.value 作为其路径。所有其他字段也同样使用 data[0]，确保它们都被写入同一个对象。
   • "#table1": "to": 这是一个将常量值添加到输出的简洁方法。#table1 表示源数据中没有名为 table1 的字段，因此 JOLT 会将字符串 "table1" 作为值，并将其映射到目标路径 to。这替代了原先的第一个 default 操作。

2. default 操作:

   • 此操作用于添加在输入JSON中不存在的默认字段。在这里，它用于添加 fieldsToReturn 数组。

3. sort 操作 (可选):

   • sort 操作会按照键的字母顺序对JSON对象进行排序。这对于确保输出的确定性和可读性非常有用，尤其是在调试或比较输出时。

最终输出验证

使用上述优化后的JOLT规范对输入JSON进行转换，将得到完全符合期望的输出：

{
  "data": [
    {
      "6": { "value": "1" },
      "7": { "value": "2" },
      "8": { "value": "Cisco MDS 9706" },
      "9": { "value": "Cisco-MDS-9706_1" },
      "10": { "value": "A001" },
      "11": { "value": "OU812" },
      "12": { "value": "ROOM5" },
      "13": { "value": "DC69" },
      "14": { "value": "86" },
      "15": { "value": "181" },
      "16": { "value": "CAB666" }
    }
  ],
  "to": "table1",
  "fieldsToReturn": [ 6, 7, 8, 9, 10, 11, 12 ]
}

可以看到，所有资产字段都已成功合并到 data 数组的单个对象中，并且 to 和 fieldsToReturn 字段也已正确添加。

总结与注意事项

• 共同索引的关键作用: 当需要将多个源字段合并到目标数组的同一个对象中时，务必在 shift 规范中使用一个共同的数组索引（如 [0]）。
• 优化 default 操作: 对于添加常量值，可以直接在 shift 规范中使用 #value: "targetPath" 的语法，以减少JOLT规范的阶段数量，提高效率。
• JOLT的灵活性: JOLT提供了强大的数据转换能力，但理解其操作符（特别是 [] 和 [index]）的行为对于实现复杂的结构重塑至关重要。
• 调试技巧: 在构建复杂的JOLT规范时，逐步测试每个操作阶段的输出，可以帮助定位问题并理解转换过程。