摘要

本文從源碼層面簡單講解SpringMVC的參數綁定原理

SpringMVC參數綁定相關組件的初始化過程

在理解初始化之前，先來認識一個接口

HandlerMethodArgumentResolver

方法參數解析器接口，這個接口是SpringMVC參數解析綁定的核心接口。不同的參數類型綁定都是通過實現這個接口來實現。也可以通過實現這個接口來自定義參數解析器。這個接口中有如下兩個方法

public interface HandlerMethodArgumentResolver {

//該解析器是否支持parameter參數的解析

boolean supportsParameter(MethodParameter parameter);

//將方法參數從給定請求(webRequest)解析為參數值并返回

Object resolveArgument(MethodParameter parameter,

ModelAndViewContainer mavContainer,

NativeWebRequest webRequest,

WebDataBinderFactory binderFactory) throws Exception;

}

初始化

RequestMappingHandlerAdapter.java類的afterPropertiesSet(line:481)方法初始化相關方法參數解析器。代碼如下

public void afterPropertiesSet() {

if (this.argumentResolvers == null) {

//初始化SpringMVC默認的方法參數解析器，并添加至argumentResolvers(HandlerMethodArgumentResolverComposite)

List resolvers = getDefaultArgumentResolvers();

this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);

}

if (this.initBinderArgumentResolvers == null) {

//初始化SpringMVC默認的初始化綁定器(@InitBinder)參數解析器，并添加至initBinderArgumentResolvers(HandlerMethodArgumentResolverComposite)

List resolvers = getDefaultInitBinderArgumentResolvers();

this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);

}

if (this.returnValueHandlers == null) {

//獲取默認的方法返回值解析器

List handlers = getDefaultReturnValueHandlers();

this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);

}

initControllerAdviceCache();

}

現在我們進入getDefalutArgumentResolvers方法，代碼如下

//默認的參數解析，創建了默認的24個參數解析器，并添加至resolvers

//這里的24個參數解析器都是針對不同的參數類型來解析的

private List getDefaultArgumentResolvers() {

List resolvers = new ArrayList();

// 基于注解的參數解析器

//一般用于帶有@RequestParam注解的簡單參數綁定，簡單參數比如byte、int、long、double、String以及對應的包裝類型

resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));

//用于處理帶有@RequestParam注解，且參數類型為Map的解析綁定

resolvers.add(new RequestParamMapMethodArgumentResolver());

//一般用于處理帶有@PathVariable注解的默認參數綁定

resolvers.add(new PathVariableMethodArgumentResolver());

//也是用于帶有@PathVariable注解的Map相關參數綁定，后續還有一些默認的參數解析器。后續還有一些參數解析器，我這里都不一一解釋了。想具體確認某個參數會交個哪個參數解析器處理，可以通過以下解析器的supportsParameter(MethodParameter parameter)方法得知

resolvers.add(new PathVariableMapMethodArgumentResolver());

resolvers.add(new MatrixVariableMethodArgumentResolver());

resolvers.add(new MatrixVariableMapMethodArgumentResolver());

resolvers.add(new ServletModelAttributeMethodProcessor(false));

resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));

resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));

resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));

resolvers.add(new RequestHeaderMapMethodArgumentResolver());

resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));

resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));

// 基于類型的參數解析器

resolvers.add(new ServletRequestMethodArgumentResolver());

resolvers.add(new ServletResponseMethodArgumentResolver());

resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));

resolvers.add(new RedirectAttributesMethodArgumentResolver());

resolvers.add(new ModelMethodProcessor());

resolvers.add(new MapMethodProcessor());

resolvers.add(new ErrorsMethodArgumentResolver());

resolvers.add(new SessionStatusMethodArgumentResolver());

resolvers.add(new UriComponentsBuilderMethodArgumentResolver());

// Custom arguments

if (getCustomArgumentResolvers() != null) {

resolvers.addAll(getCustomArgumentResolvers());

}

參數解析器添加至HandlerMethodArgumentResolverComposite這個類，這個也是實現了HandlerMethodArgumentResolver接口。這里運用涉及模式中的composite模式(組合模式)，SpringMVC中，所有請求的參數解析都是進入HandlerMethodArgumentResolverComposite類來完成的。它有兩個成員變量，如下

//它的元素在RequestMappingHandlerAdapter類的afterPropertiesSet方法中被添加，存放的是SpringMVC一些默認的HandlerMethodArgumentResolver參數解析器

private final List argumentResolvers =

new LinkedList();

//存放已經解析過的參數，已經對應的HandlerMethodArgumentResolver解析器。加快查找過程

private final Map argumentResolverCache =

new ConcurrentHashMap(256);

介紹了這么多，話不多說。直接來看一個詳細解析綁定過程吧

綁定過程

先看一個簡單參數綁定，有如下Controller和請求,代碼如下。

@Controller

@RequestMapping("/ParameterBind")

public class ParameterBindTestController {

@ResponseBody

@RequestMapping("/test1")

public String test1(int id){

System.out.println(id);

return "test1";

}

}

請求進入DispatcherServlet的doDispatch后，獲取HandlerMethod。然后根據HandlerMethod來確認HandlerApapter，確認后執行HandlerAdapter的handle方法。這里確認HandlerApater為RequestMappingHandlerAdapter，在執行handlerMethod之前，需要處理參數的綁定。然后看看詳細的參數綁定過程

執行HandlerAdapter的handler方法后，進入RequestMappingHandlerAdapter的invokeHandleMethod方法(line:711)

private ModelAndView invokeHandleMethod(HttpServletRequest request,

HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

ServletWebRequest webRequest = new ServletWebRequest(request, response);

WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);

ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

//根據handlerMethod和binderFactory創建一個ServletInvocableHandlerMethod。后續把請求直接交給ServletInvocableHandlerMethod執行。

//createRequestMappingMethod方法比較簡單，把之前RequestMappingHandlerAdapter初始化的argumentResolvers和returnValueHandlers添加至ServletInvocableHandlerMethod中

ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);

ModelAndViewContainer mavContainer = new ModelAndViewContainer();

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

modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);

mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

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

asyncWebRequest.setTimeout(this.asyncRequestTimeout);

final 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 + "]");

}

requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);

}

requestMappingMethod.invokeAndHandle(webRequest, mavContainer);

if (asyncManager.isConcurrentHandlingStarted()) {

return null;

}

return getModelAndView(mavContainer, modelFactory, webRequest);

}

然后進入invokeAndHanldle方法，然后進入invokeForRequest方法，這個方法的職責是從request中解析出HandlerMethod方法所需要的參數，然后通過反射調用HandlerMethod中的method。代碼如下

public final Object invokeForRequest(NativeWebRequest request,

ModelAndViewContainer mavContainer,

Object... providedArgs) throws Exception {

//從request中解析出HandlerMethod方法所需要的參數，并返回Object[]

Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

if (logger.isTraceEnabled()) {

StringBuilder builder = new StringBuilder("Invoking [");

builder.append(this.getMethod().getName()).append("] method with arguments ");

builder.append(Arrays.asList(args));

logger.trace(builder.toString());

}

//通過反射執行HandleMethod中的method，方法參數為args。并返回方法執行的返回值

Object returnValue = invoke(args);

if (logger.isTraceEnabled()) {

logger.trace("Method [" + this.getMethod().getName() + "] returned [" + returnValue + "]");

}

return returnValue;

}

直接進入getMethodArgumentValues方法看看其過程，代碼如下

/**

* 獲取當前請求的方法參數值。

*/

private Object[] getMethodArgumentValues(

NativeWebRequest request, ModelAndViewContainer mavContainer,

Object... providedArgs) throws Exception {

//獲取方法參數數組

MethodParameter[] parameters = getMethodParameters();

//創建一個參數數組，保存從request解析出的方法參數

Object[] args = new Object[parameters.length];

for (int i = 0; i < parameters.length; i++) {

MethodParameter parameter = parameters[i];

parameter.initParameterNameDiscovery(parameterNameDiscoverer);

GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());

args[i] = resolveProvidedArgument(parameter, providedArgs);

if (args[i] != null) {

continue;

}

//判斷之前RequestMappingHandlerAdapter初始化的那24個HandlerMethodArgumentResolver(參數解析器)，是否存在支持該參數解析的解析器

if (argumentResolvers.supportsParameter(parameter)) {

try {

args[i] = argumentResolvers.resolveArgument(parameter, mavContainer, request, dataBinderFactory);

continue;

} catch (Exception ex) {

if (logger.isTraceEnabled()) {

logger.trace(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);

}

throw ex;

}

}

if (args[i] == null) {

String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);

throw new IllegalStateException(msg);

}

}

return args;

}

進入HandlerMethodArgumentResolverComposite的resolveArgument方法

public Object resolveArgument(

MethodParameter parameter, ModelAndViewContainer mavContainer,

NativeWebRequest webRequest, WebDataBinderFactory binderFactory)

throws Exception {

//首先獲取參數解析器，這里獲取的邏輯是首先從argumentResolverCache緩存中獲取該MethodParameter匹配的HandlerMethodArgumentResolver。如果為空，遍歷初始化定義的那24個。查找匹配的HandlerMethodArgumentResolver，然后添加至argumentResolverCache緩存中

HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);

Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");

//解析參數

return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);

}

然后進入HandlerMethodArgumentResolver的resolverArgument方法

public final Object resolveArgument(

MethodParameter parameter, ModelAndViewContainer mavContainer,

NativeWebRequest webRequest, WebDataBinderFactory binderFactory)

throws Exception {

//獲取int的Class對象

Class> paramType = parameter.getParameterType();

//根據參數定義創建一個NamedValueInfo對象

NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);

//根據參數名解析出對象的值

Object arg = resolveName(namedValueInfo.name, parameter, webRequest);

if (arg == null) {

if (namedValueInfo.defaultValue != null) {

arg = resolveDefaultValue(namedValueInfo.defaultValue);

}

else if (namedValueInfo.required) {

handleMissingValue(namedValueInfo.name, parameter);

}

arg = handleNullValue(namedValueInfo.name, arg, paramType);

}

else if ("".equals(arg) && (namedValueInfo.defaultValue != null)) {

arg = resolveDefaultValue(namedValueInfo.defaultValue);

}

//上面步驟獲取的args是String類型，然后轉換為方法參數所需要的類型(int)

if (binderFactory != null) {

WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);

arg = binder.convertIfNecessary(arg, paramType, parameter);

}

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

return arg;

}

這個方法的職責是，首先獲取paramType。也就是int對應的Class對象。然后根據parameter對象創建一個NamedValueInfo對象。這個對象存放的就是參數名、是否必須、參數默認值3個成員變量。然后進入resolverName方法解析參數，里面的邏輯其實很簡單，就是根據方法的參數名來獲取request中的參數。關鍵代碼如下

String[] paramValues = webRequest.getParameterValues(name);

if (paramValues != null) {

arg = paramValues.length == 1 ? paramValues[0] : paramValues;

}

所以這里返回的值就是9999,這里返回的值還是String類型的。而需要的參數是int類型的。然后通過binder.coverIfNecessary方法把String轉換為int類型返回。

對象綁定

新加一個方法，代碼如下

@ResponseBody

@RequestMapping("/test2")

public String test2(User u){

System.out.println(u.toString());

return "test1";

}

這個請求的參數解析綁定便會交給ServletModelAttributeMethodProcessor這個類，在初始化argumentResolvers的時候。是會創建兩個不同的ServletModelAttributeMethodProcessor對象的。

resolvers.add(new ServletModelAttributeMethodProcessor(false));

resolvers.add(new ServletModelAttributeMethodProcessor(true));

這兩個有什么區別？進入supportsParameter方法看看

/**

*帶有@ModelAttribute注解返回true

* parameter不是簡單類型也返回true.

*/

public boolean supportsParameter(MethodParameter parameter) {

if (parameter.hasParameterAnnotation(ModelAttribute.class)) {

return true;

}

else if (this.annotationNotRequired) {

return !BeanUtils.isSimpleProperty(parameter.getParameterType());

}

else {

return false;

}

}

雖然test2(User u)方法沒有ModelAttribute注解，但是User.class不是簡單類型。所以該MethodHandler的參數u還是會交給ServletModelAtttributeMethodProcessor處理。

看看ServletModelAttributeMethodProcessor的resolveArgument方法。它的resolveArgument是由父類ModelAttributeMethodProcessor具體實現的，代碼如下。

/**

* 解析model中的參數，如果從ModelAndViewContainer未找到，直接通過反射實例化一個對象。具體實例化是通過父類的createAttribute方法，通過調用BeanUtils.instantiateClass方法來實例化的。這個對象便是后續傳給test2(User u)方法的對象，但是此時創建的對象里面的值都還為空，注入值是通過bindRequestParameters方法來實現的。

*/

public final Object resolveArgument(

MethodParameter parameter, ModelAndViewContainer mavContainer,

NativeWebRequest request, WebDataBinderFactory binderFactory)

throws Exception {

String name = ModelFactory.getNameForParameter(parameter);

Object attribute = (mavContainer.containsAttribute(name)) ?

mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, request);

WebDataBinder binder = binderFactory.createBinder(request, attribute, name);

if (binder.getTarget() != null) {

//將請求綁定至目標binder的target對象，也就是剛剛創建的attribute對象。

bindRequestParameters(binder, request);

//如果有驗證，則驗證參數

validateIfApplicable(binder, parameter);

if (binder.getBindingResult().hasErrors()) {

if (isBindExceptionRequired(binder, parameter)) {

throw new BindException(binder.getBindingResult());

}

}

}

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

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

mavContainer.removeAttributes(bindingResultModel);

mavContainer.addAllAttributes(bindingResultModel);

return binder.getTarget();

}

該方法的職責是實例化一個parameterType的對象，然后根據request和attribute、name創建一個WebDataBinder對象，其中。然后進入bindRequestParameters方法綁定，根據reqeust中的參數創建一個MutablePropertyValues對象。MutablePropertyValues里面存放了一個或多個PropertyValue，其中PropertyValue用于保存單個bean屬性的相關信息，比如參數名、參數值。這里需要注意的是PropertyValue并不是保存request對象的所有參數屬性信息。而是一個參數屬性對應一個PropertyValue。比如這里的reqeust對象，攜帶了兩個參數，name和age，便會分別創建兩個PropertyValue對象。對應的MutablePropertyValues結構如下圖

創建MutablePropertyValues對象化后，進入DataBinder.applyPropertyValues(DataBinder.java line737)。會根據剛剛創建的User對象。創建一個BeanWrapperImpl對象，BeanWrapperImpl實現了PropertyAccessor(屬性訪問器)接口。這是spring-bean下的一個類，在Sping中，對Bean屬性的存取都是通過BeanWrapperImpl類來實現的。BeanWarapperImpl在這里作用就是通過PropertyValue中的屬性相關描述，注入到BeanWarapperImpl對應的java對象的屬性中去。具體注入的方法是setPropertyValues，這個方法略復雜。它的職責簡單總結起來就是根據屬性名調用對應的set...方法。比如注入User對象的name屬性時，通過反射獲取setName方法。如果有該方法便調用。這也是為什么在定義SpringMVC model 對象需要set...方法。如果沒有set方法，參數注入便會失敗。

參數解析綁定總結

SpringMVC初始化時，RequestMappingHandlerAdapter類會把一些默認的參數解析器添加到argumentResolvers中。當SpringMVC接收到請求后首先根據url查找對應的HandlerMethod。

遍歷HandlerMethod的MethodParameter數組

根據MethodParameter的類型來查找確認使用哪個HandlerMethodArgumentResolver，遍歷所有的argumentResolvers的supportsParameter(MethodParameter parameter)方法。。如果返回true，則表示查找成功，當前MethodParameter，使用該HandlerMethodArgumentResolver。這里確認大多都是根據參數的注解已經參數的Type來確認。

解析參數，從request中解析出MethodParameter對應的參數，這里解析出來的結果都是String類型。

轉換參數，把對應String轉換成具體方法所需要的類型，這里就包括了基本類型、對象、List、Set、Map。

總結

以上源碼是基于SpringMVC 3.2.2.RELEASE版本。以上便是SpringMVC參數解析綁定的主要過程，希望對大家有幫助。本文可能有錯誤，希望讀者能夠指出來。

希望與廣大網友互動？？

點此進行留言吧！

總結

以上是生活随笔為你收集整理的java会员卡的绑定和解绑_SpringMVC源码之参数解析绑定原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。