目錄
參數解析器
HandlerMethodArgumentResolver
參數解析器的初始化
afterPropertiesSet初始化
getDefalutArgumentResolvers
HandlerMethodArgumentResolverComposite
參數綁定過程
對象綁定
總結
參數解析器
HandlerMethodArgumentResolver
方法參數解析器接口，這個接口是SpringMVC參數解析綁定的核心接口。不同類型的參數綁定都是通過實作這個接口來實作。可以通過實作這個接口來自定義參數解析器。
這個接口中有如下兩個方法：
boolean supportsParameter(MethodParameter parameter);
Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;
參數解析器的初始化
RequestMappingHandlerAdapter類的afterPropertiesSet方法初始化相關方法參數解析器。
afterPropertiesSet初始化
RequestMappingHandlerAdapter初始化是執行afterPropertiesSet方法進行解析器的加載。代碼如下
@Override
public void afterPropertiesSet() {
// Do this first, it may add ResponseBody advice beans
initControllerAdviceCache();
if (this.argumentResolvers == null) {
List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
if (this.initBinderArgumentResolvers == null) {
List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
if (this.returnValueHandlers == null) {
List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
}
}
getDefalutArgumentResolvers
擷取預設的參數解析器。代碼如下
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();
// Annotation-based argument resolution
resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
resolvers.add(new RequestParamMapMethodArgumentResolver());
resolvers.add(new PathVariableMethodArgumentResolver());
resolvers.add(new PathVariableMapMethodArgumentResolver());
resolvers.add(new MatrixVariableMethodArgumentResolver());
resolvers.add(new MatrixVariableMapMethodArgumentResolver());
resolvers.add(new ServletModelAttributeMethodProcessor(false));
resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
resolvers.add(new RequestHeaderMapMethodArgumentResolver());
resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
// Type-based argument resolution
resolvers.add(new ServletRequestMethodArgumentResolver());
resolvers.add(new ServletResponseMethodArgumentResolver());
resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
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());
}
// Catch-all
resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
resolvers.add(new ServletModelAttributeMethodProcessor(true));
return resolvers;
}
HandlerMethodArgumentResolverComposite
參數解析器添加至HandlerMethodArgumentResolverComposite這個類，這個也是實作了HandlerMethodArgumentResolver接口。這裡運用涉及模式中的composite模式（組合模式），SpringMVC中，所有請求的參數解析都是進入HandlerMethodArgumentResolverComposite類來完成的。它有兩個成員變量，如下
private final List<HandlerMethodArgumentResolver> argumentResolvers =
new LinkedList<HandlerMethodArgumentResolver>();
private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);
參數綁定過程
- 先看一個簡單參數綁定，有如下Controller和請求,代碼如下。
@Controller
@RequestMapping("/ParameterBind")
public class ParameterBindTestController {
@ResponseBody
@RequestMapping("/test1")
public String test1(int id){
System.out.println(id);
return "test1";
}
}
請求進入DispatcherServlet的doDispatch後，擷取mappedHandler，然後根據mappedHandler來确認HandlerApapter，确認後執行HandlerAdapter的handle方法。
這裡的HandlerApater實作類為RequestMappingHandlerAdapter，在執行controller方法之前，需要處理方法參數的綁定。下面看看詳細的參數綁定過程
執行HandlerAdapter的handler方法後，進入RequestMappingHandlerAdapter的invokeHandlerMethod方法（line:776）
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
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 = new ModelAndViewContainer();
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);
}
invocableMethod.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<String, Object> 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結構如下圖
SpringMVC參數綁定參數解析器參數解析器的初始化參數綁定過程對象綁定總結 - 建立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。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)