一、Spring MVC中重要角色

1.DispatcherServlet：前端控制器，接受所有web.xml中配置的请求，处理整个请求流程
2.HandlerMapping：处理映射器，根据请求的URL，找到对应的Handler，包括定义的拦截器
3.HandlerAdapter：Handler处理器适配器，处理不同类型的请求，主要包括有HttpReqeustHandlerAdapter、SimpleServletHandlerAdapter和SimpleControllerHandlerAdapter，这三种都比较简单，都是通过方法直接调用；RequestMappingHandlerAdapter这个处理器就是我们常用的注解形式，使用RequestMapping注解时的处理器，这种类型就是使用反射的方式调用；
4.Controller：后端处理器，用来接受请求，处理后端业务逻辑
5.ViewResolver：视图解析器，把逻辑视图解析成真正的物理视图
6.View：视图，将数据展现给用户

二、大致流程

我们先来看图 Spring mvc执行过程

1.用户发起请求到前端控制器（DispatcherServlet）
2.前端控制器会找到处理映射器（HandlerMapping）根据请求的URL，找到相应的处理器执行链
3.前端控制器找到处理器执行链后，再找到处理器适配器，找到处理器
4.执行处理器
5.处理器会返回一个ModelAndView
6.前端控制器会请求视图解析器解析视图
7.视图渲染，返回到用户页面

三、Spring MVC初始化流程源码解析

之前的所有源码分析，把整个过程的代码都粘贴上来了，感觉效率不高，很多一些不重要的代码占了大量的篇幅，导致整篇看下来抓不住重点；这次源码只粘贴重要的代码，这样过程就会很清晰。
首先Spring MVC初始化，是从我们再web.xml中配置DispatcherServlet，开始；DispatcherServlet继承了FrameworkServlet，FrameworkServlet继承了HttpServletBean，所以最开始的初始化是从HttpServletBean中的init()方法开始的

public final void init() throws ServletException {
    ...
    //我们主要看这个初始化的方法
    initServletBean();
    ...
}
protected final void initServletBean() throws ServletException {
    ...
    try {
        //初始WebApplicationContext容器
        this.webApplicationContext = initWebApplicationContext();
        initFrameworkServlet();
    }
    catch (ServletException ex) {
        this.logger.error("Context initialization failed", ex);
        throw ex;
    }
    catch (RuntimeException ex) {
        this.logger.error("Context initialization failed", ex);
        throw ex;
    }
    ...
}

protected WebApplicationContext initWebApplicationContext() {
    //获取父容器，如果我们配置了Spring的配置文件，会在这一步获取到Spring的容器
    WebApplicationContext rootContext =
            WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    WebApplicationContext wac = null;
    ...
    if (wac == null) {
        //创建容器，把父容器传进去
        wac = createWebApplicationContext(rootContext);
    }
    if (!this.refreshEventReceived) {
        onRefresh(wac);
    }
    if (this.publishContext) {
        String attrName = getServletContextAttributeName();
        getServletContext().setAttribute(attrName, wac);
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
                    "' as ServletContext attribute with name [" + attrName + "]");
        }
    }
    return wac;
}

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
    //获取到容器类型，我们是配置在web.xml中的，使用的是XmlWebApplicationContext容器类型
    Class<?> contextClass = getContextClass();
    ...
    //实例化容器
    ConfigurableWebApplicationContext wac =
            (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
    wac.setEnvironment(getEnvironment());
    //设置父容器
    wac.setParent(parent);
    //获取到我们的mvc配置文件
    String configLocation = getContextConfigLocation();
    if (configLocation != null) {
        wac.setConfigLocation(configLocation);
    }
    //根据配置初始化容器
    configureAndRefreshWebApplicationContext(wac);
    return wac;
}

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
    ...
    wac.setServletContext(getServletContext());
    wac.setServletConfig(getServletConfig());
    wac.setNamespace(getNamespace());
    //主要是看这一步，这里注册了一个容器初始化后的监听器，这一步是mvc初始化的关键
    wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
    ConfigurableEnvironment env = wac.getEnvironment();
    if (env instanceof ConfigurableWebEnvironment) {
        ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
    }
    postProcessWebApplicationContext(wac);
    applyInitializers(wac)
    //初始化Spring容器，这个我们再spring源码分析的时候，分析过spring的加载过程，这里就不进去看了
    wac.refresh();
}

这里就是容器初始化，我们主要是看到ContextRefreshListener这个监听器的注册，接下来，我们看看ContextRefreshListener这个监听器做了什么

/**
 *我们看到ContextRefreshListener这个监听器，监听了ContextRefreshedEvent这个事件
 *也就是spring容器初始化完成的事件
 **/
private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        //执行了FrameworkServlet的onApplicationEvent方法
        FrameworkServlet.this.onApplicationEvent(event);
    }
}
public void onApplicationEvent(ContextRefreshedEvent event) {
    this.refreshEventReceived = true;
    //执行初始化mvc容器的方法
    onRefresh(event.getApplicationContext());
}
protected void onRefresh(ApplicationContext context) {
    initStrategies(context);
}
protected void initStrategies(ApplicationContext context) {
    //初始化上传文件解析器
    initMultipartResolver(context);
    //初始化本地化解析器
    initLocaleResolver(context);
    //初始化主题解析器
    initThemeResolver(context);
    //初始化Handler映射器处理器组件
    initHandlerMappings(context);
    //初始化处理器适配器
    initHandlerAdapters(context);
    //初始化处理器异常解析器
    initHandlerExceptionResolvers(context);
    //初始化视图解析器
    initRequestToViewNameTranslator(context);
    //初始化视图组件
    initViewResolvers(context);
    //初始化分布管理者
    initFlashMapManager(context);
}

到这一步整个spring mvc初始化就完成了

四、spring mvc请求流程

因为DispatcherServlet继承了FrameworkServlet，FrameworkServlet继承了HttpServletBean，HttpServletBean继承了HttpServlet，也就是请求进来时，会调用到doPost或者doGet方法去，FrameworkServlet覆盖了这几个方法，我们看下doGet方法

protected final void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    //无论是doPost还是doGet都是调用processRequest方法
    processRequest(request, response);
}

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    ...
    try {
        //执行doService方法
        doService(request, response);
    }
    catch (ServletException | IOException ex) {
        failureCause = ex;
        throw ex;
    }
    catch (Throwable ex) {
        failureCause = ex;
        throw new NestedServletException("Request processing failed", ex);
    }
    finally {
        resetContextHolders(request, previousLocaleContext, previousAttributes);
        if (requestAttributes != null) {
            requestAttributes.requestCompleted();
        }
        if (logger.isDebugEnabled()) {
            if (failureCause != null) {
                this.logger.debug("Could not complete request", failureCause);
            }
            else {
                if (asyncManager.isConcurrentHandlingStarted()) {
                    logger.debug("Leaving response open for concurrent processing");
                }
                else {
                    this.logger.debug("Successfully completed request");
                }
            }
        }
        //发布ServletRequestHandledEvent事件
        publishRequestHandledEvent(request, response, startTime, failureCause);
    }
}

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ...
    //设置request属性，所以我们可以在controller中获取到下面四个属性
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
    
    ...
    try {
        //开始进入doDispatch，这个就是前段控制器最重要的方法了，所有流程都在这个方法中
        doDispatch(request, response);
    }
    finally {
        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            // Restore the original attribute snapshot, in case of an include.
            if (attributesSnapshot != null) {
                restoreAttributesAfterInclude(request, attributesSnapshot);
            }
        }
    }
}
//这个方法我们就不省略代码了，这样流程会清晰一点
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    //handler执行链，这个里会封装所有拦截器的集合，还有执行的handler
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);
            //从映射器中获取处理器执行链
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
            //从处理器适配器中获取处理器
            HandlerAdapter ha = 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 (logger.isDebugEnabled()) {
                    logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            //执行拦截器的preHandle方法
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
            //使用处理器执行相应的handle，也就是我们的业务代码
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }
            //视图处理(页面渲染)
            applyDefaultViewName(processedRequest, mv);
            //执行拦截器postHandle方法
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

Spring MVC的处理流程就结束了，太细节的东西就不讲了，大家自己有时间可以阅读下源码，例如怎么获取处理器执行链的，怎么获取处理器的，还有各种处理器是怎么去处理不同方式的请求的，带着这些问题去阅读源码。