SpringBoot中Json工具類的實現(xiàn)

更新時間：2024年10月31日 09:00:46 作者：你家寶寶

本文介紹在Java項目中實現(xiàn)一個JSON工具類,支持對象與JSON字符串之間的轉(zhuǎn)換,并提供依賴和代碼示例便于直接應(yīng)用,感興趣的可以了解一下

前言

在日常開發(fā)java項目的時候，總能遇到各種關(guān)于json的業(yè)務(wù)處理。
包括對象轉(zhuǎn)json，json轉(zhuǎn)對象，轉(zhuǎn)map等情況。

本文就實現(xiàn)一個json工具類，來處理這些業(yè)務(wù)場景。開發(fā)項目時，可以直接粘貼依賴和代碼到你的項目中使用。

正文

1、依賴引入

項目中需要先引入json對應(yīng)的包。

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.2</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-jsr310</artifactId>
  <version>2.17.2</version>
</dependency>

2、JsonUtil.java

package com.pine.common.util.json;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.regex.Pattern;

/**
 * json工具
 *
 * @author pine manage
 * @since 2024-10-30
 */
public class JsonUtil {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private static final String DEFAULT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 正則表達(dá)式，用于判斷是否是json串(只判斷是否是{}, []的結(jié)構(gòu))
     */
    private static final Pattern PREPARE_JSON_PATTERN = Pattern.compile("^\\{.*\\}$|^\\[.*]$");

    public JsonUtil() {
    }

    /**
     * json轉(zhuǎn)對象
     *
     * @param json        字符串
     * @param clazz       對象類型
     * @param ignoreError 是否忽略錯誤，true時返回null，false時拋出異常
     * @param <T>         對象泛型類型
     * @return 對象
     */
    public static <T> T json2Object(String json, Class<T> clazz, boolean ignoreError) {
        try {
            return OBJECT_MAPPER.readValue(json, clazz);
        } catch (IOException e) {
            if (ignoreError) {
                return null;
            }
            throw new RuntimeException("解析json錯誤");
        }
    }

    /**
     * json轉(zhuǎn)對象
     *
     * @param json  字符串
     * @param clazz 對象類型
     * @param <T>   對象泛型類型
     * @return 對象
     */
    public static <T> T json2Object(String json, Class<T> clazz) {
        return json2Object(json, clazz, false);
    }


    /**
     * json轉(zhuǎn)對象(忽略錯誤，出錯時返回null)
     *
     * @param json  json字符串
     * @param clazz 類型
     * @param <T>   對象泛型類型
     * @return 對象
     */
    public static <T> T json2ObjectIgnoreError(String json, Class<T> clazz) {
        return json2Object(json, clazz, true);
    }

    /**
     * json轉(zhuǎn)對象
     *
     * @param json 字符串
     * @param tr   類型封裝
     * @param <T>  對象泛型類型
     * @return 對象
     */
    public static <T> T json2Object(String json, TypeRef<T> tr) {
        try {
            return OBJECT_MAPPER.readValue(json, tr.getType());
        } catch (IOException e) {
            throw new RuntimeException("解析json錯誤");
        }
    }

    /**
     * json轉(zhuǎn)json樹
     *
     * @param json json字符串
     * @return json樹
     */
    public static JsonNode json2Tree(String json) {
        try {
            return OBJECT_MAPPER.readTree(json);
        } catch (Exception e) {
            throw new RuntimeException("解析json錯誤");
        }
    }

    /**
     * json轉(zhuǎn)map
     *
     * @param json  json字符串
     * @param clazz 類型
     * @param <T>   對象泛型類型
     * @return map
     */
    public static <T> Map<String, T> toObjectMap(String json, Class<T> clazz) {
        try {
            JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(Map.class, String.class, clazz);
            return OBJECT_MAPPER.readValue(json, javaType);
        } catch (IOException e) {
            throw new RuntimeException("解析json錯誤");
        }
    }

    /**
     * json轉(zhuǎn)list
     *
     * @param json  json字符串
     * @param clazz 類型
     * @param <T>   對象泛型類型
     * @return list
     */
    public static <T> List<T> toObjectList(String json, Class<T> clazz) {
        JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(ArrayList.class, clazz);
        try {
            return OBJECT_MAPPER.readValue(json, javaType);
        } catch (IOException e) {
            throw new RuntimeException("解析json錯誤");
        }
    }


    /**
     * 對象轉(zhuǎn)json
     *
     * @param entity 實體對象
     * @param <T>    對象泛型類型
     * @return json字符串
     */
    public static <T> String object2Json(T entity) {
        try {
            return OBJECT_MAPPER.writeValueAsString(entity);
        } catch (IOException e) {
            throw new RuntimeException("轉(zhuǎn)換json錯誤");
        }
    }

    /**
     * 對象轉(zhuǎn)json樹
     *
     * @param obj 對象
     * @return json樹
     */
    public static JsonNode object2TreeJson(Object obj) {
        try {
            return OBJECT_MAPPER.valueToTree(obj);
        } catch (Exception e) {
            throw new RuntimeException("轉(zhuǎn)換json錯誤");
        }
    }

    /**
     * 判斷一個字符串是否是json串
     *
     * @param content 內(nèi)容
     * @return true 是，false 否
     */
    public static boolean isJson(String content) {
        if (content == null || content.isEmpty()) {
            return false;
        }

        // 預(yù)判是否是json串
        if (PREPARE_JSON_PATTERN.matcher(content).matches()) {
            try {
                OBJECT_MAPPER.readTree(content);
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }


    /**
     * 獲取objectMapper對象
     *
     * @return objectMapper對象
     */
    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }


    static {
        // 禁止日期/時間默認(rèn)序列化為時間戳
        OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 設(shè)置時區(qū)為gmt+8
        OBJECT_MAPPER.setTimeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
        // 設(shè)置日期格式
        OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(DEFAULT_DATE_TIME_PATTERN));
        // 允許單引號
        OBJECT_MAPPER.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 將 BigDecimal 序列化為 bigDecimal.toPlainString(), 防止生成科學(xué)計數(shù)法
        OBJECT_MAPPER.configure(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN, Boolean.TRUE);
        // 允許序列化空的POJO類（否則會拋出異常）
        OBJECT_MAPPER.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        // 在遇到未知屬性的時候不拋出異常
        OBJECT_MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 忽略值為默認(rèn)值的屬性
        OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // java8時間類型支持
        OBJECT_MAPPER.registerModule(new JavaTimeModule());
    }
}

3、TypeRef.java

package com.pine.common.util.json;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;

import java.lang.reflect.ParameterizedType;

/**
 * type引用封裝,javaType取自范型T
 *
 * @author pine manage
 * @since 2024-10-30
 */
public abstract class TypeRef<T> {
    /**
     * javaType: 獲取范型T
     */
    private final JavaType jt = TypeFactory.defaultInstance()
            .constructType(((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);

    public TypeRef() {
    }

    public JavaType getType() {
        return this.jt;
    }
}

測試

package com.pine.common.util.json;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.pine.common.util.time.TimeUtil;
import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Map;


public class TestJson {

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.createTime = LocalDateTime.now();
        demo.date = new Date();
        demo.map = Map.of("key", "value");
        String json = JsonUtil.object2Json(demo);
        System.out.println(json);

        Demo demo1 = JsonUtil.json2Object(json, new TypeRef<>() {
        });
        System.out.println(demo1);
    }

    @Data
    private static class Demo {
        /**
         * 狀態(tài):0=啟用,1=禁用
         */
        Integer status;
        /**
         * 描述、備注
         */
        String remark;
        /**
         * 創(chuàng)建時間
         */
        @JsonFormat(pattern = TimeUtil.DEFAULT_DATE_TIME_PATTERN, timezone = TimeUtil.GMT_8)
        LocalDateTime createTime;

        @JsonFormat(pattern = TimeUtil.DEFAULT_DATE_TIME_PATTERN, timezone = TimeUtil.GMT_8)
        Date date;

        Map<String, String> map;

        BigDecimal volume;
    }
}

控制臺輸出結(jié)果：

{"createTime":"2024-10-30 14:21:03","date":"2024-10-30 14:21:03","map":{"key":"value"}}
TestJson.Demo(status=null, remark=null, createTime=2024-10-30T14:21:03, date=Wed Oct 30 14:21:03 CST 2024, map={key=value}, volume=null)

到此這篇關(guān)于SpringBoot中Json工具類的實現(xiàn)的文章就介紹到這了,更多相關(guān)SpringBoot Json工具類內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: