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

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/itsoftchenfei/article/details/88076245

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

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

目录

spring mvc知识回顾

BeanWrapper

ConversionService

Formatter

DataBinder

四者关系图

Validator

非Spring MVC的使用

扫描二维码关注公众号，回复： 5456106 查看本文章

Spring MVC的使用

HttpMessageConverter和ConversionService是什么关系？

---

spring mvc知识回顾

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

在8中是有关spring mvc request vo的处理，其实Spring官方文档有专门有些章节阐述“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的内省模式密切关联，之前的文章分享过，而PropertyEditor（只提供了String >> Object的转换）隶属于Java Bean规范。

2. ConversionService

Spring自3.0之后提供的替代PropertyEditor的机制

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

ConversionService

ConversionService及其相关一套类型转换机制是一套通用的类型转换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

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），因此它最好不要依赖过多的其他的Bean，避免造成启动失败。

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上。

上图在后面源码中细讲，对于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是没有关系的，这点很多人讲的都是错的！