项目中使用LocalDateTime系列作为DTO中时间的数据类型，但是SpringMVC收到参数后总报错，为了配置全局时间类型转换，尝试了如下处理方式。
注：本文基于Springboot2.x测试，如果无法生效可能是spring版本较低导致的。PS：如果你的Controller中的LocalDate类型的参数啥注解（RequestParam、PathVariable等）都没加，也是会出错的，因为默认情况下，解析这种参数是使用**ModelAttributeMethodProcessor**进行处理，而这个处理器要通过反射实例化一个对象出来，然后再对对象中的各个参数进行convert，但是LocalDate类没有构造函数，无法反射实例化因此会报错！！！

完成目标

  • 请求入参为 String（指定格式）转 Date，支持get、post（content-type=application/json）
  • 返回数据为Date类型转为指定的日期时间格式字符创

  • 支持Java8 日期 API，如：LocalTime、localDate 和 LocalDateTime

    GET请求及POST表单日期时间字符串格式转换

    这种情况要和时间作为Json字符串时区别对待，因为前端json转后端pojo底层使用的是Json序列化Jackson工具（HttpMessgeConverter）；而时间字符串作为普通请求参数传入时，转换用的是Converter，两者在处理方式上是有区别。

    使用自定义参数转换器（Converter）

    实现 org.springframework.core.convert.converter.Converter，自定义参数转换器，如下：

    1. @Configuration
    2. public class DateConverterConfig {
    3.   @Bean
    4.   public Converter<String, LocalDate> localDateConverter() {
    5.         return new Converter<String, LocalDate>() {
    6.           @Override
    7.           public LocalDate convert(String source) {
    8.               return LocalDate.parse(source, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    9.           }
    10.       };
    11.   }
    13.   @Bean
    14.   public Converter<String, LocalDateTime> localDateTimeConverter() {
    15.       return new Converter<String, LocalDateTime>() {
    16.           @Override
    17.           public LocalDateTime convert(String source) {
    18.               return LocalDateTime.parse(source, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    19.           }
    20.       };
    21.   }
    22. }

    小结：

  • GET请求及POST表单方式请求。

  • 支持LocalDate等Java8日期API。

点评：以上两个bean会注入到spring mvc的参数解析器（好像叫做ParameterConversionService），当传入的字符串要转为LocalDateTime类时，spring会调用该Converter对这个入参进行转换。
注意：关于自定义的参数转换器 Converter，这里我遇到了一个坑，我再这里详细记录下，本来我的想法是为了代码精简，将上面匿名内部类的写法精简成lambda表达式的方式：

  1. @Bean
  2. // @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  3. public Converter<String, LocalDate> localDateConverter() {
  4.     return source -> LocalDate.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT));
  5. }

当我再次启动项目时却出现了异常：

  1. Caused by: java.lang.IllegalArgumentException: Unable to determine source type <S> and target type <T> for your Converter [com.example.demo126.config.MappingConverterAdapter$$Lambda$522/817994751]; does the class parameterize those types?

百思不得其解，在查阅了资料才得知一二：
web项目启动注册requestMappingHandlerAdapter的时候会初始化WebBindingInitializer

  1. adapter.setWebBindingInitializer(getConfigurableWebBindingInitializer());

而ConfigurableWebBindingInitializer需要FormattingConversionService, 而FormattingConversionService会将所有的Converter添加进来，添加的时候需要获取泛型信息：

  1. @Override
  2. public void addFormatters(FormatterRegistry registry) {
  3.     for (Converter<?, ?> converter : getBeansOfType(Converter.class)) {
  4.           registry.addConverter(converter);
  5.     }
  6.     for (GenericConverter converter : getBeansOfType(GenericConverter.class)) {
  7.           registry.addConverter(converter);
  8.     }
  9.     for (Formatter<?> formatter : getBeansOfType(Formatter.class)) {
  10.           registry.addFormatter(formatter);
  11.     }
  12. }

添加Converter.class 一般是通过接口获取两个泛型的具体类型

  1. public ResolvableType as(Class<?> type) {
  2.     if (this == NONE) {
  3.       return NONE;
  4.     }
  5.     Class<?> resolved = resolve();
  6.     if (resolved == null || resolved == type) {
  7.       return this;
  8.     }
  9.     for (ResolvableType interfaceType : getInterfaces()) {
  10.       ResolvableType interfaceAsType = interfaceType.as(type);
  11.       if (interfaceAsType != NONE) {
  12.         return interfaceAsType;
  13.       }
  14.     }
  15.     return getSuperType().as(type);
  16. }

Lambda表达式的接口是Converter，并不能得到具体的类型，在窥探了SpringMVC源码后才得知原来如此，既然指导了原因，那解决办法：

  • 最简单的方法就是不适用Lambda表达式，还是老老实实的使用匿名内部类，这样就不会存在上述问题
  • 或者就是等requestMappingHandlerAdapterbean注册完成之后再添加自己的converter就不会注册到FormattingConversionService中
    1. @Bean
    2. @ConditionalOnBean(name = "requestMappingHandlerAdapter")
    3. public Converter<String, LocalDateTime> localDateTimeConverter() {
    4. return source -> LocalDateTime.parse(source, DateTimeUtils.DEFAULT_FORMATTER);
    5. }

    使用Spring注解

    使用spring自带注解@DateTimeFormat(pattern = “yyyy-MM-dd”)，如下：
    1. @DateTimeFormat(pattern = "yyyy-MM-dd")
    2. private Date startDate;
    如果使用了自定义参数转化器，Spring会优先使用该方式进行处理，即Spring注解不生效。

那么假如我们使用了自定义参数转换器，但是还是想兼容用yyyy-MM-dd形式接受呢？我们可以把前面的dateConverter改成用正则匹配方式，这样也不失为一种不错的解决方案，示例如下。

  1. /**
  2.  * 日期正则表达式
  3.  */
  4. private static final String DATE_REGEX = "[1-9]\\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])";
  6. /**
  7.  * 时间正则表达式
  8.  */
  9. private static final String TIME_REGEX = "(20|21|22|23|[0-1]\\d):[0-5]\\d:[0-5]\\d";
  11. /**
  12.  * 日期和时间正则表达式
  13.  */
  14. private static final String DATE_TIME_REGEX = DATE_REGEX + "\\s" + TIME_REGEX;
  16. /**
  17.  * 13位时间戳正则表达式
  18.  */
  19. private static final String TIME_STAMP_REGEX = "1\\d{12}";
  21. /**
  22.  * 年和月正则表达式
  23.  */
  24. private static final String YEAR_MONTH_REGEX = "[1-9]\\d{3}-(0[1-9]|1[0-2])";
  26. /**
  27.  * 年和月格式
  28.  */
  29. private static final String YEAR_MONTH_PATTERN = "yyyy-MM";
  31. @Bean
  32. public Converter<String, Date> dateConverter() {
  33.     return new Converter<String, Date>() {
  34.         @SuppressWarnings("NullableProblems")
  35.         @Override
  36.         public Date convert(String source) {
  37.             if (StrUtil.isEmpty(source)) {
  38.                 return null;
  39.             }
  40.             if (source.matches(TIME_STAMP_REGEX)) {
  41.                 return new Date(Long.parseLong(source));
  42.             }
  43.             DateFormat format;
  44.             if (source.matches(DATE_TIME_REGEX)) {
  45.                 format = new SimpleDateFormat(DEFAULT_DATETIME_PATTERN);
  46.             } else if (source.matches(DATE_REGEX)) {
  47.                 format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
  48.             } else if (source.matches(YEAR_MONTH_REGEX)) {
  49.                 format = new SimpleDateFormat(YEAR_MONTH_PATTERN);
  50.             } else {
  51.                 throw new IllegalArgumentException();
  52.             }
  53.             try {
  54.                 return format.parse(source);
  55.             } catch (ParseException e) {
  56.                 throw new RuntimeException(e);
  57.             }
  58.         }
  59.     };
  60. }

或者

  1.  @Bean
  2.     public Converter<String, Date> dateConverter() {
  3.         return new Converter<String, Date>() {
  4.             /*
  5.              * 可对value进行正则匹配，支持日期、时间等多种类型转换
  6.              * 这里我偷个懒，在匹配Date日期格式时直接使用了 hutool 为我们已经写好的解析工具类，这里就不重复造轮子了
  7.              * cn.hutool.core.date.DateUtil
  8.              * @param value
  9.              * @return
  10.              */
  11.             @SuppressWarnings("NullableProblems")
  12.             @Override
  13.             public Date convert(String source) {
  14.                 return DateUtil.parse(source.trim());
  15.             }
  16.         };
  17.     }

注：这里我偷个懒，在匹配Date日期格式时直接使用了 hutool 为我们已经写好的解析工具类，这里就不重复造轮子了，下面的方法同样使用了该工具类，想要在自己的项目中使用该工具类也很简单，在项目pom文件中引入hutool的依赖就可以了，如下：

  1. <!--hu tool 工具类-->
  2. <dependency>
  3.   <groupId>cn.hutool</groupId>
  4.   <artifactId>hutool-all</artifactId>
  5.   <version>5.1.3</version>
  6. </dependency>

小结：

  • GET请求及POST表单方式请求，但是需要在每个使用的地方加上@DateTimeFormat注解。
  • 与自定义参数转化器（Converter）不兼容。
  • 支持LocalDate等Java8日期API。

使用ControllerAdvice配合initBinder

  1. @ControllerAdvice
  2. public class GlobalExceptionHandler {
  4.     @InitBinder
  5.     protected void initBinder(WebDataBinder binder) {
  6.         binder.registerCustomEditor(LocalDate.class, new PropertyEditorSupport() {
  7.             @Override
  8.             public void setAsText(String text) throws IllegalArgumentException {
  9.                 setValue(LocalDate.parse(text, DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
  10.             }
  11.         });
  12.         binder.registerCustomEditor(LocalDateTime.class, new PropertyEditorSupport() {
  13.             @Override
  14.             public void setAsText(String text) throws IllegalArgumentException {
  15.                 setValue(LocalDateTime.parse(text, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)));
  16.             }
  17.         });
  18.         binder.registerCustomEditor(LocalTime.class, new PropertyEditorSupport() {
  19.             @Override
  20.             public void setAsText(String text) throws IllegalArgumentException {
  21.                 setValue(LocalTime.parse(text, DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
  22.             }
  23.         });
  24.         binder.registerCustomEditor(Date.class, new PropertyEditorSupport() {
  25.             @Override
  26.             public void setAsText(String text) throws IllegalArgumentException {
  27.                 SimpleDateFormat formatter = new SimpleDateFormat(DEFAULT_DATETIME_PATTERN);
  28.                 try {
  29.                     setValue(formatter.parse(text));
  30.                 } catch (Exception e) {
  31.                     throw new RuntimeException(String.format("Error parsing %s to Date", text));
  32.                 }
  33.             }
  34.         });
  35.     }   
  36. }

在实际应用中，我们可以把上面代码放到父类中，所有接口继承这个父类，达到全局处理的效果。原理就是与AOP类似，在参数进入handler之前进行转换时使用我们定义的PropertyEditorSupport来处理。
小结：

  • GET请求及POST表单方式请求。

  • 支持LocalDate等Java8日期API。

    JSON入参及返回值全局处理

    请求类型为:post,content-type=application/json， 后台用@RequestBody接收，默认接收及返回值格式为: yyyy-MM-dd HH:mm:ss

    修改 application.yml 文件

    在application.propertities文件中增加如下内容：

    1. spring:
    2.   jackson:
    3.       date-format: yyyy-MM-dd HH:mm:ss
    4.       time-zone: GMT+8

  • 支持（content-type=application/json）请求中格式为 yyyy-MM-dd HH:mm:ss的字符串，后台用@RequestBody接收，及返回值date转为yyyy-MM-dd HH:mm:ss格式string；

  • 不支持（content-type=application/json）请求中yyyy-MM-dd等类型的字符串转为date；

  • 不支持java8日期api;

    利用Jackson的JSON序列化和反序列化

    1. /**
    2. * Jackson序列化和反序列化转换器，用于转换Post请求体中的json以及将对象序列化为返回响应的json
    3. */
    4. @Bean
    5. public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
    6.   return builder -> builder
    7.           .serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)))
    8.           .serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)))
    9.           .serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)))
    10.           .serializerByType(Date.class, new DateSerializer(false, new SimpleDateFormat(DEFAULT_DATETIME_PATTERN)))
    11.           .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)))
    12.           .deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)))
    13.           .deserializerByType(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)))
    14.           .deserializerByType(Date.class, new DateDeserializers.DateDeserializer(DateDeserializers.DateDeserializer.instance, new SimpleDateFormat(DEFAULT_DATETIME_PATTERN), DEFAULT_DATETIME_PATTERN))
    15.           ;
    16. }

    小结：

  • 支持Content-Type 是application/json的POST请求，请求参数字符串和返回的格式都是yyyy-MM-dd HH:mm:ss如果请求参数是其他格式，如yyyy-MM-dd字符串则报400 Bad Request异常。

  • 支持LocalDate等Java8日期API。

PS：上面的方式是通过配置一个Jackson2ObjectMapperBuilderCustomizerBean完成的，除了这种，也可以通过自定义一个MappingJackson2HttpMessageConverter来实现。

  1. @Configuration
  2. public class JacksonConfig {
  4.     /** 默认日期时间格式 */
  5.     public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  6.     /** 默认日期格式 */
  7.     public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  8.     /** 默认时间格式 */
  9.     public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
  11.     @Bean
  12.     public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
  13.         MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
  14.         ObjectMapper objectMapper = new ObjectMapper();
  16.         // 忽略json字符串中不识别的属性
  17.         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  18.         // 忽略无法转换的对象 
  19.         objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
  20.         // PrettyPrinter 格式化输出
  21.         objectMapper.configure(SerializationFeature.INDENT_OUTPUT, true);
  22.         // NULL不参与序列化
  23.         // objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  25.         // 指定时区
  26.         objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
  27.         // 日期类型字符串处理
  28.         objectMapper.setDateFormat(new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT));
  30.         // java8日期日期处理
  31.         JavaTimeModule javaTimeModule = new JavaTimeModule();
  32.         javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  33.         javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  34.         javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  35.         javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  36.         javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  37.         javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  38.         objectMapper.registerModule(javaTimeModule);
  40.         converter.setObjectMapper(objectMapper);
  41.         return converter;
  42.     }
  43. }

以上几种方式都可以实现JSON传参时的全局化配置，更推荐后两种代码中增加配置bean的方式，可以同时支持Date和LocalDate。

JSON入参及返回值局部差异化处理

场景： 假如全局日期时间处理格式为：yyyy-MM-dd HH:mm:ss，但是某个字段要求接收或返回日期yyyy-MM-dd。

方式一 使用@DateTimeFormat和@JsonFormat注解

使用springboot自带的注解@JsonFormat(pattern = “yyyy-MM-dd”)，如下所示：

  1. @JsonFormat(pattern = "yyyy-MM-dd", timezone="GMT+8")
  2. @DateTimeFormat(pattern = "yyyy-MM-dd")
  3. private Date originalDate;

如上所示，可以在字段上增加@DateTimeFormat和@JsonFormat注解，可以分别单独指定该字段的接收和返回的日期格式。

PS:@JsonFormat和@DateTimeFormat注解都不是Spring Boot提供的，在Spring应用中也可以使用。

再次提醒，如果使用了自定义参数转化器（Converter），Spring会优先使用该方式进行处理，即@DateTimeFormat注解不生效。

方式二 自定义序列化器和反序列化器

  1. /**
  2.  * 日期序列化
  3.  */
  4. public class DateJsonSerializer extends JsonSerializer<Date> {
  5.     @Override
  6.     public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
  7.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  8.         jsonGenerator.writeString(dateFormat.format(date));
  9.     }
  10. }
  12. /**
  13.  * 日期反序列化
  14.  */
  15. public class DateJsonDeserializer extends JsonDeserializer<Date> {
  16.     @Override
  17.     public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
  18.         try {
  19.             SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  20.             return dateFormat.parse(jsonParser.getText());
  21.         } catch (ParseException e) {
  22.             throw new RuntimeException(e);
  23.         }
  24.     }
  25. }
  27. /**
  28.  * 使用方式
  29.  */
  30. @JsonSerialize(using = DateJsonSerializer.class)
  31. @JsonDeserialize(using = DateJsonDeserializer.class)
  32. private Date releaseDate;

日期时间格式化处理方式完整配置

方式一

  1. @Configuration
  2. public class DateHandlerConfig {
  4.     /** 默认日期时间格式 */
  5.     public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  6.     /** 默认日期格式 */
  7.     public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  8.     /** 默认时间格式 */
  9.     public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
  11.     /**
  12.      * LocalDate转换器，用于转换RequestParam和PathVariable参数
  13.      * `@ConditionalOnBean(name = "requestMappingHandlerAdapter")`: 等requestMappingHandlerAdapter bean注册完成之后
  14.      * 再添加自己的`converter`就不会注册到`FormattingConversionService`中
  15.      */
  16.     @Bean
  17.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  18.     public Converter<String, LocalDate> localDateConverter() {
  19.         return source -> LocalDate.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT));
  20.     }
  22.     /**
  23.      * LocalDateTime转换器，用于转换RequestParam和PathVariable参数
  24.      */
  25.     @Bean
  26.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  27.     public Converter<String, LocalDateTime> localDateTimeConverter() {
  28.         return source -> LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT));
  29.     }
  31.     /**
  32.      * LocalTime转换器，用于转换RequestParam和PathVariable参数
  33.      */
  34.     @Bean
  35.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  36.     public Converter<String, LocalTime> localTimeConverter() {
  37.         return source -> LocalTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT));
  38.     }
  40.     /**
  41.      * Date转换器，用于转换RequestParam和PathVariable参数
  42.      * 这里关于解析各种格式的日期格式采用了 hutool 的日期解析工具类
  43.      */
  44.     @Bean
  45.     public Converter<String, Date> dateConverter() {
  46.         return new Converter<String, Date>() {
  47.             @Override
  48.             public Date convert(String source) {
  49.                 return DateUtil.parse(source.trim());
  50.             }
  51.         };
  52.     }
  54.     /**
  55.      * Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
  56.      */
  57.     @Bean
  58.     public ObjectMapper objectMapper(){
  59.         ObjectMapper objectMapper = new ObjectMapper();
  60.         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  61.         objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
  63.         //LocalDateTime系列序列化和反序列化模块，继承自jsr310，我们在这里修改了日期格式
  64.         JavaTimeModule javaTimeModule = new JavaTimeModule();
  65.         javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  66.         javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  67.         javaTimeModule.addSerializer(LocalTime.class,new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  68.         javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  69.         javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  70.         javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  73.         // Date序列化和反序列化,會導致@JsonFormat失效
  74.         javaTimeModule.addSerializer(Date.class, new JsonSerializer<>() {
  75.             @Override
  76.             public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
  77.                 SimpleDateFormat formatter = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
  78.                 String formattedDate = formatter.format(date);
  79.                 jsonGenerator.writeString(formattedDate);
  80.             }
  81.         });
  82.         javaTimeModule.addDeserializer(Date.class, new JsonDeserializer<>() {
  83.             @Override
  84.             public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
  85.                 SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
  86.                 String date = jsonParser.getText();
  87.                 try {
  88.                     return format.parse(date);
  89.                 } catch (ParseException e) {
  90.                     throw new RuntimeException(e);
  91.                 }
  92.             }
  93.         });
  95.         objectMapper.registerModule(javaTimeModule);
  96.         return objectMapper;
  97.     }
  98. }

方式二

  1. import cn.hutool.core.util.StrUtil;
  2. import com.fasterxml.jackson.databind.deser.std.DateDeserializers;
  3. import com.fasterxml.jackson.databind.ser.std.DateSerializer;
  4. import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
  5. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
  6. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
  7. import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
  8. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
  9. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
  10. import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
  11. import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
  12. import org.springframework.context.annotation.Bean;
  13. import org.springframework.context.annotation.Configuration;
  14. import org.springframework.core.convert.converter.Converter;
  16. import java.text.DateFormat;
  17. import java.text.ParseException;
  18. import java.text.SimpleDateFormat;
  19. import java.time.LocalDate;
  20. import java.time.LocalDateTime;
  21. import java.time.LocalTime;
  22. import java.time.format.DateTimeFormatter;
  23. import java.util.Date;
  25. @Configuration
  26. public class DateHandlerConfig {
  28.     /**
  29.      * 日期正则表达式
  30.      */
  31.     private static final String DATE_REGEX = "[1-9]\\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])";
  33.     /**
  34.      * 时间正则表达式
  35.      */
  36.     private static final String TIME_REGEX = "(20|21|22|23|[0-1]\\d):[0-5]\\d:[0-5]\\d";
  38.     /**
  39.      * 日期和时间正则表达式
  40.      */
  41.     private static final String DATE_TIME_REGEX = DATE_REGEX + "\\s" + TIME_REGEX;
  43.     /**
  44.      * 13位时间戳正则表达式
  45.      */
  46.     private static final String TIME_STAMP_REGEX = "1\\d{12}";
  48.     /**
  49.      * 年和月正则表达式
  50.      */
  51.     private static final String YEAR_MONTH_REGEX = "[1-9]\\d{3}-(0[1-9]|1[0-2])";
  53.     /**
  54.      * 年和月格式
  55.      */
  56.     private static final String YEAR_MONTH_PATTERN = "yyyy-MM";
  58.     /**
  59.      * DateTime格式化字符串
  60.      */
  61.     private static final String DEFAULT_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  63.     /**
  64.      * Date格式化字符串
  65.      */
  66.     private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
  68.     /**
  69.      * Time格式化字符串
  70.      */
  71.     private static final String DEFAULT_TIME_PATTERN = "HH:mm:ss";
  73.     /**
  74.      * LocalDate转换器，用于转换RequestParam和PathVariable参数
  75.      */
  76.     @Bean
  77.     public Converter<String, LocalDate> localDateConverter() {
  78.         return new Converter<String, LocalDate>() {
  79.             @SuppressWarnings("NullableProblems")
  80.             @Override
  81.             public LocalDate convert(String source) {
  82.                 if (StrUtil.isEmpty(source)) {
  83.                     return null;
  84.                 }
  85.                 return LocalDate.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN));
  86.             }
  87.         };
  88.     }
  90.     /**
  91.      * LocalDateTime转换器，用于转换RequestParam和PathVariable参数
  92.      */
  93.     @Bean
  94.     public Converter<String, LocalDateTime> localDateTimeConverter() {
  95.         return new Converter<String, LocalDateTime>() {
  96.             @SuppressWarnings("NullableProblems")
  97.             @Override
  98.             public LocalDateTime convert(String source) {
  99.                 if (StrUtil.isEmpty(source)) {//使用hutool工具cn.hutool.core.util.StrUtil
  100.                     return null;
  101.                 }
  102.                 return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN));
  103.             }
  104.         };
  105.     }
  107.     /**
  108.      * LocalDate转换器，用于转换RequestParam和PathVariable参数
  109.      */
  110.     @Bean
  111.     public Converter<String, LocalTime> localTimeConverter() {
  112.         return new Converter<String, LocalTime>() {
  113.             @SuppressWarnings("NullableProblems")
  114.             @Override
  115.             public LocalTime convert(String source) {
  116.                 if (StrUtil.isEmpty(source)) {
  117.                     return null;
  118.                 }
  119.                 return LocalTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN));
  120.             }
  121.         };
  122.     }
  124.     /**
  125.      * Date转换器，用于转换RequestParam和PathVariable参数
  126.      */
  127.     @Bean
  128.     public Converter<String, Date> dateConverter() {
  129.         return new Converter<String, Date>() {
  130.             @SuppressWarnings("NullableProblems")
  131.             @Override
  132.             public Date convert(String source) {
  133.                 if (StrUtil.isEmpty(source)) {
  134.                     return null;
  135.                 }
  136.                 if (source.matches(TIME_STAMP_REGEX)) {
  137.                     return new Date(Long.parseLong(source));
  138.                 }
  139.                 DateFormat format;
  140.                 if (source.matches(DATE_TIME_REGEX)) {
  141.                     format = new SimpleDateFormat(DEFAULT_DATETIME_PATTERN);
  142.                 } else if (source.matches(DATE_REGEX)) {
  143.                     format = new SimpleDateFormat(DEFAULT_DATE_PATTERN);
  144.                 } else if (source.matches(YEAR_MONTH_REGEX)) {
  145.                     format = new SimpleDateFormat(YEAR_MONTH_PATTERN);
  146.                 } else {
  147.                     throw new IllegalArgumentException();
  148.                 }
  149.                 try {
  150.                     return format.parse(source);
  151.                 } catch (ParseException e) {
  152.                     throw new RuntimeException(e);
  153.                 }
  154.             }
  155.         };
  156.     }
  158.     /**
  159.      * Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
  160.      */
  161.     @Bean
  162.     public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
  163.         return builder -> builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)))
  164.                 .serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)))
  165.                 .serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)))
  166.                 .serializerByType(Long.class, ToStringSerializer.instance)
  167.                 .serializerByType(Date.class, new DateSerializer(false, new SimpleDateFormat(DEFAULT_DATETIME_PATTERN)))
  168.                 .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)))
  169.                 .deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)))
  170.                 .deserializerByType(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)))
  171.                 .deserializerByType(Date.class, new DateDeserializers.DateDeserializer(DateDeserializers.DateDeserializer.instance, new SimpleDateFormat(DEFAULT_DATETIME_PATTERN), DEFAULT_DATETIME_PATTERN));
  172.     }
  174.     //    @Bean
  175. //    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
  176. //        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
  177. //        ObjectMapper objectMapper = new ObjectMapper();
  178. //        // 指定时区
  179. //        objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
  180. //        // 日期类型字符串处理
  181. //        objectMapper.setDateFormat(new SimpleDateFormat(DEFAULT_DATETIME_PATTERN));
  182. //
  183. //        // Java8日期日期处理
  184. //        JavaTimeModule javaTimeModule = new JavaTimeModule();
  185. //        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)));
  186. //        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
  187. //        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
  188. //        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)));
  189. //        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
  190. //        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
  191. //        objectMapper.registerModule(javaTimeModule);
  192. //
  193. //        converter.setObjectMapper(objectMapper);
  194. //        return converter;
  195. //    }
  197. }

项目中使用（前面两种的合并）

  1. package com.ipebg.base.config;
  3. import cn.hutool.core.date.DateUtil;
  4. import cn.hutool.core.util.StrUtil;
  5. import com.fasterxml.jackson.databind.deser.std.DateDeserializers;
  6. import com.fasterxml.jackson.databind.ser.std.DateSerializer;
  7. import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
  8. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
  9. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
  10. import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
  11. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
  12. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
  13. import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
  14. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
  15. import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
  16. import org.springframework.context.annotation.Bean;
  17. import org.springframework.context.annotation.Configuration;
  18. import org.springframework.core.convert.converter.Converter;
  20. import java.text.SimpleDateFormat;
  21. import java.time.LocalDate;
  22. import java.time.LocalDateTime;
  23. import java.time.LocalTime;
  24. import java.time.format.DateTimeFormatter;
  25. import java.util.Date;
  27. /**
  28.  * 全局日期處理類
  29.  *
  30.  * @author H2014242
  31.  * 2021/3/15 上午 11:19
  32.  */
  33. @Configuration
  34. public class DateHandlerConfig {
  36.     /**
  37.      * DateTime格式化字符串
  38.      */
  39.     private static final String DEFAULT_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  41.     /**
  42.      * Date格式化字符串
  43.      */
  44.     private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
  46.     /**
  47.      * Time格式化字符串
  48.      */
  49.     private static final String DEFAULT_TIME_PATTERN = "HH:mm:ss";
  51.     /**
  52.      * LocalDate转换器，用于转换RequestParam和PathVariable参数
  53.      */
  54.     @Bean
  55.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  56.     public Converter<String, LocalDate> localDateConverter() {
  57.         return source -> {
  58.             if (StrUtil.isEmpty(source)) {
  59.                 return null;
  60.             }
  61.             return LocalDate.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN));
  62.         };
  63.     }
  65.     /**
  66.      * LocalDateTime转换器，用于转换RequestParam和PathVariable参数
  67.      * 不要听信idea的自动提示将代码转化成lambda方式，会报错
  68.      */
  69.     @Bean
  70.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  71.     public Converter<String, LocalDateTime> localDateTimeConverter() {
  72.         return source -> {
  73.             if (StrUtil.isEmpty(source)) {
  74.                 return null;
  75.             }
  76.             return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN));
  77.         };
  78.     }
  80.     /**
  81.      * LocalDate转换器，用于转换RequestParam和PathVariable参数
  82.      */
  83.     @Bean
  84.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  85.     public Converter<String, LocalTime> localTimeConverter() {
  86.         return source -> {
  87.             if (StrUtil.isEmpty(source)) {
  88.                 return null;
  89.             }
  90.             return LocalTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN));
  91.         };
  92.     }
  94.     /**
  95.      * Date转换器，用于转换RequestParam和PathVariable参数
  96.      */
  97.     @Bean
  98.     @ConditionalOnBean(name = "requestMappingHandlerAdapter")
  99.     public Converter<String, Date> dateConverter() {
  100.         return source -> DateUtil.parse(source.trim());
  101.     }
  103.     /**
  104.      * Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
  105.      */
  106.     @Bean
  107.     public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
  108.         return builder -> builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)))
  109.                 .serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)))
  110.                 .serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)))
  111.                 .serializerByType(Long.class, ToStringSerializer.instance)
  112.                 .serializerByType(Date.class, new DateSerializer(false, new SimpleDateFormat(DEFAULT_DATETIME_PATTERN)))
  113.                 .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)))
  114.                 .deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)))
  115.                 .deserializerByType(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)))
  116.                 .deserializerByType(Date.class, new DateDeserializers.DateDeserializer(DateDeserializers.DateDeserializer.instance, new SimpleDateFormat(DEFAULT_DATETIME_PATTERN), DEFAULT_DATETIME_PATTERN))
  117.                 ;
  118.     }
  120. }

总结

controller方法的参数是通过不同的HandlerMethodArgumentResolver完成解析的。如果参数标注了@RequestBody注解，实际上是通过MappingJackson2HttpMessageConverter的ObjectMapper将传入json格式数据反序列化解析成目标类型的。如果标注了@RequestParam注解，是通过在应用初始化时注入到ConversionService的一个个Converter来实现的。其他的HandlerMethodArgumentResolver也是各有各的用处，大家可以再看看相关代码，以便加深理解。

  1. // 只能处理Date类型参数的接受和返回，且必须为下面配置指定的格式。
  2. // 支持 GET请求及POST表单方式请求，支持Content-Type 是application/json的POST请求。
  3. // 不支持 LocalDate等Java8日期API。
  4. spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
  5. spring.jackson.time-zone=GMT+8
  7. // @JsonFormat处理Date类型参数的接受和返回，且必须为下面配置指定的格式。
  8. // @JsonFormat处理LocalDate等Java8日期API,只能返回的json按照指定的格式，如果没有标注@JsonFormat
  9. // 支持 GET请求及POST表单方式请求，支持Content-Type 是application/json的POST请求。
  10. // LocalDate的返回格式为 "2021-04-07",LocalDateTime的返回格式为"2021-04-07T16:53:56.525"
  11. @JsonFormat(pattern = "yyyy-MM-dd", timezone="GMT+8")
  12. private Date releaseDate;
  14. 对于参数而言，org.springframework.core.convert.converter.Converter<S, T>的优先级高于@DateTimeFormat，
  15. 也就是定义了对应时间类型的转换器，@DateTimeFormat不再起作用，格式化以转换器为准；
  17. 对于RequestBody和返回结果，@JsonFormat的优先级高于org.springframework.http.converter.HttpMessageConverter<T>，在定义了MappingJackson2HttpMessageConverter对时间的序列化与反序列化的情况下，
  18. 如果Field注解了@JsonFormat且格式不一致，以@JsonFormat注解格式为准

源码剖析

在了解完怎么样进行全局设置后，接下来我们通过debug源码来深入剖析一下Spring MVC是如何进行参数绑定的。

  1. @RequestMapping("/date")
  2. public DateEntity getDate(
  3.         LocalDate date,
  4.         LocalDateTime dateTime,
  5.         Date originalDate,
  6.         DateEntity dateEntity) {
  7.     System.out.printf("date=%s, dateTime=%s, originalDate=%s \n", date, dateTime, originalDate);
  8.     return dateEntity;
  9. }

以下是收到请求后的方法调用栈的一些关键方法：

  1. // DispatcherServlet处理请求
  2. doService:943, DispatcherServlet
  3. // 处理请求
  4. doDispatch:1040, DispatcherServlet
  5. // 生成调用链（前处理、实际调用方法、后处理）
  6. handle:87, AbstractHandlerMethodAdapter
  7. handleInternal:793, RequestMappingHandlerAdapter
  8. // 反射获取到实际调用方法，准备开始调用
  9. invokeHandlerMethod:879, RequestMappingHandlerAdapter
  10. invokeAndHandle:105, ServletInvocableHandlerMethod 
  11. // 关键步骤，从这里开始处理请求参数
  12. invokeForRequest:134, InvocableHandlerMethod
  13. getMethodArgumentValues:167, InvocableHandlerMethod
  14. resolveArgument:121, HandlerMethodArgumentResolverComposite

下面我们从关键的invokeForRequest:134, InvocableHandlerMethod处开始分析，源码如下

  1. // InvocableHandlerMethod.java
  2. @Nullable
  3. public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
  4.         Object... providedArgs) throws Exception {
  5.     // 这里完成参数的转换，得到的是转换后的值
  6.     Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
  7.     if (logger.isTraceEnabled()) {
  8.         logger.trace("Arguments: " + Arrays.toString(args));
  9.     }
  10.     // 反射调用，真正开始执行方法
  11.     return doInvoke(args);
  12. }
  13. // 具体实现
  14. protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
  15.         Object... providedArgs) throws Exception {
  16.     // 获取当前handler method的方法参数数组，封装了入参信息，比如类型、泛型等
  17.     MethodParameter[] parameters = getMethodParameters();
  18.     if (ObjectUtils.isEmpty(parameters)) {
  19.         return EMPTY_ARGS;
  20.     }
  21.     // 该数组用来存放从MethodParameter转换后的结果
  22.     Object[] args = new Object[parameters.length];
  23.     for (int i = 0; i < parameters.length; i++) {
  24.         MethodParameter parameter = parameters[i];
  25.         parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
  26.         args[i] = findProvidedArgument(parameter, providedArgs);
  27.         if (args[i] != null) {
  28.             continue;
  29.         }
  30.         // resolvers是定义的成员变量，HandlerMethodArgumentResolverComposite类型，是各式各样的HandlerMethodArgumentResolver的集合。这里来判断一下是否存在支持当前方法参数的参数处理器
  31.         if (!this.resolvers.supportsParameter(parameter)) {
  32.             throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
  33.         }
  34.         try {
  35.             // 调用HandlerMethodArgumentResolverComposite来处理参数，下面会重点看一下内部的逻辑
  36.             args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
  37.         }
  38.         catch (Exception ex) {
  39.             ......
  40.         }
  41.     }
  42.     return args;
  43. }

下面需要进入HandlerMethodArgumentResolverComposite#resolveArgument方法源码里面。

  1. // HandlerMethodArgumentResolverComposite.java
  2. @Override
  3. @Nullable
  4. public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
  5.         NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
  6.     // 这里来获取匹配当前方法参数的参数解析器
  7.     HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
  8.     if (resolver == null) {
  9.         throw new IllegalArgumentException("Unsupported parameter type [" +
  10.                 parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
  11.     }
  12.     // 调用真正的参数解析器来处理参数并返回
  13.     return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
  14. }
  15. // 获取匹配当前方法参数的参数解析器
  16. @Nullable
  17. private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
  18.     // 首先从缓存中查询是否有适配当前方法参数的参数解析器，首次进入是没有的
  19.     HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
  20.     if (result == null) {
  21.         for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
  22.             // 逐个遍历argumentResolvers这个list里的参数解析器来判断是否支持
  23.             if (resolver.supportsParameter(parameter)) {
  24.                 result = resolver;
  25.                 this.argumentResolverCache.put(parameter, result);
  26.                 break;
  27.             }
  28.         }
  29.     }
  30.     return result;
  31. }

argumentResolvers里一共有26个参数解析器，下面罗列一下常见的。

  1. this.argumentResolvers = {LinkedList@6072}  size = 26
  2.  0 = {RequestParamMethodArgumentResolver@6098} 
  3.  1 = {RequestParamMapMethodArgumentResolver@6104} 
  4.  2 = {PathVariableMethodArgumentResolver@6111} 
  5.  3 = {PathVariableMapMethodArgumentResolver@6112} 
  6.  ......
  7.  7 = {RequestResponseBodyMethodProcessor@6116} 
  8.  8 = {RequestPartMethodArgumentResolver@6117} 
  9.  9 = {RequestHeaderMethodArgumentResolver@6118} 
  10.  10 = {RequestHeaderMapMethodArgumentResolver@6119} 
  11.  ......
  12.  14 = {RequestAttributeMethodArgumentResolver@6123} 
  13.  15 = {ServletRequestMethodArgumentResolver@6124} 
  14.  ......
  15.  24 = {RequestParamMethodArgumentResolver@6107} 
  16.  25 = {ServletModelAttributeMethodProcessor@6133}

所有的参数解析器都实现了HandlerMethodArgumentResolver接口。

  1. public interface HandlerMethodArgumentResolver {
  3.     // 上面用到用来判断当前参数解析器是否支持给定的方法参数
  4.     boolean supportsParameter(MethodParameter parameter);
  6.     // 解析给定的方法参数并返回
  7.     @Nullable
  8.     Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
  9.             NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
  11. }

到这里我们整理一下思路，对方法参数的解析都是通过逐个遍历找到合适的HandlerMethodArgumentResolver来完成的。比如，如果参数上标注了@RequestParam或者@RequestBody或者@PathVariable注解，SpringMVC会用不同的参数解析器来解析。下面挑一个最常用的RequestParamMethodArgumentResolver来深入分析一下详细的解析流程。

RequestParamMethodArgumentResolver继承自AbstractNamedValueMethodArgumentResolver，AbstractNamedValueMethodArgumentResolver实现了HandlerMethodArgumentResolver接口的resolveArgument方法。

  1. // AbstractNamedValueMethodArgumentResolver.java
  2. @Override
  3. @Nullable
  4. public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
  5.         NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
  7.     // 解析出传入的原始值，作为下面方法的参数
  8.     Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
  9.     ......
  10.     if (binderFactory != null) {
  11.         // 创建 DataBinder 
  12.         WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
  13.         try {
  14.             // 通过DataBinder进行参数绑定，参数列表：原始值，目标类型，方法参数
  15.             arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
  16.         }
  17.         ......
  18.     }
  20.     handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
  22.     return arg;
  23. }
  25. // DataBinder.java
  26. @Override
  27. @Nullable
  28. public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
  29.         @Nullable MethodParameter methodParam) throws TypeMismatchException {
  30.     // 调用子类的convertIfNecessary方法，这里的具体实现是TypeConverterSupport
  31.     return getTypeConverter().convertIfNecessary(value, requiredType, methodParam);
  32. }
  34. // TypeConverterSupport.java
  35. @Override
  36. @Nullable
  37. public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
  38.         @Nullable MethodParameter methodParam) throws TypeMismatchException {
  39.     // 调用重载的convertIfNecessary方法，通过MethodParameter构造了类型描述符TypeDescriptor
  40.     return convertIfNecessary(value, requiredType,
  41.             (methodParam != null ? new TypeDescriptor(methodParam) : TypeDescriptor.valueOf(requiredType)));
  42. }
  43. // convertIfNecessary方法
  44. @Nullable
  45. @Override
  46. public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
  47.         @Nullable TypeDescriptor typeDescriptor) throws TypeMismatchException {
  49.     Assert.state(this.typeConverterDelegate != null, "No TypeConverterDelegate");
  50.     try {
  51.         // 调用TypeConverterDelegate的convertIfNecessary方法
  52.         return this.typeConverterDelegate.convertIfNecessary(null, null, value, requiredType, typeDescriptor);
  53.     }
  54.     ......
  55. }

接下来进入TypeConverterDelegate的源码。

  1. // TypeConverterDelegate.java
  2. @Nullable
  3. public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
  4.         @Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException {
  6.     // 查找是否有适合需求类型的自定义的PropertyEditor。还记得上面的 使用@ControllerAdvice配合@initBinder 那一节吗，如果有按那样配置，这里就会找到
  7.     PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);
  9.     ConversionFailedException conversionAttemptEx = null;
  11.     // 查找到类型转换服务 ConversionService
  12.     ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
  13.     // 关键判断，如果没有PropertyEditor 就使用ConversionService
  14.     if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
  15.         TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
  16.         if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
  17.             try {
  18.                 // #1，类型转换服务转换完成后就返回，下面会详细解释
  19.                 return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
  20.             }
  21.             catch (ConversionFailedException ex) {
  22.                 // fallback to default conversion logic below
  23.                 conversionAttemptEx = ex;
  24.             }
  25.         }
  26.     }
  28.     Object convertedValue = newValue;
  30.     // 关键判断，如果有PropertyEditor就使用PropertyEditor
  31.     if (editor != null || (requiredType != null && !ClassUtils.isAssignableValue(requiredType, convertedValue))) {
  32.         ......
  33.         // 由editor完成转换    
  34.         convertedValue = doConvertValue(oldValue, convertedValue, requiredType, editor);
  35.     }
  37.     boolean standardConversion = false;
  39.     if (requiredType != null) {
  40.         // Try to apply some standard type conversion rules if appropriate.
  42.         if (convertedValue != null) {
  43.             if (Object.class == requiredType) {
  44.                 return (T) convertedValue;
  45.             }
  46.             // 下面是数组、集合类型属性的处理，这里会遍历集合元素，递归调用convertIfNecessary转化，再收集处理结果
  47.             else if (requiredType.isArray()) {
  48.                 // Array required -> apply appropriate conversion of elements.
  49.                 if (convertedValue instanceof String && Enum.class.isAssignableFrom(requiredType.getComponentType())) {
  50.                     convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
  51.                 }
  52.                 return (T) convertToTypedArray(convertedValue, propertyName, requiredType.getComponentType());
  53.             }
  54.             else if (convertedValue instanceof Collection) {
  55.                 // Convert elements to target type, if determined.
  56.                 convertedValue = convertToTypedCollection(
  57.                         (Collection<?>) convertedValue, propertyName, requiredType, typeDescriptor);
  58.                 standardConversion = true;
  59.             }
  60.             else if (convertedValue instanceof Map) {
  61.                 // Convert keys and values to respective target type, if determined.
  62.                 convertedValue = convertToTypedMap(
  63.                         (Map<?, ?>) convertedValue, propertyName, requiredType, typeDescriptor);
  64.                 standardConversion = true;
  65.             }
  66.             if (convertedValue.getClass().isArray() && Array.getLength(convertedValue) == 1) {
  67.                 convertedValue = Array.get(convertedValue, 0);
  68.                 standardConversion = true;
  69.             }
  70.             if (String.class == requiredType && ClassUtils.isPrimitiveOrWrapper(convertedValue.getClass())) {
  71.                 // We can stringify any primitive value...
  72.                 return (T) convertedValue.toString();
  73.             }
  74.             else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
  75.                 ......
  76.             }
  77.             else if (convertedValue instanceof Number && Number.class.isAssignableFrom(requiredType)) {
  78.                 convertedValue = NumberUtils.convertNumberToTargetClass(
  79.                         (Number) convertedValue, (Class<Number>) requiredType);
  80.                 standardConversion = true;
  81.             }
  82.         }
  83.         else {
  84.             // convertedValue == null，空值处理
  85.             if (requiredType == Optional.class) {
  86.                 convertedValue = Optional.empty();
  87.             }
  88.         }
  90.         ......
  91.     }
  92.     // 异常处理
  93.     if (conversionAttemptEx != null) {
  94.         if (editor == null && !standardConversion && requiredType != null && Object.class != requiredType) {
  95.             throw conversionAttemptEx;
  96.         }
  97.         logger.debug("Original ConversionService attempt failed - ignored since " +
  98.                 "PropertyEditor based conversion eventually succeeded", conversionAttemptEx);
  99.     }
  101.     return (T) convertedValue;
  102. }

假如我们配置了自定义的Converter，会进入#1的分支，由ConversionService进行类型转换，以其子类GenericConversionService为例。

  1. // GenericConversionService.java
  2. @Override
  3. @Nullable
  4. public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
  5.     ......
  6.     // 从缓存中找到匹配类型的conveter，以LocalDateTime为例，会找到我们自定义的localDateTimeConverter
  7.     GenericConverter converter = getConverter(sourceType, targetType);
  8.     if (converter != null) {
  9.         // 通过工具方法调用真正的converter完成类型转换。至此，完成了源类型到目标类型的转换
  10.         Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType);
  11.         return handleResult(sourceType, targetType, result);
  12.     }
  13.     return handleConverterNotFound(source, sourceType, targetType);
  14. }

以上就是处理标注@RequestParam注解的参数的RequestParamMethodArgumentResolver解析流程。
下面来看一下处理标注@RequestBody注解的参数的RequestResponseBodyMethodProcessor的解析流程，仍然是从resolveArgument方法切入。

  1. // RequestResponseBodyMethodProcessor.java
  2. @Override
  3. public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
  4.         NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
  6.     parameter = parameter.nestedIfOptional();
  7.     // 在这里完成参数的解析
  8.     Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
  9.     ......
  10.     return adaptArgumentIfNecessary(arg, parameter);
  11. }
  13. @Override
  14. protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
  15.         Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
  17.     HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
  18.     Assert.state(servletRequest != null, "No HttpServletRequest");
  19.     ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
  20.     // 调用父类AbstractMessageConverterMethodArgumentResolver完成参数解析
  21.     Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
  22.     if (arg == null && checkRequired(parameter)) {
  23.         throw new HttpMessageNotReadableException("Required request body is missing: " +
  24.                 parameter.getExecutable().toGenericString(), inputMessage);
  25.     }
  26.     return arg;
  27. }

下面进入父类AbstractMessageConverterMethodArgumentResolver的源码。

  1. // AbstractMessageConverterMethodArgumentResolver.java
  2. @Nullable
  3. protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
  4.         Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
  5.     ......
  6.     EmptyBodyCheckingHttpInputMessage message;
  7.     try {
  8.         message = new EmptyBodyCheckingHttpInputMessage(inputMessage);
  9.         // 遍历HttpMessageConverter
  10.         for (HttpMessageConverter<?> converter : this.messageConverters) {
  11.             Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
  12.             GenericHttpMessageConverter<?> genericConverter =
  13.                     (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
  14.             if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
  15.                     (targetClass != null && converter.canRead(targetClass, contentType))) {
  16.                 if (message.hasBody()) {
  17.                     HttpInputMessage msgToUse =
  18.                             getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
  19.                     // 实际由MappingJackson2HttpMessageConverter调用父类AbstractJackson2HttpMessageConverter的read方法完成解析，
  20.                     body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
  21.                             ((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
  22.                     body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
  23.                 }
  24.                 else {
  25.                     body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
  26.                 }
  27.                 break;
  28.             }
  29.         }
  30.     }
  31.     ......
  32.     return body;
  33. }
  35. // AbstractJackson2HttpMessageConverter.java
  36. @Override
  37. public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
  38.         throws IOException, HttpMessageNotReadableException {
  39.     // 获得要转换的目标参数Java类型，如LocalDateTime等
  40.     JavaType javaType = getJavaType(type, contextClass);
  41.     // 调用本类的readJavaType方法
  42.     return readJavaType(javaType, inputMessage);
  43. }
  45. // AbstractJackson2HttpMessageConverter.java
  46. private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) throws IOException {
  47.     try {
  48.         if (inputMessage instanceof MappingJacksonInputMessage) {
  49.             Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
  50.             if (deserializationView != null) {
  51.                 return this.objectMapper.readerWithView(deserializationView).forType(javaType).
  52.                         readValue(inputMessage.getBody());
  53.             }
  54.         }
  55.         // 调用jackson类库，将HTTP的json请求信息解析为需要的参数类型。至此，将json请求转换成目标Java类型
  56.         return this.objectMapper.readValue(inputMessage.getBody(), javaType);
  57.     }
  58.     ......
  59. }