Spring MVC 源码 - HandlerAdapter 组件（二）之 ServletInvocableHandlerMethod

作者：Li_阴宅 | 2024-08-02 03:50:56

踩

servletinvocablehandlermethod

HandlerAdapter 组件

HandlerAdapter 组件，处理器的适配器。因为处理器 handler 的类型是 Object 类型，需要有一个调用者来实现 handler 是怎么被执行。Spring 中的处理器的实现多变，比如用户的处理器可以实现 Controller 接口或者 HttpRequestHandler 接口，也可以用 @RequestMapping 注解将方法作为一个处理器等，这就导致 Spring MVC 无法直接执行这个处理器。所以这里需要一个处理器适配器，由它去执行处理器

HandlerAdapter 组件（二）之 ServletInvocableHandlerMethod

本文是接着《HandlerAdapter 组件（一）之 HandlerAdapter》一文来分享 ServletInvocableHandlerMethod 组件。在 HandlerAdapter 执行处理器的过程中，主要的任务还是交由它来完成的。ServletInvocableHandlerMethod 封装 HandlerMethod 处理器对象，它还包含 HandlerMethodArgumentResolver 参数解析器和 HandlerMethodReturnValueHandler 返回值处理器等组件。虽然内容不多，但还是有必要另一篇进行分析。

回顾

先来回顾一下 RequestMappingHandlerAdapter 是如何创建 ServletInvocableHandlerMethod 对象的，可以回到《HandlerAdapter 组件（一）之 HandlerAdapter》中 RequestMappingHandlerAdapter 小节下面的 invokeHandlerMethod 方法，如下：


@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, 
                                           HandlerMethod handlerMethod) throws Exception {
    // ... 省略相关代码
    // <4> 创建 ServletInvocableHandlerMethod 对象，并设置其相关属性
    ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    if (this.argumentResolvers != null) {
        invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    }
    if (this.returnValueHandlers != null) {
        invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    }
    invocableMethod.setDataBinderFactory(binderFactory);
    invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
    // ... 省略相关代码
    // <9> 执行调用
    invocableMethod.invokeAndHandle(webRequest, mavContainer);
    // ... 省略相关代码
}
 
protected ServletInvocableHandlerMethod createInvocableHandlerMethod(HandlerMethod handlerMethod) {
    return new ServletInvocableHandlerMethod(handlerMethod);
}

将 HandlerMethod 处理器封装成 ServletInvocableHandlerMethod 对象，然后设置参数解析器和返回值处理器

这里设置了 ServletInvocableHandlerMethod 对象的 resolvers、parameterNameDiscoverer 和 returnValueHandlers 相关属性

调用invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs)方法，执行处理器

类图

ServletInvocableHandlerMethod 的整体类图如下：

依次分析

HandlerMethod

org.springframework.web.method.HandlerMethod，处理器的方法的封装对象

在《HandlerMapping 组件（三）之 AbstractHandlerMethodMapping》的 AbstractHandlerMethodMapping 小节中已经分析过该对象

InvocableHandlerMethod

org.springframework.web.method.support.InvocableHandlerMethod，继承 HandlerMethod 类，可 invoke 调用的 HandlerMethod 实现类。

也就是说，HandlerMethod 只提供了处理器的方法的基本信息，不提供调用逻辑。


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

invokeForRequest

invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) 方法，执行请求，方法如下：


@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {
 
    // <1> 解析参数
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    }
    // <2> 执行调用
    return doInvoke(args);
}

调用 getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) 方法，解析方法的参数们，如下：


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 对象，并设置 parameterNameDiscoverer 到其中
        MethodParameter parameter = parameters[i];
        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
        // <1> 先从 providedArgs 中获得参数。如果获得到，则进入下一个参数的解析，默认情况 providedArgs 不会传参
        args[i] = findProvidedArgument(parameter, providedArgs);
        if (args[i] != null) {
            continue;
        }
         // <2> 判断 resolvers 是否支持当前的参数解析
        if (!this.resolvers.supportsParameter(parameter)) {
            throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
        }
        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;
}

先从 providedArgs 中获得参数。如果获得到，则进入下一个参数的解析。默认情况下，providedArgs 参数不会传递，所以可以暂时先忽略。保证核心逻辑的理解

判断 argumentResolvers 是否支持当前的参数解析。如果支持，则进行解析。

调用 doInvoke(Object... args) 方法，执行方法的调用，方法如下：


@Nullable
protected Object doInvoke(Object... args) throws Exception {
    // <1> 设置方法为可访问
    ReflectionUtils.makeAccessible(getBridgedMethod());
    try {
        // <2> 执行调用
        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);
        }
    }
}

设置方法为可访问

通过反射执行该方法

注意，这里获取到的 Method 对象可能是桥接方法，桥接方法：如果泛型对象，编译器则会自动生成一个桥接方法（java1.5向后兼容）

ServletInvocableHandlerMethod

org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod，继承 InvocableHandlerMethod 类，用于 DispatcherServlet 执行 HandlerMethod 处理器

构造方法


public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
    private static final Method CALLABLE_METHOD = ClassUtils.getMethod(Callable.class, "call");
    
    /** 返回结果处理器组合对象 */
    @Nullable
    private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
    
    public ServletInvocableHandlerMethod(Object handler, Method method) {
        super(handler, method);
    }
 
    public ServletInvocableHandlerMethod(HandlerMethod handlerMethod) {
        super(handlerMethod);
    }
}

invokeAndHandle

invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) 方法，处理请求，执行处理器，并处理返回结果，方法如下：


public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
    // <1> 执行调用
    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    // <2> 设置响应状态码
    setResponseStatus(webRequest);
 
    // <3> 设置 ModelAndViewContainer 为请求已处理，返回，和 @ResponseStatus 注解相关
    if (returnValue == null) {
        if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
            disableContentCachingIfNecessary(webRequest);
            mavContainer.setRequestHandled(true);
            return;
        }
    } else if (StringUtils.hasText(getResponseStatusReason())) {
        mavContainer.setRequestHandled(true);
        return;
    }
 
    // <4> 设置 ModelAndViewContainer 为请求未处理
    mavContainer.setRequestHandled(false);
    Assert.state(this.returnValueHandlers != null, "No return value handlers");
    try {
        // <5> 处理返回值
        this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    } catch (Exception ex) {
        if (logger.isTraceEnabled()) {
            logger.trace(formatErrorForReturnValue(returnValue), ex);
        }
        throw ex;
    }
}

调用 InvocableHandlerMethod 父类的 invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) 方法，执行调用

调用 setResponseStatus(ServletWebRequest webRequest) 设置响应的状态码，方法如下：


private void setResponseStatus(ServletWebRequest webRequest) throws IOException {
    // 获得状态码，和 @ResponseStatus 注解相关
    HttpStatus status = getResponseStatus();
    if (status == null) {
        return;
    }
    // 设置响应的状态码
    HttpServletResponse response = webRequest.getResponse();
    if (response != null) {
        String reason = getResponseStatusReason();
        if (StringUtils.hasText(reason)) { // 有 reason ，则设置 status + reason
            response.sendError(status.value(), reason);
        } else { // 无 reason ，则仅设置 status
            response.setStatus(status.value());
        }
    }
 
    // To be picked up by RedirectView
    // 为了 RedirectView ，所以进行设置
    webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status);
}

设置 ModelAndViewContainer 为请求已处理，返回，和 @ResponseStatus 注解相关

设置 ModelAndViewContainer 为请求未处理

调用 HandlerMethodReturnValueHandlerComposite 的 handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) 方法，处理返回值。

总结

在 HandlerAdapter 执行 HandlerMethod 处理器的过程中，会将该处理器封装成 ServletInvocableHandlerMethod 对象，通过该对象来执行处理器。因为 HandlerMethod 处理器里面仅包含了方法的所有信息，如何解析参数、调用对应的方法、以及处理返回结果，它本身并不知道如何去处理，这里 Spring MVC 借助于 ServletInvocableHandlerMethod 对象来进行操作，原理就是通过反射机制执行该方法

其中涉及到的 HandlerMethodArgumentResolver 参数解析器和 HandlerMethodReturnValueHandler 返回值处理器是比较关键的两个组件，在接下来会逐个进行分析

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/917118