JSON数据生成扁平化字段名

用标准规则生成扁平化数据是无法直接作为数据库的列名定义的，如果想直接用于列名定义请查看，如果想用标准化的扁平化方案，请搜索JsonFlattener的使用

    /**
     * JSON扁平化总入口
     *
     * 会将所有的_去除
     * 会将_后的第一个字母大写
     * @param json
     * @return
     */
    public static JSONArray unfold(String json) {
        if (json.startsWith("{")) {
            return unfold(changeJsonObj(JSON.parseObject(json)));
        } else if (json.startsWith("[")) {
            return unfold(changeJsonArr(JSON.parseArray(json)));
        } else {
            return null;
        }
    }

    /**
     * 去除 下划线
     * 如果下划线后面是小写字母，自动大写
     * @param json
     * @return
     */
    private static String formatJSON(String json) {
        String[] array = json.split("_");
        if (array.length > 1) {
            StringBuilder r = new StringBuilder();
            for (int i = 0; i < array.length; i++) {
                String s = array[i];
                char c = s.charAt(0);
                if (Character.isLowerCase(c) && i > 0) {
                    s = Character.toUpperCase(s.charAt(0)) + s.substring(1);
                }
                r.append(s);
            }
            return r.toString();
        } else {
            return array[0];
        }
    }

    /**
     * key值转换
     * 去除 下划线
     * 如果下划线后面是小写字母，自动大写
     * @param jsonObj
     * @return
     */
    private static JSONObject changeJsonObj(JSONObject jsonObj) {
        JSONObject resJson = new JSONObject();
        Set<String> keySet = jsonObj.keySet();
        for (String key : keySet) {
            String resKey = formatJSON(key);
            try {
                if (jsonObj.get(key) instanceof JSONObject) {
                    JSONObject jsonobj1 = (JSONObject) jsonObj.get(key);
                    resJson.put(resKey, changeJsonObj(jsonobj1));
                } else if (jsonObj.get(key) instanceof JSONArray) {
                    JSONArray jsonArr = (JSONArray) jsonObj.get(key);
                    resJson.put(resKey, changeJsonArr(jsonArr));
                }else {
                    resJson.put(resKey, jsonObj.get(key));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return resJson;
    }

    /**
     * key值转换
     * 去除 下划线
     * 如果下划线后面是小写字母，自动大写
     * @param jsonArr
     * @return
     */
    private static JSONArray changeJsonArr(JSONArray jsonArr) {
        JSONArray resJson = new JSONArray();
        for (int i = 0; i < jsonArr.size(); i++) {
            if (jsonArr.get(i) instanceof List) {
                JSONArray array = changeJsonArr(jsonArr.getJSONArray(i));
                resJson.addAll(array);
            } else {
                JSONObject jsonObj = jsonArr.getJSONObject(i);
                resJson.add(changeJsonObj(jsonObj));
            }

        }
        return resJson;
    }

    /**
     * 递归获取所有的key
     * @param jsonObject
     * @return
     */
    private static Set<String> getAllKey(JSONObject jsonObject) {
        Set<String> myset = new HashSet<>();
        Iterator<String> keys = jsonObject.keySet().iterator();// jsonObject.keys();
        while (keys.hasNext()) {
            String key = keys.next();
            myset.add(key);
            if (jsonObject.get(key) instanceof JSONObject) {
                JSONObject innerObject = (JSONObject) jsonObject.get(key);
                myset.addAll(getAllKey(innerObject));
            } else if (jsonObject.get(key) instanceof JSONArray) {
                JSONArray innerObject = (JSONArray) jsonObject.get(key);
                myset.addAll(getAllKey(innerObject));
            }
        }
        return myset;
    }

    /**
     * 递归获取所有的key
     * @param json1
     * @return
     */
    private static Set<String> getAllKey(JSONArray json1) {
        Set<String> myset = new HashSet<>();
        if (json1 != null ) {
            Iterator i1 = json1.iterator();
            while (i1.hasNext()) {
                Object key = i1.next();
                if (key instanceof  JSONObject) {
                    JSONObject innerObject = (JSONObject) key;
                    myset.addAll(getAllKey(innerObject));
                } else if (key instanceof JSONArray) {
                    JSONArray innerObject = (JSONArray) key;
                    myset.addAll(getAllKey(innerObject));
                }
            }
        }
        return myset;
    }


    /**
     * JSON数据扁平化
     * @param jsonObject
     * @return
     */
    private static JSONArray unfold(JSONObject jsonObject) {
        JSONArray r = unfoldJsonObject(jsonObject);
        return unfoldResult(r);
    }


    /**
     * JSON数据扁平化
     * @param jsonArray
     * @return
     */
    private static JSONArray unfold(JSONArray jsonArray) {
        JSONArray array = unfoldJsonArray(jsonArray, null, null);
        JSONArray resultList = new JSONArray();
        for (int i = 0; i < array.size(); i++) {
            JSONObject jsonObject = array.getJSONObject(i);
            jsonObject = unfastenJson(jsonObject.toJSONString());
            JSONArray r = unfold(jsonObject);
            resultList.addAll(r);
    }
        return resultList;
    }

    /**
     * JSON数据扁平化
     * @param jsonArray
     * @return
     */
    private static JSONArray unfoldResult(JSONArray jsonArray) {
        if (checkJSONChildHaveArray(jsonArray)) {
            JSONArray result = new JSONArray();
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject resultJson = jsonArray.getJSONObject(i);
                JSONArray child = unfoldJsonObject(resultJson);
                result.addAll(unfold(child));
            }
            return result;
        }
        return jsonArray;
    }


    /**
     * 将数组拆分，如果数组包含数组将被合并   [[1,2,3],[3,4,5]] = [1,2,3,3,4,5]
     * @param jsonArray
     * @param parent
     * @param key
     * @return
     */
    private static JSONArray unfoldJsonArray(List jsonArray, JSONObject parent, String key) {
        JSONArray resultList = new JSONArray();
        jsonArray.forEach(data -> {
            if (data instanceof List && ((List) data).size() > 0){
                resultList.addAll(unfoldJsonArray((List) data, parent, key));
            } else {
                if (parent == null) {
                    resultList.add(data);
                } else {
                    JSONObject result = JSONObject.parseObject(parent.toJSONString());
                    result.put(key, data);
                    resultList.add(result);
                }
            }
        });
        return resultList;
    }

    /**
     * 将子节点为数组的进行扩展
     * @param jsonObject
     * @return
     */
    private static JSONArray unfoldJsonObject(JSONObject jsonObject) {
        JSONArray resultList = new JSONArray();
        if (checkJSONChildHaveArray(jsonObject)) {
            for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
                String k = entry.getKey();
                Object data = entry.getValue();
                if (data instanceof List && ((List) data).size() > 0) {
                    JSONArray array = unfoldJsonArray((List) data, jsonObject, k);
                    array.forEach(charge -> {
                        JSONObject result = unfastenJson(((JSONObject) charge).toJSONString());
                        resultList.add(result);
                    });
                    break;
                }
            }
        } else {
            resultList.add(unfastenJson(jsonObject.toJSONString()));
        }
        return resultList;
    }

    /**
     * 扁平化JSON，数组节点不处理
     * @param json
     * @return
     */
    private static JSONObject unfastenJson(String json) {
        String replace = json.replace("_", "@-@");
        JsonFlattener jsonFlattener = new JsonFlattener(replace);
        jsonFlattener.withFlattenMode(FlattenMode.KEEP_ARRAYS);
        jsonFlattener.withSeparator('_');
        Map<String, Object> dataMap = jsonFlattener.flattenAsMap();
        String r = new JSONObject(dataMap).toJSONString().replace("@-@", "_");
        return JSONObject.parseObject(r);
    }

    /**
     * 确认JSON子节点是否还有数组
     * @param array
     * @return
     */
    private static boolean checkJSONChildHaveArray(JSONArray array) {
        for (int i = 0; i < array.size(); i++) {
            JSONObject jsonObject = array.getJSONObject(i);
            for (Object o : jsonObject.values()) {
                if (o instanceof List && ((List) o).size() > 0) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 确认JSON子节点是否还有数组
     * @param json
     * @return
     */
    private static boolean checkJSONChildHaveArray(JSONObject json) {
        for (Object o : json.values()) {
            if (o instanceof List && ((List) o).size() > 0) {
                return true;
            }
        }
        return false;
    }


    /**
     * 去重 只要JSON数据相同的则去除
     * @param jsonArray
     * @return
     */
    private static JSONArray set(JSONArray jsonArray) {
        List<String> set = new ArrayList<>();
        JSONArray result = new JSONArray();
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String s = jsonObject.toJSONString();
            if (!set.contains(s)) {
                result.add(jsonObject);
                set.add(s);
            }
        }
        return result;
    }