基于Jackson的Json工具类

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;

@Slf4j
public class JsonUtil {
   

    public static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    static {
   
        // 对象的所有字段全部列入序列化
        OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // 取消默认转换timestamps形式
        OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 忽略空Bean转json的错误
        OBJECT_MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        // 忽略 在json字符串中存在，但在java对象中不存在对应属性的情况。防止错误
        OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 所有的日期格式都统一为以下的格式，即yyyy-MM-dd HH:mm:ss
        OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(CommonConstant.DATETIME_FORMAT_FORMAT));
        // 兼容时间格式
        JavaTimeModule module = new JavaTimeModule();
        module.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(
                      DateTimeFormatter.ofPattern(CommonConstant.DATETIME_FORMAT_FORMAT)))
              .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(
                      DateTimeFormatter.ofPattern(CommonConstant.DATETIME_FORMAT_FORMAT)))
              .addSerializer(LocalDate.class,
                             new LocalDateSerializer(DateTimeFormatter.ofPattern(CommonConstant.DATE_DEFAULT_FORMAT)))
              .addDeserializer(LocalDate.class, new LocalDateDeserializer(
                      DateTimeFormatter.ofPattern(CommonConstant.DATE_DEFAULT_FORMAT))).addDeserializer(LocalTime.class,
                                                                                                        new LocalTimeDeserializer(
                                                                                                                DateTimeFormatter.ofPattern(
                                                                                                                        CommonConstant.TIME_DEFAULT_FORMAT)))
              .addSerializer(LocalTime.class,
                             new LocalTimeSerializer(DateTimeFormatter.ofPattern(CommonConstant.TIME_DEFAULT_FORMAT)));
        OBJECT_MAPPER.registerModule(module);
    }

    public static ObjectMapper getObjectMapper() {
   
        return OBJECT_MAPPER;
    }

    public static <T> T parseObject(String jsonString, Class<T> clazz) {
   
        try {
   
            return OBJECT_MAPPER.readValue(jsonString, clazz);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonString转为自定义对象失败", e);
        }
    }

    public static <T> T parseObject(File file, Class<T> clazz) {
   
        try {
   
            return OBJECT_MAPPER.readValue(file, clazz);
        } catch (IOException e) {
   
            throw new SystemException("从文件中读取json字符串转为自定义对象失败", e);
        }
    }

    public static <T> T[] parseObjectArray(String jsonString, Class<T> clazz) {
   
        try {
   
            return OBJECT_MAPPER.readerForArrayOf(clazz).readValue(jsonString);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonString转为Array失败", e);
        }
    }

    public static <T> List<T> parseObjectList(String jsonString, Class<T> clazz) {
   
        try {
   
            return OBJECT_MAPPER.readerForListOf(clazz).readValue(jsonString);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonString转为List失败", e);
        }
    }

    public static <T> Map<String, T> parseObjectMap(String jsonString, Class<T> clazz) {
   
        try {
   
            return OBJECT_MAPPER.readerForMapOf(clazz).readValue(jsonString);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonString转为Map失败", e);
        }
    }

    public static <T> T parseObject(String jsonString, TypeReference<T> reference) {
   
        try {
   
            return OBJECT_MAPPER.readValue(jsonString, reference);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonString转换Object失败", e);
        }
    }

    public static String toJsonString(Object object) {
   
        try {
   
            return OBJECT_MAPPER.writeValueAsString(object);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("Object转JSONString失败", e);
        }
    }

    public static byte[] toByteArray(Object object) {
   
        try {
   
            return OBJECT_MAPPER.writeValueAsBytes(object);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("Object转ByteArray失败", e);
        }
    }

    public static void objectToFile(File file, Object object) {
   
        try {
   
            OBJECT_MAPPER.writeValue(file, object);
        } catch (Exception e) {
   
            throw new SystemException("Object写入文件失败", e);
        }
    }

    public static JsonNode parseJsonObject(String jsonString) {
   
        try {
   
            return OBJECT_MAPPER.readTree(jsonString);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonString转为JsonNode失败", e);
        }
    }

    public static JsonNode parseJsonObject(Object object) {
   
        return OBJECT_MAPPER.valueToTree(object);
    }

    public static String toJsonString(JsonNode jsonNode) {
   
        try {
   
            return OBJECT_MAPPER.writeValueAsString(jsonNode);
        } catch (JsonProcessingException e) {
   
            throw new SystemException("JsonNode转JSONString失败", e);
        }
    }

    public static ObjectNode newJsonObject() {
   
        return OBJECT_MAPPER.createObjectNode();
    }

    public static ArrayNode newJsonArray() {
   
        return OBJECT_MAPPER.createArrayNode();
    }

}