JSONUtils

一，引入依赖

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.2</version>
</dependency>

二，工具类

package cn.codeduck.pgsql;

import com.google.gson.*;
import com.google.gson.internal.LinkedTreeMap;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;

import java.io.IOException;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 处理json
 */
public class JsonUtil {

    private static Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss")
            .registerTypeAdapter(new TypeToken<Map<String, Object>>() {}.getType(), new MapTypeAdapter())
            .registerTypeAdapter(Integer.class, new IntegerAdapter())
            .registerTypeAdapter(Long.class, new LongAdapter())
            .registerTypeAdapter(BigDecimal.class, new BigDecimalAdapter())
            .create();

    /**
     * 对象转换成json字符串
     *
     * @param src the src
     * @return string string
     */
    public static String toJson(Object src) {
        return gson.toJson(src);
    }

    /**
     * json字符串转换成对象
     *
     * @param <T>      the type parameter
     * @param json     the json
     * @param classOfT the class of t
     * @return t t
     */
    public static <T> T fromJson(String json, Class<T> classOfT) {
        return gson.fromJson(json, classOfT);
    }

    /**
     * json字符串转换成对象(集合)
     *
     * @param <T>     the type parameter
     * @param json    the json
     * @param typeOfT the type of t
     * @return t t
     */
    public static <T> T fromJson(String json, Type typeOfT){
        return gson.fromJson(json, typeOfT);
    }

}

class IntegerAdapter implements JsonSerializer, JsonDeserializer {
    @Override
    public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (json.getAsString().equals("") || json.getAsString().equals("null")) {
            return null;
        }

        return json.getAsInt();
    }
    @Override
    public JsonElement serialize(Object src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive((Integer) src);
    }
}

class LongAdapter implements JsonSerializer, JsonDeserializer {
    @Override
    public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (json.getAsString().equals("") || json.getAsString().equals("null")) {
            return null;
        }
        return json.getAsLong();
    }
    @Override
    public JsonElement serialize(Object src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive((Long) src);
    }
}

class BigDecimalAdapter implements JsonSerializer, JsonDeserializer {
    @Override
    public BigDecimal deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (json.getAsString().equals("") || json.getAsString().equals("null")) {
            return null;
        }
        return json.getAsBigDecimal();
    }
    @Override
    public JsonElement serialize(Object src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive((BigDecimal) src);
    }
}

class MapTypeAdapter extends TypeAdapter<Object> {
    @Override
    public Object read(JsonReader in) throws IOException {
        JsonToken token = in.peek();
        switch (token) {
            case BEGIN_ARRAY:
                List<Object> list = new ArrayList<>();
                in.beginArray();
                while (in.hasNext()) {
                    list.add(read(in));
                }
                in.endArray();
                return list;

            case BEGIN_OBJECT:
                Map<String, Object> map = new LinkedTreeMap<>();
                in.beginObject();
                while (in.hasNext()) {
                    map.put(in.nextName(), read(in));
                }
                in.endObject();
                return map;

            case STRING:
                return in.nextString();

            case NUMBER:
                /**
                 * 改写数字的处理逻辑，将数字值分为整型与浮点型。
                 */
                Double dbNum = in.nextDouble();

                // 数字超过long的最大值，返回浮点类型
                if (dbNum > Long.MAX_VALUE) {
                    return dbNum;
                }

                // 判断数字是否为整数值
                Long lngNum = dbNum.longValue();
                if (BigDecimal.valueOf(lngNum).compareTo(BigDecimal.valueOf(dbNum)) == 0) {
                    return lngNum;
                } else {
                    return BigDecimal.valueOf(dbNum);
                }

            case BOOLEAN:
                return in.nextBoolean();

            case NULL:
                in.nextNull();
                return null;

            default:
                throw new IllegalStateException();
        }
    }
    @Override
    public void write(JsonWriter out, Object value) throws IOException {
        // 序列化无需实现
    }
}