SpringMVC源码总结（九）HandlerMethodArgumentResolver介绍

本文章主要介绍HandlerMethodArgumentResolver在SpringMVC中的使用，介绍几个HandlerMethodArgumentResolver具体的使用情况，然后说明HandlerMethodArgumentResolver的注册来源以及如何自定义注册。 

首先具体看下请求映射到的handler的对应的映射函数的参数形式有哪些： 

HandlerMethodArgumentResolver接口只有两个方法：  
Java代码  

1. //判断是否支持要转换的参数类型  
2. boolean supportsParameter(MethodParameter parameter);  
3. //当支持后进行相应的转换  
4. Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,  
5.             NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;  

HandlerMethodArgumentResolver接口的抽象类：AbstractMessageConverterMethodArgumentResolver仅仅引入了HttpMessageConverter，即转换的工作有这些HttpMessageConverter来完成具体的转换和判断由子类来实现。 
如下：  
Java代码  

1. public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {  
2.   
3.     protected final Log logger = LogFactory.getLog(getClass());  
4.   
5.     protected final List<HttpMessageConverter<?>> messageConverters;  
6.   
7.     protected final List<MediaType> allSupportedMediaTypes;  
8.      //略  
9. }  

AbstractMessageConverterMethodArgumentResolver 的抽象子类AbstractMessageConverterMethodProcessor仅仅是加入了对响应数据进行转换的支持。 
也就是AbstractMessageConverterMethodProcessor的子类不仅可以用来转换请求数据，也可以用来转换响应数据。 
AbstractMessageConverterMethodProcessor的子类HttpEntityMethodProcessor，支持请求和响应的转换，代码如下：  
Java代码  

1. @Override  
2.     public boolean supportsParameter(MethodParameter parameter) {  
3.         return HttpEntity.class.equals(parameter.getParameterType());  
4.     }  
5.   
6.     @Override  
7.     public boolean supportsReturnType(MethodParameter returnType) {  
8.         return HttpEntity.class.isAssignableFrom(returnType.getParameterType());  
9.     }  

使用场景如下：  
Java代码  

1. @RequestMapping(value="/test/http",method=RequestMethod.POST)  
2.     @ResponseBody  
3.     public Map<String,Object> testHttp(HttpEntity<String> httpEntity)   
4.             //略   
5.         }  
6.   
7.   
8. @RequestMapping(value="/test/httpEntity",method=RequestMethod.GET)  
9.     public HttpEntity<String> testHttpEntity(){  
10.         //略  
11.     }  

AbstractMessageConverterMethodProcessor的子类RequestResponseBodyMethodProcessor：支持@RequestBody和@ResponseBody,代码如下：  
Java代码  

1. @Override  
2.     public boolean supportsParameter(MethodParameter parameter) {  
3.                //查找参数中是否含有@RequestBody注解  
4.         return parameter.hasParameterAnnotation(RequestBody.class);  
5.     }  
6.   
7.     @Override  
8.     public boolean supportsReturnType(MethodParameter returnType) {  
9.   
10. //查找参数中是否含有@RequestBody注解或者controller类上是否含有@RequestBody  
11.         return ((AnnotationUtils.findAnnotation(returnType.getContainingClass(), ResponseBody.class) != null) ||  
12.                 (returnType.getMethodAnnotation(ResponseBody.class) != null));  
13.     }  

使用场景如下：  
Java代码  

1. @RequestMapping(value="/test/requestBody",method=RequestMethod.POST)  
2.     @ResponseBody  
3.     public Map<String,Object> testrequestBody(@RequestBody Map<String,Object> map1){  
4.         Map<String,Object> map=new HashMap<String,Object>();  
5.         map.put("name","lg");  
6.         map.put("age",23);  
7.         map.put("date",new Date());  
8.         return map;  
9.     }  

HttpEntityMethodProcessor具体的解析参数的过程：  
Java代码  

1. @Override  
2.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,  
3.             NativeWebRequest webRequest, WebDataBinderFactory binderFactory)  
4.             throws IOException, HttpMediaTypeNotSupportedException {  
5.   
6.         HttpInputMessage inputMessage = createInputMessage(webRequest);  
7.         Type paramType = getHttpEntityType(parameter);  
8.   
9.         Object body = readWithMessageConverters(webRequest, parameter, paramType);  
10.         return new HttpEntity<Object>(body, inputMessage.getHeaders());  
11.     }  

就是通过HttpMessageConverter来进一步的判断是否支持HttpEntity<T>中我们想要的T类型以及是否支持相应的content-type，如public Map<String,Object> testHttp(HttpEntity<String> httpEntity) ，则会选择StringHttpMessageConverter来进行转换。具体的选择过程如下：  
Java代码  

1. protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage,  
2.             MethodParameter methodParam, Type targetType) throws IOException, HttpMediaTypeNotSupportedException {  
3.   
4.         MediaType contentType;  
5.         try {  
6.             contentType = inputMessage.getHeaders().getContentType();  
7.         }  
8.         catch (InvalidMediaTypeException ex) {  
9.             throw new HttpMediaTypeNotSupportedException(ex.getMessage());  
10.         }  
11.         if (contentType == null) {  
12.             contentType = MediaType.APPLICATION_OCTET_STREAM;  
13.         }  
14.   
15.         Class<?> contextClass = methodParam.getContainingClass();  
16.   
17.         for (HttpMessageConverter<?> converter : this.messageConverters) {  
18.             if (converter instanceof GenericHttpMessageConverter) {  
19.                 GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;  
20.                 if (genericConverter.canRead(targetType, contextClass, contentType)) {  
21.                     if (logger.isDebugEnabled()) {  
22.                         logger.debug("Reading [" + targetType + "] as \"" +  
23.                                 contentType + "\" using [" + converter + "]");  
24.                     }  
25.                     return genericConverter.read(targetType, contextClass, inputMessage);  
26.                 }  
27.             }  
28.             Class<T> targetClass = (Class<T>)  
29.                     ResolvableType.forMethodParameter(methodParam, targetType).resolve(Object.class);  
30.             if (converter.canRead(targetClass, contentType)) {  
31.                 if (logger.isDebugEnabled()) {  
32.                     logger.debug("Reading [" + targetClass.getName() + "] as \"" +  
33.                             contentType + "\" using [" + converter + "]");  
34.                 }  
35.                 return ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);  
36.             }  
37.         }  
38.   
39.         throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);  
40.     }  

同理RequestResponseBodyMethodProcessor也会使用相应的HttpMessageConverter来进行转换。如public Map<String,Object> testrequestBody(@RequestBody Map<String,Object> map1)则会选择MappingJackson2HttpMessageConverter或者MappingJacksonHttpMessageConverter来完成转换。

再看看另一类的HandlerMethodArgumentResolver： 
RequestParamMethodArgumentResolver支持的类型有，一种是含@RequestParam注解的参数，另一种就是简单类型，如Integer、String、Date、URI, URL,Locale等： 
源代码如下：  
Java代码  

1. public boolean supportsParameter(MethodParameter parameter) {  
2.         Class<?> paramType = parameter.getParameterType();  
3.         if (parameter.hasParameterAnnotation(RequestParam.class)) {  
4.             if (Map.class.isAssignableFrom(paramType)) {  
5.                 String paramName = parameter.getParameterAnnotation(RequestParam.class).value();  
6.                 return StringUtils.hasText(paramName);  
7.             }  
8.             else {  
9.                 return true;  
10.             }  
11.         }  
12.         else {  
13.             if (parameter.hasParameterAnnotation(RequestPart.class)) {  
14.                 return false;  
15.             }  
16.             else if (MultipartFile.class.equals(paramType) || "javax.servlet.http.Part".equals(paramType.getName())) {  
17.                 return true;  
18.             }  
19.             else if (this.useDefaultResolution) {  
20.                 return BeanUtils.isSimpleProperty(paramType);  
21.             }  
22.             else {  
23.                 return false;  
24.             }  
25.         }  
26.     }  

BeanUtils.isSimpleProperty(paramType)判断是否是简单类型的具体内容如下：  
Java代码  

1. /** 
2.      * Check if the given type represents a "simple" property: 
3.      * a primitive, a String or other CharSequence, a Number, a Date, 
4.      * a URI, a URL, a Locale, a Class, or a corresponding array. 
5.      * <p>Used to determine properties to check for a "simple" dependency-check. 
6.      * @param clazz the type to check 
7.      * @return whether the given type represents a "simple" property 
8.      * @see org.springframework.beans.factory.support.RootBeanDefinition#DEPENDENCY_CHECK_SIMPLE 
9.      * @see org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#checkDependencies 
10.      */  
11.     public static boolean isSimpleProperty(Class<?> clazz) {  
12.         Assert.notNull(clazz, "Class must not be null");  
13.         return isSimpleValueType(clazz) || (clazz.isArray() && isSimpleValueType(clazz.getComponentType()));  
14.     }  
15.   
16.   
17. public static boolean isSimpleValueType(Class<?> clazz) {  
18.         return ClassUtils.isPrimitiveOrWrapper(clazz) || clazz.isEnum() ||  
19.                 CharSequence.class.isAssignableFrom(clazz) ||  
20.                 Number.class.isAssignableFrom(clazz) ||  
21.                 Date.class.isAssignableFrom(clazz) ||  
22.                 clazz.equals(URI.class) || clazz.equals(URL.class) ||  
23.                 clazz.equals(Locale.class) || clazz.equals(Class.class);  
24.     }  

即当请求为 http://localhost:8080/test?name=abc时，处理函数若为test(String name)，则对name的解析就是采用RequestParamMethodArgumentResolver来解析的。 

RequestHeaderMethodArgumentResolver:主要用来处理含有@RequestHeader注解的参数，但同时该参数又不是Map类型。如下：  
Java代码  

1. @Override  
2.     public boolean supportsParameter(MethodParameter parameter) {  
3.         return parameter.hasParameterAnnotation(RequestHeader.class)  
4.                 && !Map.class.isAssignableFrom(parameter.getParameterType());  
5.     }  
6.   
7.   
8.     @Override  
9.     protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {  
10.         String[] headerValues = request.getHeaderValues(name);  
11.         if (headerValues != null) {  
12.             return (headerValues.length == 1 ? headerValues[0] : headerValues);  
13.         }  
14.         else {  
15.             return null;  
16.         }  
17.     }  

源代码已经说明的很明白了。 
使用场景：  
Java代码  

1. @RequestMapping(value="/test/requestHeader",method=RequestMethod.GET)  
2.     @ResponseBody  
3.     public Map<String,Object> testrequestHeader(@RequestHeader String  Accept){  

若想获取所有的header信息：则使用另一个RequestHeaderMapMethodArgumentResolver，它则用来获取所有的header信息：  
Java代码  

1. public class RequestHeaderMapMethodArgumentResolver implements HandlerMethodArgumentResolver {  
2.   
3. //这里已经写明白了，要求参数必须含有@RequestHeader注解，并且是Map类型  
4.     @Override  
5.     public boolean supportsParameter(MethodParameter parameter) {  
6.         return parameter.hasParameterAnnotation(RequestHeader.class)  
7.                 && Map.class.isAssignableFrom(parameter.getParameterType());  
8.     }  
9.   
10.     @Override  
11.     public Object resolveArgument(  
12.             MethodParameter parameter, ModelAndViewContainer mavContainer,  
13.             NativeWebRequest webRequest, WebDataBinderFactory binderFactory)  
14.             throws Exception {  
15.   
16.         Class<?> paramType = parameter.getParameterType();  
17.   
18.         if (MultiValueMap.class.isAssignableFrom(paramType)) {  
19.             MultiValueMap<String, String> result;  
20.             if (HttpHeaders.class.isAssignableFrom(paramType)) {  
21.                 result = new HttpHeaders();  
22.             }  
23.             else {  
24.                 result = new LinkedMultiValueMap<String, String>();  
25.             }  
26.             for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {  
27.                 String headerName = iterator.next();  
28.                 for (String headerValue : webRequest.getHeaderValues(headerName)) {  
29.                     result.add(headerName, headerValue);  
30.                 }  
31.             }  
32.             return result;  
33.         }  
34.         else {  
35.             Map<String, String> result = new LinkedHashMap<String, String>();  
36.             for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {  
37.                 String headerName = iterator.next();  
38.                 String headerValue = webRequest.getHeader(headerName);  
39.                 result.put(headerName, headerValue);  
40.             }  
41.             return result;  
42.         }  
43.     }  
44. }  

从上面的解析过程可以看出，参数类型可以是普通的Map类型，也可以是MultiValueMap或者进一步的HttpHeaders，他们与普通Map类型的区别是他们对value值后者们是以List形式存放，前者是以String形式存放。 
使用场景：  
Java代码  

1. @RequestMapping(value="/test/requestHeader",method=RequestMethod.GET)  
2.     @ResponseBody  
3.     public Map<String,Object> testrequestHeader(@RequestHeader Map<String,Object> map1){  
4.   
5.   
6. public Map<String,Object> testrequestHeader(@RequestHeader MultiValueMap<String,Object> map1){  

PathVariableMethodArgumentResolver:主要针对含有@PathVariable的参数，代码如下：  
Java代码  

1. @Override  
2.     public boolean supportsParameter(MethodParameter parameter) {  
3.         if (!parameter.hasParameterAnnotation(PathVariable.class)) {  
4.             return false;  
5.         }  
6.         if (Map.class.isAssignableFrom(parameter.getParameterType())) {  
7.             String paramName = parameter.getParameterAnnotation(PathVariable.class).value();  
8.             return StringUtils.hasText(paramName);  
9.         }  
10.         return true;  
11.     }  
12.   
13.   
14.   
15. @Override  
16.     @SuppressWarnings("unchecked")  
17.     protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {  
18.         Map<String, String> uriTemplateVars =  
19.             (Map<String, String>) request.getAttribute(  
20.                     HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);  
21.         return (uriTemplateVars != null) ? uriTemplateVars.get(name) : null;  
22.     }  

对于支持的类型也说明的很详细。首先必须含有@PathVariable注解，其次如果是Map类型，必须要指定@PathVariable的值，即这个 
ArgumentResolver只能获取一个uri变量。要想获取多个则要使用PathVariableMapMethodArgumentResolver：  

Java代码  

1. @Override  
2.     public boolean supportsParameter(MethodParameter parameter) {  
3.         PathVariable annot = parameter.getParameterAnnotation(PathVariable.class);  
4.         return ((annot != null) && (Map.class.isAssignableFrom(parameter.getParameterType()))  
5.                 && (!StringUtils.hasText(annot.value())));  
6.     }  
7.   
8. public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,  
9.             NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {  
10.   
11.         @SuppressWarnings("unchecked")  
12.         Map<String, String> uriTemplateVars =  
13.                 (Map<String, String>) webRequest.getAttribute(  
14.                         HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);  
15.   
16.         if (!CollectionUtils.isEmpty(uriTemplateVars)) {  
17.             return new LinkedHashMap<String, String>(uriTemplateVars);  
18.         }  
19.         else {  
20.             return Collections.emptyMap();  
21.         }  
22.     }  

它要求必须含有@PathVariable注解，并且必须是Map类型，并且@PathVariable注解的value没有值。同时我们可以从PathVariableMapMethodArgumentResolver和PathVariableMethodArgumentResolver上面看出，他们的取值都是从request的属性上进行获取的webRequest.getAttribute( 
HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);也就是说，在解析完@RequestMapping匹配工作后，便将这些参数设置进request的属性上，属性名为HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE。其他的HandlerMethodArgumentResolver可以自行研究，这里不再说明。 


至此，我们就要说明下HandlerMethodArgumentResolver的注册来源： 
它的来源分为两部分，一部分spring默认的HandlerMethodArgumentResolver，另一部分就是我们自定义的HandlerMethodArgumentResolver。 
还是先看mvc:annotation-driven中配置自定义的HandlerMethodArgumentResolver：  
Java代码  

1. <mvc:annotation-driven >  
2.         <mvc:argument-resolvers>  
3.             <bean class="xxx"></bean>  
4.         </mvc:argument-resolvers>  
5.     </mvc:annotation-driven>    

在mvc:argument-resolvers标签下配置相应的自定义的HandlerMethodArgumentResolver。 
然后在mvc:annotation-driven的注解驱动类AnnotationDrivenBeanDefinitionParser中会有这样的代码：  
Java代码  

1. ManagedList<?> argumentResolvers = getArgumentResolvers(element, parserContext);  
2.   
3. //略  
4. if (argumentResolvers != null) {  
5.             handlerAdapterDef.getPropertyValues().add("customArgumentResolvers", argumentResolvers);  
6.         }  

其中getArgumentResolvers就是获取我们自定义的HandlerMethodArgumentResolver  
Java代码  

1. private ManagedList<?> getArgumentResolvers(Element element, ParserContext parserContext) {  
2.         Element resolversElement = DomUtils.getChildElementByTagName(element, "argument-resolvers");  
3.         if (resolversElement != null) {  
4.             ManagedList<BeanDefinitionHolder> argumentResolvers = extractBeanSubElements(resolversElement, parserContext);  
5.             return wrapWebArgumentResolverBeanDefs(argumentResolvers, parserContext);  
6.         }  
7.         return null;  
8.     }  

从上面的代码可以看出，获取我们自定义的HandlerMethodArgumentResolver然后把它设置进RequestMappingHandlerAdapter的customArgumentResolvers参数中，RequestMappingHandlerAdapter有两个与HandlerMethodArgumentResolver有关的参数：  

Java代码  

1. private List<HandlerMethodArgumentResolver> customArgumentResolvers;  
2. private HandlerMethodArgumentResolverComposite argumentResolvers;  

HandlerMethodArgumentResolverComposite 也仅仅是内部存放一个List<HandlerMethodArgumentResolver>集合，同时本身又继承HandlerMethodArgumentResolver，所以它的实现都是靠内部的List<HandlerMethodArgumentResolver>集合来实现的。  
Java代码  

1. private final List<HandlerMethodArgumentResolver> argumentResolvers =  
2.             new LinkedList<HandlerMethodArgumentResolver>();  
3.   
4. //使用了适合高并发的ConcurrentHashMap来进行缓存  
5.     private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =  
6.             new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);  
7.   
8.   
9.     /** 
10.      * Return a read-only list with the contained resolvers, or an empty list. 
11.      */  
12.     public List<HandlerMethodArgumentResolver> getResolvers() {  
13.         return Collections.unmodifiableList(this.argumentResolvers);  
14.     }  
15.   
16.     /** 
17.      * Whether the given {@linkplain MethodParameter method parameter} is supported by any registered 
18.      * {@link HandlerMethodArgumentResolver}. 
19.      */  
20.     @Override  
21.     public boolean supportsParameter(MethodParameter parameter) {  
22.         return getArgumentResolver(parameter) != null;  
23.     }  
24.   
25.     /** 
26.      * Iterate over registered {@link HandlerMethodArgumentResolver}s and invoke the one that supports it. 
27.      * @exception IllegalStateException if no suitable {@link HandlerMethodArgumentResolver} is found. 
28.      */  
29.     @Override  
30.     public Object resolveArgument(  
31.             MethodParameter parameter, ModelAndViewContainer mavContainer,  
32.             NativeWebRequest webRequest, WebDataBinderFactory binderFactory)  
33.             throws Exception {  
34.   
35.         HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);  
36.         Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");  
37.         return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);  
38.     }  
39.   
40.     /** 
41.      * Find a registered {@link HandlerMethodArgumentResolver} that supports the given method parameter. 
42.      */  
43.     private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {  
44.         HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);  
45.         if (result == null) {  
46.             for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {  
47.                 if (logger.isTraceEnabled()) {  
48.                     logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +  
49.                             parameter.getGenericParameterType() + "]");  
50.                 }  
51.                 if (methodArgumentResolver.supportsParameter(parameter)) {  
52.                     result = methodArgumentResolver;  
53.                     this.argumentResolverCache.put(parameter, result);  
54.                     break;  
55.                 }  
56.             }  
57.         }  
58.         return result;  
59.     }  

在RequestMappingHandlerAdapter完成参数设置后，会调用afterPropertiesSet方法  
Java代码  

1. @Override  
2.     public void afterPropertiesSet() {  
3.         if (this.argumentResolvers == null) {  
4.             List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();  
5.             this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);  
6.         }  
7.         if (this.initBinderArgumentResolvers == null) {  
8.             List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();  
9.             this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);  
10.         }  
11.         if (this.returnValueHandlers == null) {  
12.             List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();  
13.             this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);  
14.         }  
15.         initControllerAdviceCache();  
16.     }  

getDefaultArgumentResolvers方法完成了所有的HandlerMethodArgumentResolver的汇总，如下：  
Java代码  

1. private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {  
2.         List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();  
3.   
4.         // Annotation-based argument resolution  
5.         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));  
6.         resolvers.add(new RequestParamMapMethodArgumentResolver());  
7.         resolvers.add(new PathVariableMethodArgumentResolver());  
8.         resolvers.add(new PathVariableMapMethodArgumentResolver());  
9.         resolvers.add(new MatrixVariableMethodArgumentResolver());  
10.         resolvers.add(new MatrixVariableMapMethodArgumentResolver());  
11.         resolvers.add(new ServletModelAttributeMethodProcessor(false));  
12.         resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));  
13.         resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));  
14.         resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));  
15.         resolvers.add(new RequestHeaderMapMethodArgumentResolver());  
16.         resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));  
17.         resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));  
18.   
19.         // Type-based argument resolution  
20.         resolvers.add(new ServletRequestMethodArgumentResolver());  
21.         resolvers.add(new ServletResponseMethodArgumentResolver());  
22.         resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));  
23.         resolvers.add(new RedirectAttributesMethodArgumentResolver());  
24.         resolvers.add(new ModelMethodProcessor());  
25.         resolvers.add(new MapMethodProcessor());  
26.         resolvers.add(new ErrorsMethodArgumentResolver());  
27.         resolvers.add(new SessionStatusMethodArgumentResolver());  
28.         resolvers.add(new UriComponentsBuilderMethodArgumentResolver());  
29.   
30.         // Custom arguments  
31. //获取我们自定义的HandlerMethodArgumentResolver  
32.         if (getCustomArgumentResolvers() != null) {  
33.             resolvers.addAll(getCustomArgumentResolvers());  
34.         }  
35.   
36.         // Catch-all  
37.         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));  
38.         resolvers.add(new ServletModelAttributeMethodProcessor(true));  
39.   
40.         return resolvers;  
41.     }  

不仅汇总了spring默认的，同时加进来我们自定义的HandlerMethodArgumentResolver。至此，HandlerMethodArgumentResolver的来龙去脉都说清楚了。然后就是我们自定义HandlerMethodArgumentResolver,下一篇文章再说。