Json串key按照字典顺序拼接

对于待签名字符串拼写规则：参数名的k按照字典顺序排列，每个参数(k-v)之间用“&”链接。如果v为普通元素集合，则其顺序按照给定的顺序排列；若果为复杂对象的集合，则集合元素的书序仍然为给定的顺序，但对象的参数按照字典顺序排列。

例如：

{
    "ff": [
        {
            "ffb": "ffb_11", 
            "ffa": "ffa_11"
        }, {
            "ffb": "ffb_22", 
            "ffa": [
                11, 
                22
            ]
        }
    ], 
    "aa": "aa_11", 
    "bb": 1000, 
    "cc": 2021.01, 
    "dd": {
        "ddz": "ddz_11", 
        "ddy": "ddy_11", 
        "ddx": {
            "xx": "xx_11", 
            "xy": "xy_11", 
            "xz": "xz_11"
            }
    }, 
    "ee": [
        "11", 
        "22"
    ]}

按上述规则生成的待签名字符串为：
aa=aa_11&bb=1000&cc=2021.01&dd={ddx={xx=xx_11&xy=xy_11&xz=xz_11}&ddy=ddy_11&ddz=ddz_11}&ee=[11,22]&ff=[{ffa=ffa_11&ffb=ffb_11},{ffa=[11,22]&ffb=ffb_22}]

  <dependency>
      <groupId>org.json</groupId>
      <artifactId>json</artifactId>
      <version>20171018</version>
  </dependency> 

示例代码：

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.*;
/**
 * @ClassName JsonUtil
 * @Description Json通用工具
 * @Date 2020-12-28 15:51
 * @Version 1.0
 */
public class JsonUtil {

public static String jsonObjConverSortStr(String jsonText) throws JSONException {
        System.out.println("### jsonText >> " + jsonText);
        StringBuffer returnBuStr = new StringBuffer();
        jsonObjParseRecur(returnBuStr, jsonText, true);
        return returnBuStr.toString();
    }

    private static void jsonObjParseRecur(StringBuffer returnBuStr, String jsonText, boolean isComplexObj) throws JSONException {
        JSONObject jsonObj = new JSONObject(jsonText);
        Iterator<String> keys = jsonObj.keys();

        // 局部key集合 并排序
        Set<String> keySetSort = new HashSet<>();
        while (keys.hasNext()) {
            String key = keys.next();
            keySetSort.add(key);
        }
        List<String> sortList = new ArrayList<>(keySetSort);
        Collections.sort(sortList);

        // 开始遍历 递归解析
        for (String key : sortList) {
//                System.out.println("### " + key + " >> " + jsonObj.get(key).toString());
            if (returnBuStr.length() == 0 || isComplexObj) {
                returnBuStr.append(key).append("=");
                isComplexObj = false;
            } else {
                returnBuStr.append("&").append(key).append("=");
            }

            StringBuffer sbSubArr = new StringBuffer();
            if (jsonObj.optJSONArray(key) instanceof JSONArray) { // 类型 - JSONArray
                JSONArray jsonArray = jsonObj.getJSONArray(key);
                returnBuStr.append("[");

                for (int i = 0; i < jsonArray.length(); i++) {
                    Object obj = jsonArray.get(i);

                    // JSONArray - 依然是数组元素
                    if (obj instanceof JSONArray) {
                        String jsonArrayObjString = obj.toString();
                        if (sbSubArr.length() == 0) {
                            sbSubArr.append(jsonArrayObjString);
                        } else {
                            sbSubArr.append(",").append(jsonArrayObjString);
                        }
                        continue;
                    }

                    // JSONArray - jsonObj复杂对象
                    if (obj instanceof JSONObject) {
                        JSONObject jsonObjTemp = jsonArray.getJSONObject(i);
                        if (i == 0) {
                            sbSubArr.append("{");
                            jsonObjParseRecur(sbSubArr, jsonObjTemp.toString(), true);
                            sbSubArr.append("}");
                        } else {
                            sbSubArr.append(",{");
                            jsonObjParseRecur(sbSubArr, jsonObjTemp.toString(), true);
                            sbSubArr.append("}");
                        }
                    }

                    // JSONArray - 普通元素
                    if (!(obj instanceof JSONArray) && !(obj instanceof JSONObject)) {
//                            System.out.println("### 既不是JSONObj又不是JSONArray, 须收集各个元素 ####");
                        if (sbSubArr.length() == 0) {
                            sbSubArr.append(obj.toString());
                        } else {
                            sbSubArr.append(",").append(obj.toString());
                        }
                    }
                }
                returnBuStr.append(sbSubArr);
                returnBuStr.append("]");
            } else if (jsonObj.optJSONObject(key) instanceof JSONObject) { // 类型 - JSONObject
                returnBuStr.append("{");
                jsonObjParseRecur(returnBuStr, jsonObj.optJSONObject(key).toString(), true);
                returnBuStr.append("}");

            } else { // 以上两种情况都不是的情况下，则为普通元素
//                    System.out.println("### key >> " + key + ", value >> " + jsonObj.get(key).toString() + ", 既不是JSONObj又不是JSONArray ####");
                returnBuStr.append(jsonObj.get(key).toString());
            }
        }
//        System.out.println("### jsonStrBu >> " + returnBuStr.toString());
    }
}