devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringMVC源码总结（九）HandlerMethodArgumentResolver介绍_handlermethodargumentresolver获取attribute

作者：正经夜光杯 | 2024-08-02 03:36:49

赞

踩

handlermethodargumentresolver获取attribute
本文章主要介绍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,下一篇文章再说。 
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/917062
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号