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<GenericConverter> globalConverters;
        private final Map<ConvertiblePair, GenericConversionService.ConvertersForPair> converters;
        ...
}

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

 private static class ConvertersForPair {
        private final LinkedList<GenericConverter> 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<Class<?>> 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<String, Date> {

    private static final List<String> 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<T>, 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去解析的），只是本人自己的认知，如有异议，欢迎反驳

第一种方式	第四种方式/类中单独配置	第四种方式/全局配置
63 75 79 61 74 77 69 80 83 65 76 79 61 73 76	67 77 80 67 79 82 57 70 73 60 70 72 57 66 69	70 82 85 72 82 85 58 69 72 59 74 80 61 71 74

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