问题
springboot 版本：spring-boot 2.3.12
今天在开发一个redis 热key服务端的过程中，碰到2个问题：
- jdk8的LocalDateTime,LocalDate,LocalTime类型的字段在序列化，会被序列成["2021","12","22","18","56","40"]这样的数组；
- 服务接受请求LocalDateTime类型的参数时，要求参数为 "2021-12-22T18:56"，中间加"T"（ISO-8601) 才能够正常实现反序列化，yyyy-MM-dd HH:mm:ss 格式的字符串反序列化会报异常，异常信息如下：
org.springframework.http.converter.HttpMessageNotReadableException: Invalid JSON input: Cannot deserialize value of type `java.time.LocalDateTime` from String "2021-12-22 18:56:40": Failed to deserialize java.time.LocalDateTime: (java.time.format.DateTimeParseException) Text '2020-05-04 00:00' could not be parsed at index 10; nested exception is com.fasterxml.jackson.databind.exc.InvalidFormatException: Cannot deserialize value of type `java.time.LocalDateTime` from String "2021-12-22 18:56:40": Failed to deserialize java.time.LocalDateTime: (java.time.format.DateTimeParseException) Text '2021-12-22 18:56:40' could not be parsed at index 10 // 省略部分异常信息 Caused by: java.time.format.DateTimeParseException: Text '2021-12-22 18:56:40' could not be parsed at index 10
系统默认的序列化&反序列化方式给人感觉比较反人类，给所有功能相关都会带来困惑和额外的转化工作量，需要使用一种更符合大家使用习惯的方式解决一下。
方案职责的定位
LocalDateTime序列化&反序列化的使用应该是应用服务的共性问题，发挥作用的层次在springmvc 的HttpMessageConverter层次，个人想法-解决方案应该放在基础框架或脚手架层次（如果所在公司又自己的框架或脚手架），这样所有使用框架及脚手架的应用都会因此受益。
解决过程
定位问题
spring boot 在mvc请求的处理过程中，负责json 格式序列化和反序列化的是Jackson*HttpMessageConverter，具体哪个类定位一下即可，所有的请求response在spring boot里统一在RequestResponseBodyMethodProcessor这个类的handleReturnValue方法中进行的。
@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException { mavContainer.setRequestHandled(true); ServletServerHttpRequest inputMessage = createInputMessage(webRequest); ServletServerHttpResponse outputMessage = createOutputMessage(webRequest); //这里即是使用各种MessageConverter对返回的对象进行序列化处理的地方 writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage); }
顺着writeWithMessageConverters方法继续往下debug，最终找到了Jackson的converter -> AbstractJackson2HttpMessageConverter的withInternal方法。
@Override protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { MediaType contentType = outputMessage.getHeaders().getContentType(); JsonEncoding encoding = getJsonEncoding(contentType); OutputStream outputStream = StreamUtils.nonClosing(outputMessage.getBody()); JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputStream, encoding); try { //此处忽略不相关的代码 //此处即是将返回对象序列化的objectWriter ObjectWriter objectWriter = (serializationView != null ? this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer()); if (filters != null) { objectWriter = objectWriter.with(filters); } if (javaType != null && javaType.isContainerType()) { objectWriter = objectWriter.forType(javaType); } SerializationConfig config = objectWriter.getConfig(); if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) && config.isEnabled(SerializationFeature.INDENT_OUTPUT)) { objectWriter = objectWriter.with(this.ssePrettyPrinter); } //此处开始进行序列化 objectWriter.writeValue(generator, value); writeSuffix(generator, object); generator.flush(); generator.close(); } catch (InvalidDefinitionException ex) { throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex); } catch (JsonProcessingException ex) { throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex); } }
objectWriter是真正执行序列化的，它是由ObjectMapper来创建的，再来看以下ObjectMapper,
关键的序列化组件由_serializerFactory提供，由内部提供了很多类型对象序列化支撑。
再继续跟踪，最终进入了LocalDateTime类型的序列化类->LocalDateTimeSerializer，通过serialize方法进行序列化，在包里我们还可以看到很多JSR310的日期类型的序列化类。
再来看serialize方法，其中有一个很重要的逻辑->useTimestamp方法，在父类JSR310FormattedSerializerBase中实现，单独摘出来
protected boolean useTimestamp(SerializerProvider provider) { if (_useTimestamp != null) { return _useTimestamp.booleanValue(); } if (_shape != null) { if (_shape == Shape.STRING) { return false; } if (_shape == Shape.NUMBER_INT) { return true; } } //这里让人眼前一亮，意味着可以通过外置扩展的方式来给一个配置好的_formatter return (_formatter == null) && (provider != null) && provider.isEnabled(getTimestampsFeature()); }
这个方法默认返回true，默认_formatter是null，provider.isEnabled也是true，这里我们应该已经找到解题之道了—我们可以试图给-LocalDateTimeSerializer一个定义好的_formatter，或者给定配置让它生成一个formatter.
整理一下调用链路
整理一下思路：LocalDateTimeSerializer->...->DefaultSerializerProvider->Prefetch->ObjectWritter->ObjectMapper
看一下不起眼的Prefetch的关键方法-_serializerProvider
protected DefaultSerializerProvider _serializerProvider() { return _serializerProvider.createInstance(_config, _serializerFactory); }
通过此方法将ObjectWritter中的_serializerFactory来创建一个默认的DefaultSerializerProvider。
好了，回过头来溯源已经清楚了，其实还是ObjectMapper来传入进去的。那么我们就研究在ObjectMapper创建时如何做一下扩展，将自己的扩展解决方案融入到ObjectMapper中就可以了。
解决方案
AbstractJackson2HttpMessageConverter的实现类MappingJackson2HttpMessageConverter，找到这个bean的创建位置
再看一下ObjectMapper的创建位置
如图所示，MappingJackson2HtttMessageConverter的ObjectMapper在JacksonAutoConfiguration中创建的，并且通过Jackson2ObjectMapperBuilder 来创建的，这个类很重要，我们看一下这个build方法。
public <T extends ObjectMapper> T build() { ObjectMapper mapper; if (this.createXmlMapper) { mapper = (this.defaultUseWrapper != null ? new XmlObjectMapperInitializer().create(this.defaultUseWrapper, this.factory) : new XmlObjectMapperInitializer().create(this.factory)); } else { mapper = (this.factory != null ? new ObjectMapper(this.factory) : new ObjectMapper()); } //这里的configure就是配置mapper的，做包括序列在内的各种配置的 configure(mapper); return (T) mapper; }
configure方法：
public void configure(ObjectMapper objectMapper) { Assert.notNull(objectMapper, "ObjectMapper must not be null"); MultiValueMap<Object, Module> modulesToRegister = new LinkedMultiValueMap<>(); if (this.findModulesViaServiceLoader) { ObjectMapper.findModules(this.moduleClassLoader).forEach(module -> registerModule(module, modulesToRegister)); } else if (this.findWellKnownModules) { registerWellKnownModulesIfAvailable(modulesToRegister); } if (this.modules != null) { this.modules.forEach(module -> registerModule(module, modulesToRegister)); } if (this.moduleClasses != null) { for (Class<? extends Module> moduleClass : this.moduleClasses) { registerModule(BeanUtils.instantiateClass(moduleClass), modulesToRegister); } } List<Module> modules = new ArrayList<>(); for (List<Module> nestedModules : modulesToRegister.values()) { modules.addAll(nestedModules); } objectMapper.registerModules(modules); //此处省去不关注的代码 }
这个Module是个抽象类，有这么多实现，JavaTimeModule就是时间相关的模块
看一下JavaTimeModule说明
Class that registers capability of serializing java.time objects with the Jackson core.
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
Note that as of 2.x, if auto-registering modules, this package will register legacy version, JSR310Module, and NOT this module. 3.x will change the default. Legacy version has the same functionality, but slightly different default configuration: see JSR310Module for details.
再看一下JavaTimeModule的核心代码，它的构造方法里加入了这么多的序列化及反序列化类，不过是都是默认的，我们需要使用JavaTimeModule创建一个我们需要的类。
public final class JavaTimeModule extends SimpleModule { private static final long serialVersionUID = 1L; public JavaTimeModule() { super(PackageVersion.VERSION); // First deserializers // // Instant variants: addDeserializer(Instant.class, InstantDeserializer.INSTANT); addDeserializer(OffsetDateTime.class, InstantDeserializer.OFFSET_DATE_TIME); addDeserializer(ZonedDateTime.class, InstantDeserializer.ZONED_DATE_TIME); // // Other deserializers addDeserializer(Duration.class, DurationDeserializer.INSTANCE); addDeserializer(LocalDateTime.class, LocalDateTimeDeserializer.INSTANCE); addDeserializer(LocalDate.class, LocalDateDeserializer.INSTANCE); addDeserializer(LocalTime.class, LocalTimeDeserializer.INSTANCE); addDeserializer(MonthDay.class, MonthDayDeserializer.INSTANCE); addDeserializer(OffsetTime.class, OffsetTimeDeserializer.INSTANCE); addDeserializer(Period.class, JSR310StringParsableDeserializer.PERIOD); addDeserializer(Year.class, YearDeserializer.INSTANCE); addDeserializer(YearMonth.class, YearMonthDeserializer.INSTANCE); addDeserializer(ZoneId.class, JSR310StringParsableDeserializer.ZONE_ID); addDeserializer(ZoneOffset.class, JSR310StringParsableDeserializer.ZONE_OFFSET); // then serializers: addSerializer(Duration.class, DurationSerializer.INSTANCE); addSerializer(Instant.class, InstantSerializer.INSTANCE); addSerializer(LocalDateTime.class, LocalDateTimeSerializer.INSTANCE); addSerializer(LocalDate.class, LocalDateSerializer.INSTANCE); addSerializer(LocalTime.class, LocalTimeSerializer.INSTANCE); addSerializer(MonthDay.class, MonthDaySerializer.INSTANCE); addSerializer(OffsetDateTime.class, OffsetDateTimeSerializer.INSTANCE); addSerializer(OffsetTime.class, OffsetTimeSerializer.INSTANCE); addSerializer(Period.class, new ToStringSerializer(Period.class)); addSerializer(Year.class, YearSerializer.INSTANCE); addSerializer(YearMonth.class, YearMonthSerializer.INSTANCE);
回过头来继续看Jackson2ObjectMapperBuilder的创建，在JacksonAutoConfiguration中创建
@Configuration(proxyBeanMethods = false) @ConditionalOnClass(Jackson2ObjectMapperBuilder.class) static class JacksonObjectMapperBuilderConfiguration { @Bean @Scope("prototype") @ConditionalOnMissingBean Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder(ApplicationContext applicationContext, List<Jackson2ObjectMapperBuilderCustomizer> customizers) { //这里有Jackson2ObjectMapperBuilderCustomizer，意味着我们可以通过自定义它的Cutomizer， //来做一下个性化扩展 Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder(); builder.applicationContext(applicationContext); customize(builder, customizers); return builder; } private void customize(Jackson2ObjectMapperBuilder builder, List<Jackson2ObjectMapperBuilderCustomizer> customizers) { for (Jackson2ObjectMapperBuilderCustomizer customizer : customizers) { customizer.customize(builder); } } }
熟悉spring 设计风格的同学应该知道，这里的Customizer 类似于RestTemplateBuilder中的customizer，是方便我们做扩展用的，这就是spring 牛逼之处，再次深深膜拜一下，了解到这里几乎可以确定，我们扩展一个Jackson2ObjectMapperBuilderCustomizer的实现，就可以达成我们的目的了。
代码实现
给出代码设计
import com.fasterxml.jackson.databind.Module; 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 org.springframework.beans.factory.BeanFactoryUtils; import org.springframework.beans.factory.ListableBeanFactory; import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer; import org.springframework.boot.autoconfigure.jackson.JacksonProperties; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; import org.springframework.util.CollectionUtils; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.format.DateTimeFormatter; import java.util.Collection; /** * @author zhaoxinbo * @name: ApplicationWebConfig * @description: web配置类 * @date 2021/12/2120:40 */ @Configuration public class ApplicationWebConfig { private static final String STANDARD_LOCAL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss SSS"; private static final String STANDARD_LOCAL_DATE_FORMAT = "yyyy-MM-dd"; private static final String STANDARD_LOCAL_TIME_FORMAT = "HH:mm:ss SSS"; @Bean public LocalJackson2ObjectMapperBuilderCustomizer localJackson2ObjectMapperBuilderCustomizer(ApplicationContext applicationContext, JacksonProperties jacksonProperties) { return new LocalJackson2ObjectMapperBuilderCustomizer(applicationContext, jacksonProperties); } /** * 创建应用自己的JavaTimeModule * <p> * 1. Jackson默认不会创建spring 容器管理的JavaTimeModule，我们可以创建这样一个实例去覆盖系统默认的； * 2. 在此我们可以自定义JSR310日期的序列化&反序列化对象 * </p> * @return */ @Bean public JavaTimeModule javaTimeModule() { JavaTimeModule module = new JavaTimeModule(); /** serializers */ LocalDateTimeSerializer localDateTimeSerializer = new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(STANDARD_LOCAL_DATETIME_FORMAT)); LocalDateSerializer localDateSerializer = new LocalDateSerializer(DateTimeFormatter.ofPattern(STANDARD_LOCAL_DATE_FORMAT)); LocalTimeSerializer localTimeSerializer = new LocalTimeSerializer(DateTimeFormatter.ofPattern(STANDARD_LOCAL_TIME_FORMAT)); module.addSerializer(LocalDateTime.class, localDateTimeSerializer); module.addSerializer(LocalDate.class, localDateSerializer); module.addSerializer(LocalTime.class, localTimeSerializer); /** deserializers */ LocalDateTimeDeserializer localDateTimeDeserializer = new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(STANDARD_LOCAL_DATETIME_FORMAT)); LocalDateDeserializer localDateDeserializer = new LocalDateDeserializer(DateTimeFormatter.ofPattern(STANDARD_LOCAL_DATE_FORMAT)); LocalTimeDeserializer localTimeDeserializer = new LocalTimeDeserializer(DateTimeFormatter.ofPattern(STANDARD_LOCAL_TIME_FORMAT)); module.addDeserializer(LocalDateTime.class, localDateTimeDeserializer); module.addDeserializer(LocalDate.class, localDateDeserializer); module.addDeserializer(LocalTime.class, localTimeDeserializer); return module; } /** * <p> * 1. 自定义Jackson2ObjectMapperBuilderCustomizer; * 2. 将自定义创建JavaTimeModule配置在 Jackson2ObjectMapperBuilder 中 * 3. JacksonAutoConfiguration 中在创建ObjectMapper时就会把我们自己的JavaTimeModule初始化为对应的Serializer了 * </p> */ static final class LocalJackson2ObjectMapperBuilderCustomizer implements Jackson2ObjectMapperBuilderCustomizer, Ordered { private final ApplicationContext applicationContext; private final JacksonProperties jacksonProperties; LocalJackson2ObjectMapperBuilderCustomizer(ApplicationContext applicationContext, JacksonProperties jacksonProperties) { this.applicationContext = applicationContext; this.jacksonProperties = jacksonProperties; } @Override public int getOrder() { return Ordered.LOWEST_PRECEDENCE - 100; } @Override public void customize(Jackson2ObjectMapperBuilder builder) { if (this.jacksonProperties.getDefaultPropertyInclusion() != null) { builder.serializationInclusion(this.jacksonProperties.getDefaultPropertyInclusion()); } if (this.jacksonProperties.getTimeZone() != null) { builder.timeZone(this.jacksonProperties.getTimeZone()); } configureModules(builder); } /** * 将自定义创建JavaTimeModule配置在 Jackson2ObjectMapperBuilder * @param builder */ private void configureModules(Jackson2ObjectMapperBuilder builder) { Collection<Module> modules = getBeans(this.applicationContext, Module.class); if(CollectionUtils.isEmpty(modules)) { return; } builder.modulesToInstall(modules.toArray(new Module[0])); } private static <T> Collection<T> getBeans(ListableBeanFactory beanFactory, Class<T> type) { return BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory, type).values(); } } }
效果展示
反序列化
发起请求
url:/worker/test/queryByTime
method: post
请求参数：
{ "updateTime": "2021-12-22 17:12:47 599", "appName": "app-worker" }
结果展示
序列化
发起请求
url:127.0.0.1:9000/worker/node/query?appName=app-worker
method: get
结果展示
{ "code": "00000", "data": [ { "id": 507, "appName": "app-worker", "ip": "10.255.22.204", "port": 11111, "createTime": "2021-12-22 17:12:47 000", "updateTime": "2021-12-23 11:10:34 000" }, { "id": 511, "appName": "app-worker", "ip": "172.20.99.148", "port": 11111, "createTime": "2021-12-23 11:03:26 000", "updateTime": "2021-12-23 11:10:35 000" } ] }
其他实现方案
在JSR310属性上使用@Jsonformat注解，在看代码过程中看到这种解决方式，不过所有JSR310属性都要加，不满足要求，这种方式我并未做验证，有空闲时间了可以做一下验证。
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
