Gson key “_“ 驼峰命名

import cn.hutool.core.date.DatePattern;
import com.google.common.reflect.TypeToken;
import com.google.gson.*;
import org.apache.commons.lang3.StringUtils;

import javax.validation.constraints.NotNull;
import java.lang.reflect.Type;
import java.util.*;

public class GsonUtil {

    private static Gson gson = null;

    static {

        gson = new GsonBuilder().setDateFormat(DatePattern.NORM_DATETIME_PATTERN)
                .registerTypeAdapter(new TypeToken<HashMap<String, Object>>() {
                }.getType(), (JsonDeserializer<HashMap<String, Object>>) (json, typeOfT, context) -> {
                    HashMap<String, Object> hashMap = new HashMap<>();
                    JsonObject jsonObject = json.getAsJsonObject();
                    Set<Map.Entry<String, JsonElement>> entrySet = jsonObject.entrySet();
                    for (Map.Entry<String, JsonElement> entry : entrySet) {
                        Object ot = entry.getValue();
                        if (ot instanceof JsonPrimitive) {
                            hashMap.put(entry.getKey(), ((JsonPrimitive) ot).getAsString());
                        } else {
                            hashMap.put(entry.getKey(), ot);
                        }
                    }
                    return hashMap;
                }).create();


    }


    public GsonUtil() {
        throw new InstantiationError("Must not instantiate this class");
    }

    /**
     * 将Obj转换成Json
     *
     * @param obj
     * @return
     */
    public static @NotNull String ToJson(Object obj) {
        return gson.toJson(obj);
    }


    public static JsonElement strToJsonElement(String str) {
        JsonElement jsonElement = JsonParser.parseString(str);
        return jsonElement;
    }

    public static JsonElement objectToJsonElement(Object obj) {
        String str = GsonUtil.ToJson(obj);
        JsonElement jsonElement = GsonUtil.strToJsonElement(str);
        return jsonElement;
    }


    /**
     * 将Json串转成对应的实体
     *
     * @param jsonStr
     * @param cls
     * @param <T>
     * @return
     */
    public static @NotNull <T> T jsonStrToClz(String jsonStr, Class<T> cls) {
        return gson.fromJson(jsonStr, cls);
    }


    /**
     * 将Json串转成对应的实体
     *
     * @param <T>
     * @param json
     * @param cls
     * @return
     */
    public static <T> T JsonElementToClz(JsonElement json, Class<T> cls) {
        return gson.fromJson(json, cls);
    }


    /**
     * Json转List
     *
     * @param jsonStr
     * @param cls
     * @param <T>
     * @return
     */
    public static @NotNull <T> List<T> jsonStrToList(String jsonStr, Class<T> cls) {

        return gson.fromJson(jsonStr, new TypeToken<List<T>>() {
        }.getType());
    }

    /**
     * 转成list
     * 解决泛型问题
     *
     * @param jsonStr json string
     * @param cls     object class
     * @param <T>     class type
     * @return object list
     */
    public static <T> List<T> jsonToBeanList(String jsonStr, Class<T> cls) {
        List<T> list = new ArrayList<>();
        JsonArray array = (new JsonParser()).parse(jsonStr).getAsJsonArray();
        Iterator<JsonElement> var4 = array.iterator();
        if (var4.hasNext()) {
            do {
                JsonElement elem = var4.next();
                list.add(gson.fromJson(elem, cls));
            } while (var4.hasNext());
        }
        return list;
    }


    /**
     * json string to set
     *
     * @param jsonStr json string
     * @return list
     */
    public static @NotNull <T> Set<T> jsonToSet(String jsonStr) {
        return gson.fromJson(jsonStr, (new TypeToken<Set<T>>() {
        }).getType());
    }

    /**
     * json string to class set
     *
     * @param jsonStr json string
     * @param cls     object class
     * @param <T>     class type
     * @return object list
     */
    public static <T> Set<T> jsonToBeanSet(String jsonStr, Class<T> cls) {
        Set<T> set = new HashSet<>();
        JsonArray array = (new JsonParser()).parse(jsonStr).getAsJsonArray();
        Iterator<JsonElement> var4 = array.iterator();
        if (var4.hasNext()) {
            do {
                JsonElement elem = var4.next();
                set.add(gson.fromJson(elem, cls));
            } while (var4.hasNext());
        }
        return set;
    }


    /**
     * 转成list中有map的
     *
     * @param jsonStr
     * @return
     */
    public static @NotNull <T> List<Map<String, T>> jsonToListMaps(String jsonStr) {
        return gson.fromJson(jsonStr, new TypeToken<List<Map<String, T>>>() {
        }.getType());
    }

    /**
     * 转成map的
     *
     * @param jsonStr
     * @return
     */
    public static @NotNull <T> Map<String, T> jsonToMaps(String jsonStr) {
        return gson.fromJson(jsonStr, new TypeToken<Map<String, T>>() {
        }.getType());
    }


    /**
     * map to object
     *
     * @param map map
     * @param <T> class type
     * @return map
     */
    public static @NotNull <E, T> T mapToBean(Map<String, E> map, Class<T> cls) {
        String gsonString = gson.toJson(map);
        return jsonStrToClz(gsonString, cls);
    }

    /**
     * object to map
     *
     * @param obj obj
     * @param <T> class type
     * @return map
     */
    public static @NotNull <T> Map<String, T> beanToMap(Object obj) {
        Type typeToken = new TypeToken<HashMap<String, Object>>() {
        }.getType();
        return gson.fromJson(gson.toJson(obj), typeToken);
    }

    /**
     * deep copy bean to another bean
     *
     * @param e   param object
     * @param cls result type
     * @param <E> param type
     * @param <T> result type
     * @return target bean response
     */
    public static @NotNull <E, T> T deepCopyBean(E e, Class<T> cls) {
        String gsonString = gson.toJson(e);
        return gson.fromJson(gsonString, cls);
    }


    /**
     * json key 驼峰命名
     *
     * @param jsonElement JsonObject
     * @return
     */
    public static JsonElement covertJsonObject(JsonElement jsonElement) {

        JsonObject json = new JsonObject();

        JsonObject jsonObject = jsonElement.getAsJsonObject();

        for (String key : jsonObject.keySet()) {
            JsonElement je = jsonObject.get(key);
            if (je.isJsonArray()) {
                je = covertJsonArray(je);
            } else if (je.isJsonObject()) {
                je = covertJsonObject(je);
            }


            key = GsonUtil.covertName(key);

            if (je.isJsonArray()) {
                json.add(key, je);
            } else if (je.isJsonObject()) {
                json.add(key, je);
            } else {
                boolean flag = je.toString().equals("\"\"") || je.toString().equals("null");
                if (!flag) {
                    json.add(key, je);
                }
            }
        }


        return json;
    }


    /**
     * json key 驼峰命名
     *
     * @param jsonElement JsonArray
     * @return
     */
    public static JsonElement covertJsonArray(JsonElement jsonElement) {
        JsonArray jsonArray = new JsonArray();
        for (JsonElement je : jsonElement.getAsJsonArray()) {
            if (je.isJsonArray()) {
                je = covertJsonArray(je);
            } else if (je.isJsonObject()) {
                je = GsonUtil.covertJsonObject(je);
            }
            jsonArray.add(je);
        }

        return jsonArray;
    }


    /**
     * "_" 驼峰命名
     *
     * @param para key
     * @return
     */
    public static String covertName(String para) {
        if (StringUtils.isEmpty(para)) {
            return "";
        }

        if (!para.contains("_")) {
            return para;
        }

        StringBuilder result = new StringBuilder();

        String[] split = para.split("_");

        for (String str : split) {
            if (result.length() == 0) {
                result.append(str.toLowerCase());
            } else {
                result.append(str.substring(0, 1).toUpperCase());
                result.append(str.substring(1).toLowerCase());
            }
        }

        return result.toString();
    }


}