SpringMVC源码-执行流程

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        try {
            ModelAndView mv = null;
            Object dispatchException = null;

            try {
　　　　　　　　　　//1.检查是否为文件上传请求
                processedRequest = this.checkMultipart(request);
                multipartRequestParsed = processedRequest != request;
　　　　　　　　　　//2.根据当前的请求地址找到哪个类能来处理
                mappedHandler = this.getHandler(processedRequest);
　　　　　　　　　　//3.如果没有找到对应的处理器（控制器）来处理这个请求，就报404或抛异常
if (mappedHandler == null) {
                    this.noHandlerFound(processedRequest, response);
                    return;
                }
　　　　　　　　　　//4.拿到能执行这个类所有方法的适配器（反射工具）；
            　　HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
　　　　　　　　　　　　
                    if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }
　　　　　　　　　　//处理器方法被调用；控制器（Controller）、处理器（Handler）
　　　　　　　　　　//5.适配器来执行目标方法，将目标方法执行完成后的返回值作为视图名，设置保存到ModelAndView中
　　　　　　　　　　//目标方法无论怎么写，最终适配器执行完成以后都会将执行后的信息封装到ModelAndView
               mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }
　　　　　　　　　　//6.如果没有视图名，设置一个默认的视图名
                this.applyDefaultViewName(processedRequest, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            } catch (Exception var20) {
                dispatchException = var20;
            } catch (Throwable var21) {
                dispatchException = new NestedServletException("Handler dispatch failed", var21);
            }
　　　　　　　//转发到目标页面
　　　　　　　//7.根据方法最终执行完成后封装的ModelAndView，转发到对应页面，而且ModelAndView中的数据可以从请求域中获取
            this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
        } catch (Exception var22) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
        } catch (Throwable var23) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
        }

    } finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        } else if (multipartRequestParsed) {
            this.cleanupMultipart(processedRequest);
        }

    }
}

mappedHandler = this.getHandler(processedRequest);

@Nullable
private List handlerMappings;

@Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();
            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }
        return null;
    }

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
            Iterator var2 = this.handlerAdapters.iterator();

            while(var2.hasNext()) {
                HandlerAdapter adapter = (HandlerAdapter)var2.next();
                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");
    }

    /** 文件上传解析器 */
    private MultipartResolver multipartResolver;

    /** 区域解析器和国际化有关 */
    private LocaleResolver localeResolver;

    /** 主题解析器；强大的主题效果切换 */
    private ThemeResolver themeResolver;

    /** handler映射信息；HandlerMapping */
    private List handlerMappings;

    /** handler适配器 */
    private List handlerAdapters;

    /** SpringMVC强大的异常解析功能：异常解析器 */
    private List handlerExceptionResolvers;

    /** 请求到视图名转换器 */
    private RequestToViewNameTranslator viewNameTranslator;

    /** FlsahMap+Manager:SpringMVC中进行重定向携带数据的功能 */
    private FlashMapManager flashMapManager;

    /** 视图解析器 */
    private List viewResolvers;

    protected void initStrategies(ApplicationContext context) {
        this.initMultipartResolver(context);
        this.initLocaleResolver(context);
        this.initThemeResolver(context);
        this.initHandlerMappings(context);
        this.initHandlerAdapters(context);
        this.initHandlerExceptionResolvers(context);
        this.initRequestToViewNameTranslator(context);
        this.initViewResolvers(context);
        this.initFlashMapManager(context);
    }