可以看到HandlerMethod它持有的屬性是非常多的，提供的能力也是很強的。
但是不知道小伙伴有沒有發現，雖然它持有了目標的Method，但是它并沒有提供invoke執行它的能力，如果你要執行它還得自己把Method拿去自己執行。

所以總的來說它的職責還是很單一的：HandlerMethod它只負責準備數據，封裝數據，而而不提供具體使用的方式方法~

看看它的繼承樹：

它主要有兩個子類：InvocableHandlerMethod和ServletInvocableHandlerMethod，從命名就知道他倆都是有invoke調用能力的~

它是對HandlerMethod的擴展，增加了調用能力。這個能力在Spring MVC可是非常非常重要的，它能夠在調用的時候，把方法入參的參數都封裝進來（從HTTP request里，當然借助的必然是HandlerMethodArgumentResolver）

// @since 3.1
public class InvocableHandlerMethod extends HandlerMethod {
    private static final Object[] EMPTY_ARGS = new Object[0];

    // 它額外提供的幾個屬性，可以看到和數據綁定、數據校驗就扯上關系了~~~

    // 用于產生數據綁定器、校驗器
    @Nullable
    private WebDataBinderFactory dataBinderFactory;
    // HandlerMethodArgumentResolver用于入參的解析
    private HandlerMethodArgumentResolverComposite resolvers = new HandlerMethodArgumentResolverComposite();
    // 用于獲取形參名
    private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    
    ... // 省略構造函數 全部使用super的
    // 它自己的三大屬性都使用set方法設置進來~~~并且沒有提供get方法
    // 也就是說：它自己內部使用就行了~~~

    // 在給定請求的上下文中解析方法的參數值后調用該方法。 也就是說：方法入參里就能夠自動使用請求域（包括path里的，requestParam里的、以及常規對象如HttpSession這種）
    // 解釋下providedArgs作用：調用者可以傳進來，然后直接doInvoke()的時候原封不動的使用它
    //（彌補了請求域沒有所有對象的不足，畢竟有些對象是用戶自定義的嘛~）
    @Nullable
    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        // 雖然它是最重要的方法，但是此處不講，因為核心原來還是`HandlerMethodArgumentResolver`
        // 它只是把解析好的放到對應位置里去~~~
        // 說明：這里傳入了ParameterNameDiscoverer，它是能夠獲取到形參名的。
        // 這就是為何注解里我們不寫value值，通過形參名字來匹配也是ok的核心原因~
        Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
        if (logger.isTraceEnabled()) { // trace信息，否則日志也特多了~
            logger.trace("Arguments: " + Arrays.toString(args));
        }
        return doInvoke(args);
    }

    // doInvoke()方法就不說了，就是個普通的方法調用
    // ReflectionUtils.makeAccessible(getBridgedMethod());
    // return getBridgedMethod().invoke(getBean(), args); 
}

對于最后的invoke()，說明一點：這里可是執行的目標方法getBean()哦~~~

這個子類主要提供的能力就是提供了invoke調用目標Bean的目標方法的能力，在這個調用過程中可大有文章可為，當然最為核心的邏輯可是各種各樣的HandlerMethodArgumentResolver來完成的，詳見下文有分曉。
InvocableHandlerMethod這個子類雖然它提供了調用了能力，但是它卻依舊還沒有和Servlet的API綁定起來，畢竟使用的是Spring自己通用的的NativeWebRequest，so很容易想到它還有一個子類就是干這事的~

ServletInvocableHandlerMethod

它是對InvocableHandlerMethod的擴展，它增加了返回值和響應狀態碼的處理，另外在ServletInvocableHandlerMethod有個內部類ConcurrentResultHandlerMethod繼承于它，支持異常調用結果處理，Servlet容器下Controller在查找適配器時發起調用的最終就是ServletInvocableHandlerMethod。

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
    private static final Method CALLABLE_METHOD = ClassUtils.getMethod(Callable.class, "call");

    // 處理方法返回值
    @Nullable
    private HandlerMethodReturnValueHandlerComposite returnValueHandlers;

    // 構造函數略
    
    // 設置處理返回值的HandlerMethodReturnValueHandler
    public void setHandlerMethodReturnValueHandlers(HandlerMethodReturnValueHandlerComposite returnValueHandlers) {
        this.returnValueHandlers = returnValueHandlers;
    }


    // 它不是復寫，但是是對invokeForRequest方法的進一步增強  因為調用目標方法還是靠invokeForRequest
    // 本處是把方法的返回值拿來進一步處理~~~比如狀態碼之類的
    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        // 設置HttpServletResponse返回狀態碼 這里面還是有點意思的  因為@ResponseStatus#code()在父類已經解析了  但是子類才用
        setResponseStatus(webRequest);


        // 重點是這一句話：mavContainer.setRequestHandled(true); 表示該請求已經被處理過了
        if (returnValue == null) {

            // Request的NotModified為true 有@ResponseStatus注解標注 RequestHandled=true 三個條件有一個成立,則設置請求處理完成并返回
            if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
                mavContainer.setRequestHandled(true);
                return;
            }
        // 返回值不為null,@ResponseStatus存在reason 同樣設置請求處理完成并返回
        } else if (StringUtils.hasText(getResponseStatusReason())) {
            mavContainer.setRequestHandled(true);
            return;
        }

        // 前邊都不成立,則設置RequestHandled=false即請求未完成
        // 繼續交給HandlerMethodReturnValueHandlerComposite處理
        // 可見@ResponseStatus的優先級還是蠻高的~~~~~
        mavContainer.setRequestHandled(false);
        Assert.state(this.returnValueHandlers != null, "No return value handlers");
        try {
        
            // 關于對方法返回值的處理，參見：https://blog.csdn.net/f641385712/article/details/90370542
            this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        } catch (Exception ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(formatErrorForReturnValue(returnValue), ex);
            }
            throw ex;
        }
    }

    // 設置返回的狀態碼到HttpServletResponse 里面去
    private void setResponseStatus(ServletWebRequest webRequest) throws IOException {
        HttpStatus status = getResponseStatus();
        if (status == null) { // 如果調用者沒有標注ResponseStatus.code()此注解  此處就忽略它
            return;
        }

        HttpServletResponse response = webRequest.getResponse();
        if (response != null) {
            String reason = getResponseStatusReason();

            // 此處務必注意：若有reason，那就是sendError  哪怕你是200哦~
            if (StringUtils.hasText(reason)) {
                response.sendError(status.value(), reason);
            } else {
                response.setStatus(status.value());
            }
        }

        // 設置到request的屬性，把響應碼給過去。為了在redirect中使用
        // To be picked up by RedirectView
        webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status);
    }

    private boolean isRequestNotModified(ServletWebRequest webRequest) {
        return webRequest.isNotModified();
    }


    // 這個方法RequestMappingHandlerAdapter里有調用
    ServletInvocableHandlerMethod wrapConcurrentResult(Object result) {
        return new ConcurrentResultHandlerMethod(result, new ConcurrentResultMethodParameter(result));
    }

    // 內部類們
    private class ConcurrentResultMethodParameter extends HandlerMethodParameter {
        @Nullable
        private final Object returnValue;
        private final ResolvableType returnType;
        public ConcurrentResultMethodParameter(Object returnValue) {
            super(-1);
            this.returnValue = returnValue;
            // 主要是這個解析 兼容到了泛型類型 比如你的返回值是List 它也能把你的類型拿出來
            this.returnType = (returnValue instanceof ReactiveTypeHandler.CollectedValuesList ?
                    ((ReactiveTypeHandler.CollectedValuesList) returnValue).getReturnType() :
                    ResolvableType.forType(super.getGenericParameterType()).getGeneric());
        }

        // 若返回的是List  這里就是List的類型哦  下面才是返回泛型類型
        @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();
        }


        // 即使實際返回類型為ResponseEntity>，也要確保對@ResponseBody-style處理從reactive 類型中收集值
        // 是對reactive 的一種兼容
        @Override
        public  boolean hasMethodAnnotation(Class annotationType) {
            // Ensure @ResponseBody-style handling for values collected from a reactive type
            // even if actual return type is ResponseEntity>
            return (super.hasMethodAnnotation(annotationType) ||
                    (annotationType == ResponseBody.class && this.returnValue instanceof ReactiveTypeHandler.CollectedValuesList));
        }
    }


    // 這個非常有意思   內部類繼承了自己（外部類） 進行增強
    private class ConcurrentResultHandlerMethod extends ServletInvocableHandlerMethod {
        // 返回值
        private final MethodParameter returnType;

        // 此構造最終傳入的handler是個Callable
        // result方法返回值 它支持支持異常調用結果處理
        public ConcurrentResultHandlerMethod(final Object result, ConcurrentResultMethodParameter returnType) {
            super((Callable