根据参数位置解析多层 JSON 支持多维数组

客官°小女子只卖身不卖艺 2023-09-24 14:19 83阅读 0赞

最近有一个需求，需要用定时任务调用第三方接口，第三方接口前面可能有多层，即第三层传递的参数来自第二层接口返回的结果，参数需要在前台配置，参数是灵活配置的，如：第二层需要第一层返回结果的 token，需要通过 A.B.C 去解析 JSON 获取 token

比如如下 JSON，前端传递位置就能获取具体的值

*  `result.teacher[0].subject[2].name`,
 *  `result.teacher[0].subject[0].score[1][1][0]`,
 *  `result.teacher[0].subject[2].score[1][1].name`,
 *  `timestamp[1]`

{
        
        "result": {
        
            "teacher": [
                {
        
                    "name": "admin",
                    "subject": [
                        {
        
                            "name": "语文",
                            "score": [
                                [
                                    [1, 2],
                                    [3,4]
                                ],
                                [
                                    [5,6],
                                    [7,8]
                                ]
                            ]
                        },
                        {
        
                            "name": "数学",
                            "score": 99
                        },
                        {
        
                            "name": "英语",
                            "score": [
                                [
                                    {
        
                                        "name": "初一期中",
                                        "score": 66
                                    },
                                    {
        
                                        "name": "初一期末",
                                        "score": 77
                                    }
                                ],
                                [
                                    {
        
                                        "name": "初二期中",
                                        "score": 88
                                    },
                                    {
        
                                        "name": "初二期末",
                                        "score": 99
                                    }
                                ]
                            ]
                        }
                    ],
                    "age": 99,
                    "address": "西安市"
                }
            ]
        },
        "timestamp": [123, 456,789]
    }

直接上代码，代码比较简单，目前暂时满足需求，后续有修改再追加

public class Test {
        
        public static void main(String[] args) {
        
            String s = "{\n" +
                    "    'result': {\n" +
                    "        'teacher': [\n" +
                    "            {\n" +
                    "                'name': 'admin',\n" +
                    "                'subject': [\n" +
                    "                    {'name': '语文','score': [[[1,2],[3,4]],[[5,6],[7,8]]]},\n" +
                    "                    {'name': '数学','score': 99},\n" +
                    "                    {'name': '英语', 'score': [[{'name':'初一期中', 'score':66},{'name':'初一期末', 'score':77}],[{'name':'初二期中', 'score':88},{'name':'初二期末', 'score':99}]]}\n" +
                    "                ],\n" +
                    "                'age': 99,\n" +
                    "                'address': '西安市'\n" +
                    "            }\n" +
                    "        ]\n" +
                    "    },\n" +
                    "    'timestamp': [123, 456,789]\n" +
                    "}";
            JSONObject jsonObject = JSONObject.parseObject(s);
            String lockValue = "result.teacher[0].subject[2].name";
            String lockValue2 = "result.teacher[0].subject[0].score[1][1][0]";
            String lockValue3 = "result.teacher[0].subject[2].score[1][1].name";
            String lockValue4 = "timestamp[1]";
            System.out.println(resolveJson(lockValue, jsonObject));
            System.out.println(resolveJson(lockValue2, jsonObject));
            System.out.println(resolveJson(lockValue3, jsonObject));
            System.out.println(resolveJson(lockValue4, jsonObject));
        }
    
        /**
         * 解析 json ，支持 A.B.C，A[0].B.[2]
         */
        public static String resolveJson(String lockValue, JSONObject jsonObject) {
        
            String[] split = lockValue.split("\\.");
            Object obj = null;
            for (int i = 0; i < split.length; i++) {
        
                try {
        
                    // 判断是否解析数组
                    if (split[i].contains("[") && split[i].contains("]")) {
        
                        String prefix = split[i].substring(0, split[i].indexOf("["));
                        // 判断是否解析多维数组
                        if (split[i].contains("][")) {
        
                            obj = resolveManyArr(jsonObject, split[i]);
                        } else {
        
                            obj = jsonObject.get(prefix);
                            String index = split[i].substring(prefix.length() + 1, split[i].indexOf("]"));
                            obj = JSONArray.parseArray(JSONObject.toJSONString(obj)).get(Integer.parseInt(index));
                        }
                    } else {
        
                        obj = jsonObject.get(split[i]);
                    }
                    if (i != split.length - 1) {
        
                        jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
                    }
                } catch (Exception e) {
        
                	// 解析错误处理
                    JSONObject errorJson = new JSONObject();
                    errorJson.put("param", split[i]);
                    errorJson.put("value", obj);
                    errorJson.put("error", e.getMessage());
                    obj = JSONObject.toJSONString(errorJson);
                    System.out.println("参数解析失败-----" + split[i]);
                    e.printStackTrace();
                }
            }
    
            String paramValue;
            try {
        
                paramValue = JSONObject.toJSONString(obj);
            } catch (Exception e) {
        
                assert jsonObject != null;
                paramValue = jsonObject.toString();
            }
            return paramValue;
        }
    
        /**
         * Description: 解析多维数组
         *
         * @return: java.lang.Object
         */
    
        public static Object resolveManyArr(JSONObject jsonObject, String resolveParam) {
        
            JSONArray jsonArray = null;
            Object obj = null;
            String prefix = resolveParam.substring(0, resolveParam.indexOf("["));
            if (resolveParam.contains("][")) {
        
                String[] indArr = resolveParam.substring(prefix.length() + 1, resolveParam.length() - 1).split("]\\[");
                if (indArr.length > 1) {
        
                    for (int j = 0; j < indArr.length; j++) {
        
                        obj = j == 0 ? jsonObject.getJSONArray(prefix).get(Integer.parseInt(indArr[j])) : JSONArray.parseArray(JSONObject.toJSONString(jsonArray)).get(Integer.parseInt(indArr[j]));
                        if (j != indArr.length - 1) {
        
                            jsonArray = JSONArray.parseArray(JSONObject.toJSONString(obj));
                        }
                    }
                }
            }
            return obj;
        }
    }

测试结果  
![在这里插入图片描述][7e39921ee21c40f2a18e01f86d46b172.png]

[7e39921ee21c40f2a18e01f86d46b172.png]: https://img-blog.csdnimg.cn/7e39921ee21c40f2a18e01f86d46b172.png