对象与json字符串 大驼峰小驼峰转换

package com.nuzar.fcms.framwork.route.convert;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.*;
import com.nuzar.fcms.framwork.route.Result;
import com.nuzar.fcms.framwork.route.PHResponse;
import org.springframework.util.StringUtils;

import java.lang.reflect.Type;
import java.util.List;
import java.util.Objects;

/**
 * <p>
 * 请求参数转换与响应报文解析的实现类
 * </p>
 *
 * 
 */
public class UpperCamelConvert<T, E> implements RequestConvert<T, String>, ResponseParse<E> {

    /**
     * 将请求参数转换成 JSON 字符串，字段命名风格从小驼峰 ==> 大驼峰
     *
     * @param request 用户定义 api 的入参
     * @return 字段名为大驼峰的 JSON 字符串
     */
    @Override
    public String convert(T request) {
        if (Objects.isNull(request)) {
            return "";
        }
        if (request instanceof String) {
            return request.toString();
        }
        return objToUpperCamelStr(request);
    }

    /**
     * {@link PHResponse}类型响应报文的解析，将{@link PHResponse#result1} JSON字符串转成{@link Result#getData()}的值，字段命名风格从大驼峰 ==> 小驼峰
     *
     * @param response       服务 api 返回的报文
     * @param returnDataType 用户定义 api  方法的{@link Result}中泛型的类型
     * @return 用户定义 api 方法的 {@link Result}
     */
    @Override
    public Result<E> parse(String response, Type returnDataType) {
        E returnData = null;
        PHResponse tosResponse = upperCamelStrToObj(response, PHResponse.class);
        if (!tosResponse.isSuccess()) {
            return Result.fail(tosResponse.getErrorInfo());
        }
        if (Objects.equals(returnDataType.getTypeName(), Void.class.getTypeName())) {
            return Result.success();
        }
        if (StringUtils.hasText(tosResponse.getResult1())) {
            returnData = upperCamelStrToObj(tosResponse.getResult1(), returnDataType);
        }
        return Result.success(returnData);

    }

    /**
     * 将对象转换为 JSON 字符串，字段命名风格从小驼峰 ==> 大驼峰
     *
     * @param source 待转换的对象
     * @return 字段名为大驼峰风格的 JSON 字符串
     */
    public static String objToUpperCamelStr(Object source) {
        JSON parse = JSONUtil.parse(source);
        if (parse instanceof JSONObject) {
            JSONObject upperCamelJsonObj = formatKey((JSONObject) parse, true);
            return upperCamelJsonObj.toString();

        } else if (parse instanceof JSONArray) {
            JSONArray upperCamelJsonArray = formatKey((JSONArray) parse, true);
            return upperCamelJsonArray.toString();
        }
        return parse.toJSONString(0);
    }

    /**
     * 将 JSON 字符串转换为指定类型对象，字段命名风格从大驼峰 ==> 小驼峰
     *
     * @param source 待转换的字符串
     * @param clazz  输出对象的class实例
     * @param <E>    输出对象的类型
     * @return 字段名为小驼峰风格的对象
     */
    public static <E> E upperCamelStrToObj(String source, Class<E> clazz) {
        JSONObject upperCamelObj = JSONUtil.parseObj(source);
        JSONObject lowerCamelObj = formatKey(upperCamelObj, false);
        return lowerCamelObj.toBean(clazz);
    }

    /**
     * 将 JSON 字符串转换为指定类型对象，字段命名风格从大驼峰 ==> 小驼峰
     *
     * @param source 待转换的字符串
     * @param type   泛型类型
     * @param <E>    输出对象的类型
     * @return 字段名为小驼峰风格的对象
     */
    public static <E> E upperCamelStrToObj(String source, Type type) {
        JSONObject upperCamelObj = JSONUtil.parseObj(source);
        JSONObject lowerCamelObj = formatKey(upperCamelObj, false);
        return lowerCamelObj.toBean(type);
    }

    /**
     * 将 JSON 对象转换为指定类型对象，字段命名风格从大驼峰 ==> 小驼峰
     *
     * @param source 待转换的JSON对象
     * @param type   泛型类型
     * @param <E>    输出对象的类型
     * @return 字段名为小驼峰风格的对象
     */
    public static <E> E upperCamelStrToObj(JSONObject source, Type type) {
        JSONObject lowerCamelObj = formatKey(source, false);
        return lowerCamelObj.toBean(type);
    }

    /**
     * 将 JSON 字符串转换为指定类型的列表，字段命名风格从大驼峰 ==> 小驼峰
     *
     * @param source 待转换的字符串
     * @param clazz  输出对象的class实例
     * @param <E>    输出对象的类型
     * @return 字段名为小驼峰风格的对象列表
     */
    public static <E> List<E> upperCamelStrToList(String source, Class<E> clazz) {
        JSONArray upperCamelArray = JSONUtil.parseArray(source);
        JSONArray lowerCamelArray = formatKey(upperCamelArray, false);
        return lowerCamelArray.toList(clazz);
    }


    /**
     * 转换为 大/小 驼峰命名风格的JSONObject
     *
     * @param source 等待转换的JSONObject
     * @param upper  true：首字母大写；false：首字母小写
     * @return 转换后的JSONObject
     */
    public static JSONObject formatKey(final JSONObject source, boolean upper) {
        JSONObject real = new JSONObject();
        for (String sourceKey : source.keySet()) {
            Object value = source.get(sourceKey);
            String realKey = sourceKey;
            //开头两个及两个以上字符为大写，为特殊名词 key ，不做处理
            boolean specialKey = realKey.length() > 1 && Character.isUpperCase(realKey.charAt(1)) && Character.isUpperCase(realKey.charAt(0));
            if (!specialKey) {
                // 下划线转换为驼峰格式
                realKey = sourceKey.contains("_") ? StrUtil.toCamelCase(sourceKey) : sourceKey;
                // 首字母大写或者小写
                realKey = upper ? StrUtil.upperFirst(realKey) : StrUtil.lowerFirst(realKey);
            }

            if (value instanceof JSONObject) {
                real.set(realKey, formatKey((JSONObject) value, upper));
            } else if (value instanceof JSONArray) {
                JSONArray arrayObj = formatKey((JSONArray) value, upper);
                real.set(realKey, arrayObj);
            } else {
                real.set(realKey, value);
            }
        }
        return real;
    }

    /**
     * 转换为 大/小 驼峰命名风格的JSONArray
     *
     * @param source 等待转换的JSONArray
     * @param upper  true：首字母大写；false：首字母小写
     * @return 转换后的JSONArray
     */
    public static JSONArray formatKey(final JSONArray source, boolean upper) {
        JSONArray real = new JSONArray();
        for (Object obj : source) {
            Object realItem = obj instanceof String ? obj : formatKey((JSONObject) obj, upper);
            real.add(realItem);
        }
        return real;
    }

}