问题背景

上一个篇章讲了json字符串的递归取值，这个篇章讲一下递归组装json字符串，但只能是一个思路，因为组装逻辑需要根据业务的本身需求来指定，但万卷不离其中
注意事项：

这个只能提供代码思路

包含JSONObject和JSONArray的json字符串进行递归取值，附源码（一）

包含JSONObject和JSONArray的json字符串进行递归组装思路（二）

json字符串进行递归组装

1 先判断第一层的value是否为JSONObject还是JSONArray，都不是那么就是普通的数据类型
2 如果是普通数据类型那么直接生成一个JSONObject
3 不是普通数据类型，根据为JSONObject还是JSONArray进行递归，中间可能又有JSONObject和JSONArray交叉递归

	//递归JSONObject，lastField为Json字符串的上一级
    private JSONObject recurseJSONObject(HashMap<String, Object> lineMap, field lastField, List<field> fields) {
        //初始化一个JSONObject
		JSONObject leaf = new JSONObject();
        if (CollectionUtils.isNotEmpty(fields)) {
            for (int i = 0; i < fields.size(); i++) {
                Field field = fields.get(i);
                if (field == null || field.getCode() == null) {
                    continue;
                }
                if (Constants.InputParam.equals(field.getIoType())) {
					//匹配出当前的field的上一级为lastField就可以继续组装
                    if (lastField.getId().equals(field.getParentId())) {
                        if (Constants.LEAF.equals(field.getIsLeaf())) {
                            if (!lineMap.containsKey(field.getCode()) || lineMap.get(field.getCode()) == null) {
                                continue;
                            }
							//如果包含就组装为一个JSONObject里面的键值对，这里的value为String或者Number
                            leaf.put(field.getCode(), lineMap.get(field.getCode()));
                        } else {
                            if (Constants.JSONOBJECT.equals(field.getDataType())) {
								//value为JSONObject
                                leaf.put(field.getCode(), recurseJSONObject(lineMap, field, dataxItemFields));
                            } else {
								//value为JSONArray
                                leaf.put(field.getCode(), recurseJSONArray(lineMap, field, dataxItemFields));
                            }
                        }
                    }
                }
            }
        }
        return leaf;
    }
    
    //递归JSONArray，lastField为Json字符串的上一级
    private JSONArray recurseJSONArray(HashMap<String, Object> lineMap, field lastField, List<field> fields) {
        JSONArray leaf = new JSONArray();
        JSONObject jsonObject = new JSONObject();
        if (CollectionUtils.isNotEmpty(fields)) {
            for (int i = 0; i < fields.size(); i++) {
                Field field = fields.get(i);
                if (field == null || field.getCode() == null) {
                    continue;
                }
                if (Constants.InputParam.equals(field.getIoType())) {
					//匹配出当前的field的上一级为lastField就可以继续组装
                    if (lastField.getId().equals(field.getParentId())) {
                        if (Constants.LEAF.equals(field.getIsLeaf())) {
                            if (!lineMap.containsKey(field.getCode()) || lineMap.get(field.getCode()) == null) {
                                continue;
                            }
							//如果包含就组装为一个JSONObject里面的键值对，这里的value为String或者Number
                            jsonObject.put(field.getCode(), lineMap.get(field.getCode()));
                            log.info("jsonObjectArr: {}", jsonObject);
                        } else {
                            if (Constants.JSONOBJECT.equals(field.getDataType())) {
								//value为JSONObject
                                jsonObject.put(field.getCode(),recurseJSONObject(lineMap, field, fields));
                            } else {
								//value为JSONArray
                                jsonObject.put(field.getCode(), recurseJSONArray(lineMap, field, fields));
                                log.info("arr: {}", jsonObject);
                            }
                        }
                    }
                }
            }
            if (!jsonObject.isEmpty()) {
                leaf.add(jsonObject);
            }
        }
        return leaf;
    }



    //每个入参map都进行一次递归
	//inputList需要组装的参数，每一个HashMap<String, Object>就是组装一个JSONObject
	//fields数据库里面定义组装JSONObject定的规则，所以这个是根据不同项目的需求设置的
    private List<JSONObject> queryParam(List<HashMap<String, Object>> inputList, List<field> fields) {

        log.info(("Begin queryParam"));
        List<JSONObject> jsonObjectList = Lists.newArrayList();
		//使用HashMap<String, Object>循环组装每一个JSONObject
        for (HashMap<String, Object> inputMap : inputList) {
			//如果当前inputMap为null，跳过这条一个
            if (inputMap == null || inputMap.isEmpty()) {
                continue;
            }
			//初始化组装的JSONObject
            JSONObject jsonObject = new JSONObject();
			//使用在fields里面我们需要的字段
            for (int j = 0; j < fields.size(); j++) {
                Field field = fields.get(j);
				//表里面getCode是我需要的关键字，如果没有跳过
                if (field == null || field.getCode() == null) {
                    continue;
                }
                //先判断是否为入参，再判断是否为parentId==0，最后判断是否为叶子节点，如果为叶子节点直接加入对象
                if (Constants.InputParam.equals(field.getIoType())) {
                    if (field.getParentId().intValue() == Constants.ParentId) {
                        if (Constants.LEAF.equals(field.getIsLeaf())) {
							//需要匹配输入参数中是否包含我需要的字段，如果包含就组装为一个JSONObject里面的键值对，这里的value为String或者Number
                            if (inputMap.containsKey(field.getCode())) {
                                jsonObject.put(field.getCode(), inputMap.get(field.getCode()));
                            }
                        } else {
							//getDataType判断value为JSONObject还是JSONArray
                            if (Constants.JSONOBJECT.equals(field.getDataType())) {
								//value为JSONObject
                                jsonObject.put(field.getCode(), recurseJSONObject(inputMap, field, fields));
                            } else {
								//value为JSONArray
                                jsonObject.put(field.getCode(), recurseJSONArray(inputMap, field, fields));
                            }
                        }
                    }
                }
            }
			//每个组装后的jsonObject不为空就加入List
            if (!jsonObject.isEmpty()) {
                jsonObjectList.add(jsonObject);
            }
		}
		return jsonObjectList;
	}