SpringMVC源碼總結（九）HandlerMethodArgumentResolver介紹

本文章主要介紹HandlerMethodArgumentResolver在SpringMVC中的使用，介紹幾個HandlerMethodArgumentResolver具體的使用情況，然後說明HandlerMethodArgumentResolver的註冊來源以及如何自定義註冊。 

首先具體看下請求映射到的handler的對應的映射函數的參數形式有哪些： 

HandlerMethodArgumentResolver接口只有兩個方法： 

//判斷是否支持要轉換的參數類型
boolean supportsParameter(MethodParameter parameter);
//當支持後進行相應的轉換
Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;

HandlerMethodArgumentResolver接口的抽象類：AbstractMessageConverterMethodArgumentResolver僅僅引入了HttpMessageConverter，即轉換的工作有這些HttpMessageConverter來完成具體的轉換和判斷由子類來實現。 
如下： 

public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {

    protected final Log logger = LogFactory.getLog(getClass());

    protected final List<HttpMessageConverter<?>> messageConverters;

    protected final List<MediaType> allSupportedMediaTypes;
     //略
}

AbstractMessageConverterMethodArgumentResolver 的抽象子類AbstractMessageConverterMethodProcessor僅僅是加入了對響應數據進行轉換的支持。 
也就是AbstractMessageConverterMethodProcessor的子類不僅可以用來轉換請求數據，也可以用來轉換響應數據。 
AbstractMessageConverterMethodProcessor的子類HttpEntityMethodProcessor，支持請求和響應的轉換，代碼如下： 

@Override
    public boolean supportsParameter(MethodParameter parameter) {
        return HttpEntity.class.equals(parameter.getParameterType());
    }

    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        return HttpEntity.class.isAssignableFrom(returnType.getParameterType());
    }

使用場景如下： 

@RequestMapping(value="/test/http",method=RequestMethod.POST)
    @ResponseBody
    public Map<String,Object> testHttp(HttpEntity<String> httpEntity)
            //略
        }


@RequestMapping(value="/test/httpEntity",method=RequestMethod.GET)
    public HttpEntity<String> testHttpEntity(){
        //略
    }

AbstractMessageConverterMethodProcessor的子類RequestResponseBodyMethodProcessor：支持@RequestBody和@ResponseBody,代碼如下： 

@Override
    public boolean supportsParameter(MethodParameter parameter) {
               //查找參數中是否含有@RequestBody註解
        return parameter.hasParameterAnnotation(RequestBody.class);
    }

    @Override
    public boolean supportsReturnType(MethodParameter returnType) {

//查找參數中是否含有@RequestBody註解或者controller類上是否含有@RequestBody
        return ((AnnotationUtils.findAnnotation(returnType.getContainingClass(), ResponseBody.class) != null) ||
                (returnType.getMethodAnnotation(ResponseBody.class) != null));
    }

使用場景如下： 

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

HttpEntityMethodProcessor具體的解析參數的過程： 

@Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
            throws IOException, HttpMediaTypeNotSupportedException {

        HttpInputMessage inputMessage = createInputMessage(webRequest);
        Type paramType = getHttpEntityType(parameter);

        Object body = readWithMessageConverters(webRequest, parameter, paramType);
        return new HttpEntity<Object>(body, inputMessage.getHeaders());
    }

就是通過HttpMessageConverter來進一步的判斷是否支持HttpEntity<T>中我們想要的T類型以及是否支持相應的content-type，如public Map<String,Object> testHttp(HttpEntity<String> httpEntity) ，則會選擇StringHttpMessageConverter來進行轉換。具體的選擇過程如下： 

protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage,
            MethodParameter methodParam, Type targetType) throws IOException, HttpMediaTypeNotSupportedException {

        MediaType contentType;
        try {
            contentType = inputMessage.getHeaders().getContentType();
        }
        catch (InvalidMediaTypeException ex) {
            throw new HttpMediaTypeNotSupportedException(ex.getMessage());
        }
        if (contentType == null) {
            contentType = MediaType.APPLICATION_OCTET_STREAM;
        }

        Class<?> contextClass = methodParam.getContainingClass();

        for (HttpMessageConverter<?> converter : this.messageConverters) {
            if (converter instanceof GenericHttpMessageConverter) {
                GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;
                if (genericConverter.canRead(targetType, contextClass, contentType)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Reading [" + targetType + "] as \"" +
                                contentType + "\" using [" + converter + "]");
                    }
                    return genericConverter.read(targetType, contextClass, inputMessage);
                }
            }
            Class<T> targetClass = (Class<T>)
                    ResolvableType.forMethodParameter(methodParam, targetType).resolve(Object.class);
            if (converter.canRead(targetClass, contentType)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Reading [" + targetClass.getName() + "] as \"" +
                            contentType + "\" using [" + converter + "]");
                }
                return ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
            }
        }

        throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
    }

同理RequestResponseBodyMethodProcessor也會使用相應的HttpMessageConverter來進行轉換。如public Map<String,Object> testrequestBody(@RequestBody Map<String,Object> map1)則會選擇MappingJackson2HttpMessageConverter或者MappingJacksonHttpMessageConverter來完成轉換。

再看看另一類的HandlerMethodArgumentResolver： 
RequestParamMethodArgumentResolver支持的類型有，一種是含@RequestParam註解的參數，另一種就是簡單類型，如Integer、String、Date、URI, URL,Locale等： 
源代碼如下： 

public boolean supportsParameter(MethodParameter parameter) {
        Class<?> paramType = parameter.getParameterType();
        if (parameter.hasParameterAnnotation(RequestParam.class)) {
            if (Map.class.isAssignableFrom(paramType)) {
                String paramName = parameter.getParameterAnnotation(RequestParam.class).value();
                return StringUtils.hasText(paramName);
            }
            else {
                return true;
            }
        }
        else {
            if (parameter.hasParameterAnnotation(RequestPart.class)) {
                return false;
            }
            else if (MultipartFile.class.equals(paramType) || "javax.servlet.http.Part".equals(paramType.getName())) {
                return true;
            }
            else if (this.useDefaultResolution) {
                return BeanUtils.isSimpleProperty(paramType);
            }
            else {
                return false;
            }
        }
    }

BeanUtils.isSimpleProperty(paramType)判斷是否是簡單類型的具體內容如下： 

/**
     * Check if the given type represents a "simple" property:
     * a primitive, a String or other CharSequence, a Number, a Date,
     * a URI, a URL, a Locale, a Class, or a corresponding array.
     * <p>Used to determine properties to check for a "simple" dependency-check.
     * @param clazz the type to check
     * @return whether the given type represents a "simple" property
     * @see org.springframework.beans.factory.support.RootBeanDefinition#DEPENDENCY_CHECK_SIMPLE
     * @see org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#checkDependencies
     */
    public static boolean isSimpleProperty(Class<?> clazz) {
        Assert.notNull(clazz, "Class must not be null");
        return isSimpleValueType(clazz) || (clazz.isArray() && isSimpleValueType(clazz.getComponentType()));
    }


public static boolean isSimpleValueType(Class<?> clazz) {
        return ClassUtils.isPrimitiveOrWrapper(clazz) || clazz.isEnum() ||
                CharSequence.class.isAssignableFrom(clazz) ||
                Number.class.isAssignableFrom(clazz) ||
                Date.class.isAssignableFrom(clazz) ||
                clazz.equals(URI.class) || clazz.equals(URL.class) ||
                clazz.equals(Locale.class) || clazz.equals(Class.class);
    }

即當請求爲 http://localhost:8080/test?name=abc時，處理函數若爲test(String name)，則對name的解析就是採用RequestParamMethodArgumentResolver來解析的。 

RequestHeaderMethodArgumentResolver:主要用來處理含有@RequestHeader註解的參數，但同時該參數又不是Map類型。如下： 

@Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(RequestHeader.class)
                && !Map.class.isAssignableFrom(parameter.getParameterType());
    }


    @Override
    protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
        String[] headerValues = request.getHeaderValues(name);
        if (headerValues != null) {
            return (headerValues.length == 1 ? headerValues[0] : headerValues);
        }
        else {
            return null;
        }
    }

源代碼已經說明的很明白了。 
使用場景： 

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

若想獲取所有的header信息：則使用另一個RequestHeaderMapMethodArgumentResolver，它則用來獲取所有的header信息： 

public class RequestHeaderMapMethodArgumentResolver implements HandlerMethodArgumentResolver {

//這裏已經寫明白了，要求參數必須含有@RequestHeader註解，並且是Map類型
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(RequestHeader.class)
                && Map.class.isAssignableFrom(parameter.getParameterType());
    }

    @Override
    public Object resolveArgument(
            MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
            throws Exception {

        Class<?> paramType = parameter.getParameterType();

        if (MultiValueMap.class.isAssignableFrom(paramType)) {
            MultiValueMap<String, String> result;
            if (HttpHeaders.class.isAssignableFrom(paramType)) {
                result = new HttpHeaders();
            }
            else {
                result = new LinkedMultiValueMap<String, String>();
            }
            for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
                String headerName = iterator.next();
                for (String headerValue : webRequest.getHeaderValues(headerName)) {
                    result.add(headerName, headerValue);
                }
            }
            return result;
        }
        else {
            Map<String, String> result = new LinkedHashMap<String, String>();
            for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
                String headerName = iterator.next();
                String headerValue = webRequest.getHeader(headerName);
                result.put(headerName, headerValue);
            }
            return result;
        }
    }
}

從上面的解析過程可以看出，參數類型可以是普通的Map類型，也可以是MultiValueMap或者進一步的HttpHeaders，他們與普通Map類型的區別是他們對value值後者們是以List形式存放，前者是以String形式存放。 
使用場景： 

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


public Map<String,Object> testrequestHeader(@RequestHeader MultiValueMap<String,Object> map1){

PathVariableMethodArgumentResolver:主要針對含有@PathVariable的參數，代碼如下： 

@Override
    public boolean supportsParameter(MethodParameter parameter) {
        if (!parameter.hasParameterAnnotation(PathVariable.class)) {
            return false;
        }
        if (Map.class.isAssignableFrom(parameter.getParameterType())) {
            String paramName = parameter.getParameterAnnotation(PathVariable.class).value();
            return StringUtils.hasText(paramName);
        }
        return true;
    }



@Override
    @SuppressWarnings("unchecked")
    protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
        Map<String, String> uriTemplateVars =
            (Map<String, String>) request.getAttribute(
                    HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
        return (uriTemplateVars != null) ? uriTemplateVars.get(name) : null;
    }

對於支持的類型也說明的很詳細。首先必須含有@PathVariable註解，其次如果是Map類型，必須要指定@PathVariable的值，即這個 
ArgumentResolver只能獲取一個uri變量。要想獲取多個則要使用PathVariableMapMethodArgumentResolver： 

@Override
    public boolean supportsParameter(MethodParameter parameter) {
        PathVariable annot = parameter.getParameterAnnotation(PathVariable.class);
        return ((annot != null) && (Map.class.isAssignableFrom(parameter.getParameterType()))
                && (!StringUtils.hasText(annot.value())));
    }

public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

        @SuppressWarnings("unchecked")
        Map<String, String> uriTemplateVars =
                (Map<String, String>) webRequest.getAttribute(
                        HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);

        if (!CollectionUtils.isEmpty(uriTemplateVars)) {
            return new LinkedHashMap<String, String>(uriTemplateVars);
        }
        else {
            return Collections.emptyMap();
        }
    }

它要求必須含有@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： 

<mvc:annotation-driven >
        <mvc:argument-resolvers>
            <bean class="xxx"></bean>
        </mvc:argument-resolvers>
    </mvc:annotation-driven>

在mvc:argument-resolvers標籤下配置相應的自定義的HandlerMethodArgumentResolver。 
然後在mvc:annotation-driven的註解驅動類AnnotationDrivenBeanDefinitionParser中會有這樣的代碼： 

ManagedList<?> argumentResolvers = getArgumentResolvers(element, parserContext);

//略
if (argumentResolvers != null) {
            handlerAdapterDef.getPropertyValues().add("customArgumentResolvers", argumentResolvers);
        }

其中getArgumentResolvers就是獲取我們自定義的HandlerMethodArgumentResolver 

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

從上面的代碼可以看出，獲取我們自定義的HandlerMethodArgumentResolver然後把它設置進RequestMappingHandlerAdapter的customArgumentResolvers參數中，RequestMappingHandlerAdapter有兩個與HandlerMethodArgumentResolver有關的參數： 

private List<HandlerMethodArgumentResolver> customArgumentResolvers;
private HandlerMethodArgumentResolverComposite argumentResolvers;

HandlerMethodArgumentResolverComposite 也僅僅是內部存放一個List<HandlerMethodArgumentResolver>集合，同時本身又繼承HandlerMethodArgumentResolver，所以它的實現都是靠內部的List<HandlerMethodArgumentResolver>集合來實現的。 

private final List<HandlerMethodArgumentResolver> argumentResolvers =
            new LinkedList<HandlerMethodArgumentResolver>();

//使用了適合高併發的ConcurrentHashMap來進行緩存
    private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
            new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);


    /**
     * Return a read-only list with the contained resolvers, or an empty list.
     */
    public List<HandlerMethodArgumentResolver> getResolvers() {
        return Collections.unmodifiableList(this.argumentResolvers);
    }

    /**
     * Whether the given {@linkplain MethodParameter method parameter} is supported by any registered
     * {@link HandlerMethodArgumentResolver}.
     */
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return getArgumentResolver(parameter) != null;
    }

    /**
     * Iterate over registered {@link HandlerMethodArgumentResolver}s and invoke the one that supports it.
     * @exception IllegalStateException if no suitable {@link HandlerMethodArgumentResolver} is found.
     */
    @Override
    public Object resolveArgument(
            MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
            throws Exception {

        HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
        Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");
        return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
    }

    /**
     * Find a registered {@link HandlerMethodArgumentResolver} that supports the given method parameter.
     */
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
        if (result == null) {
            for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
                            parameter.getGenericParameterType() + "]");
                }
                if (methodArgumentResolver.supportsParameter(parameter)) {
                    result = methodArgumentResolver;
                    this.argumentResolverCache.put(parameter, result);
                    break;
                }
            }
        }
        return result;
    }

在RequestMappingHandlerAdapter完成參數設置後，會調用afterPropertiesSet方法 

@Override
    public void afterPropertiesSet() {
        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);
        }
        initControllerAdviceCache();
    }

getDefaultArgumentResolvers方法完成了所有的HandlerMethodArgumentResolver的彙總，如下： 

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()));
        resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
        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()));
        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
//獲取我們自定義的HandlerMethodArgumentResolver
        if (getCustomArgumentResolvers() != null) {
            resolvers.addAll(getCustomArgumentResolvers());
        }

        // Catch-all
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
        resolvers.add(new ServletModelAttributeMethodProcessor(true));

        return resolvers;
    }

不僅彙總了spring默認的，同時加進來我們自定義的HandlerMethodArgumentResolver。至此，HandlerMethodArgumentResolver的來龍去脈都說清楚了。然後就是我們自定義HandlerMethodArgumentResolver,下一篇文章再說。 

轉載自：http://blog.csdn.net/z69183787/article/details/52817089