多层级对象转一层Map

服务端之间的调用，如果涉及参数校验，就需要把json传参拍平，增加到加签验签中。

加签验签，一方面是校验请求的合法性，另一方方面是校验传参的完整性，以及传参没有被篡改。

本文提供json拍平的方法，适用于任何传参类型。如果传参中有字节流，转为Base64字符串参与加签验签。

ObjectToMap

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 多层级对象转Map
 * @date 2023/8/18 11:55 AM
 */
@Slf4j
public class ObjectToMap {

    /**
     * 使用Gson拍平对象，即当有多层json嵌套时，可以把多层的json拍平为一层
     *
     * @param object 需要拍平的对象，必须符合json格式
     * @param parentKey 父级key
     * @return 拍平后的map
     */
    public static Map<String, Object> parseJson2Map(Object object, String parentKey) {

        // 定义一个map用来存放拍平后的数据
        Map<String, Object> map = new HashMap<>();

        // 如果对象为空则直接返回
        if (ObjectUtils.isEmpty(object)) {
            return map;
        }

        // object转为JSONObject对象
        JsonObject jsonObject = new Gson().fromJson(object.toString(), JsonObject.class);

        // 遍历JSONObject对象
        for (Map.Entry<String, JsonElement> objectItem : jsonObject.entrySet()) {
            // 获取key
            String key = objectItem.getKey();
            // 获取value
            JsonElement value = objectItem.getValue();

            // 定义key
            String fullKey =
                    (StringUtils.isBlank(parentKey)) ? key : (parentKey.trim() + "." + key);

            // 判断对象的类型，如果是空类型，按照空类型处理
            if (value.isJsonNull()) {
                map.put(fullKey, null);
            }

            // 如果是JsonObject对象则递归处理
            else if (value.isJsonObject()) {
                // 获取结果，并添加到map
                map.putAll(parseJson2Map(value.getAsJsonObject(), fullKey));
            }

            // 如果是JsonArray数组则迭代，然后进行递归
            else if (value.isJsonArray()) {
                // 获取JSON数组
                JsonArray jsonArray = value.getAsJsonArray();
                // 初始迭代器
                Iterator<JsonElement> iterator = jsonArray.iterator();
                // 初始化索引
                int index = 0;
                // 遍历
                while (iterator.hasNext()) {
                    // 获取元素
                    JsonElement jsonElementTemp = iterator.next();
                    // fullKey增加列表索引编号
                    String fullIndexKey = fullKey + "." + index;

                    // 如果不是JSON对象则直接添加到map
                    if (jsonElementTemp.isJsonPrimitive()) {
                        // 添加到map
                        map.put(fullIndexKey, jsonElementTemp);
                    }
                    // 结果为null，单独判断，添加到map
                    else if (jsonElementTemp.isJsonNull()) {
                        map.put(fullIndexKey, null);
                    }
                    // 如果是JSON对象则递归处理
                    else {
                        // 递归调用
                        // 获取结果，并添加到map
                        map.putAll(parseJson2Map(jsonElementTemp, fullIndexKey));
                    }

                    // 索引自增
                    index++;
                }
            }

            // 如果是JsonPrimitive对象则获取当中的值
            else if (value.isJsonPrimitive()) {
                map.put(fullKey, value);
            }
        }

        // 返回结果
        return map;
    }
}

使用

    // Json字符串转json对象
    Object object = JSON.parseObject(jsonStr);
// 调用方法拍平Json对象
    Map<String, Object> map = ObjectToMap.parseJson2Map(object, null);
// 上一个方法全部返回对象，需要转换为什么，下一次继续处理。二者解耦
    // Map转换
    Map<String, String> finalMap = objectMapToStringMap(map);


/**
 * ObjectMap转StringMap
 *
 * <p>值为Object的Map转换为值为String的Map
 *
 * @param objectMap ObjectMap
 * @return StringMap
 */
public static Map<String, String> objectMapToStringMap(Map<String, Object> objectMap) {

    // 定义返回值
    Map<String, String> stringMap = new HashMap<>((objectMap.size() + 1));

    // 初始化迭代器，遍历ObjectMap
    Iterator<Map.Entry<String, Object>> iterator = objectMap.entrySet().iterator();
    while (iterator.hasNext()) {
        // 获取下一个元素
        Map.Entry<String, Object> next = iterator.next();

        // 判断是否为空
        if (ObjectUtils.isEmpty(next.getValue())) {

            // 将ObjectMap转换为StringMap
            stringMap.put(next.getKey(), null);

        } else if (((JsonPrimitive) next.getValue()).isNumber()) {

            // 去除小数点后的值
            String number =
                    new BigDecimal(((JsonPrimitive) next.getValue()).getAsString())
                            .stripTrailingZeros()
                            .toPlainString();
            // 将ObjectMap转换为StringMap
            stringMap.put(next.getKey(), number);

        } else {

            // 将ObjectMap转换为StringMap
            stringMap.put(next.getKey(), ((JsonPrimitive) next.getValue()).getAsString());
        }
    }

    // 返回StringMap
    return stringMap;
}