springboot-mvc:入参日期类型转换String->Date

4种方式：

1.通过在application.ym中配置 spring.mvc.data-format: yyyy-MM-dd HH:mm:ss ，使用的是ParserConverter

• 优点：简单的配置就可以，很方便
• 缺点：只能设置一种格式生效（ps:可以通过addFormatterForFieldType方法设置多种格式，但是它内部维护的是一个linkedList,会将最后设置的addFirst,查找时从头开始找，找到即返回，所以生效的始终是最后设置的那个格式），参考如下配置，当传入yyyy/MM/dd这种格式时会报错

  第一步：
  spring:
    mvc:
      date-format: yyyy/MM/dd
  
  第二步：
  @Configuration
  public class TestAutoConfiguration {
  
      @Bean
      BeanPost beanPost() {
          return new BeanPost();
      }
  
  }
  
  class BeanPost implements BeanPostProcessor {
  
      @Override
      public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
          if (bean instanceof FormattingConversionService) {
              FormattingConversionService conversionService = (FormattingConversionService)bean;
              conversionService.addFormatterForFieldType(Date.class, new DateFormatter("yyyy-MM-dd HH:mm:ss"));
          }
          return bean;
      }
  }
  

• 原理：在WebMvcAutoConfiguration中会注入一个FormattingConversionService，用于解析入参的类型转换，FormattingConversionService中维护了一个converters

WebMvcAutoConfiguration {
               @Bean
		@Override
		public FormattingConversionService mvcConversionService() {
			WebConversionService conversionService = new WebConversionService(
					this.mvcProperties.getDateFormat());
			addFormatters(conversionService);
			return conversionService;
		}
}

WebMvcProperties{
    private String dateFormat;
　　...
}

FormattingConversionService ...{
　　private final GenericConversionService.Converters converters = new GenericConversionService.Converters();
　　...
}

再来看下这个converters对象，里面维护了一个map，map的key是ConvertiblePair，包含了转换的sourceType和targetType，value是ConvertersForPair，里面的list是可以真正用于转换操作的converter的集合，就是上面提到的会linkedList

 private static class Converters {
        private final Set globalConverters;
        private final Map converters;
        ...
}

 public static final class ConvertiblePair {
        private final Class<?> sourceType;
        private final Class<?> targetType;
        ...
}

 private static class ConvertersForPair {
        private final LinkedList converters;
        ...
}

 了解到上面的结构之后，就可以清楚的知道当一个请求进入之后的参数绑定过程，但是在调试的过程中发现一个问题，就是这段代码

@Override
	@Nullable
	public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
		MethodParameter nestedParameter = parameter.nestedIfOptional();

		Object resolvedName = resolveStringValue(namedValueInfo.name);
		if (resolvedName == null) {
			throw new IllegalArgumentException(
					"Specified name must not resolve to null: [" + namedValueInfo.name + "]");
		}

		Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
		if (arg == null) {
			if (namedValueInfo.defaultValue != null) {
				arg = resolveStringValue(namedValueInfo.defaultValue);
			}
			else if (namedValueInfo.required && !nestedParameter.isOptional()) {
				handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
			}
			arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
		}
		else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
			arg = resolveStringValue(namedValueInfo.defaultValue);
		}

		if (binderFactory != null) {
			WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
			try {
				arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
			}
			catch (ConversionNotSupportedException ex) {
				throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
						namedValueInfo.name, parameter, ex.getCause());
			}
			catch (TypeMismatchException ex) {
				throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
						namedValueInfo.name, parameter, ex.getCause());

			}
		}

		handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
		return arg;
	}

 跟进去看到这个方法执行时返回的始终是SimpleTypeConverter，那如果不是这个SimpleTypeConverter会不会跟上面的执行过程不一样呢？

protected TypeConverter getTypeConverter() {
		if (getTarget() != null) {
			return getInternalBindingResult().getPropertyAccessor();
		}
		else {
			return getSimpleTypeConverter();
		}
	}

 带着这个疑问，继续翻源码，可以看到是因为在上一步的WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);时，target写死了是null，所以才会返回SimpleTypeConverter,这样的话是不是可以有另一种方式传入一个target呢？目前看到的入口就是这里，好像改不了

2.在Date类型的入参上加上注解 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")，使用的是AnnotationParserConverter，本质上也是使用ParserConverter

• 优点：可以针对不同的参数要求灵活配置
• 缺点：每一个Date类型的参数都需要配置，增加代码量，这种converter属于default，配置了第一种方式也会有这个converter存在，但是它在linkedList中的位置在后面，会被第一种覆盖掉，也不知道是为什么还要加进去.........　　

  	public WebConversionService(String dateFormat) {
  		super(false);
  		this.dateFormat = StringUtils.hasText(dateFormat) ? dateFormat : null;
  		if (this.dateFormat != null) {
  			addFormatters();
  		}
  		else {
  			addDefaultFormatters(this);
  		}
  	}
  
  	@Override
  	public void addFormatterForFieldAnnotation(AnnotationFormatterFactory<? extends Annotation> annotationFormatterFactory) {
  		Class<? extends Annotation> annotationType = getAnnotationType(annotationFormatterFactory);
  		if (this.embeddedValueResolver != null && annotationFormatterFactory instanceof EmbeddedValueResolverAware) {
  			((EmbeddedValueResolverAware) annotationFormatterFactory).setEmbeddedValueResolver(this.embeddedValueResolver);
  		}
  		Set> fieldTypes = annotationFormatterFactory.getFieldTypes();
  		for (Class<?> fieldType : fieldTypes) {
  			addConverter(new AnnotationPrinterConverter(annotationType, annotationFormatterFactory, fieldType));
  			addConverter(new AnnotationParserConverter(annotationType, annotationFormatterFactory, fieldType));
  		}
  	}
  

• 原理：

     AnnotationParserConverter{
            ...
               @Override
  		@SuppressWarnings("unchecked")
  		@Nullable
  		public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
  			Annotation ann = targetType.getAnnotation(this.annotationType);
  			if (ann == null) {
  				throw new IllegalStateException(
  						"Expected [" + this.annotationType.getName() + "] to be present on " + targetType);
  			}
  			AnnotationConverterKey converterKey = new AnnotationConverterKey(ann, targetType.getObjectType());
  			GenericConverter converter = cachedParsers.get(converterKey);
  			if (converter == null) {
  				Parser<?> parser = this.annotationFormatterFactory.getParser(
  						converterKey.getAnnotation(), converterKey.getFieldType());
  				converter = new ParserConverter(this.fieldType, parser, FormattingConversionService.this);
  				cachedParsers.put(converterKey, converter);
  			}
  			return converter.convert(source, sourceType, targetType);
  		}
  }
  
        ParserConverter {
               ...
                  @Nullable
  		public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
  			String text = (String) source;
  			if (!StringUtils.hasText(text)) {
  				return null;
  			}
  			Object result;
  			try {
  				result = this.parser.parse(text, LocaleContextHolder.getLocale());
  			}
  			catch (IllegalArgumentException ex) {
  				throw ex;
  			}
  			catch (Throwable ex) {
  				throw new IllegalArgumentException("Parse attempt failed for value [" + text + "]", ex);
  			}
  			TypeDescriptor resultType = TypeDescriptor.valueOf(result.getClass());
  			if (!resultType.isAssignableTo(targetType)) {
  				result = this.conversionService.convert(result, resultType, targetType);
  			}
  			return result;
  		}
    
  }
  

3.自定义converter,本质就是将自定义的converter放到第一种的那个linkedList的头部

• 优点：统一管理，可以配置多个formatter
• 缺点：目前没有发现，哈哈

@Component
public class DateConverterConfig implements Converter {

    private static final List formarts = new ArrayList<>(4);
    static {
        formarts.add("yyyy-MM");
        formarts.add("yyyy-MM-dd");
        formarts.add("yyyy-MM-dd hh:mm");
        formarts.add("yyyy-MM-dd hh:mm:ss");
    }

    @Override
    public Date convert(String source) {
        String value = source.trim();
        if ("".equals(value)) {
            return null;
        }
        if (source.matches("^\\d{4}-\\d{1,2}$")) {
            return parseDate(source, formarts.get(0));
        } else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2}$")) {
            return parseDate(source, formarts.get(1));
        } else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}$")) {
            return parseDate(source, formarts.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, formarts.get(3));
        } else {
            throw new IllegalArgumentException("Invalid boolean value '" + source + "'");
        }
    }

    /**
     * 格式化日期
     * 
     * @param dateStr String 字符型日期
     * @param format String 格式
     * @return Date 日期
     */
    public Date parseDate(String dateStr, String format) {
        Date date = null;
        try {
            DateFormat dateFormat = new SimpleDateFormat(format);
            date = dateFormat.parse(dateStr);
        } catch (Exception e) {

        }
        return date;
    }

}

通过下面的方式将所有的bean加进去，所以也是可以覆盖的

		@Override
		public void addFormatters(FormatterRegistry registry) {
			for (Converter<?, ?> converter : getBeansOfType(Converter.class)) {
				registry.addConverter(converter);
			}
			for (GenericConverter converter : getBeansOfType(GenericConverter.class)) {
				registry.addConverter(converter);
			}
			for (Formatter<?> formatter : getBeansOfType(Formatter.class)) {
				registry.addFormatter(formatter);
			}
		}

4.通过@InitBinder,绑定CustomDateEditor，此方式可以覆盖第一种，某个类中的可以覆盖全局的，因为底层维护的是一个map,全局的会优先读取，后面的会按照你文件中写的顺序加载

上面的三种方式查找converter是一样的流程editor==null，具体参考org.springframework.beans.TypeConverterDelegate#convertIfNecessary(java.lang.String, java.lang.Object, java.lang.Object, java.lang.Class, org.springframework.core.convert.TypeDescriptor)方法，第四种方式的editor!=null,直接使用editor去解析

全局配置
@ControllerAdvice
public class CoreAspect {

    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
    }

}

某个类单独配置
@RestController
@RequestMapping("/api")
public class TestController {

    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
    }

    @RequestMapping("/test")
    public Object test(Date date) {
        // Date date = new Date();
        return date.getTime();
    }
}

 这种方式每次请求都会去执行initBinder，如果只是一个全局的设置，感觉效率会比第一种方式低，简单的验证了一下，时间上好像差不多，感觉可以忽略掉了，（前三种方式需要从converts里面去查找，里面有一系列的循环操作，第四种虽然每次都去执行initBinder方法，但是最后是直接使用editor去解析的），只是本人自己的认知，如有异议，欢迎反驳

 参考链接：https://blog.csdn.net/eumenides_/article/details/79033505