spring源码------一个请求在spring中的处理过程（HandlerAdapter的选择跟请求的处理）代码及流程图说明 （4）

@[toc]

前提

 这部分的内容是基于spring源码------一个请求在spring中的处理过程（从FrameworkServlet规范到DispatcherServlet）代码及流程图说明 （2）文章的进一步的对doDispatch方法的内部分析的。前面已经讲了getHandler方法的分析，这里就接着讲下一步的getHandlerAdapter方法

    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ......
    //获取封装了HandlerInterceptor的HandlerExecutionChain
                mappedHandler = getHandler(processedRequest);
                //如果不存在对应的处理链则返回
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                //从HandlerExecutionChain中获取Handler然后寻找合适的HandlerAdapter
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    ......
}

1.HandlerAdapter对象

 先根据官方的类注释来了解一下HandlerAdapter类的作用。这个类的作用是spring中的一个可扩展的接口类，允许对spring的允许对核心MVC工作流进行参数化，在DispatcherServlet中会对所有的这个类的实现类进行遍历，对于想要指定自己的web的工作流的开发者来说，可以实现这个接口。需要注意的是，实现这个接口的类，一般还需要实现Ordered接口或者贴上@Order注解来指定优先级。接下来对这个类的方法进行分析：

public interface HandlerAdapter {
    
    boolean supports(Object handler);
    
    @Nullable
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
    
    long getLastModified(HttpServletRequest request, Object handler);
}

 这几个方法的作用说明：

1. supports
    这个方法作用就是在寻找合适的HandlerAdapter的时候，根据这个方法的返回结果来表示当前的HandlerAdapter是否适合处理当前的请求
2. handle
    这个方法就是处理请求的方法，返回一个ModelAndView视图对象
3. getLastModified
    这个是为了支持一些HandlerAdapter类不支持HttpServlet的getLastModified方法用的。这个方法前面介绍过你们可以看看前面的文章。

2. 获取HandlerAdapter对象的getHandlerAdapter方法

2.1 getHandlerAdapter方法分析

 直接先看getHandlerAdapter方法的逻辑：

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        //寻找合适的HandlerAdapter
        if (this.handlerAdapters != null) {
            for (HandlerAdapter adapter : this.handlerAdapters) {
                //如果找到了合适的就结束这个方法，直接返回
                if (adapter.supports(handler)) {
                    return adapter;
                }
            }
        }
        throw new ServletException("No adapter for handler [" + handler +
                "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
    }

 可以看到逻辑很简单，就是遍历封装了HandlerAdapter对象的handlerAdapters这个成员遍历，寻找合适的HandlerAdapter然后返回。这里需要注意的是，找到了第一个合适的HandlerAdapter方法就会结束，所以HandlerAdapter在handlerAdapters中的顺序很重要，这也是上面的HandlerAdapter类描述中建议实现Ordered接口或者贴上@Order注解。
 关于handlerAdapters这个变量，他的填充是在上下文刷新的后进行填充的跟，逻辑在DispatchServlet类的initHandlerAdapters方法中。

    private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;
        //是否寻找所有的HandlerAdapter，默认为true
        if (this.detectAllHandlerAdapters) {
            //在ApplicationContext中查找所有handleradapter，包括祖先上下文
            Map matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            //如果存在则进行排序
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList<>(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerAdapters);
            }
        }
        else {
            try {
                //如果不寻找所有的，则只寻找名称为handlerAdapter，类型为HandlerAdapter的bean
                HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
                this.handlerAdapters = Collections.singletonList(ha);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerAdapter later.
            }
        }
        ////如果容器中没有，则用默认的，一般情况下不会到这一波，关于默认的配置会读取DispatcherServlet.properties配置文件中的配置
        if (this.handlerAdapters == null) {
            this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
                        "': using default strategies from DispatcherServlet.properties");
            }
        }
    }

2.1.1 容器中的HandlerAdapter对象以及实现的选择

 在spring中HandlerAdapter的子实现类会注册到容器中的有以下几个，RequestMappingHandlerAdapter,HttpRequestHandlerAdapter,SimpleControllerHandlerAdapter。这些类都是在WebMvcConfigurationSupport中用@Bean注解注册到容器中的。

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
    @Bean
    public RequestMappingHandlerAdapter requestMappingHandlerAdapter(
            ContentNegotiationManager mvcContentNegotiationManager,
            FormattingConversionService mvcConversionService, Validator mvcValidator) {

        RequestMappingHandlerAdapter adapter = createRequestMappingHandlerAdapter();
        }

        @Bean
    public HttpRequestHandlerAdapter httpRequestHandlerAdapter() {
        return new HttpRequestHandlerAdapter();
    }

        @Bean
    public SimpleControllerHandlerAdapter simpleControllerHandlerAdapter() {
        return new SimpleControllerHandlerAdapter();
    }

}

 其中RequestMappingHandlerAdapter的父类AbstractHandlerMethodAdapter实现了Ordred接口，设置的优先级,高于HttpRequestHandlerAdapter跟SimpleControllerHandlerAdapter这两个类（没事试下Ordred接口，也没有贴@Order注解），所以遍历的顺序也是这个类最先。因此每次请求第一个调用的就是RequestMappingHandlerAdapter方法。后面的分析都用这个类进行分析。

private int order = Ordered.LOWEST_PRECEDENCE;

public void setOrder(int order) {
        this.order = order;
    }

2.1.2 RequestMappingHandlerAdapter对supports的实现

 RequestMappingHandlerAdapter的父类抽象类AbstractHandlerMethodAdapter实现了HandlerAdapter接口supports方法。

    @Override
    public final boolean
    supports(Object handler) {
        //handler是HandlerMethod的类型的，并且满足子类实现的判断逻辑
        return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
    }

 看看由RequestMappingHandlerAdapter实现的supportsInternal方法

    @Override
    protected boolean supportsInternal(HandlerMethod handlerMethod) {
        return true;
    }

 发现返回的是一个固定的true，因为任何方法参数和返回值类型都将以被处理。

3. HandlerAdapter对请求处理的hadler方法

3.1 逻辑交给子类实现的hadler方法

 在选择完HandlerAdapter后，会先调用HandlerExecutionChain的拦截器的preHandle方法。然后就会调用HandlerAdapter对请求进行处理了。
 进入到AbstractHandlerMethodAdapter的handle方法，逻辑完全委托给了子类去实现handleInternal方法来处理。

    public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {

        return handleInternal(request, response, (HandlerMethod) handler);
    }

 实现的逻辑在RequestMappingHandlerAdapter的handleInternal方法中。

3.2 handleInternal逻辑

    protected ModelAndView handleInternal(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

        ModelAndView mav;
        //检查请求方法是不是支持的，以及如果设置了需要session但是却不存在session（意思是当前请求的时候已经存在session了）
        checkRequest(request);
        // Execute invokeHandlerMethod in synchronized block if required.
        //是否在session级别上执行同步操作，默认为false
        if (this.synchronizeOnSession) {
            //获取session，如果不存在session，不创建新的session
            HttpSession session = request.getSession(false);
            //如果session不为空则在session上加锁
            if (session != null) {
                Object mutex = WebUtils.getSessionMutex(session);
                synchronized (mutex) {
                    //调用处理方法
                    mav = invokeHandlerMethod(request, response, handlerMethod);
                }
            }
            else {//不存在session则不加锁处理
                // No HttpSession available -> no mutex necessary
                mav = invokeHandlerMethod(request, response, handlerMethod);
            }
        }
        else {
            //不需要session同步，则直接调用处理方法
            mav = invokeHandlerMethod(request, response, handlerMethod);
        }
        //如果返回头不包含缓存控制相关的信息（Cache-Control属性表示缓存控制（缓存指的缓存服务器）相关的，这个可以自行查询相关资料了解）
        if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
            //根据，handlerMethod构建一个SessionAttributesHandler对象（会把对应的SessionAttributes注解封装起来），并判断是否存在@SessionAttributes注解属性
            if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
                //生产Http头
                applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
            }
            else {
                //准备返回
                prepareResponse(response);
            }
        }

        return mav;
    }

 上面的方法逻辑也算是比较简单的，可以分为三步。

1. 调用处理方法之前的请求检查，检查是否是支持的请求方式，请求是否在同一个session中
2. 调用请求的处理方法，返回视图对象ModelAndView
3. 检查response对象是否有缓存控制相关的操作，没有则进行相关的处理

3.2.1 调用处理方法的逻辑invokeHandlerMethod

 上面的核心的步骤就在invokeHandlerMethod方法中，这个方法中的逻辑分支比较多，基本上一行代码就是一个逻辑步骤。相当于是一个聚合，spring中的代码很多都是这样的。这里就每一个步骤做什么进行讲解，但是不会深入到每个步骤的内部逻辑：

    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        //创建ServletWebRequest
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        try {
            //获取处理类中的所有的贴有@InitBinder注解的方法，然后封装处理为一个WebDataBinderFactory对象
            WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
            //获取处理类中的所有的贴有@ModelAttribute注解的方法，然后封装处理为一个WebDataBinderFactory对象
            ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
            //根据handlerMethod创建ServletInvocableHandlerMethod对象
            ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
            //设置请求参数解析器，这个参数解析器可以自定义
            if (this.argumentResolvers != null) {
                invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
            }
            //设置返回参数处理器，这个也可以自定义
            if (this.returnValueHandlers != null) {
                invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
            }
            //设置前面处理的封装@InitBinder注解信息的WebDataBinderFactory
            invocableMethod.setDataBinderFactory(binderFactory);
            //设置方法跟构造器参数解析的类
            invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
            //创建视图容器
            ModelAndViewContainer mavContainer = new ModelAndViewContainer();
            //把上下文中的跟这个请求相关的请求放到返回时的视图中， 这里的相关的请求指的是请求包含或者请求转发
            mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
            //调用所有 贴有ModelAttribute注解的方法，将返回结果添加到视图中
            modelFactory.initModel(webRequest, mavContainer, invocableMethod);
            //设置是否忽略 重定向时候的默认模型
            mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
            //设置异步请求相关的
            AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
            asyncWebRequest.setTimeout(this.asyncRequestTimeout);

            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
            asyncManager.setTaskExecutor(this.taskExecutor);
            asyncManager.setAsyncWebRequest(asyncWebRequest);
            asyncManager.registerCallableInterceptors(this.callableInterceptors);
            asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
            //如果异步请求有结果了，就用异步的结果
            if (asyncManager.hasConcurrentResult()) {
                Object result = asyncManager.getConcurrentResult();
                mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
                asyncManager.clearConcurrentResult();
                LogFormatUtils.traceDebug(logger, traceOn -> {
                    String formatted = LogFormatUtils.formatValue(result, !traceOn);
                    return "Resume with async result [" + formatted + "]";
                });
                invocableMethod = invocableMethod.wrapConcurrentResult(result);
            }
            //调用最终的处理方法
            invocableMethod.invokeAndHandle(webRequest, mavContainer);
            if (asyncManager.isConcurrentHandlingStarted()) {
                return null;
            }

            return getModelAndView(mavContainer, modelFactory, webRequest);
        }
        finally {
            webRequest.requestCompleted();
        }
    }

 方法的逻辑比较复杂，先看看简单的看看步骤：

1. 获取请求处理类中贴有@InitBinder注解的方法，然后创建一个WebDataBinderFactory类
2. 获取请求处理类中贴有@ModelAttribute注解的方法，然后创建一个ModelFactory类
3. 将请求处理类封装为一个ServletInvocableHandlerMethod对象
4. 设置请求参数解析器组合类
5. 设置返回参数解析器组合类
6. 设置前面封装@InitBinder注解的WebDataBinderFactory类
7. 设置方法跟构造器参数解析的类
8. 创建视图容器ModelAndViewContainer，然后初始化并设置初始的一些模型
9. 处理异步请求相关的
10. 调用请求处理类，对应的处理方法。

  这里的步骤虽然多，但是还是可以简单的分为用户处理方法调用前的准备工作，跟调用处理方法两个步骤。这里对于准备的工作不做解析，主要看处理方法invokeAndHandle的调用。其余方法的逻辑后面会有文章进行介绍，这里就讲跟主题相关的。

3.2.2 调用我们定义的controller类中的逻辑的步骤invokeAndHandle

 进入到invokeAndHandle方法

    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {
        //调用处理的方法，获取处理的结果
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        //如果方法上有ResponseStatus注解，则按照我们设置的返回状态进行返回
        setResponseStatus(webRequest);
        //如果方法结果为null
        if (returnValue == null) {
            //如果请求没有修改过，或者返回状态不为null，或者请求得到处理了都会设置请求为已经处理的状态然后返回
            if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
                disableContentCachingIfNecessary(webRequest);
                mavContainer.setRequestHandled(true);
                return;
            }
        }
        else if (StringUtils.hasText(getResponseStatusReason())) {
            //设置请求为已经处理的状态
            mavContainer.setRequestHandled(true);
            return;
        }

        mavContainer.setRequestHandled(false);
        Assert.state(this.returnValueHandlers != null, "No return value handlers");
        try {
            //对返回的结果进行进一步的处理，这些都是一些扩展点
            this.returnValueHandlers.handleReturnValue(
                    returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(formatErrorForReturnValue(returnValue), ex);
            }
            throw ex;
        }
    }

这里的逻辑就是调用处理方法，获取返回结果，如果处理结果是已经处理过的则直接返回，没有就处理过则对返回的结果进行进一步的处理。现在要继续看的是invokeForRequest方法。

    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        //调用扩展的参数处理的逻辑，得到方法调用钱的参数
        Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
        if (logger.isTraceEnabled()) {
            logger.trace("Arguments: " + Arrays.toString(args));
        }
        //进行方法的调用
        return doInvoke(args);
    }



    @Nullable
    protected Object doInvoke(Object... args) throws Exception {
        ReflectionUtils.makeAccessible(getBridgedMethod());
        try {
            return getBridgedMethod().invoke(getBean(), args);
        }
        ......

 逻辑很简单就是调用自己扩展的参数处理方法，用处理过后的参数作为入参然后用反射调用定义的逻辑处理方法（就是我们controller中定义的方法），最后返回调用的结果。

 到这里整个HandlerAdapter的选择跟请求的处理逻辑就结束了。