springmvc--5--ServletInvocableHandlerMethod增强的处理器方法

旧城等待， 2022-10-29 09:05 249阅读 0赞

# springmvc–`ServletInvocableHandlerMethod`增强的处理器方法 #

### 文章目录 ###

*  springmvc--\`ServletInvocableHandlerMethod\`增强的处理器方法
 *  1 用途
 *  2 \`ServletInvocableHandlerMethod\`是什么？
 *   *  2.1 \`HandlerMethod\`的属性
     *  2.2 \`InvocableHandlerMethod\`的属性
     *  2.3 \`ServletInvocableHandlerMethod\`的属性
     *  2.4 \`ServletInvocableHandlerMethod\`的构造方法
 *  3 \`invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,Object... providedArgs)\`方法，执行处理器方法和处理返回值
 *   *  3.1 \`invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs)\`方法，执行处理器方法， 并得到返回值
     *   *  3.1.1 获取执行处理器方法的参数对象
         *  3.1.2 真正执行处理器方法
     *  3.2 设置 \`@ResponseStatus\`注解指定的响应状态码
     *  3.3 得到返回值的类型
 *  5 \`DefaultParameterNameDiscoverer\`默认的参数名发现器
 *  6 \`MethodParameter\` 方法参数
 *   *  6.1 设置方法参数名发现策略
     *  6.2 获取方法参数上的注解信息
     *  6.3 获取参数类型
 *  7 \`HandlerMethodArgumentResolverComposite\` 参数解析器组合
 *   *  7.1 \`supportsParameter\`方法
     *  7.2 \`resolveArgument\`方法
 *  8 \`HandlerMethod\`类的两个内部类
 *   *  8.1 \`HandlerMethodParameter\` 封装方法参数
     *  8.2 \`ReturnValueMethodParameter\` 封装方法返回值
 *  9 \`ServletInvocableHandlerMethod\`类的两个内部类
 *   *  9.1 \`ConcurrentResultHandlerMethod\`
     *  9.2\`ConcurrentResultMethodParameter\`
 *  10 \`HandlerMethodReturnValueHandlerComposite\` 返回值处理器组合
 *   *  10.1 \`supportsReturnType\`方法
     *  10.2 \`handleReturnValue\`方法

# 1 用途 #

上一篇文章，由于篇幅问题，未能真正看到执行处理器方法过程（即反射`invoke()`方法）。这篇文章我们就来详细看一下它是如何解析处理器方法参数，调用处理器方法，处理返回值的。

# 2 `ServletInvocableHandlerMethod`是什么？ #

首先看它的类图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]

它是`HandlerMethod`的子类，主要就是为了增强`HandlerMethod`。

## 2.1 `HandlerMethod`的属性 ##

public class HandlerMethod { 
 
 //处理器方法所在类的对象
 private final Object bean;
 
 @Nullable
 private final BeanFactory beanFactory;
 
 //处理器方法所在类的clazz对象
 private final Class<?> beanType;
 
 //处理器方法
 private final Method method;
 
 //桥接处理器方法
 private final Method bridgedMethod;
 
 //处理器方法参数对象
 private final MethodParameter[] parameters;
 
 //响应状态码，@ResponseStatus注解指定
 @Nullable
 private HttpStatus responseStatus;
 
 //响应原因，@ResponseStatus注解指定
 @Nullable
 private String responseStatusReason;
 
 @Nullable
 private HandlerMethod resolvedFromHandlerMethod;
 
 /** * 如果该方法是接口定义的且被重写 * 那么这里保存父接口方法参数的注解信息 */
 @Nullable
 private volatile List<Annotation[][]> interfaceParameterAnnotations;
 
 //方法描述
 private final String description;
 }

## 2.2 `InvocableHandlerMethod`的属性 ##

public class InvocableHandlerMethod extends HandlerMethod { 
    
        //空参数对象
        private static final Object[] EMPTY_ARGS = new Object[0];
    
        //处理器方法参数解析器组合
        private HandlerMethodArgumentResolverComposite resolvers = new HandlerMethodArgumentResolverComposite();
    
        //参数名发现器
        private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    
        //数据绑定工厂
        @Nullable
        private WebDataBinderFactory dataBinderFactory;
    }

> 在原来的基础上增加了对处理器方法参数的解析支持

## 2.3 `ServletInvocableHandlerMethod`的属性 ##

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod { 
    
        private static final Method CALLABLE_METHOD = ClassUtils.getMethod(Callable.class, "call");
    
        //处理器方法返回值处理器组合
        @Nullable
        private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
    }

> 在原来的基础上增加了对处理器方法返回值处理的支持

## 2.4 `ServletInvocableHandlerMethod`的构造方法 ##

/** * ServletInvocableHandlerMethod的构造方法 */
    public ServletInvocableHandlerMethod(HandlerMethod handlerMethod) { 
        super(handlerMethod);
    }
    
    /** * InvocableHandlerMethod的构造方法 */
    public InvocableHandlerMethod(HandlerMethod handlerMethod) { 
        super(handlerMethod);
    }
    
    
    /** * HandlerMethod的构造方法 */
    protected HandlerMethod(HandlerMethod handlerMethod) { 
        Assert.notNull(handlerMethod, "HandlerMethod is required");
        this.bean = handlerMethod.bean;
        this.beanFactory = handlerMethod.beanFactory;
        this.beanType = handlerMethod.beanType;
        this.method = handlerMethod.method;
        this.bridgedMethod = handlerMethod.bridgedMethod;
        this.parameters = handlerMethod.parameters;
        this.responseStatus = handlerMethod.responseStatus;
        this.responseStatusReason = handlerMethod.responseStatusReason;
        this.description = handlerMethod.description;
        this.resolvedFromHandlerMethod = handlerMethod.resolvedFromHandlerMethod;
    }

> 其实就是拷贝原`HandlerMethod`对象的值，创建一个功能更强的对象。

# 3 `invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,Object... providedArgs)`方法，执行处理器方法和处理返回值 #

> 从上一篇文章中，我们已经知道是通过`ServletInvocableHandlerMethod`的`invokeAndHandle()`方法完成处理器方法执行的。

/** * Invoke the method and handle the return value through one of the * configured {@link HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers}. * @param webRequest the current request * @param mavContainer the ModelAndViewContainer for this request * @param providedArgs "given" arguments matched by type (not resolved) */
    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
                                Object... providedArgs) throws Exception { 
    
        //执行处理器方法， 并得到返回值，见3.1
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        //设置@ResponseStatus注解指定的响应状态码，见3.2
        setResponseStatus(webRequest);
    
        //没有返回值
        if (returnValue == null) { 
            /** * 满足下列条件之一的，就不进行后续处理了，直接返回 * 1.未修改请求 * 2.通过@ResponseStatus注解设置了响应状态码 * 3.当前请求已被处理，即ModelAndViewContainer中requestHandled属性为true */
            if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) { 
                disableContentCachingIfNecessary(webRequest);
                //设置请求已经被处理
                mavContainer.setRequestHandled(true);
                return;
            }
        }
        //有返回值，且通过@ResponseStatus注解指定了响应状态原因
        else if (StringUtils.hasText(getResponseStatusReason())) { 
            //设置请求已经被处理
            mavContainer.setRequestHandled(true);
            return;
        }
    
        //设置请求还未被处理
        mavContainer.setRequestHandled(false);
        Assert.state(this.returnValueHandlers != null, "No return value handlers");
        try { 
            /** * getReturnValueType(returnValue)方法，得到返回值的类型，见3.3 * 使用返回值处理器处理返回值，见10.2 */
            this.returnValueHandlers.handleReturnValue(
                returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) { 
            if (logger.isTraceEnabled()) { 
                logger.trace(formatErrorForReturnValue(returnValue), ex);
            }
            throw ex;
        }
    }
    
    
    /*************************************************************************************/
    /** * Does the given request qualify as "not modified"? * @see ServletWebRequest#checkNotModified(long) * @see ServletWebRequest#checkNotModified(String) */
    private boolean isRequestNotModified(ServletWebRequest webRequest) { 
        //ServletWebRequest的属性，默认为false
        //该属性标识请求是否未修改
        return webRequest.isNotModified();
    }
    
    /** * Return the specified response status, if any. * @since 4.3.8 * @see ResponseStatus#code() */
    @Nullable
    protected HttpStatus getResponseStatus() { 
        //该属性中保存了@ResponseStatus注解设置的响应状态码
        return this.responseStatus;
    }
    
    /** * Return the associated response status reason, if any. * @since 4.3.8 * @see ResponseStatus#reason() */
    @Nullable
    protected String getResponseStatusReason() { 
        //该属性中保存了@ResponseStatus注解设置的响应原因
        return this.responseStatusReason;
    }

## 3.1 `invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs)`方法，执行处理器方法， 并得到返回值 ##

/** * Invoke the method after resolving its argument values in the context of the given request. * Argument values are commonly resolved through * {@link HandlerMethodArgumentResolver HandlerMethodArgumentResolvers}. * The {@code providedArgs} parameter however may supply argument values to be used directly, * i.e. without argument resolution. Examples of provided argument values include a * {@link WebDataBinder}, a {@link SessionStatus}, or a thrown exception instance. * Provided argument values are checked before argument resolvers. * Delegates to {@link #getMethodArgumentValues} and calls {@link #doInvoke} with the * resolved arguments. * @param request the current request * @param mavContainer the ModelAndViewContainer for this request * @param providedArgs "given" arguments matched by type, not resolved * @return the raw value returned by the invoked method * @throws Exception raised if no suitable argument resolver can be found, * or if the method raised an exception * @see #getMethodArgumentValues * @see #doInvoke */
 @Nullable
 public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
 Object... providedArgs) throws Exception { 
 
 //获取执行处理器方法的参数对象，见3.1.1
 Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
 if (logger.isTraceEnabled()) { 
 logger.trace("Arguments: " + Arrays.toString(args));
 }
 //执行处理器方法，见3.1.2
 return doInvoke(args);
 }

> 从上面可以发现，就两个步骤，先解析处理器方法的参数，然后使用反射执行处理器方法。

### 3.1.1 获取执行处理器方法的参数对象 ###

//一个空数组
 private static final Object[] EMPTY_ARGS = new Object[0];
 //默认的参数名发现器
 private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
 
 
 /** * Get the method argument values for the current request, checking the provided * argument values and falling back to the configured argument resolvers. * The resulting array will be passed into {@link #doInvoke}. * @since 5.1.2 */
 protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
 Object... providedArgs) throws Exception { 
 
 //获取方法参数
 MethodParameter[] parameters = getMethodParameters();
 //处理器方法没有参数，直接返回一个空数组
 if (ObjectUtils.isEmpty(parameters)) { 
 return EMPTY_ARGS;
 }
 
 //否则开始进入下面参数的解析流程
 Object[] args = new Object[parameters.length];
 for (int i = 0; i < parameters.length; i++) { 
 /** * MethodParameter是spring定义的类，不是JDK的 * 见6 */
 MethodParameter parameter = parameters[i];
 //设置方法参数名发现策略，见6.1
 parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
 /** * 获取提供的参数 * 在这种场景下providedArgs时null，没有指定参数 */
 args[i] = findProvidedArgument(parameter, providedArgs);
 if (args[i] != null) { 
 continue;
 }
 //参数解析器不支持解析当前参数，见7.1
 if (!this.resolvers.supportsParameter(parameter)) { 
 throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
 }
 //解析请求映射为处理器方法的参数，见7.2
 try { 
 args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
 }
 catch (Exception ex) { 
 // Leave stack trace for later, exception may actually be resolved and handled...
 if (logger.isDebugEnabled()) { 
 String exMsg = ex.getMessage();
 if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) { 
 logger.debug(formatArgumentError(parameter, exMsg));
 }
 }
 throw ex;
 }
 }
 return args;
 }
 
 
 /***********************************************************************************/
 /** * Return the method parameters for this handler method. * 方法参数在创建HandlerMethod对象的时候就已经被解析出来了 */
 public MethodParameter[] getMethodParameters() { 
 return this.parameters;
 }
 
 /** * 一个一个的遍历，判断是不是该参数类型的实例 */
 @Nullable
 protected static Object findProvidedArgument(MethodParameter parameter, @Nullable Object... providedArgs) { 
 if (!ObjectUtils.isEmpty(providedArgs)) { 
 for (Object providedArg : providedArgs) { 
 if (parameter.getParameterType().isInstance(providedArg)) { 
 return providedArg;
 }
 }
 }
 return null;
 }

> 遍历方法参数，一个一个的使用参数解析器解析。

### 3.1.2 真正执行处理器方法 ###

/** * Invoke the handler method with the given argument values. */
    @Nullable
    protected Object doInvoke(Object... args) throws Exception { 
        ReflectionUtils.makeAccessible(getBridgedMethod());
        try { 
            //反射执行方法
            return getBridgedMethod().invoke(getBean(), args);
        }
        catch (IllegalArgumentException ex) { 
            assertTargetBean(getBridgedMethod(), getBean(), args);
            String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
            throw new IllegalStateException(formatInvokeError(text, args), ex);
        }
        catch (InvocationTargetException ex) { 
            // Unwrap for HandlerExceptionResolvers ...
            Throwable targetException = ex.getTargetException();
            if (targetException instanceof RuntimeException) { 
                throw (RuntimeException) targetException;
            }
            else if (targetException instanceof Error) { 
                throw (Error) targetException;
            }
            else if (targetException instanceof Exception) { 
                throw (Exception) targetException;
            }
            else { 
                throw new IllegalStateException(formatInvokeError("Invocation failure", args), targetException);
            }
        }
    }

## 3.2 设置 `@ResponseStatus`注解指定的响应状态码 ##

/** * Set the response status according to the {@link ResponseStatus} annotation. */
    private void setResponseStatus(ServletWebRequest webRequest) throws IOException { 
        //获取指定的状态码
        HttpStatus status = getResponseStatus();
        if (status == null) { 
            return;
        }
    
        //将状态码设置到HttpServletResponse对象中
        HttpServletResponse response = webRequest.getResponse();
        if (response != null) { 
            String reason = getResponseStatusReason();
            if (StringUtils.hasText(reason)) { 
                response.sendError(status.value(), reason);
            }
            else { 
                response.setStatus(status.value());
            }
        }
    
        // To be picked up by RedirectView
        webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status);
    }
    
    
    /** * Return the specified response status, if any. * @since 4.3.8 * @see ResponseStatus#code() */
    @Nullable
    protected HttpStatus getResponseStatus() { 
        //HandlerMethod类的一个属性，保存了@ResponseStatus注解指定的响应状态码
        return this.responseStatus;
    }

## 3.3 得到返回值的类型 ##

/** * Return the actual return value type. */
    public MethodParameter getReturnValueType(@Nullable Object returnValue) { 
       return new ReturnValueMethodParameter(returnValue);
    }

> 构建一个方法返回值参数对象，见`8.2`

# 5 `DefaultParameterNameDiscoverer`默认的参数名发现器 #

类图如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 1]

> 很明显，`DefaultParameterNameDiscoverer`是`ParameterNameDiscoverer`接口的一种策略实现。我们来看看`ParameterNameDiscoverer`接口的方法。

public interface ParameterNameDiscoverer { 
 
 //获取方法的参数名
 @Nullable
 String[] getParameterNames(Method method);
 
 
 //获取构造器的参数名
 @Nullable
 String[] getParameterNames(Constructor<?> ctor);
 
 }

> 从这个接口我们就知道，这个类的作用是用来获取方法参数的`参数名`，它不同的实现类无非是手段不同（`反射`或`ASM`）

# 6 `MethodParameter` 方法参数 #

> 这是`spring`核心包中的一个类，它表示方法的某个参数，它是`spring`对`JDK`中`Parameter`的增强。

public class MethodParameter { 
 
 //空注解数组
 private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
 
 
 //Executable是Method和Constructor的共同父类
 private final Executable executable;
 
 //参数的索引，从0开始
 private final int parameterIndex;
 
 //JDK反射包中，方法参数
 @Nullable
 private volatile Parameter parameter;
 
 //嵌套级别
 private int nestingLevel;
 
 /** Map from Integer level to Integer type index. */
 @Nullable
 Map<Integer, Integer> typeIndexesPerLevel;
 
 /** The containing class. Could also be supplied by overriding {@link #getContainingClass()} */
 //方法参数方法所在的类，即方法参数的包含类
 @Nullable
 private volatile Class<?> containingClass;
 
 //参数类型
 @Nullable
 private volatile Class<?> parameterType;
 
 //参数泛型类型
 @Nullable
 private volatile Type genericParameterType;
 
 //参数拥有的注解
 @Nullable
 private volatile Annotation[] parameterAnnotations;
 
 //参数名发现器
 @Nullable
 private volatile ParameterNameDiscoverer parameterNameDiscoverer;
 
 //参数名
 @Nullable
 private volatile String parameterName;
 
 //嵌套的方法参数
 @Nullable
 private volatile MethodParameter nestedMethodParameter;
 }

> 它将参数的一些常用属性封装到一个类中，方便我们使用

## 6.1 设置方法参数名发现策略 ##

/** * Initialize parameter name discovery for this method parameter. * This method does not actually try to retrieve the parameter name at * this point; it just allows discovery to happen when the application calls * {@link #getParameterName()} (if ever). */
 public void initParameterNameDiscovery(@Nullable ParameterNameDiscoverer parameterNameDiscoverer) { 
 //设置参数名发现策略
 this.parameterNameDiscoverer = parameterNameDiscoverer;
 }

## 6.2 获取方法参数上的注解信息 ##

/** * Return the annotations associated with the specific method/constructor parameter. */
 public Annotation[] getParameterAnnotations() { 
 //缓存的参数注解信息
 Annotation[] paramAnns = this.parameterAnnotations;
 //没有缓存，就解析方法参数
 if (paramAnns == null) { 
 /** * 原生的反射方法得到该方法上所有参数注解信息 * 一个方法上可能有多个参数，一个参数上可能有多个注解 * 很明显二维数组结构 */
 Annotation[][] annotationArray = this.executable.getParameterAnnotations();
 //当前参数索引，从0开始
 int index = this.parameterIndex;
 /** * 该方法参数对应的方法是一个构造器 * 并且该方法是一个内部类 * 那么在JDK9以下的版本中必须使用实际索引位置减1来访问该参数 */
 if (this.executable instanceof Constructor &&
 ClassUtils.isInnerClass(this.executable.getDeclaringClass()) &&
 annotationArray.length == this.executable.getParameterCount() - 1) { 
 // Bug in javac in JDK <9: annotation array excludes enclosing instance parameter
 // for inner classes, so access it with the actual parameter index lowered by 1
 index = this.parameterIndex - 1;
 }
 //获取参数对应的注解信息
 paramAnns = (index >= 0 && index < annotationArray.length ?
 adaptAnnotationArray(annotationArray[index]) : EMPTY_ANNOTATION_ARRAY);
 this.parameterAnnotations = paramAnns;
 }
 return paramAnns;
 }
 
 
 /** * A template method to post-process a given annotation array before * returning it to the caller. * The default implementation simply returns the given annotation array as-is. * @param annotations the annotation array about to be returned * @return the post-processed annotation array (or simply the original one) * @since 4.2 * 这是一个模板方法，子类可以重写该方法操作参数注解 */
 protected Annotation[] adaptAnnotationArray(Annotation[] annotations) { 
 return annotations;
 }

> 内部使用反射获取方法参数注解

## 6.3 获取参数类型 ##

/** * Return the type of the method/constructor parameter. * @return the parameter type (never {@code null}) */
 public Class<?> getParameterType() { 
 Class<?> paramType = this.parameterType;
 if (paramType != null) { 
 return paramType;
 }
 //方法参数所在类和方法所在类不是同一个类
 if (getContainingClass() != getDeclaringClass()) { 
 paramType = ResolvableType.forMethodParameter(this, null, 1).resolve();
 }
 if (paramType == null) { 
 //反射计算参数类型
 paramType = computeParameterType();
 }
 this.parameterType = paramType;
 return paramType;
 }
 
 /** * Return the containing class for this method parameter. * @return a specific containing class (potentially a subclass of the * declaring class), or otherwise simply the declaring class itself * @see #getDeclaringClass() * 当前方法参数所在类的clazz对象 */
 public Class<?> getContainingClass() { 
 Class<?> containingClass = this.containingClass;
 return (containingClass != null ? containingClass : getDeclaringClass());
 }
 
 
 /** * Return the class that declares the underlying Method or Constructor. * 当前方法所在类的clazz对象 */
 public Class<?> getDeclaringClass() { 
 return this.executable.getDeclaringClass();
 }
 
 
 
 /** * 参数索引小于0，就使用反射method.getReturnType()获取方法返回值类型 * 否则使用executable.getParameterTypes()方法得到所有参数类型数组 */
 private Class<?> computeParameterType() { 
 if (this.parameterIndex < 0) { 
 Method method = getMethod();
 if (method == null) { 
 return void.class;
 }
 if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(getContainingClass())) { 
 return KotlinDelegate.getReturnType(method);
 }
 return method.getReturnType();
 }
 return this.executable.getParameterTypes()[this.parameterIndex];
 }

# 7 `HandlerMethodArgumentResolverComposite` 参数解析器组合 #

> 这个解析器组合持有一个解析器的`list`集合，并实现解析器接口。

![在这里插入图片描述][20210218111355142.png_pic_center]

下面是`HandlerMethodArgumentResolver`定义的方法

public interface HandlerMethodArgumentResolver { 
    
        /** * 该解析器是否支持解析该方法参数 */
        boolean supportsParameter(MethodParameter parameter);
    
        /** * 解析方法参数 * 从模型视图容器中找到该方法参数对应的值 */
        @Nullable
        Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                               NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
    
    }

再来看看`HandlerMethodArgumentResolverComposite` 的属性

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver { 
 
 //持有的参数解析器列表
 private final List<HandlerMethodArgumentResolver> argumentResolvers = new ArrayList<>();
 
 //缓存参数使用的参数解析器
 private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
 new ConcurrentHashMap<>(256);
 }

## 7.1 `supportsParameter`方法 ##

/** * Whether the given {@linkplain MethodParameter method parameter} is * supported by any registered {@link HandlerMethodArgumentResolver}. */
    @Override
    public boolean supportsParameter(MethodParameter parameter) { 
        //获取第一个能够解析该参数的解析器
       return getArgumentResolver(parameter) != null;
    }

获取第一个能够解析该参数的解析器

/** * Find a registered {@link HandlerMethodArgumentResolver} that supports * the given method parameter. */
    @Nullable
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) { 
        //先从缓存中获取参数使用的解析器
        HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
        if (result == null) { 
            //遍历调用每一个参数解析器的supportsParameter方法，找到第一个支持该方法参数的解析器
            for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) { 
                if (resolver.supportsParameter(parameter)) { 
                    result = resolver;
                    //缓存
                    this.argumentResolverCache.put(parameter, result);
                    break;
                }
            }
        }
        return result;
    }

## 7.2 `resolveArgument`方法 ##

/** * Iterate over registered * {@link HandlerMethodArgumentResolver HandlerMethodArgumentResolvers} * and invoke the one that supports it. * @throws IllegalArgumentException if no suitable argument resolver is found */
    @Override
    @Nullable
    public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception { 
    
        //获取第一个能够解析该参数的解析器
        HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
        if (resolver == null) { 
            throw new IllegalArgumentException("Unsupported parameter type [" +
                                               parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
        }
        //调用参数解析器的resolveArgument()方法解析方法参数
        return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
    }

> 很容易发现，真正执行解析逻辑的是`HandlerMethodArgumentResolverComposite` 持有的`HandlerMethodArgumentResolver`对象。

# 8 `HandlerMethod`类的两个内部类 #

> `HandlerMethod`类有两个内部类，分别为`HandlerMethodParameter`和`ReturnValueMethodParameter`。接下来我们就来看看这两个类都有什么作用？

## 8.1 `HandlerMethodParameter` 封装方法参数 ##

先来看它的类图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 2]

> 很明显，它继承了`MethodParameter`，在原来的基础上增加了合并父接口被重写方法的参数注解的功能

/** * A MethodParameter with HandlerMethod-specific behavior. */
 protected class HandlerMethodParameter extends SynthesizingMethodParameter { 
 
 //方法参数上拥有的注解（已合并父接口被重写方法的参数注解）
 @Nullable
 private volatile Annotation[] combinedAnnotations;
 
 public HandlerMethodParameter(int index) { 
 super(HandlerMethod.this.bridgedMethod, index);
 }
 
 protected HandlerMethodParameter(HandlerMethodParameter original) { 
 super(original);
 }
 
 @Override
 public Class<?> getContainingClass() { 
 return HandlerMethod.this.getBeanType();
 }
 
 @Override
 public <T extends Annotation> T getMethodAnnotation(Class<T> annotationType) { 
 return HandlerMethod.this.getMethodAnnotation(annotationType);
 }
 
 @Override
 public <T extends Annotation> boolean hasMethodAnnotation(Class<T> annotationType) { 
 return HandlerMethod.this.hasMethodAnnotation(annotationType);
 }
 
 /** * 核心方法，得到方法参数上的注解信息 * 重写了MethodParameter类的方法，主要是合并接口上被重写的方法的参数注解 */
 @Override
 public Annotation[] getParameterAnnotations() { 
 Annotation[] anns = this.combinedAnnotations;
 if (anns == null) { 
 //调用父类方法获取方法参数注解，见6.2
 anns = super.getParameterAnnotations();
 //获取当前方法参数索引，MethodParameter类中一个属性表示参数索引，见6
 int index = getParameterIndex();
 //获取当前方法在接口中被重写方法的所有参数注解信息
 if (index >= 0) { 
 for (Annotation[][] ifcAnns : getInterfaceParameterAnnotations()) { 
 if (index < ifcAnns.length) { 
 //得到被重写方法的索引位置参数的注解信息
 Annotation[] paramAnns = ifcAnns[index];
 //下面代码就是合并重写方法的参数注解信息了
 if (paramAnns.length > 0) { 
 List<Annotation> merged = new ArrayList<>(anns.length + paramAnns.length);
 merged.addAll(Arrays.asList(anns));
 //双重循环对比注解类型，合并注解
 for (Annotation paramAnn : paramAnns) { 
 boolean existingType = false;
 for (Annotation ann : anns) { 
 if (ann.annotationType() == paramAnn.annotationType()) { 
 existingType = true;
 break;
 }
 }
 if (!existingType) { 
 merged.add(adaptAnnotation(paramAnn));
 }
 }
 anns = merged.toArray(new Annotation[0]);
 }
 }
 }
 }
 this.combinedAnnotations = anns;
 }
 return anns;
 }
 
 @Override
 public HandlerMethodParameter clone() { 
 return new HandlerMethodParameter(this);
 }
 }

> 获取当前方法在接口中被重写方法的参数注解信息

private List<Annotation[][]> getInterfaceParameterAnnotations() { 
 //父接口方法参数注解信息缓存
 List<Annotation[][]> parameterAnnotations = this.interfaceParameterAnnotations;
 if (parameterAnnotations == null) { 
 parameterAnnotations = new ArrayList<>();
 /** * getAllInterfacesForClassAsSet()方法得到对应类的所有接口 * 遍历每个接口中的方法，找出被当前方法重写的方法，然后获取方法所有参数注解信息 */
 for (Class<?> ifc : ClassUtils.getAllInterfacesForClassAsSet(this.method.getDeclaringClass())) { 
 for (Method candidate : ifc.getMethods()) { 
 if (isOverrideFor(candidate)) { 
 parameterAnnotations.add(candidate.getParameterAnnotations());
 }
 }
 }
 this.interfaceParameterAnnotations = parameterAnnotations;
 }
 return parameterAnnotations;
 }
 
 //按照重写方法的定义进行判断，找到接口中被当前方法重写的方法
 private boolean isOverrideFor(Method candidate) { 
 //方法名或方法参数数量不同，肯定不是被重写的方法
 if (!candidate.getName().equals(this.method.getName()) ||
 candidate.getParameterCount() != this.method.getParameterCount()) { 
 return false;
 }
 //方法名或方法参数数量相同，且参数类型相同，肯定是被重写的方法
 Class<?>[] paramTypes = this.method.getParameterTypes();
 if (Arrays.equals(candidate.getParameterTypes(), paramTypes)) { 
 return true;
 }
 //一个一个参数的比对类型
 for (int i = 0; i < paramTypes.length; i++) { 
 if (paramTypes[i] !=
 ResolvableType.forMethodParameter(candidate, i, this.method.getDeclaringClass()).resolve()) { 
 return false;
 }
 }
 return true;
 }

## 8.2 `ReturnValueMethodParameter` 封装方法返回值 ##

> `ReturnValueMethodParameter`继承`HandlerMethodParameter`，使用参数索引位置`-1`表示方法返回值

/** * A MethodParameter for a HandlerMethod return type based on an actual return value. */
 private class ReturnValueMethodParameter extends HandlerMethodParameter { 
 
 //方法返回值
 @Nullable
 private final Object returnValue;
 
 //使用-1来索引返回值
 public ReturnValueMethodParameter(@Nullable Object returnValue) { 
 super(-1);
 this.returnValue = returnValue;
 }
 
 protected ReturnValueMethodParameter(ReturnValueMethodParameter original) { 
 super(original);
 this.returnValue = original.returnValue;
 }
 
 //获取参数（返回值）类型
 @Override
 public Class<?> getParameterType() { 
 return (this.returnValue != null ? this.returnValue.getClass() : super.getParameterType());
 }
 
 @Override
 public ReturnValueMethodParameter clone() { 
 return new ReturnValueMethodParameter(this);
 }
 }

# 9 `ServletInvocableHandlerMethod`类的两个内部类 #

> `ServletInvocableHandlerMethod`类有两个内部类，分别为`ConcurrentResultHandlerMethod`和`ConcurrentResultMethodParameter`。接下来我们就来看看这两个类都有什么作用？

## 9.1 `ConcurrentResultHandlerMethod` ##

/** * A nested subclass of {@code ServletInvocableHandlerMethod} that uses a * simple {@link Callable} instead of the original controller as the handler in * order to return the fixed (concurrent) result value given to it. Effectively * "resumes" processing with the asynchronously produced return value. */
 private class ConcurrentResultHandlerMethod extends ServletInvocableHandlerMethod { 
 
 private final MethodParameter returnType;
 
 public ConcurrentResultHandlerMethod(final Object result, ConcurrentResultMethodParameter returnType) { 
 super((Callable<Object>) () -> { 
 if (result instanceof Exception) { 
 throw (Exception) result;
 }
 else if (result instanceof Throwable) { 
 throw new NestedServletException("Async processing failed", (Throwable) result);
 }
 return result;
 }, CALLABLE_METHOD);
 
 if (ServletInvocableHandlerMethod.this.returnValueHandlers != null) { 
 setHandlerMethodReturnValueHandlers(ServletInvocableHandlerMethod.this.returnValueHandlers);
 }
 this.returnType = returnType;
 }
 
 /** * Bridge to actual controller type-level annotations. */
 @Override
 public Class<?> getBeanType() { 
 return ServletInvocableHandlerMethod.this.getBeanType();
 }
 
 /** * Bridge to actual return value or generic type within the declared * async return type, e.g. Foo instead of {@code DeferredResult<Foo>}. */
 @Override
 public MethodParameter getReturnValueType(@Nullable Object returnValue) { 
 return this.returnType;
 }
 
 /** * Bridge to controller method-level annotations. */
 @Override
 public <A extends Annotation> A getMethodAnnotation(Class<A> annotationType) { 
 return ServletInvocableHandlerMethod.this.getMethodAnnotation(annotationType);
 }
 
 /** * Bridge to controller method-level annotations. */
 @Override
 public <A extends Annotation> boolean hasMethodAnnotation(Class<A> annotationType) { 
 return ServletInvocableHandlerMethod.this.hasMethodAnnotation(annotationType);
 }
 }

## 9.2`ConcurrentResultMethodParameter` ##

/** * MethodParameter subclass based on the actual return value type or if * that's null falling back on the generic type within the declared async * return type, e.g. Foo instead of {@code DeferredResult<Foo>}. */
 private class ConcurrentResultMethodParameter extends HandlerMethodParameter { 
 
 @Nullable
 private final Object returnValue;
 
 private final ResolvableType returnType;
 
 public ConcurrentResultMethodParameter(Object returnValue) { 
 super(-1);
 this.returnValue = returnValue;
 this.returnType = (returnValue instanceof ReactiveTypeHandler.CollectedValuesList ?
 ((ReactiveTypeHandler.CollectedValuesList) returnValue).getReturnType() :
 ResolvableType.forType(super.getGenericParameterType()).getGeneric());
 }
 
 public ConcurrentResultMethodParameter(ConcurrentResultMethodParameter original) { 
 super(original);
 this.returnValue = original.returnValue;
 this.returnType = original.returnType;
 }
 
 @Override
 public Class<?> getParameterType() { 
 if (this.returnValue != null) { 
 return this.returnValue.getClass();
 }
 if (!ResolvableType.NONE.equals(this.returnType)) { 
 return this.returnType.toClass();
 }
 return super.getParameterType();
 }
 
 @Override
 public Type getGenericParameterType() { 
 return this.returnType.getType();
 }
 
 @Override
 public <T extends Annotation> boolean hasMethodAnnotation(Class<T> annotationType) { 
 // Ensure @ResponseBody-style handling for values collected from a reactive type
 // even if actual return type is ResponseEntity<Flux<T>>
 return (super.hasMethodAnnotation(annotationType) ||
 (annotationType == ResponseBody.class &&
 this.returnValue instanceof ReactiveTypeHandler.CollectedValuesList));
 }
 
 @Override
 public ConcurrentResultMethodParameter clone() { 
 return new ConcurrentResultMethodParameter(this);
 }
 }

# 10 `HandlerMethodReturnValueHandlerComposite` 返回值处理器组合 #

> 这个处理器组合持有一个处理器的`list`集合，并实现处理器接口。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 3]

下面是`HandlerMethodReturnValueHandler`定义的方法

public interface HandlerMethodReturnValueHandler { 
    
        /** * 该处理器是否支持解析该返回值类型 */
        boolean supportsReturnType(MethodParameter returnType);
    
        /** * 处理返回值 * 将返回值添加到模型并设置视图 * 或者调用ModelAndViewContainer的setRequestHandled()方法，将requestHandled属性 * 置为true，表明已经处理该响应 */
        void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
                               ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception;
    
    }

再来看看`HandlerMethodReturnValueHandlerComposite` 的属性

public class HandlerMethodReturnValueHandlerComposite implements HandlerMethodReturnValueHandler { 
 
 //持有的返回值解析器列表
 private final List<HandlerMethodReturnValueHandler> returnValueHandlers = new ArrayList<>();
 }

## 10.1 `supportsReturnType`方法 ##

/** * Whether the given {@linkplain MethodParameter method return type} is supported by any registered * {@link HandlerMethodReturnValueHandler}. */
    @Override
    public boolean supportsReturnType(MethodParameter returnType) { 
            //获取第一个能够解析该返回值的处理器
        return getReturnValueHandler(returnType) != null;
    }

获取第一个能够解析该返回值的处理器

@Nullable
    private HandlerMethodReturnValueHandler getReturnValueHandler(MethodParameter returnType) { 
        //遍历调用每一个返回值解析器的supportsReturnType方法，找到第一个支持该方法返回值的处理器
        for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { 
            if (handler.supportsReturnType(returnType)) { 
                return handler;
            }
        }
        return null;
    }

## 10.2 `handleReturnValue`方法 ##

/** * Iterate over registered {@link HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers} and invoke the one that supports it. * @throws IllegalStateException if no suitable {@link HandlerMethodReturnValueHandler} is found. */
    @Override
    public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
                                  ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { 
    
        //获取第一个能够处理该返回值的处理器
        HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
        if (handler == null) { 
            throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
        }
        //调用返回值处理器的handleReturnValue()方法处理返回值
        handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
    }

获取第一个能够处理该返回值的处理器

@Nullable
    private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) { 
        //判断当前返回值是不是异步返回值
        boolean isAsyncValue = isAsyncReturnValue(value, returnType);
        //此处遍历所有的返回值解析器，找到第一个支持该方法返回值的处理器
        for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { 
            if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) { 
                continue;
            }
            if (handler.supportsReturnType(returnType)) { 
                return handler;
            }
        }
        return null;
    }
    
    /** * 异步返回值的判断由springmvc提供的AsyncHandlerMethodReturnValueHandler类 * 的isAsyncReturnValue()方法完成 */
    private boolean isAsyncReturnValue(@Nullable Object value, MethodParameter returnType) { 
        for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { 
            if (handler instanceof AsyncHandlerMethodReturnValueHandler &&
                ((AsyncHandlerMethodReturnValueHandler) handler).isAsyncReturnValue(value, returnType)) { 
                return true;
            }
        }
        return false;
    }

> 真正执行解析逻辑的是`HandlerMethodReturnValueHandlerComposite` 持有的`HandlerMethodReturnValueHandler`对象。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/166c1529822045c786741854a7c67e00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/9f12bc1c644246968145721076ed1efc.png
[20210218111355142.png_pic_center]: /images/20221024/5715e332b1a04d5a8031ac5c8ede9cd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/654e9bbfed0a486fb619754e4e672811.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/a873c7e748014ed3bd30dbd280dcc845.png