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 泛型对象
* @param content JSON字符串内容
* @param clazz List泛型中对象类型
* @return List集合
*/
public static List parseArray(String content, Class clazz) {
try {
return MAPPER.readValue(content, new TypeReference>() {
//
});
} catch (Exception e) {
LOGGER.error("JSON反序列化失败：" + e.getMessage(), e);
throw new XxxRuntimeException("JSON反序列化失败：" + e.getMessage(), e);
}
}
/**
* 将JSON字符串内容转换为对象类型
*
* @param content JSON字符串内容
* @param valueType 值类型
* @param 对象类型
* @return 将JSON字符串内容转换为对象类型
*/
public static T parseObject(String content, Class 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 对象类型
* @return 将JSON字符串内容转换为对象类型
*/
public static 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 泛型类型
* @param content JSON字符串内容
* @param valueTypeRef 泛型类型
* @return 对象类型
*/
public static T parseObject(String content, TypeReference 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 泛型对象
* @param fromValue 对象值
* @param toValueTypeRef 目标对象泛型
* @return 目标对象
*/
public static T convertObject(Object fromValue, TypeReference toValueTypeRef) {
return MAPPER.convertValue(fromValue, toValueTypeRef);
}
/**
* 将来源对象转换为目标对象
*
* @param 泛型对象
* @param fromValue 对象值
* @param toValueType 目标对象class类型
* @return 目标对象
*/
public static T convertObject(Object fromValue, Class 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 {
/**
* 构造方法
*
*/
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 patternList = new ArrayList(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 patternMap = new HashMap();
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 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;
}
}