java 实现解析请求参数_springmvc 请求参数解析细节

川长思鸟来 2022-11-09 12:30 194阅读 0赞

springmvc 的请求流程，相信大家已经很熟悉了，不熟悉的同学可以参考下资料！

有了整体流程的概念，是否对其中的实现细节就很清楚呢？我觉得不一定，比如:单是参数解析这块，就是个大学问呢？

首先，我们从最靠近请求末端的地方说起！此时，handler已经找到，即将进行处理！

这是在 RequestMappingHandlerAdapter 的处理方法 handleInternal(), 将请求交给业务代码的地方！

以下是 @ModelAttributeMethodProcessor进行处理的参数处理堆栈:

![8f900a89c6347c561fdf2122f13be562.png][]

![961ddebeb323a10fe0623af514929fc1.png][]

"http-nio-8080-exec-2@2414" daemon prio=5 tid=0x21 nid=NA runnable

java.lang.Thread.State: RUNNABLE

at org.springframework.beans.BeanWrapperImpl$BeanPropertyHandler.setValue(BeanWrapperImpl.java:358)

at org.springframework.beans.AbstractNestablePropertyAccessor.processLocalProperty(AbstractNestablePropertyAccessor.java:469)

at org.springframework.beans.AbstractNestablePropertyAccessor.setPropertyValue(AbstractNestablePropertyAccessor.java:292)

at org.springframework.beans.AbstractNestablePropertyAccessor.setPropertyValue(AbstractNestablePropertyAccessor.java:280)

at org.springframework.beans.AbstractPropertyAccessor.setPropertyValues(AbstractPropertyAccessor.java:95)

at org.springframework.validation.DataBinder.applyPropertyValues(DataBinder.java:859)

at org.springframework.validation.DataBinder.doBind(DataBinder.java:755)

at org.springframework.web.bind.WebDataBinder.doBind(WebDataBinder.java:192)

at org.springframework.web.bind.ServletRequestDataBinder.bind(ServletRequestDataBinder.java:106)

at org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor.bindRequestParameters(ServletModelAttributeMethodProcessor.java:152)

at org.springframework.web.method.annotation.ModelAttributeMethodProcessor.resolveArgument(ModelAttributeMethodProcessor.java:113)

at org.springframework.web.method.support.HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:121)

at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:158)

at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:128)

at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:97)

at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:827)

at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:738)

at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85)

at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:967)

at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:901)

at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:970)

at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:861)

at javax.servlet.http.HttpServlet.service(HttpServlet.java:635)

at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:846)

at javax.servlet.http.HttpServlet.service(HttpServlet.java:742)

at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231)

at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)

at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)

at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)

at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)

at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:198)

at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96)

at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:496)

at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:140)

at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:81)

at org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:650)

at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:87)

at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:342)

at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:803)

at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:66)

at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:790)

at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1459)

at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)- locked <0x19d0>(a org.apache.tomcat.util.net.NioEndpoint$NioSocketWrapper)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)

at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)

at java.lang.Thread.run(Thread.java:745)

//org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

@OverrideprotectedModelAndView handleInternal(HttpServletRequest request,

HttpServletResponse response, HandlerMethod handlerMethod)throwsException \{

ModelAndView mav;

checkRequest(request);//Execute invokeHandlerMethod in synchronized block if required.

if (this.synchronizeOnSession) \{

HttpSession session= request.getSession(false);if (session != null) \{

Object mutex=WebUtils.getSessionMutex(session);synchronized(mutex) \{

mav=invokeHandlerMethod(request, response, handlerMethod);

\}else\{//No HttpSession available -> no mutex necessary

mav =invokeHandlerMethod(request, response, handlerMethod);

\}else\{//No synchronization on session demanded at all...//更多的时候，我们都是无状态请求的，所以都会走这里，进行业务接入

mav =invokeHandlerMethod(request, response, handlerMethod);

\}if (!response.containsHeader(HEADER\_CACHE\_CONTROL)) \{if(getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) \{

applyCacheSeconds(response,this.cacheSecondsForSessionAttributeHandlers);

\}else\{

prepareResponse(response);

\}returnmav;

\}//然后交给 RequestMappingHandlerAdapter 处理

/\*\*\* Invoke the \{@linkRequestMapping\} handler method preparing a \{@linkModelAndView\}

\* if view resolution is required.

\*@since4.2

\*@see\#createInvocableHandlerMethod(HandlerMethod)\*/

protectedModelAndView invokeHandlerMethod(HttpServletRequest request,

HttpServletResponse response, HandlerMethod handlerMethod)throwsException \{//将request和response封装为一个类，方便后续使用

ServletWebRequest webRequest = newServletWebRequest(request, response);try\{//使用 binderFactory 进行参数解析，该 binderFactory 将会伴随整个参数的一生//这个binderFactory 与 方法和参数关联//然后根据 binderFactory 获取 modelFactory, modelFactory 会绑定一些属性和参数解析器到里面，备用

WebDataBinderFactory binderFactory =getDataBinderFactory(handlerMethod);

ModelFactory modelFactory=getModelFactory(handlerMethod, binderFactory);//创建 最终可用于调用业务方法的包装

ServletInvocableHandlerMethod invocableMethod =createInvocableHandlerMethod(handlerMethod);

invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);

invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);

invocableMethod.setDataBinderFactory(binderFactory);

invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);//作为返回属性的一个容器

ModelAndViewContainer mavContainer = newModelAndViewContainer();

mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));

modelFactory.initModel(webRequest, mavContainer, invocableMethod);

mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

AsyncWebRequest asyncWebRequest=WebAsyncUtils.createAsyncWebRequest(request, response);

asyncWebRequest.setTimeout(this.asyncRequestTimeout);

WebAsyncManager asyncManager=WebAsyncUtils.getAsyncManager(request);

asyncManager.setTaskExecutor(this.taskExecutor);

asyncManager.setAsyncWebRequest(asyncWebRequest);

asyncManager.registerCallableInterceptors(this.callableInterceptors);

asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);if(asyncManager.hasConcurrentResult()) \{

Object result=asyncManager.getConcurrentResult();

mavContainer= (ModelAndViewContainer) asyncManager.getConcurrentResultContext()\[0\];

asyncManager.clearConcurrentResult();if(logger.isDebugEnabled()) \{

logger.debug("Found concurrent result value \[" + result + "\]");

invocableMethod=invocableMethod.wrapConcurrentResult(result);

\}//进一步调用 handler 方法,进入参数解析状态

invocableMethod.invokeAndHandle(webRequest, mavContainer);if(asyncManager.isConcurrentHandlingStarted()) \{return null;

\}returngetModelAndView(mavContainer, modelFactory, webRequest);

\}finally\{

webRequest.requestCompleted();

\}private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throwsException \{

Class> handlerType =handlerMethod.getBeanType();

Set methods = this.initBinderCache.get(handlerType);if (methods == null) \{

methods=MethodIntrospector.selectMethods(handlerType, INIT\_BINDER\_METHODS);this.initBinderCache.put(handlerType, methods);

List initBinderMethods = new ArrayList();//Global methods first

for (Entry> entry : this.initBinderAdviceCache.entrySet()) \{if(entry.getKey().isApplicableToBeanType(handlerType)) \{

Object bean=entry.getKey().resolveBean();for(Method method : entry.getValue()) \{

initBinderMethods.add(createInitBinderMethod(bean, method));

\}for(Method method : methods) \{

Object bean=handlerMethod.getBean();

initBinderMethods.add(createInitBinderMethod(bean, method));

\}returncreateDataBinderFactory(initBinderMethods);

\}privateModelFactory getModelFactory(HandlerMethod handlerMethod, WebDataBinderFactory binderFactory) \{

SessionAttributesHandler sessionAttrHandler=getSessionAttributesHandler(handlerMethod);

Class> handlerType =handlerMethod.getBeanType();

Set methods = this.modelAttributeCache.get(handlerType);if (methods == null) \{

methods=MethodIntrospector.selectMethods(handlerType, MODEL\_ATTRIBUTE\_METHODS);this.modelAttributeCache.put(handlerType, methods);

List attrMethods = new ArrayList();//Global methods first

for (Entry> entry : this.modelAttributeAdviceCache.entrySet()) \{if(entry.getKey().isApplicableToBeanType(handlerType)) \{

Object bean=entry.getKey().resolveBean();for(Method method : entry.getValue()) \{

attrMethods.add(createModelAttributeMethod(binderFactory, bean, method));

\}for(Method method : methods) \{

Object bean=handlerMethod.getBean();

attrMethods.add(createModelAttributeMethod(binderFactory, bean, method));

\}return newModelFactory(attrMethods, binderFactory, sessionAttrHandler);

\}//org.springframework.web.method.support.InvocableHandlerMethod

/\*\*\* Invoke the method and handle the return value through one of the

\* configured \{@linkHandlerMethodReturnValueHandler\}s.

\*@paramwebRequest the current request

\*@parammavContainer the ModelAndViewContainer for this request

\*@paramprovidedArgs "given" arguments matched by type (not resolved)\*/

public voidinvokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,

Object... providedArgs)throwsException \{//此处只处理返回值问题，具体的调用逻辑再封装, 其中 providedArgs 此时仅是空值，将会在后续处理

Object returnValue =invokeForRequest(webRequest, mavContainer, providedArgs);

setResponseStatus(webRequest);if (returnValue == null) \{if (isRequestNotModified(webRequest) || getResponseStatus() != null ||mavContainer.isRequestHandled()) \{

mavContainer.setRequestHandled(true);return;

\}else if(StringUtils.hasText(getResponseStatusReason())) \{

mavContainer.setRequestHandled(true);return;

mavContainer.setRequestHandled(false);try\{this.returnValueHandlers.handleReturnValue(

returnValue, getReturnValueType(returnValue), mavContainer, webRequest);

\}catch(Exception ex) \{if(logger.isTraceEnabled()) \{

logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);

\}throwex;

以上大体调用流程，下面我们来看下参数解析：

/\*\*\* Invoke the method after resolving its argument values in the context of the given request.

Argument values are commonly resolved through \{@linkHandlerMethodArgumentResolver\}s.

\* The \{@codeprovidedArgs\} parameter however may supply argument values to be used directly,

\* i.e. without argument resolution. Examples of provided argument values include a

\* \{@linkWebDataBinder\}, a \{@linkSessionStatus\}, or a thrown exception instance.

\* Provided argument values are checked before argument resolvers.

\*@paramrequest the current request

\*@parammavContainer the ModelAndViewContainer for this request

\*@paramprovidedArgs "given" arguments matched by type, not resolved

\*@returnthe raw value returned by the invoked method

\*@exceptionException raised if no suitable argument resolver can be found,

\* or if the method raised an exception\*/

publicObject invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,

Object... providedArgs)throwsException \{//真正的参数解析在此处开始，是本文关心的点, 此时 providedArgs 还是为空的

Object\[\] args =getMethodArgumentValues(request, mavContainer, providedArgs);if(logger.isTraceEnabled()) \{

logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +

"' with arguments " +Arrays.toString(args));

Object returnValue=doInvoke(args);if(logger.isTraceEnabled()) \{

logger.trace("Method \[" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +

"\] returned \[" + returnValue + "\]");

\}returnreturnValue;

真正的参数解析如下:

/\*\*\* Get the method argument values for the current request.\*/

privateObject\[\] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,

Object... providedArgs)throwsException \{

MethodParameter\[\] parameters=getMethodParameters();

Object\[\] args= newObject\[parameters.length\];for (int i = 0; i < parameters.length; i++) \{

MethodParameter parameter=parameters\[i\];

parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);

args\[i\]=resolveProvidedArgument(parameter, providedArgs);if (args\[i\] != null) \{continue;

\}//依次遍历解析器，只要有一个支持解析，则进行解析逻辑，否则抛出异常

if (this.argumentResolvers.supportsParameter(parameter)) \{try\{//进行具体解析器的解析，当然，这里是解析器列表，调用后会再进行合适解析器的筛选过程

args\[i\] = this.argumentResolvers.resolveArgument(

parameter, mavContainer, request,this.dataBinderFactory);continue;

\}catch(Exception ex) \{if(logger.isDebugEnabled()) \{

logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);

\}throwex;

\}if (args\[i\] == null) \{throw new IllegalStateException("Could not resolve method parameter at index " +parameter.getParameterIndex()+ " in " + parameter.getMethod().toGenericString() +

": " + getArgumentResolutionErrorMessage("No suitable resolver for", i));

\}returnargs;

可以看出，参数解析主要分为几步:

1. 获取参数类型数组,供后续填充使用;

2. 对每个参数类型，单独调用参数解析过程;

3. 在进行具体解析之前，先尝试简单解析是否成功(类似于读取缓存)，不成功则再进行深度解析;

4. 深度解析交由所有解析器进行处理, 即 HandlerMethodArgumentResolverComposite, 它包含了所有的解析器;

//org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

/\*\*\* Iterate over registered \{@linkHandlerMethodArgumentResolver\}s and invoke the one that supports it.

\*@throwsIllegalStateException if no suitable \{@linkHandlerMethodArgumentResolver\} is found.\*/@OverridepublicObject resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,

NativeWebRequest webRequest, WebDataBinderFactory binderFactory)throwsException \{//获取具体适用的解析器，即调用其 supportsParameter(param) 方法判断即可

HandlerMethodArgumentResolver resolver =getArgumentResolver(parameter);if (resolver == null) \{throw new IllegalArgumentException("Unknown parameter type \[" + parameter.getParameterType().getName() + "\]");

\}//解析器获取到后，就交由具体的解析器进行解析了，这里有很多的分支了，咱们可以挑选几个来看一下就可以了

returnresolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);

下面，我我们看一下 @ModelAttribute 修饰的参数解析方法(注意: 这里的解析只是针对任意一个参数的解析，所以无需关注整体参数形式):

//org.springframework.web.method.annotation.ModelAttributeMethodProcessor

/\*\*\* Resolve the argument from the model or if not found instantiate it with

\* its default if it is available. The model attribute is then populated

\* with request values via data binding and optionally validated

\* if \{@code@java.validation.Valid\} is present on the argument.

\*@throwsBindException if data binding and validation result in an error

\* and the next method parameter is not of type \{@linkErrors\}.

\*@throwsException if WebDataBinder initialization fails.\*/@Overridepublic finalObject resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,

NativeWebRequest webRequest, WebDataBinderFactory binderFactory)throwsException \{//获取参数名字, 如: User user 获取的结果为 user ; 其实现原理为获取该注解的 value 值//如果缓存中没有该参数的解析,那么就实例化一个参数实例，并放入缓存

String name =ModelFactory.getNameForParameter(parameter);

Object attribute= (mavContainer.containsAttribute(name) ?mavContainer.getModel().get(name) :

createAttribute(name, parameter, binderFactory, webRequest));if (!mavContainer.isBindingDisabled(name)) \{

ModelAttribute ann= parameter.getParameterAnnotation(ModelAttribute.class);if (ann != null && !ann.binding()) \{

mavContainer.setBindingDisabled(name);

\}//将参数包装进 WebDataBinder 中，方便统一操作, 将参数实例放入到 target 字段域中

WebDataBinder binder =binderFactory.createBinder(webRequest, attribute, name);if (binder.getTarget() != null) \{//进行参数的解析过程, 将由 ServletModelAttributeMethodProcessor 处理

if (!mavContainer.isBindingDisabled(name)) \{

bindRequestParameters(binder, webRequest);

validateIfApplicable(binder, parameter);if (binder.getBindingResult().hasErrors() &&isBindExceptionRequired(binder, parameter)) \{throw newBindException(binder.getBindingResult());

\}//Add resolved attribute and BindingResult at the end of the model

Map bindingResultModel =binder.getBindingResult().getModel();

mavContainer.removeAttributes(bindingResultModel);

mavContainer.addAllAttributes(bindingResultModel);returnbinder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);

\}//如下为获取参数名的实现方式,如果指明 value, 则直接获取, 否则生成一个参数简称名的字段, 注意此处的名字并不一定是 参数真正的命名//其实函数的调用只要参数位置正确即可，并不需要真实的变量名

public staticString getNameForParameter(MethodParameter parameter) \{

ModelAttribute ann= parameter.getParameterAnnotation(ModelAttribute.class);

String name= (ann != null ? ann.value() : null);return (StringUtils.hasText(name) ?name : Conventions.getVariableNameForParameter(parameter));

\}//org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor

/\*\*\* This implementation downcasts \{@linkWebDataBinder\} to

\* \{@linkServletRequestDataBinder\} before binding.

\*@seeServletRequestDataBinderFactory\*/@Overrideprotected voidbindRequestParameters(WebDataBinder binder, NativeWebRequest request) \{//取出request 对象，因为只有 request 中有需要处理的参数,此时和 response 是确认无关的

ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);

ServletRequestDataBinder servletBinder=(ServletRequestDataBinder) binder;//调用自身的 binder 处理

servletBinder.bind(servletRequest);

\}/\*\*\* Bind the parameters of the given request to this binder's target,

\* also binding multipart files in case of a multipart request.

This call can create field errors, representing basic binding

\* errors like a required field (code "required"), or type mismatch

\* between value and bean property (code "typeMismatch").

Multipart files are bound via their parameter name, just like normal

\* HTTP parameters: i.e. "uploadedFile" to an "uploadedFile" bean property,

\* invoking a "setUploadedFile" setter method.

The type of the target property for a multipart file can be MultipartFile,

\* byte\[\], or String. The latter two receive the contents of the uploaded file;

\* all metadata like original file name, content type, etc are lost in those cases.

\*@paramrequest request with parameters to bind (can be multipart)

\*@seeorg.springframework.web.multipart.MultipartHttpServletRequest

\*@seeorg.springframework.web.multipart.MultipartFile

\*@see\#bind(org.springframework.beans.PropertyValues)\*/

public voidbind(ServletRequest request) \{//将所有请求参数封装到 mpvs, 使后续可以直接获取, 其实现为 使用 ArrayList 来保存属性，参考: request.getParameterNames()

MutablePropertyValues mpvs = newServletRequestParameterPropertyValues(request);

MultipartRequest multipartRequest= WebUtils.getNativeRequest(request, MultipartRequest.class);if (multipartRequest != null) \{

bindMultipart(multipartRequest.getMultiFileMap(), mpvs);

\}//此处作为扩展点，预留

addBindValues(mpvs, request);//调用webDataBinder 设值到参数绑定

doBind(mpvs);

\}//org.springframework.web.bind.WebDataBinder

/\*\*\* This implementation performs a field default and marker check

\* before delegating to the superclass binding process.

\*@see\#checkFieldDefaults

\*@see\#checkFieldMarkers\*/@Overrideprotected voiddoBind(MutablePropertyValues mpvs) \{//检查默认值和 marker 设置

checkFieldDefaults(mpvs);

checkFieldMarkers(mpvs);//调用父类实现数据 绑定，其实就是反射调用字段

super.doBind(mpvs);

\}//DataBinder.doBind()

/\*\*\* Actual implementation of the binding process, working with the

\* passed-in MutablePropertyValues instance.

\*@parammpvs the property values to bind,

\* as MutablePropertyValues instance

\*@see\#checkAllowedFields

\*@see\#checkRequiredFields

\*@see\#applyPropertyValues\*/

protected voiddoBind(MutablePropertyValues mpvs) \{

checkAllowedFields(mpvs);

checkRequiredFields(mpvs);//处理值

applyPropertyValues(mpvs);

\}/\*\*\* Apply given property values to the target object.

Default implementation applies all of the supplied property

\* values as bean property values. By default, unknown fields will

\* be ignored.

\*@parammpvs the property values to be bound (can be modified)

\*@see\#getTarget

\*@see\#getPropertyAccessor

\*@see\#isIgnoreUnknownFields

\*@see\#getBindingErrorProcessor

\*@seeBindingErrorProcessor\#processPropertyAccessException\*/

protected voidapplyPropertyValues(MutablePropertyValues mpvs) \{try\{//Bind request parameters onto target object.

getPropertyAccessor().setPropertyValues(mpvs, isIgnoreUnknownFields(), isIgnoreInvalidFields());

\}catch(PropertyBatchUpdateException ex) \{//Use bind error processor to create FieldErrors.

for(PropertyAccessException pae : ex.getPropertyAccessExceptions()) \{

getBindingErrorProcessor().processPropertyAccessException(pae, getInternalBindingResult());

@Overridepublic void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, booleanignoreInvalid)throwsBeansException \{

List propertyAccessExceptions = null;//此处获取参数对象的n个字段为列表,以进行循环赋值, 即循环的依据是外部传入多少值,而不是参数实例有多少字段

List propertyValues = (pvs instanceof MutablePropertyValues ?((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));//多个参数值给定时，循环设值即可

for(PropertyValue pv : propertyValues) \{try\{//This method may throw any BeansException, which won't be caught//here, if there is a critical failure such as no matching field.//We can attempt to deal only with less serious exceptions.//对单个 field 设值

setPropertyValue(pv);

\}catch(NotWritablePropertyException ex) \{if (!ignoreUnknown) \{throwex;

\}//Otherwise, just ignore it and continue...

\}catch(NullValueInNestedPathException ex) \{if (!ignoreInvalid) \{throwex;

\}//Otherwise, just ignore it and continue...

\}catch(PropertyAccessException ex) \{if (propertyAccessExceptions == null) \{

propertyAccessExceptions= new LinkedList();

propertyAccessExceptions.add(ex);

\}//org.springframework.beans.AbstractNestablePropertyAccessor

@Overridepublic void setPropertyValue(PropertyValue pv) throwsBeansException \{

PropertyTokenHolder tokens=(PropertyTokenHolder) pv.resolvedTokens;if (tokens == null) \{

String propertyName=pv.getName();

AbstractNestablePropertyAccessor nestedPa;try\{

nestedPa=getPropertyAccessorForPropertyPath(propertyName);

\}catch(NotReadablePropertyException ex) \{throw new NotWritablePropertyException(getRootClass(), this.nestedPath +propertyName,"Nested property in path '" + propertyName + "' does not exist", ex);

tokens=getPropertyNameTokens(getFinalPath(nestedPa, propertyName));if (nestedPa == this) \{

pv.getOriginalPropertyValue().resolvedTokens=tokens;

nestedPa.setPropertyValue(tokens, pv);

\}else\{

setPropertyValue(tokens, pv);

\}//对字段特殊处理，否则直接设值

protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throwsBeansException \{if (tokens.keys != null) \{

processKeyedProperty(tokens, pv);

\}else\{

processLocalProperty(tokens, pv);

\}private voidprocessLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) \{

PropertyHandler ph=getLocalPropertyHandler(tokens.actualName);if (ph == null || !ph.isWritable()) \{if(pv.isOptional()) \{if(logger.isDebugEnabled()) \{

logger.debug("Ignoring optional value for property '" + tokens.actualName +

"' - property not found on bean class \[" + getRootClass().getName() + "\]");

\}return;

\}else\{throwcreateNotWritablePropertyException(tokens.canonicalName);

Object oldValue= null;try\{

Object originalValue=pv.getValue();

Object valueToApply=originalValue;if (!Boolean.FALSE.equals(pv.conversionNecessary)) \{if(pv.isConverted()) \{

valueToApply=pv.getConvertedValue();

\}else\{if (isExtractOldValueForEditor() &&ph.isReadable()) \{try\{

oldValue=ph.getValue();

\}catch(Exception ex) \{if (ex instanceofPrivilegedActionException) \{

ex=((PrivilegedActionException) ex).getException();

\}if(logger.isDebugEnabled()) \{

logger.debug("Could not read previous value of property '" +

this.nestedPath + tokens.canonicalName + "'", ex);

valueToApply=convertForProperty(

tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());

pv.getOriginalPropertyValue().conversionNecessary= (valueToApply !=originalValue);

\}//经过各种判定后，终于调用反射了

ph.setValue(this.wrappedObject, valueToApply);

\}catch(TypeMismatchException ex) \{throwex;

\}catch(InvocationTargetException ex) \{

PropertyChangeEvent propertyChangeEvent= newPropertyChangeEvent(this.rootObject, this.nestedPath +tokens.canonicalName, oldValue, pv.getValue());if (ex.getTargetException() instanceofClassCastException) \{throw newTypeMismatchException(propertyChangeEvent, ph.getPropertyType(), ex.getTargetException());

\}else\{

Throwable cause=ex.getTargetException();if (cause instanceofUndeclaredThrowableException) \{//May happen e.g. with Groovy-generated methods

cause =cause.getCause();

\}throw newMethodInvocationException(propertyChangeEvent, cause);

\}catch(Exception ex) \{

PropertyChangeEvent pce= newPropertyChangeEvent(this.rootObject, this.nestedPath +tokens.canonicalName, oldValue, pv.getValue());throw newMethodInvocationException(pce, ex);

\}//org.springframework.beans.BeanWrapperImpl$BeanPropertyHandler

@Overridepublic void setValue(final Object object, Object valueToApply) throwsException \{final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?((GenericTypeAwarePropertyDescriptor)this.pd).getWriteMethodForActualAccess() :this.pd.getWriteMethod());if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) \{if (System.getSecurityManager() != null) \{

AccessController.doPrivileged(new PrivilegedAction() \{

@OverridepublicObject run() \{

writeMethod.setAccessible(true);return null;

\});

\}else\{

writeMethod.setAccessible(true);

\}final Object value =valueToApply;if (System.getSecurityManager() != null) \{try\{

AccessController.doPrivileged(new PrivilegedExceptionAction() \{

@Overridepublic Object run() throwsException \{

writeMethod.invoke(object, value);return null;

\}, acc);

\}catch(PrivilegedActionException ex) \{throwex.getException();

\}else\{//java.lang.reflect.Method, 反射设值

writeMethod.invoke(getWrappedInstance(), value);

所以，对于 @ModelAttribute 参数解析,其实主要有几步:

1. 获取 request 中的参数，封装到 MutablePropertyValues 中;

2. 依次检查每个字段域的有效性;

3. 处理字段类型的转换,如:将 String 转换为 int;

4. 获取字段的反射方法,进行字段值的绑定;

5. 循环设置,直到所有字段都检查完;

6. 验证字段的有效性,如有异常，抛出;

7. 做最后的数据类型确认，如果进一步处理，则转换;(conversionService)

//验证字段有效性，如有必要的话, 以 Valid\* 开头即符合验证前提

/\*\*\* Validate the model attribute if applicable.

The default implementation checks for \{@code@javax.validation.Valid\},

\* Spring's \{@linkorg.springframework.validation.annotation.Validated\},

\* and custom annotations whose name starts with "Valid".

\*@parambinder the DataBinder to be used

\*@parammethodParam the method parameter\*/

protected voidvalidateIfApplicable(WebDataBinder binder, MethodParameter methodParam) \{

Annotation\[\] annotations=methodParam.getParameterAnnotations();for(Annotation ann : annotations) \{

Validated validatedAnn= AnnotationUtils.getAnnotation(ann, Validated.class);//只要以 Valid 打头的验证都可以，即做到 spring 自身的验证方式有效，但是也兼容其他框架的验证方式

if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) \{

Object hints= (validatedAnn != null ?validatedAnn.value() : AnnotationUtils.getValue(ann));

Object\[\] validationHints= (hints instanceof Object\[\] ? (Object\[\]) hints : newObject\[\] \{hints\});//调用验证方式，一般为 调用其 validate() 方法;

binder.validate(validationHints);break;

\}/\*\*\* Invoke the specified Validators, if any, with the given validation hints.

Note: Validation hints may get ignored by the actual target Validator.

\*@paramvalidationHints one or more hint objects to be passed to a \{@linkSmartValidator\}

\*@see\#setValidator(Validator)

\*@seeSmartValidator\#validate(Object, Errors, Object...)\*/

public voidvalidate(Object... validationHints) \{for(Validator validator : getValidators()) \{if (!ObjectUtils.isEmpty(validationHints) && validator instanceofSmartValidator) \{

((SmartValidator) validator).validate(getTarget(), getBindingResult(), validationHints);

\}else if (validator != null) \{

validator.validate(getTarget(), getBindingResult());

![8f900a89c6347c561fdf2122f13be562.png][]

![961ddebeb323a10fe0623af514929fc1.png][]

//转换堆栈如下:

"http-nio-8080-exec-6@2418" daemon prio=5 tid=0x25 nid=NA runnable

java.lang.Thread.State: RUNNABLE

at org.springframework.core.convert.support.GenericConversionService.handleResult(GenericConversionService.java:328)

at org.springframework.core.convert.support.GenericConversionService.convert(GenericConversionService.java:204)

at org.springframework.beans.TypeConverterDelegate.convertIfNecessary(TypeConverterDelegate.java:173)

at org.springframework.beans.TypeConverterDelegate.convertIfNecessary(TypeConverterDelegate.java:108)

at org.springframework.beans.TypeConverterSupport.doConvert(TypeConverterSupport.java:64)

at org.springframework.beans.TypeConverterSupport.convertIfNecessary(TypeConverterSupport.java:47)

at org.springframework.validation.DataBinder.convertIfNecessary(DataBinder.java:713)

at org.springframework.web.method.annotation.ModelAttributeMethodProcessor.resolveArgument(ModelAttributeMethodProcessor.java:126)