spring mvc的DataBinder、Validator、BeanWrapper、ConversionService、Formatter

我不是女神ヾ 2022-03-15 11:44 251阅读 0赞

很多人对spring mvc的请求处理流程都不陌生，今天我们要展开讲解的是请求体数据body的绑定、验证、格式化、类型转换，它是怎样实现的呢？其实就是大家熟悉的HandlerAdapter干的事情。

为何要讲这个呢？其实和我最近的工作内容是分不开的，刚好在设计开发一个数据聚合组件（它主要是解决微服务化后vo 拆分之疼），当然后续会开源出来的。

**目录**

spring mvc知识回顾

BeanWrapper

ConversionService

Formatter

DataBinder

四者关系图

Validator

非Spring MVC的使用

Spring MVC的使用

HttpMessageConverter和ConversionService是什么关系？

--------------------

### **spring mvc知识回顾** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 1][]

<table> 
 <tbody> 
 <tr> 
 <td>1</td> 
 <td style="width:638px;">用户向服务器发送请求，请求被Spring的DispatcherServlet（简称DS）捕获</td> 
 </tr> 
 <tr> 
 <td>2~5</td> 
 <td style="width:638px;">DS 首先对URL进行解析，得到请求资源标识符（URI），然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回</td> 
 </tr> 
 <tr> 
 <td>6~7</td> 
 <td style="width:638px;">DS 根据获得的Handler，选择一个合适的HandlerAdapter（如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）</td> 
 </tr> 
 <tr> 
 <td>8</td> 
 <td style="width:638px;"> 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：验证、格式化、类型转换 <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-config-message-converters" rel="nofollow">HttpMessageConveter</a>：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息。 </td> 
 </tr> 
 <tr> 
 <td>9</td> 
 <td style="width:638px;">Handler执行完成后，向DS返回一个ModelAndView对象</td> 
 </tr> 
 <tr> 
 <td>10</td> 
 <td style="width:638px;">此时DS将开始执行拦截器的postHandler(...)方法</td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td style="width:638px;">DS根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)。并调用&nbsp;该ViewResolver 结合Model和View，来渲染视图。将渲染结果返回给客户端。</td> 
 </tr> 
 </tbody> 
</table>

在8中是有关spring mvc request vo的处理，其实Spring官方文档有专门有些章节阐述“[Validation, Data Binding, and Type Conversion][Validation_ Data Binding_ and Type Conversion]”，其实用法很简单，但它内部是如何实现的却鲜有人知晓。

### BeanWrapper ###

BeanWrapper是一个方便开发人员使用字符串来对Java Bean的属性执行get、set操作的工具类。它为那些UI类app提供了极大的便利，是以字符串和用户交互的。

Foo foo = new Foo();
    BeanWrapperImpl fooWrapper = new BeanWrapperImpl(foo);
    fooWrapper.setPropertyValue("intProperty", "1");
    Object intProperty = fooWrapper.getPropertyValue("intProperty");

另外，BeanWrapper内部使用了两种机制：

> 1. PropertyEditor
> 
> BeanWrapper和java bean的内省模式密切关联，[之前的文章][Link 1]分享过，而PropertyEditor（只提供了String >> Object的转换）隶属于[Java Bean][]规范。

> 2. ConversionService
> 
> Spring自3.0之后提供的替代PropertyEditor的机制

注：按照Spring官方文档的说法，当容器内没有注册ConversionService的时候，会退回使用PropertyEditor机制。

### ConversionService ###

ConversionService及其相关一套[类型转换机制][Link 2]是一套通用的类型转换SPI，相比PropertyEditor只提供String >> Object的转换，ConversionService能够提供任意Object >> Object的转换。

由此我们可以看出，Spring为何要使用ConversionService替代PropertyEditor有三个原因：

1.  ConversionService功能更强大，支持的类型转换范围更广
2.  [ConverterFactory][]支持一整个class hierarchy的转换（也就是多态），PropertyEditor则不行
3.  Java Bean这个规范最初是和Java GUI（Swing）一起诞生的，PropertyEditor接口里有大量和GUI相关的方法，显然已经过时了。顺便提一句，Java Bean和POJO不是一个概念，Java Bean不仅有setter、getter，还有一系列和Java GUI配套的东西。

### Formatter ###

[Formatter SPI][]是另外一套和PropertyEditor类似的，String<->Object的转换机制，但是有两个优点：

1. 接口更干净，没有关于GUI的部分，只有 Printer.print() 和 Parser.parse() 两个方法
2. 基于注解，支持**同一类型的属性根据不同的格式**来做String<->Object的转换。比如日期类型，一个字段的格式是yyyy-MM-dd，另一个格式是yyyyMMdd，如果利用PropertyEditor是比较麻烦，但是在这里就可以利用`@DateTimeFormat`来达到这个效果。

Spring提供了DefaultFormattingConversionService来支持Formatter SPI，也就是说如果要使用Formatter SPI，依然可以利用ConversionService接口。

注：Formatter SPI必须基于注解才可以使用，这点和ConversionService基于类型不同。

### DataBinder ###

[DataBinder][]主要提供了两个功能：

1.  利用BeanWrapper，给对象的属性设值
2.  在设值的同时做Validation

//引自org.springframework.validation;
 public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 public void bind(PropertyValues pvs) {
 MutablePropertyValues mpvs = pvs instanceof MutablePropertyValues ? (MutablePropertyValues)pvs : new MutablePropertyValues(pvs);
 this.doBind(mpvs);
 }
 protected void doBind(MutablePropertyValues mpvs) {
 this.checkAllowedFields(mpvs);
 this.checkRequiredFields(mpvs);
 this.applyPropertyValues(mpvs);
 }
 protected void applyPropertyValues(MutablePropertyValues mpvs) {
 try {
 this.getPropertyAccessor().setPropertyValues(mpvs, this.isIgnoreUnknownFields(), this.isIgnoreInvalidFields());
 } catch (PropertyBatchUpdateException var7) {
 PropertyAccessException[] var3 = var7.getPropertyAccessExceptions();
 int var4 = var3.length;
 
 for(int var5 = 0; var5 < var4; ++var5) {
 PropertyAccessException pae = var3[var5];
 this.getBindingErrorProcessor().processPropertyAccessException(pae, this.getInternalBindingResult());
 }
 }
 }
 }

### 前四者关系图 ###

ConversionService有两种实现，也就是说，如果要支持Formatter SPI，只需要让BeanWrapper切换使用不同的ConversionService即可。

*  DefaultConversionService，不支持Formatter SPI
 *  DefaultFormattingConversionService，支持Formatter SPI

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 2][]

### Validator ###

`Validator`较简单，如果类路径上存在 [Bean Validation][]（例如，Hibernate Validator），则将`LocalValidatorFactoryBean` 注册为全局Validator，以便与@Valid一起使用在controller 方法参数上。

### 非Spring MVC的使用 ###

Spring Core Context（要解析spring xml的）其实也使用ConversionService，但是是非强制的。让Spring Core Context使用conversionService的方式很简单，配置一个名字叫做`conversionService`的Bean即可。需要注意的是，因为这个Bean是在非常早的时候就被使用的（[AbstractApplicationContext\#L834][AbstractApplicationContext_L834]），因此它最好不要依赖过多的其他的Bean，避免造成启动失败。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 3][]

Spring在读取xml配置文件的时候，因为xml文件实际上是一个文本文件，所有值的设置都是String，这个时候如果给bean的复杂类型属性设置值，它会用到PropertyEditor或ConversionService。

*<bean id="someBean" class="a.b.c.SomeBean"> 
    <property name="color" value="red"/> 
</bean>  *

例子中的`color`属性是`Color`类型，这时就会利用到PropertyEditor和ConversionService。

### Spring MVC的使用 ###

Spring MVC对于conversionService的使用比较特殊，它自己会注册一个名字叫做`mvcConversionService`类型为`DefaultFormattingConversionService`的Bean。因此会存在以下陷阱：

*  如果Core Context中也定义了一个ConversionService，那么在MVC环境下，会有两个ConversionService的Bean。
 *  针对Core Context的`ConversionService`做的Customize如[FormatterRegistrar][]、`ConverterRegistry`、`FormatterRegistry`、`ConversionServiceFactoryBean`、`FormattingConversionServiceFactoryBean`是不会应用到MVC的那个ConversionService上。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 4][]

上图在后面源码中细讲，对于mvcConversionService的配置途径见“`DataBinder`”或“[MVC Config API][]”。

### HttpMessageConverter和ConversionService是什么关系？ ###

> 个人理解，可以他们是不同的两种东西，二者各司其职，前者转换请求body信息和响应body信息，后者用于请求参数的转换。都可以接受文本信息，最终解析成对象。根本的区别：
> 
> **HttpMessageConvert**
> 
> 官方文档中的说明：We can use the *@RequestBody* annotation on the argument of a Controller method to indicate **that the body of the HTTP Request is deserialized to that particular Java entity**. To determine the appropriate converter, Spring will use the “Content-Type” header from the client request.
> 
> 对，*@RequestBody决定了要使用*HttpMessageConverter，而Content-Type则是选择具体某一个配置器。HttpMessageConverter<T>,默认有很多配置器：StringHttpMessageConverter，ByteArrayHttpMessageConverter，SourceHttpMessageConverter，FormHttpMessageConverter 。
> 
> **ConversionService**
> 
> 它使用的是 **WebDataBinder** （extends DataBinder），处理url或@RequestParam等非*@RequestBody参数*，它数据绑定是这样的流程：
> 
> 1. 将ServletRequest对象及处理方法入参对象实例传给DataBinder 
> 2. DataBinder 调用转配在Spring Web上下文中的ConversionService进行数据类型转换、数据格式化等工作，将ServletRequest中的消息填充到入参对象中
> 3. 调用 Validator 对已经绑定的请求信息数据的入参对象进行数据合法性校验，生成数据绑定结果 BindingResult。BindingResult 包含完成绑定的入参对象和相应的校验错误对象。而后将 BindingResult 中的入参对象及校验错误对象赋给处理方法的入参。

// 引自org.springframework.web.bind.annotation.support.HandlerMethodInvoker
 // 进行数据类型转换、填充并验证
 private Object[] resolveHandlerArguments(Method handlerMethod, Object handler,
 		NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
 
 	Class<?>[] paramTypes = handlerMethod.getParameterTypes();
 	Object[] args = new Object[paramTypes.length];
 // controller方法的每个参数
 	for (int i = 0; i < args.length; i++) {
 		MethodParameter methodParam = new SynthesizingMethodParameter(handlerMethod, i);
 		methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
 		GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
 		String paramName = null;
 		String headerName = null;
 		boolean requestBodyFound = false;
 		String cookieName = null;
 		String pathVarName = null;
 		String attrName = null;
 		boolean required = false;
 		String defaultValue = null;
 		boolean validate = false;
 		Object[] validationHints = null;
 		int annotationsFound = 0;
 		Annotation[] paramAnns = methodParam.getParameterAnnotations();
 
 		for (Annotation paramAnn : paramAnns) {
 			if (RequestParam.class.isInstance(paramAnn)) {
 				RequestParam requestParam = (RequestParam) paramAnn;
 				paramName = requestParam.name();
 				required = requestParam.required();
 				defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
 				annotationsFound++;
 			}
 			else if (RequestHeader.class.isInstance(paramAnn)) {
 				RequestHeader requestHeader = (RequestHeader) paramAnn;
 				headerName = requestHeader.name();
 				required = requestHeader.required();
 				defaultValue = parseDefaultValueAttribute(requestHeader.defaultValue());
 				annotationsFound++;
 			}
 			else if (RequestBody.class.isInstance(paramAnn)) {
 				requestBodyFound = true;
 				annotationsFound++;
 			}
 			else if (CookieValue.class.isInstance(paramAnn)) {
 				CookieValue cookieValue = (CookieValue) paramAnn;
 				cookieName = cookieValue.name();
 				required = cookieValue.required();
 				defaultValue = parseDefaultValueAttribute(cookieValue.defaultValue());
 				annotationsFound++;
 			}
 			else if (PathVariable.class.isInstance(paramAnn)) {
 				PathVariable pathVar = (PathVariable) paramAnn;
 				pathVarName = pathVar.value();
 				annotationsFound++;
 			}
 			else if (ModelAttribute.class.isInstance(paramAnn)) {
 				ModelAttribute attr = (ModelAttribute) paramAnn;
 				attrName = attr.value();
 				annotationsFound++;
 			}
 			else if (Value.class.isInstance(paramAnn)) {
 				defaultValue = ((Value) paramAnn).value();
 			}
 			else {
 				Validated validatedAnn = AnnotationUtils.getAnnotation(paramAnn, Validated.class);
 				if (validatedAnn != null || paramAnn.annotationType().getSimpleName().startsWith("Valid")) {
 					validate = true;
 					Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(paramAnn));
 					validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[]{hints});
 				}
 			}
 		}
 
 		if (annotationsFound > 1) {
 			throw new IllegalStateException("Handler parameter annotations are exclusive choices - " +
 					"do not specify more than one such annotation on the same parameter: " + handlerMethod);
 		}
 
 		if (annotationsFound == 0) {
 			Object argValue = resolveCommonArgument(methodParam, webRequest);
 			if (argValue != WebArgumentResolver.UNRESOLVED) {
 				args[i] = argValue;
 			}
 			else if (defaultValue != null) {
 				args[i] = resolveDefaultValue(defaultValue);
 			}
 			else {
 				Class<?> paramType = methodParam.getParameterType();
 				if (Model.class.isAssignableFrom(paramType) || Map.class.isAssignableFrom(paramType)) {
 					if (!paramType.isAssignableFrom(implicitModel.getClass())) {
 						throw new IllegalStateException("Argument [" + paramType.getSimpleName() + "] is of type " +
 								"Model or Map but is not assignable from the actual model. You may need to switch " +
 								"newer MVC infrastructure classes to use this argument.");
 					}
 					args[i] = implicitModel;
 				}
 				else if (SessionStatus.class.isAssignableFrom(paramType)) {
 					args[i] = this.sessionStatus;
 				}
 				else if (HttpEntity.class.isAssignableFrom(paramType)) {
 					// 调用HttpMessageConvert服务
 					args[i] = resolveHttpEntityRequest(methodParam, webRequest);
 				}
 				else if (Errors.class.isAssignableFrom(paramType)) {
 					throw new IllegalStateException("Errors/BindingResult argument declared " +
 							"without preceding model attribute. Check your handler method signature!");
 				}
 				else if (BeanUtils.isSimpleProperty(paramType)) {
 					paramName = "";
 				}
 				else {
 					attrName = "";
 				}
 			}
 		}
 
 		if (paramName != null) {
 // 调用ConversionService服务
 			args[i] = resolveRequestParam(paramName, required, defaultValue, methodParam, webRequest, handler);
 		}
 		else if (headerName != null) {
 // 调用ConversionService服务
 			args[i] = resolveRequestHeader(headerName, required, defaultValue, methodParam, webRequest, handler);
 		}
 		else if (requestBodyFound) {
 // 调用HttpMessageConvert服务
 			args[i] = resolveRequestBody(methodParam, webRequest, handler);
 		}
 		else if (cookieName != null) {
 // 调用HttpMessageConvert服务
 			args[i] = resolveCookieValue(cookieName, required, defaultValue, methodParam, webRequest, handler);
 		}
 		else if (pathVarName != null) {
 // 调用HttpMessageConvert服务
 			args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler);
 		}
 		else if (attrName != null) {
 // 调用ConversionService服务
 			WebDataBinder binder =
 					resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler);
 			boolean assignBindingResult = (args.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]));
 			if (binder.getTarget() != null) {
 				doBind(binder, webRequest, validate, validationHints, !assignBindingResult);
 			}
 			args[i] = binder.getTarget();
 			if (assignBindingResult) {
 				args[i + 1] = binder.getBindingResult();
 				i++;
 			}
 			implicitModel.putAll(binder.getBindingResult().getModel());
 		}
 	}
 	return args;
 }

最后，HttpMessageConverter和ConversionService是没有关系的，这点很多人讲的都是错的！![Link 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70]: /images/20220315/5ec55fb326264812ab6de312c7a8bc16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 1]: /images/20220315/735c5f6168844dcfa9bb1337f3da1695.png
[Validation_ Data Binding_ and Type Conversion]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation
[Link 1]: /images/20220315/4f5820a5c8e6488ebe692429245aaf17.png
[Java Bean]: https://docs.oracle.com/javase/tutorial/javabeans/advanced/customization.html
[Link 2]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#core-convert
[ConverterFactory]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#core-convert-ConverterFactory-SPI
[Formatter SPI]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#format
[DataBinder]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation-binder
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 2]: /images/20220315/2e09c71232c244e088c00bf7b611429a.png
[Bean Validation]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation-beanvalidation-overview
[AbstractApplicationContext_L834]: https://github.com/spring-projects/spring-framework/blob/v4.3.7.RELEASE/spring-context/src/main/java/org/springframework/context/support/AbstractApplicationContext.java#L834
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 3]: /images/20220315/cd4308a5d9644ab391582efcb347f309.png
[FormatterRegistrar]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#format-FormatterRegistrar-SPI
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70 4]: /images/20220315/2cffeaae9f0449caa6ecacbfa2174ad5.png
[MVC Config API]: https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-config-customize