JSON工具類（FastJson,Gson,Jackson）

最近看到很多微信公衆號推送的文章裏面都提到放棄使用FastJson，要更換其他的兩個可以參考下面的封裝，僅供參考，如要使用請自測後使用，

一：FastJson工具類：

FastJsonUtil代碼如下：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author 哲思小輝
 * @version 1.0.0
 * @ClassName FastJsonUtil.java
 * @Description fastJson工具類
 * @Param
 * @createTime 2020年06月25日 16:58:00
 */
@Slf4j
public class FastJsonUtil {
    private FastJsonUtil() {
    }

    /**
     * 轉成json 字符串 （不保留格式，換行、空格都會去掉）
     *
     * @param object
     * @return
     */
    public static String toJson(Object object) {
        if (object == null) {
            return null;
        }
        if (object instanceof String) {
            return String.valueOf(JSON.parse(object.toString()));
        }
        return JSON.toJSONString(object);
    }

    /**
     * 轉成json 字符串(保留格式)
     *
     * @param object
     * @return
     */
    public static String toJsonString(Object object) {
        if (object == null) {
            return null;
        }
        return String.valueOf(JSON.parse(JSON.toJSONString(object)));
    }

    /**
     * 轉成Map<String,Object>
     *
     * @param object
     * @return
     */
    public static Map<String, Object> toMap(Object object) {
        String text = toJson(object);
        Map<String, Object> map = null;
        if (text != null) {
            map = JSON.parseObject(text, Map.class);
        }
        return map;
    }

    /**
     * 轉成Map<String,String>
     *
     * @param object
     * @return
     */
    public static Map<String, String> toMapString(Object object) {
        String text = toJson(object);
        Map<String, String> map = null;
        if (text != null) {
            map = JSON.parseObject(text, new TypeReference<Map<String, String>>() {
            });
        }
        return map;
    }

    /**
     * 轉成Map<String,T>
     *
     * @param object
     * @return
     */
    public static <T> Map<String, T> toMap(Object object, Class<T> clzz) {
        String text = toJson(object);
        Map<String, T> map = null;
        if (text != null) {
            map = JSON.parseObject(text, new ParameterizedTypeMap(clzz));
        }
        return map;
    }


    /**
     * 轉成List <String>
     *
     * @param object
     * @return
     */
    public static List toList(Object object) {
        String text = toJson(object);
        List list = null;
        if (text != null) {
            list = JSON.parseObject(text, List.class);
        }
        return list;
    }

    /**
     * 轉成List<T>
     *
     * @param object
     * @param clzz
     * @param <T>
     * @return
     */
    public static <T> List<T> toList(Object object, Class<T> clzz) {
        String text = toJson(object);
        return JSON.parseArray(text, clzz);
    }

    /**
     * 轉成JavaBean
     *
     * @param object
     * @param clzz
     * @param <T>
     * @return
     */
    public static <T> T toJavaBean(Object object, Class<T> clzz) {
        String text = toJson(object);
        T t = null;
        if (text != null) {
            t = JSON.parseObject(text, clzz);
        }
        return t;
    }

    /**
     * 轉成Set
     *
     * @param object
     * @return
     */
    public static Set toSet(Object object) {
        String text = toJson(object);
        Set set = null;
        if (text != null) {
            set = JSON.parseObject(text, Set.class);
        }
        return set;
    }

    /**
     * 轉成Set<T>
     *
     * @param object
     * @return
     */
    public static <T> Set<T> toSet(Object object, Class<T> clzz) {
        String text = toJson(object);
        Set<T> set = null;
        if (text != null) {
            set = JSON.parseObject(text, new ParameterizedTypeSet(clzz));
        }
        return set;
    }


    private static class ParameterizedTypeSet implements ParameterizedType {
        Class clazz;

        public ParameterizedTypeSet(Class clz) {
            clazz = clz;
        }

        @Override
        public Type[] getActualTypeArguments() {
            return new Type[]{clazz};
        }

        @Override
        public Type getRawType() {
            return Set.class;
        }

        @Override
        public Type getOwnerType() {
            return null;
        }
    }


    private static class ParameterizedTypeMap implements ParameterizedType {
        Class clazz;

        public ParameterizedTypeMap(Class clz) {
            clazz = clz;
        }

        @Override
        public Type[] getActualTypeArguments() {
            return new Type[]{String.class, clazz};
        }

        @Override
        public Type getRawType() {
            return Map.class;
        }

        @Override
        public Type getOwnerType() {
            return null;
        }
    }


}

二：GsonJson工具類：

GsonJsonUtil代碼：

import com.google.gson.*;
import com.google.gson.reflect.TypeToken;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author 哲思小輝
 * @version 1.0.0
 * @ClassName GsonJsonUtil.java
 * @Description Gson格式化工具
 * @Param
 * @createTime 2020年05月13日 16:40:00
 */
@Slf4j
public class GsonJsonUtil {
    private GsonJsonUtil() {
    }

    private static final Gson gson = new GsonBuilder()
            .enableComplexMapKeySerialization() //當Map的key爲複雜對象時,需要開啓該方法
            .serializeNulls() //當字段值爲空或null時，依然對該字段進行轉換
            .setDateFormat("yyyy-MM-dd HH:mm:ss:SSS") //時間轉化爲特定格式
            .disableHtmlEscaping() //防止特殊字符出現亂碼
            .registerTypeAdapter(Double.class, (JsonSerializer<Double>) (src, typeOfSrc, context) -> {
                if (src == src.longValue()) {
                    return new JsonPrimitive(src.longValue());
                }
                return new JsonPrimitive(src);
            }).create();


    /**
     * 轉成json 字符串 如果是字符串就直接返回原字符串
     *
     * @param object
     * @return
     */
    public static String toJson(Object object) {
        String jsonStr = null;
        try {
            if (object instanceof String) {
                return (String) object;
            }
            jsonStr = gson.toJson(object);
        } catch (Exception e) {
            log.error("json數據格式化報異常{}", e);
        }
        return jsonStr;
    }


    /**
     * 轉成Map<String,T>
     *
     * @param object
     * @return
     */
    public static <T> Map<String, T> toMap(Object object, Class<T> clzz) {
        String text = toJson(object);
        Map<String, T> map = null;
        if (text != null) {
            try {
                map = gson.fromJson(text, new ParameterizedTypeMap(clzz));
            } catch (Exception e) {
                log.error("json字符串轉Map<String, T>異常：{}", e);
            }
        }
        return map;
    }

    /**
     * 轉成Map<String,JsonObject>
     *
     * @param object
     * @return
     */
    public static Map<String, JsonObject> toMap(Object object) {
        String text = toJson(object);
        Map<String, JsonObject> map = null;
        if (text != null) {
            try {
                map = gson.fromJson(text, new TypeToken<Map<String, JsonObject>>() {
                }.getType());
            } catch (Exception e) {
                log.error("json字符串轉Map<String, JsonObject>異常：{}", e);
            }
        }
        return map;
    }

    /**
     * 轉成List 裏面默認數據類型是LinkedTreeMap所以直接轉成JsonObject類型
     *
     * @param object
     * @return
     */
    public static List<JsonObject> toList(Object object) {
        String text = toJson(object);
        List<JsonObject> list = null;
        if (text != null) {
            try {
                list = gson.fromJson(text, new TypeToken<List<JsonObject>>() {
                }.getType());
            } catch (Exception e) {
                log.error("json字符串轉List<JsonObject>異常：{}", e);
            }
        }
        return list;
    }

    /**
     * 轉成List<T>
     *
     * @param object
     * @param clzz
     * @param <T>
     * @return
     */
    public static <T> List<T> toList(Object object, Class<T> clzz) {
        String text = toJson(object);
        List<T> list = null;
        if (text != null) {
            try {
                list = gson.fromJson(text, new ParameterizedTypeList(clzz));
            } catch (Exception e) {
                log.error("json字符串轉List<T>異常：{}", e);
            }
        }
        return list;
    }

    /**
     * 轉成JavaBean
     *
     * @param object
     * @param clzz
     * @param <T>
     * @return
     */
    public static <T> T toJavaBean(Object object, Class<T> clzz) {
        String text = toJson(object);
        T t = null;
        if (text != null && clzz != null) {
            try {
                t = gson.fromJson(text, clzz);
            } catch (Exception e) {
                log.error("json字符串轉T異常：{}", e);
            }
        }
        return t;
    }

    /**
     * 轉成Set<JsonObject>
     *
     * @param object
     * @return
     */
    public static Set<JsonObject> toSet(Object object) {
        String text = toJson(object);
        Set<JsonObject> set = null;
        if (text != null) {
            try {
                set = gson.fromJson(text, new TypeToken<Set<JsonObject>>() {
                }.getType());
            } catch (Exception e) {
                log.error("json字符串轉Set<JsonObject>異常：{}", e);
            }
        }
        return set;
    }

    /**
     * 轉成Set<T>
     *
     * @param object
     * @param clzz
     * @return
     */
    public static <T> Set<T> toSet(Object object, Class<T> clzz) {
        String text = toJson(object);
        Set<T> set = null;
        if (text != null) {
            try {
                set = gson.fromJson(text, new ParameterizedTypeSet(clzz));
            } catch (Exception e) {
                log.error("json字符串轉Set<T>異常：{}", e);
            }
        }
        return set;
    }


    private static class ParameterizedTypeList implements ParameterizedType {
        Class clazz;

        public ParameterizedTypeList(Class clz) {
            clazz = clz;
        }

        @Override
        public Type[] getActualTypeArguments() {
            return new Type[]{clazz};
        }

        @Override
        public Type getRawType() {
            return List.class;
        }

        @Override
        public Type getOwnerType() {
            return null;
        }
    }

    private static class ParameterizedTypeSet implements ParameterizedType {
        Class clazz;

        public ParameterizedTypeSet(Class clz) {
            clazz = clz;
        }

        @Override
        public Type[] getActualTypeArguments() {
            return new Type[]{clazz};
        }

        @Override
        public Type getRawType() {
            return Set.class;
        }

        @Override
        public Type getOwnerType() {
            return null;
        }
    }


    private static class ParameterizedTypeMap implements ParameterizedType {
        Class clazz;

        public ParameterizedTypeMap(Class clz) {
            clazz = clz;
        }

        @Override
        public Type[] getActualTypeArguments() {
            return new Type[]{String.class, clazz};
        }

        @Override
        public Type getRawType() {
            return Map.class;
        }

        @Override
        public Type getOwnerType() {
            return null;
        }
    }
}

三、Jackson工具類：

JackSonJsonUtil代碼如下：

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import lombok.extern.slf4j.Slf4j;

import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author 哲思小輝
 * @version 1.0.0
 * @ClassName JackSonJsonUtil.java
 * @Description Json工具類
 * @Param
 * @createTime 2020年03月25日 16:58:00
 */
@Slf4j
public class JackSonJsonUtil {
    private JackSonJsonUtil() {
    }

    private static final ObjectMapper objectMapper = new ObjectMapper();

    static{
        //序列化的時候序列對象的所有屬性
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        //取消時間的轉化格式,默認是時間戳,可以取消,同時需要設置要表現的時間格式
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));


        // 對於空的對象轉json的時候不拋出錯誤
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

        // 禁用遇到未知屬性拋出異常
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT);

        objectMapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
        objectMapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES);
        objectMapper.enable(JsonParser.Feature.ALLOW_SINGLE_QUOTES);

    }

    /**
     * 轉成json 字符串 （不保留格式，換行、空格都會去掉）
     *
     * @param object
     * @return
     */
    public static String toJson(Object object) {
        String jsonStr = null;
        try {
            // 針對的是轉義字符串
            if (object instanceof String) {
                JsonNode jsonNode = objectMapper.readTree(String.valueOf(object));
                jsonStr = objectMapper.writeValueAsString(jsonNode);
            } else {
                jsonStr = objectMapper.writeValueAsString(object);
            }
        } catch (JsonProcessingException e) {
            log.error("json數據格式化報異常{}", e);
        }

        return jsonStr;
    }


    /**
     * 轉成Map<String,Object>
     *
     * @param object
     * @return
     */
    public static Map<String, Object> toMap(Object object) {
        String text = toJson(object);
        Map<String, Object> map = null;
        if (text != null) {
            try {
                map = objectMapper.readValue(text, Map.class);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉Map異常：{}", e);
            }
        }
        return map;
    }

    /**
     * 轉成Map<String,T>
     *
     * @param object
     * @return
     */
    public static <T> Map<String, T> toMap(Object object, Class<T> clzz) {
        String text = toJson(object);
        Map<String, T> map = null;
        if (text != null && clzz != null) {
            try {
                JavaType javaType = objectMapper.getTypeFactory().constructMapType(Map.class, String.class, clzz);
                map = objectMapper.readValue(text, javaType);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉Map異常：{}", e);
            }
        }
        return map;
    }

    /**
     * 轉成List <String>
     *
     * @param object
     * @return
     */
    public static List toList(Object object) {
        String text = toJson(object);
        List list = null;
        if (text != null ) {
            try {
                list = objectMapper.readValue(text, List.class);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉List異常：{}", e);
            }
        }
        return list;
    }

    /**
     * 轉成List<T>
     *
     * @param object
     * @param clzz
     * @param <T>
     * @return
     */
    public static <T> List<T> toList(Object object, Class<T> clzz) {
        String text = toJson(object);
        List<T> list = null;
        if (text != null) {
            try {
                JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, clzz);
                list = objectMapper.readValue(text, javaType);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉List<T>異常：{}", e);
            }
        }
        return list;
    }

    /**
     * 轉成JavaBean
     *
     * @param object
     * @param clzz
     * @param <T>
     * @return
     */
    public static <T> T toJavaBean(Object object, Class<T> clzz) {
        String text = toJson(object);
        T t = null;
        if (text != null) {
            try {
                t = objectMapper.readValue(text, clzz);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉Java實體異常：{}", e);
            }
        }
        return t;
    }

    /**
     * 轉成Set
     *
     * @param object
     * @return
     */
    public static Set toSet(Object object) {
        String text = toJson(object);
        Set set = null;
        if (text != null) {
            try {
                set = objectMapper.readValue(text, Set.class);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉Set異常：{}", e);
            }
        }
        return set;
    }

    /**
     * 轉成Set<T>
     *
     * @param object
     * @param clzz
     * @return
     */
    public static <T> Set<T> toSet(Object object, Class<T> clzz) {
        String text = toJson(object);
        Set<T> set = null;
        if (text != null) {
            try {
                JavaType javaType = objectMapper.getTypeFactory().constructCollectionLikeType(Set.class, clzz);
                set = objectMapper.readValue(text, javaType);
            } catch (JsonProcessingException e) {
                log.error("json字符串轉Set<T>異常：{}", e);
            }
        }
        return set;
    }

}

文章同時會更新到公衆號，覺得對你有幫助或者有用的可以關注一下哦

JSON工具類（FastJson,Gson,Jackson）

一：FastJson工具類：

二：GsonJson工具類：

Java使用證書ssl連接域服務器設置

Disruptor購物案例（秒殺）

knife4j（swagger的升級版）使用

HttpServletResponse和 ResponseEntity下載文件預覽圖片

Spring的事務使用

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結