使用fastjson递归解析json子节点中包含的文本json

基于fastjson实现的工具类，fastjson版本：
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.75</version>
</dependency>

1、使用fastjson递归解析json子节点中包含文本json转化为正常json

 public static void handleTextToJson(JSONObject jsonObj) {
        for (String key : jsonObj.keySet()) {
            try {
                Object value = JSON.parse(String.valueOf(jsonObj.get(key)));
                if (value instanceof String) {
                    jsonObj.put(key, value);
                } else if (value instanceof JSONObject) {
                    JSONObject json = JSONObject.parseObject(String.valueOf(value));
                    handleTextToJson(json);
                    jsonObj.put(key, json);
                } else if (value instanceof JSONArray) {
                    JSONArray jsonArr = JSONArray.parseArray(String.valueOf(value));
                    JSONArray newJsonArr = new JSONArray();
                    for (int i = 0; i < jsonArr.size(); i++) {
                        if (jsonArr.get(i) instanceof JSONObject) {
                            JSONObject json = JSONObject.parseObject(String.valueOf(jsonArr.get(i)));
                            handleTextToJson(json);
                            newJsonArr.add(json);
                        } else {
                            newJsonArr.add(jsonArr.get(i));
                        }
                    }
                    jsonObj.put(key, newJsonArr);
                }
            } catch (Exception e) {

            }
        }
    }

2、层级路径匹配json，输出匹配到的路径地址

  //模糊层级关系转换为json实际匹配到的path,目前只支持通配符*，匹配不到，则resultSet返回空；如果没有通配符*，则匹配实际存在，仍放入resultSet中
	//regexPath为模糊路径，json参数为需要匹配的json串，初始resultSet赋值空即可
    //regexPath例子：demo.test.data_trc_*.yyy_*.data ---> demo.test.data_trc_er133444.yyy_78454.data
    public static void matchPathFormJson(String regexPath, String json, Set<String> resultSet) {
        try {
            if (regexPath == null) {
                return;
            }
            if (!regexPath.contains("*")) {
                Object o = JSONPath.read(json, regexPath);
                if (!isEmptyFromJson(o)) {
                    resultSet.add(regexPath);
                }
                return;
            }
            String[] regexPathArr = regexPath.split("\\.");
            String firstRegexStr = "";
            for (int i = 0; i < regexPathArr.length; i++) {
                if (regexPathArr[i].contains("*") && StrUtil.isBlank(firstRegexStr)) {
                    firstRegexStr = regexPathArr[i];
                }
            }
            if (StrUtil.isBlank(firstRegexStr)) {
                return;
            }
            String regexReplace = firstRegexStr.replaceAll("\\*", "\\.\\*");
            //获取模糊匹配的层级的前一层
            String prePath = regexPath.substring(0, regexPath.indexOf(firstRegexStr));
            //获取模糊匹配的层级的后面部分
            String endPath = regexPath.substring(regexPath.indexOf(firstRegexStr) + firstRegexStr.length(), regexPath.length());
            Object o = JSONPath.read(json, prePath);
            Set<String> pathSet = new HashSet<>();
            if (o instanceof JSONObject) {
                JSONObject preJson = JSONObject.parseObject(String.valueOf(o));
                for (Map.Entry<String, Object> f : preJson.entrySet()) {
                    Pattern pattern = Pattern.compile(regexReplace);
                    Matcher matcher = pattern.matcher(f.getKey());
                    if (matcher.matches()) {
                        pathSet.add(prePath + matcher.group() + endPath);
                    }
                }
                for (String newPath : pathSet) {
                    //递归查找
                    matchPathFormJson(newPath, json, resultSet);
                }
            } else if (o instanceof JSONArray) {
                JSONArray preArr = JSONArray.parseArray(String.valueOf(o));
                for (int i = 0; i < preArr.size(); i++) {
                    if (preArr.get(i) instanceof JSONObject) {
                        JSONObject preJson = JSONObject.parseObject(String.valueOf(preArr.get(i)));
                        for (Map.Entry<String, Object> f : preJson.entrySet()) {
                            Pattern pattern = Pattern.compile(regexReplace);
                            Matcher matcher = pattern.matcher(f.getKey());
                            if (matcher.matches()) {
                                pathSet.add(prePath + matcher.group() + endPath);
                            }
                        }
                    }
                    for (String newPath : pathSet) {
                        //递归查找
                        matchPathFormJson(newPath, json, resultSet);
                    }
                }
            }
        } catch (Exception e) {
            //查找失败不做处理，说明找不到json路径
            log.error("查找模糊路径在json中实际路径失败");
        }
    }
	
	public static boolean isEmptyFromJson(Object obj) {
        if (obj == null) {
            return true;
        }
        if ("[]".equals(String.valueOf(obj)) || "{}".equals(String.valueOf(obj))) {
            return true;
        }
        if (obj instanceof String) {
            return ((String) obj).trim().length() == 0;
        }
        if (obj instanceof JSONObject) {
            return ((JSONObject) obj).isEmpty();
        }
        if (obj instanceof JSONArray) {
            return ((JSONArray) obj).isEmpty();
        }
        return false;
    }