【全局配置时间序列化】localdatetime 失效问题

全局配置
@Configuration
public class JacksonCustomizerConfig {

/**
 * 自定义ObjectMapper
 *
 * @return ObjectMapper
 */
@Bean
public ObjectMapper getObjectMapper() {
    return JsonUtil.OBJECT_MAPPER;
}

/**
 * 自定义HttpMessageConverter
 *
 * @param objectMapper 自定义ObjectMapper
 * @return HttpMessageConverter
 */
@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter(ObjectMapper objectMapper) {
    MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter(objectMapper);
    List<MediaType> supportedMediaTypes = new ArrayList<>();
    supportedMediaTypes.add(MediaType.APPLICATION_JSON);
    supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
    mappingJackson2HttpMessageConverter.setSupportedMediaTypes(supportedMediaTypes);
    return mappingJackson2HttpMessageConverter;
}


/**
 * description:LocalDateTime转换器，用于转换RequestParam和PathVariable参数
 * 接收毫秒级时间戳字符串——>LocalDateTime
 */
@Bean
public Converter<Long, LocalDateTime> longToLocalDateTimeConverter() {
    return new Converter<Long, LocalDateTime>() {
        @Override
        public LocalDateTime convert(Long source) {
            return Instant.ofEpochMilli(source).atZone(ZoneId.systemDefault()).toLocalDateTime();
        }
    };
}

/*
 * description:LocalDateTime转换器，用于转换RequestParam和PathVariable参数
 * 接收毫秒级时间戳字符串——>LocalDateTime
 */
@Bean
public Converter<String, LocalDateTime> stringToLocalDateTimeConverter() {
    return new Converter<String, LocalDateTime>() {
        @Override
        public LocalDateTime convert(String source) {
            long timestamp = Long.parseLong(source);
            return Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
        }
    };
}

}

public class JsonUtil {

private static final Logger log = LoggerFactory.getLogger(JsonUtil.class);

public static final ThreadLocal<SimpleDateFormat> formatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

/**
 * ObjectMapper是线程安全的，可以共享使用
 */
public static final ObjectMapper OBJECT_MAPPER;

static {
    OBJECT_MAPPER = new ObjectMapper();
    JavaTimeModule javaTimeModule = new JavaTimeModule();
    javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
    javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
    javaTimeModule.addSerializer(Date.class, new DateSerializer());
    javaTimeModule.addDeserializer(Date.class, new DateDeserializer());

    SimpleModule longModule = new SimpleModule();
    longModule.addSerializer(Long.class, ToStringSerializer.instance);
    longModule.addDeserializer(Long.class, new LongDeserializer());

    OBJECT_MAPPER.registerModule(javaTimeModule);
    OBJECT_MAPPER.registerModule(longModule);
    OBJECT_MAPPER.setDateFormat(formatThreadLocal.get());

    OBJECT_MAPPER.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
    OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}

private static final MapLikeType mapLikeType = TypeFactory.defaultInstance().constructMapLikeType(HashMap.class, String.class, Object.class);


private static class DateDeserializer extends JsonDeserializer<Date> {
    public static final Pattern number = Pattern.compile("(\\d)+");

    @Override
    public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        String valueAsString = jsonParser.getValueAsString();
        if (!StringUtils.hasText(valueAsString)) {
            return null;
        }
        try {
            if (number.matcher(valueAsString).matches()) {
                return new Date(Long.parseLong(valueAsString));
            }
            return formatThreadLocal.get().parse(valueAsString);
        } catch (ParseException e) {
            log.error("Date反序列化格式错误！", e);
        }
        return null;
    }
}

private static class DateSerializer extends JsonSerializer<Date> {

    @Override
    public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if (value == null) {
            return;
        }
        gen.writeString(formatThreadLocal.get().format(value));
    }
}

private static class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
    @Override
    public LocalDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        String valueAsString = jsonParser.getValueAsString();
        if (!StringUtils.hasText(valueAsString)) {
            return null;
        }

        long timestamp = Long.parseLong(valueAsString);
        Instant instant = Instant.ofEpochMilli(timestamp);
        ZoneId zone = ZoneId.systemDefault();

        return LocalDateTime.ofInstant(instant, zone);
    }
}

private static class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
    @Override
    public void serialize(LocalDateTime localDateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {

        Long timestamp = localDateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
        jsonGenerator.writeString(String.valueOf(timestamp));
    }
}

//Long反序列化字符串
private static class LongDeserializer extends JsonDeserializer<Long> {
    @Override
    public Long deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {

        String valueAsString = jsonParser.getValueAsString();
        if (!StringUtils.hasText(valueAsString)) {
            return null;
        }
        return Long.valueOf(valueAsString);
    }
}

public static Map<String, Object> parseJSONString(String content) throws JsonProcessingException {
    checkContent(content);
    return OBJECT_MAPPER.readValue(content, mapLikeType);
}


/**
 * 解析Map数据
 *
 * @param content   json字符串
 * @param keyType   Map-Key泛型数据类型的Class
 * @param valueType Map-Value泛型数据类型的Class
 * @param <K>       Key数据类型
 * @param <V>       Value数据类型
 * @return 返回指定k, v的Map
 * @throws JsonProcessingException 解析异常
 */
public static <K, V> Map<K, V> parseMapJsonString(String content, Class<K> keyType, Class<V> valueType) throws JsonProcessingException {
    checkContent(content);
    MapLikeType mapLikeType = TypeFactory.defaultInstance().constructMapLikeType(HashMap.class, keyType, valueType);
    return OBJECT_MAPPER.readValue(content, mapLikeType);
}

/**
 * 解析List数据
 *
 * @param content json字符串
 * @param type    List泛型数据的Class
 * @param <T>     元素泛型数据类型
 * @return 返回指定泛型的集合
 * @throws JsonProcessingException 解析异常
 */
public static <T> List<T> parseListJsonString(String content, Class<T> type) throws JsonProcessingException {
    checkContent(content);
    CollectionLikeType listType = TypeFactory.defaultInstance().constructCollectionLikeType(ArrayList.class, type);
    return OBJECT_MAPPER.readValue(content, listType);

}

public static <T> Set<T> parseSetJsonString(String content, Class<T> type) throws JsonProcessingException {
    checkContent(content);
    CollectionLikeType setType = TypeFactory.defaultInstance().constructCollectionLikeType(HashSet.class, type);
    return OBJECT_MAPPER.readValue(content, setType);
}

public static String[] parseStringArrayJsonString(String content) throws JsonProcessingException {
    checkContent(content);
    ArrayType stringArrayType = TypeFactory.defaultInstance().constructArrayType(String.class);
    return OBJECT_MAPPER.readValue(content, stringArrayType);
}

private static void checkContent(String content) {
    if (!StringUtils.hasText(content)) {
        throw new IllegalArgumentException("请传入正确的JSON数据");
    }
}

}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
private final MappingJackson2HttpMessageConverter converter;
private final ObjectMapper objectMapper;
public SwaggerConfig(MappingJackson2HttpMessageConverter converter, ObjectMapper objectMapper){
this.converter = converter;
this.objectMapper = objectMapper;
}
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
// 设置格式化内容
converter.setObjectMapper(objectMapper);
converters.add(0, converter);
}
}