package com.ryxx.util;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.ser.std.DateSerializer;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
@SuppressWarnings("unused")
@Slf4j
public final class JacksonUtils {
private static final String pattern = "yyyy-MM-dd HH:mm:ss.SSS";
private static final String timeZoneString = "Asia/Shanghai";
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final String SERIALIZATION_ERROR_MESSAGE = JacksonUtils.class.getName() + ": Serialize error.";
private static final String DESERIALIZATION_ERROR_MESSAGE = JacksonUtils.class.getName() + ": Deserialize error.";
static {
// POJO对象的属性值不论是什么，序列化时都显示
MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
// 设置在反序列化时忽略在JSON字符串中存在，而在Java中不存在的属性
MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 设置序列化时间类型不使用时间戳形式（jackson时间类型默认都是序列化为时间戳形式的）
MAPPER.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
// 为了处理JSON中的日期字符串并正确转换为 LocalDate，我们需要注册在 ObjectMapper 实例中注册 JavaTimeModule 模块。
// 还需要禁止把日期转换为时间戳字符串的动作
JavaTimeModule javaTimeModule = new JavaTimeModule();
// Date类型序列化、反序列化全局配置-方式1
// MAPPER.setDateFormat(new SimpleDateFormat(pattern));
// Date类型序列化、反序列化全局配置-方式2
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
simpleDateFormat.setTimeZone(TimeZone.getTimeZone(timeZoneString));
javaTimeModule.addSerializer(Date.class, new DateSerializer(false, simpleDateFormat));
javaTimeModule.addDeserializer(Date.class, new DateDeserializer());
// LocalDateTime类型序列化、反序列化全局配置
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(pattern)));
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(pattern)));
MAPPER.registerModule(javaTimeModule);
}
/**
* Object to json string.
*
* @param obj obj
* @return json string
*/
public static String toJson(Object obj) {
try {
return MAPPER.writeValueAsString(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException(SERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Object to json string byte array.
*
* @param obj obj
* @return json string byte array
*/
public static byte[] toJsonBytes(Object obj) {
try {
return MAPPER.writeValueAsBytes(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException(SERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param json json string
* @param cls class of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(byte[] json, Class<T> cls) {
try {
return MAPPER.readValue(json, cls);
} catch (Exception e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param json json string
* @param cls {@link Type} of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(byte[] json, Type cls) {
try {
return MAPPER.readValue(json, constructJavaType(cls));
} catch (Exception e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param inputStream json string input stream
* @param cls class of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(InputStream inputStream, Class<T> cls) {
try {
return MAPPER.readValue(inputStream, cls);
} catch (IOException e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param json json string byte array
* @param typeReference {@link TypeReference} of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(byte[] json, TypeReference<T> typeReference) {
try {
return MAPPER.readValue(json, typeReference);
} catch (Exception e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param json json string
* @param cls class of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(String json, Class<T> cls) {
try {
return MAPPER.readValue(json, cls);
} catch (IOException e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param json json string
* @param type {@link Type} of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(String json, Type type) {
try {
return MAPPER.readValue(json, MAPPER.constructType(type));
} catch (IOException e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param json json string
* @param typeReference {@link TypeReference} of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(String json, TypeReference<T> typeReference) {
try {
return MAPPER.readValue(json, typeReference);
} catch (IOException e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Object.
*
* @param inputStream json string input stream
* @param type {@link Type} of object
* @param <T> General type
* @return object
*/
public static <T> T toObj(InputStream inputStream, Type type) {
try {
return MAPPER.readValue(inputStream, MAPPER.constructType(type));
} catch (IOException e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Json string deserialize to Jackson {@link JsonNode}.
*
* @param json json string
* @return {@link JsonNode}
*/
public static JsonNode readTree(String json) {
try {
return MAPPER.readTree(json);
} catch (IOException e) {
throw new RuntimeException(DESERIALIZATION_ERROR_MESSAGE, e);
}
}
/**
* Register subtype for child class.
*
* @param clz child class
* @param type type name of child class
*/
public static void registerSubtype(Class<?> clz, String type) {
MAPPER.registerSubtypes(new NamedType(clz, type));
}
/**
* Create a new empty Jackson {@link ObjectNode}.
*
* @return {@link ObjectNode}
*/
public static ObjectNode createEmptyJsonNode() {
return new ObjectNode(MAPPER.getNodeFactory());
}
/**
* Create a new empty Jackson {@link ArrayNode}.
*
* @return {@link ArrayNode}
*/
public static ArrayNode createEmptyArrayNode() {
return new ArrayNode(MAPPER.getNodeFactory());
}
/**
* Parse object(usually a bean) to Jackson {@link JsonNode}.
*
* @param obj object
* @return {@link JsonNode}
*/
public static JsonNode transferToJsonNode(Object obj) {
return MAPPER.valueToTree(obj);
}
/**
* construct java type -> Jackson Java Type.
*
* @param type java type
* @return JavaType {@link JavaType}
*/
public static JavaType constructJavaType(Type type) {
return MAPPER.constructType(type);
}
public static ObjectMapper getObjectMapper() {
return MAPPER;
}
/**
* Date类型反序列化定制
*/
public static class DateDeserializer extends JsonDeserializer<Date> {
private static final List<String> patternList = new ArrayList<String>(4);
static {
patternList.add("yyyy-MM");
patternList.add("yyyy-MM-dd");
patternList.add("yyyy-MM-dd hh:mm");
patternList.add("yyyy-MM-dd hh:mm:ss");
patternList.add("yyyy-MM-dd hh:mm:ss.SSS");
}
@Override
public Date deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
String source = p.getText().trim();
if ("".equals(source)) {
return null;
}
if (source.matches("^\\d{4}-\\d{1,2}$")) {
return parseDate(source, patternList.get(0));
} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2}$")) {
return parseDate(source, patternList.get(1));
} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}$")) {
return parseDate(source, patternList.get(2));
} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}:\\d{1,2}$")) {
return parseDate(source, patternList.get(3));
} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}:\\d{1,2}.\\d{1,3}$")) {
return parseDate(source, patternList.get(4));
} else if (source.matches("^\\d{13}$")) {//毫秒
return new Date(Long.parseLong(source));
} else if (source.matches("^\\d{10}$")) {//秒
return new Date(Long.parseLong(source) * 1000);
} else {
throw new IllegalArgumentException("Invalid Date value '" + source + "'");
}
}
/**
* 功能描述：格式化日期
*
* @param dateStr String 字符型日期
* @param format String 格式
* @return Date 日期
*/
private Date parseDate(String dateStr, String format) {
Date date = null;
try {
DateFormat dateFormat = new SimpleDateFormat(format);
date = dateFormat.parse(dateStr);
} catch (Exception e) {
e.printStackTrace();
}
return date;
}
}
}