jackson反序列化時間萬能日期格式匹配集成

使用jackson的registerModule功能，註冊不同日期類型的反序列化器，支持各種場景的日期格式匹配，並封裝類型fastjson式的調用方式。

主入口類JSON：

package xxx.util;

import java.lang.reflect.Type;
import java.util.List;
import java.util.TimeZone;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import xxx.XxxRuntimeException;
import xxx.DateDeserializer;
import xxx.SqlDateDeserializer;
import xxx.TimestampDeserializer;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.type.TypeFactory;

/**
 * JSON工具類（使用jackson封裝）
 * 
 * @author 許暢
 * @since JDK1.8
 * @version 2020年6月8日 許暢 新建
 */
public class JSON {
    
    /**
     * 日誌
     */
    private final static Logger LOGGER = LoggerFactory.getLogger(JSON.class);
    
    /**
     * 轉換器
     */
    private static ObjectMapper MAPPER;
    
    static {
        MAPPER = new ObjectMapper();
        // 允許沒有引號的字段名
        MAPPER.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        // 允許單引號字段名
        MAPPER.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 自動給字段名加上引號
        MAPPER.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
        // 時間默認以時間戳格式寫
        // MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
        MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 設置時間轉換所使用的默認時區
        MAPPER.setTimeZone(TimeZone.getDefault());
        // null不生成到json字符串中
        MAPPER.setSerializationInclusion(Include.NON_NULL);
        
        // 全局日期反序列化配置
        SimpleModule module = new SimpleModule();
        module.addDeserializer(java.util.Date.class, new DateDeserializer());
        module.addDeserializer(java.sql.Date.class, new SqlDateDeserializer());
        module.addDeserializer(java.sql.Timestamp.class, new TimestampDeserializer());
        MAPPER.registerModule(module);
    }
    
    /**
     * 構造方法
     */
    private JSON() {
        
    }
    
    /**
     * 將JSON字符串內容轉換爲集合類型
     * 
     * @param <T> 泛型對象
     * @param content JSON字符串內容
     * @param clazz List泛型中對象類型
     * @return List集合
     */
    public static <T> List<T> parseArray(String content, Class<T> clazz) {
        try {
            return MAPPER.readValue(content, new TypeReference<List<T>>() {
                //
            });
        } catch (Exception e) {
            LOGGER.error("JSON反序列化失敗：" + e.getMessage(), e);
            throw new XxxRuntimeException("JSON反序列化失敗：" + e.getMessage(), e);
        }
    }
    
    /**
     * 將JSON字符串內容轉換爲對象類型
     * 
     * @param content JSON字符串內容
     * @param valueType 值類型
     * @param <T> 對象類型
     * @return 將JSON字符串內容轉換爲對象類型
     */
    public static <T> T parseObject(String content, Class<T> valueType) {
        try {
            return MAPPER.readValue(content, valueType);
        } catch (Exception e) {
            LOGGER.error("JSON反序列化失敗：" + e.getMessage(), e);
            throw new XxxRuntimeException("JSON反序列化失敗：" + e.getMessage(), e);
        }
    }
    
    /**
     * 將JSON字符串內容轉換爲泛型所對應的類型
     * 
     * @param content JSON字符串內容
     * @param genericType 泛型類型
     * @param <T> 對象類型
     * @return 將JSON字符串內容轉換爲對象類型
     */
    public static <T> T parseObject(String content, Type genericType) {
        try {
            return MAPPER.readValue(content, TypeFactory.defaultInstance().constructType(genericType));
        } catch (Exception e) {
            LOGGER.error("JSON反序列化失敗：" + e.getMessage(), e);
            throw new XxxRuntimeException("JSON反序列化失敗：" + e.getMessage(), e);
        }
    }
    
    /**
     * 將JSON字符串內容轉換爲對象類型-對象泛型支持
     * 
     * @param <T> 泛型類型
     * @param content JSON字符串內容
     * @param valueTypeRef 泛型類型
     * @return 對象類型
     */
    public static <T> T parseObject(String content, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER.readValue(content, valueTypeRef);
        } catch (Exception e) {
            LOGGER.error("JSON反序列化失敗：" + e.getMessage(), e);
            throw new XxxRuntimeException("JSON反序列化失敗：" + e.getMessage(), e);
        }
    }
    
    /**
     * 將對象轉換爲JSON字符串
     * 
     * @param object 對象
     * @return JSON字符串
     */
    public static String toJSONString(Object object) {
        try {
            return MAPPER.writeValueAsString(object);
        } catch (Exception e) {
            LOGGER.error("JSON序列化失敗：" + e.getMessage(), e);
            throw new XxxRuntimeException("JSON序列化失敗：" + e.getMessage(), e);
        }
    }
    
    /**
     * 將來源對象轉換爲目標對象
     * 
     * @param <T> 泛型對象
     * @param fromValue 對象值
     * @param toValueTypeRef 目標對象泛型
     * @return 目標對象
     */
    public static <T> T convertObject(Object fromValue, TypeReference<T> toValueTypeRef) {
        return MAPPER.convertValue(fromValue, toValueTypeRef);
    }
    
    /**
     * 將來源對象轉換爲目標對象
     * 
     * @param <T> 泛型對象
     * @param fromValue 對象值
     * @param toValueType 目標對象class類型
     * @return 目標對象
     */
    public static <T> T convertObject(Object fromValue, Class<T> toValueType) {
        return MAPPER.convertValue(fromValue, toValueType);
    }
    
    /**
     * 獲取ObjectMapper對象
     * 
     * @return 獲取ObjectMapper對象
     */
    public static ObjectMapper getMapper() {
        return MAPPER;
    }
    
}

 

自定義DateDeserializer日期反序列化器：

package xxx;

import java.io.IOException;
import java.util.Date;

import xxx.DatePatternUtil;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;

/**
 * java.util.Date類型反序列化配置
 * 
 * @author 許暢
 * @since JDK1.8
 * @version 2020年6月9日 許暢 新建
 */
public class DateDeserializer extends StdDeserializer<Date> {
    
    /**
     * 構造方法
     *
     */
    public DateDeserializer() {
        this(null);
    }
    
    /**
     * 構造方法
     *
     * @param vc Class
     */
    public DateDeserializer(Class<?> vc) {
        super(vc);
    }
    
    /**
     * @see com.fasterxml.jackson.databind.JsonDeserializer#deserialize(com.fasterxml.jackson.core.JsonParser,
     *      com.fasterxml.jackson.databind.DeserializationContext)
     */
    @Override
    public Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        return DatePatternUtil.getPatternDate(p.getValueAsString());
    }
}

萬能日期匹配器DatePatternUtil：

package xxx.util;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 日期正則匹配工具類
 * 
 * @author 許暢
 * @since JDK1.7
 * @version 2019年5月15日 許暢 新建
 */
public class DatePatternUtil {
    
    /**
     * 構造方法
     */
    private DatePatternUtil() {
        
    }
    
    /** 格式化 */
    private static final List<Pattern> patternList = new ArrayList<Pattern>(5);
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN1 = Pattern.compile("\\d{4}");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN2 = Pattern.compile("\\d{4}-\\d{1,2}");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN3 = Pattern.compile("(\\d{4}\\-\\d{1,2}\\-\\d{1,2})");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN4 = Pattern.compile("(\\d{4}\\-\\d{1,2}\\-\\d{1,2} \\d{1,2}:\\d{1,2})");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN5 = Pattern.compile("\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{1,2}:\\d{1,2}");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN6 = Pattern
        .compile("\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{1,2}:\\d{1,2}\\.\\d+");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN7 = Pattern.compile("\\d{4}/\\d{1,2}/\\d{1,2}");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN8 = Pattern
        .compile("\\w{3}\\s\\w{3}\\s\\d{1,2}\\s\\d{4}\\s\\d{1,2}:\\d{1,2}:\\d{1,2}\\sGMT\\+0800");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN9 = Pattern.compile("\\d{4}\\d{1,2}");
    
    /** 格式匹配模式 */
    private static final Pattern PATTERN10 = Pattern.compile("(\\d{4}\\d{1,2}\\d{1,2})");
    
    /** 格式化 */
    private static final Map<Pattern, String> patternMap = new HashMap<Pattern, String>();
    
    static {
        patternMap.put(PATTERN1, "yyyy");
        patternMap.put(PATTERN2, "yyyy-MM");
        patternMap.put(PATTERN3, "yyyy-MM-dd");
        patternMap.put(PATTERN4, "yyyy-MM-dd HH:mm");
        patternMap.put(PATTERN5, "yyyy-MM-dd HH:mm:ss");
        patternMap.put(PATTERN6, "yyyy-MM-dd HH:mm:ss.SSS");
        patternMap.put(PATTERN7, "yyyy/MM/dd");
        patternMap.put(PATTERN8, "EEE MMM dd yyyy HH:mm:ss 'GMT+0800'");
        patternMap.put(PATTERN9, "yyyyMM");
        patternMap.put(PATTERN10, "yyyyMMdd");
        
        // 添加pattern
        patternList.add(PATTERN1);
        patternList.add(PATTERN2);
        patternList.add(PATTERN3);
        patternList.add(PATTERN4);
        patternList.add(PATTERN5);
        patternList.add(PATTERN6);
        patternList.add(PATTERN7);
        patternList.add(PATTERN8);
        patternList.add(PATTERN9);
        patternList.add(PATTERN10);
    }
    
    /**
     * 獲取需要反序列化爲正確格式的日期
     * 
     * @param strDateValue 字符串類型的日期值
     * @return Date
     */
    public static Date getPatternDate(String strDateValue) {
        String value = strDateValue;
        if (value == null || "".equals(value.trim()) || "null".equalsIgnoreCase(value.trim())) {
            return null;
        }
        // 解決字符串被自動轉碼導致的問題，在此將轉碼後的字符串還原。
        if (value.indexOf('%') >= 0) {
            try {
                value = URLDecoder.decode(value, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                //
            }
        }
        
        String format = getMatchFormat(value);
        if (format == null) {
            // 如果以上8種時間格式都無法匹配，校驗是否是時間戳格式，如果是就直接轉換爲Date，否則直接拋出異常
            Matcher matcher = Pattern.compile("[-]?\\d+").matcher(value);
            boolean isMatch = matcher.matches();
            if (isMatch) {
                return new Date(Long.valueOf(value));
            }
            throw new IllegalArgumentException("不支持的時間格式:" + value);
        }
        
        if (format.indexOf("GMT") > 0) {
            SimpleDateFormat objSimpleFormat = new SimpleDateFormat(format, Locale.US);
            try {
                return objSimpleFormat.parse(value);
            } catch (ParseException e) {
                throw new IllegalArgumentException("不支持的時間格式:" + value);
            }
        }
        
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            return sdf.parse(value);
        } catch (ParseException e) {
            throw new IllegalArgumentException("不支持的時間格式:" + value);
        }
    }
    
    /**
     * 根據值獲取合適的格式
     *
     * 
     * @param value 數據
     * @return 格式
     */
    private static String getMatchFormat(final String value) {
        Pattern pattern = null;
        for (Iterator<Pattern> iterator = patternList.iterator(); iterator.hasNext();) {
            pattern = iterator.next();
            Matcher matcher = pattern.matcher(value);
            boolean isMatch = matcher.matches();
            if (isMatch) {
                return patternMap.get(pattern);
            }
        }
        return null;
    }
    
}