Question

我有一个ObjectNode作为输入参数，我不知道这个节点的确切结构。我的意思是它里面可以有任意数量的层，从非常简单的NameValuePair<String,String>数组到像HashMap<String,Object>这样的复杂结构。如何将它解析为简单的平面结构，如NameValuePair<String,String>数组？我之前为具有已知结构的ObjectNodes做过，但现在我不知道。

我感谢任何帮助和任何想法。

添加细节：例如，如果我知道，在ObjectNode中我总是会找到HashMap<String,String>，而这就是全部，我可以这样做：

ObjectNode parametersNode = (ObjectNode) request.get("parameters");
        Iterator fieldNames = parametersNode.getFieldNames();
        HashMap<String,String> oldParams = new HashMap<String,String>();

        while (fieldNames.hasNext()) {
            String name = (String) fieldNames.next();
            oldParams.put(name, parametersNode.get(name).asText());
        }

但是，如果这个ObjectNode的结构是一个黑盒子怎么办？我不知道地图中是否有地图，数组或一堆地图。它可以来自不同的来源，我不知道我将在任何时刻得到什么样的结构。它可以是：

{
"name":"value",
"name1":"value1"
}

或

{
"name":"value",
"arg1": [
         "name1":"value1",
         "name1":"value1"
        ]
}

或

{
"name":"value",
"arg1": [
         {"name1":"value1"},
         {"name1":"value1"}
        ]
}

或任何更复杂的结构。我事先没有任何信息，我得到了什么。如何将这样的黑盒ObjectNode转换为名称 - 值对的平面数组？有没有通用算法？

最后，无论初始结构的复杂程度如何，我都应该得到简单的结构：

{
  "name":"value",
  "name1":"value1",
  "name2":"value2"
}

Answer 1

由于我没有答案，我自己做了。对于那些将面临同样问题的人，我在这里发布。它没有任何递归，我在不应该使用的地方使用HashMap，但它是作为概念证明并且打算重构的。请注意，它是通过邮递员在Switchyard上作为网络服务进行测试的，因此没有主要方法。

public ArrayList<HashMap<String, String>> convertToFlatFormat(
            JsonNode request) {
        Stack<Pair> stack = new Stack<Pair>();
        ArrayList<HashMap<String, String>> parametersList = new ArrayList<HashMap<String, String>>();
        stack.push(new Pair("", request));
        HashMap<String, Integer> counts = new HashMap<String, Integer>();
        while (!stack.isEmpty()) {
            Pair higherNodePair = stack.pop();
            String nodeName = higherNodePair.name;
            JsonNode higherNode = (JsonNode) higherNodePair.object;
            String newNamePrefix = "";
            if (higherNode.isArray()) {
                ArrayNode higherArrayNode = (ArrayNode) higherNode;
                for (int i = 0; i < higherNode.size(); i++) {
                    JsonNode node = higherArrayNode.get(i);
                    String key = new Integer(i).toString();
                    if (node.isObject()) {
                        if (nodeName.equals("")) {
                            stack.push(new Pair(newNamePrefix, node));
                        } else {
                            stack.push(new Pair(nodeName + "_" + newNamePrefix
                                    , node));
                        }
                    } else if (node.isArray()) {
                        if (nodeName.equals("")) {
                            stack.push(new Pair(newNamePrefix, node));
                        } else {
                            stack.push(new Pair(nodeName + "_" + newNamePrefix
                                    , node));
                        }
                    } else if (node.isValueNode()) {
                        ValueNode valueNode = (ValueNode) node;
                        String value = valueNode.getTextValue();
                        HashMap<String, String> pair = null;
                        if (nodeName.equals("")) {
                            pair = new HashMap<String, String>();
                            pair.put(newNamePrefix + key, value);
                        } else {
                            pair = new HashMap<String, String>();
                            pair.put(nodeName + "_" + newNamePrefix + key,
                                    value);
                        }
                        parametersList.add(pair);
                    }
                }

            } else {
                Iterator<String> iterate = higherNode.getFieldNames();
                while (iterate.hasNext()) {
                    String key = iterate.next();
                    JsonNode node = higherNode.get(key);
                    if (node.isObject()) {
                        if (nodeName.equals("")) {
                            stack.push(new Pair(newNamePrefix + key, node));
                        } else {
                            stack.push(new Pair(nodeName + "_" + newNamePrefix
                                    + key, node));
                        }
                    } else if (node.isArray()) {
                        if (nodeName.equals("")) {
                            stack.push(new Pair(newNamePrefix + key, node));
                        } else {
                            stack.push(new Pair(nodeName + "_" + newNamePrefix
                                    + key, node));
                        }
                    } else if (node.isValueNode()) {
                        ValueNode valueNode = (ValueNode) node;
                        String value = valueNode.getTextValue();
                        HashMap<String, String> pair = null;
                        if (nodeName.equals("")) {
                            pair = new HashMap<String, String>();
                            pair.put(newNamePrefix + key, value);
                        } else {
                            pair = new HashMap<String, String>();
                            pair.put(nodeName + "_" + newNamePrefix + key,
                                    value);
                        }
                        parametersList.add(pair);
                    }
                }
            }
        }
        return parametersList;
    }

    private class Pair {
        public String name;
        public Object object;

        public Pair(String name, Object object) {
            this.name = name;
            this.object = object;
        }
    }

输入是：

{
 "name1":"value1",
 "name2":"value2",
  "name3":[
         {
          "ComponentId":"qwer",
          "InstanceId":"amba"
         },
         {
          "ComponentId":"qwer",
          "InstanceId":"coramba"
         },
         {
          "ComponentId":"dsa",
          "InstanceId":"badar"
         },
         {
          "ComponentId":"dsa",
          "InstanceId":"fdarr"
         },
         {
          "ComponentId":"dsa",
          "InstanceId":"sdddd"
         }
         ]
}

输出结果为：

[
    {
        "name1": "value1"
    },
    {
        "name2": "value2"
    },
    {
        "name3__dsa_1_ComponentId": "dsa"
    },
    {
        "name3__dsa_1_InstanceId": "sdddd"
    },
    {
        "name3__dsa_2_ComponentId": "dsa"
    },
    {
        "name3__dsa_2_InstanceId": "fdarr"
    },
    {
        "name3__dsa_3_ComponentId": "dsa"
    },
    {
        "name3__dsa_3_InstanceId": "badar"
    },
    {
        "name3__qwer_1_ComponentId": "qwer"
    },
    {
        "name3__qwer_1_InstanceId": "coramba"
    },
    {
        "name3__qwer_2_ComponentId": "qwer"
    },
    {
        "name3__qwer_2_InstanceId": "amba"
    }
]

从多层ObjectNode中检索线结构

1 个答案: