Spring MVC DispatcherServlet 解读

在整个 Spring MVC 框架中，DispatcherServlet 处于核心位置，它负责协调和组织不同组件完成请求处理并返回响应工作。DispatcherServlet 是 Spring MVC 统一的入口，所有的请求都通过它。DispatcherServlet 是前端控制器，配置在 web.xml 文件中，Servlet 依自已定义的具体规则拦截匹配的请求，分发到目标 Controller 来处理。 初始化 DispatcherServlet 时，该框架在web应用程序 WEB-INF 目录中寻找一个名为 [servlet-名称]-servlet.xml 的文件，并在那里定义相关的Beans，重写在全局中定义的任何Beans。在看 DispatcherServlet 类之前，我们先来看一下请求处理的大致流程：

1. Tomcat 启动，对 DispatcherServlet 进行实例化，然后调用它的 init() 进行初始化，在这个初始化过程中完成了：对 web.xml 中初始化参数的加载；建立 WebApplicationContext (Spring MVC的IOC容器)；进行组件的初始化；
2. 客户端发出请求，由 Tomcat 接收到这个请求，如果匹配 DispatcherServlet 在 web.xml中配置的映射路径，Tomcat 就将请求转交给 DispatcherServlet 处理；
3. DispatcherServlet 从容器中取出所有 HandlerMapping 实例（每个实例对应一个 HandlerMapping接口的实现类）并遍历，每个 HandlerMapping 会根据请求信息，通过自己实现类中的方式去找到处理该请求的 Handler(执行程序，如 Controller 中的方法)，并且将这个 Handler 与一堆 HandlerInterceptor (拦截器)封装成一个 HandlerExecutionChain 对象，一旦有一个 HandlerMapping 可以找到 Handler则退出循环；
4. DispatcherServlet 取出 HandlerAdapter 组件，根据已经找到的 Handler，再从所有HandlerAdapter 中找到可以处理该 Handler 的 HandlerAdapter 对象；
5. 执行 HandlerExecutionChain 中所有拦截器的 preHandler()，然后再利用 HandlerAdapter 执行 Handler ，执行完成得到 ModelAndView，再依次调用拦截器的 postHandler()；
6. 利用 ViewResolver 将 ModelAndView 或是 Exception (可解析成 ModelAndView)解析成View，然后 View 会调用 render() 再根据 ModelAndView 中的数据渲染出页面；
7. 最后再依次调用拦截器的 afterCompletion()，这一次请求就结束了。

 

Spring MVC 的核心就是 DispatcherServlet，DispatcherServlet 实质也是一个 HttpServlet。DispatcherSevlet 负责将请求分发，所有的请求都有经过它来统一分发。

  大致看下SpringMVC请求处理的流程：

 
  用户向服务器发送请求，请求会到 DispatcherServlet，DispatcherServlet 对请求URL进行解析，得到请求资源标识符（URI），然后根据该URI，调用 HandlerMapping 获得该Handler配置的所有相关的对象（包括一个Handler处理器对象、多个 HandlerInterceptor 拦截器对象），最后以 HandlerExecutionChain 对象的形式返回。
  DispatcherServlet 根据获得的 Handler，选择一个合适的 HandlerAdapter。提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

• HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息
• 数据转换：对请求消息进行数据转换。如String转换成 Integer、Double 等
• 数据格式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
• 数据验证： 验证数据的有效性（长度、格式等），验证结果存储到 BindingResult 或 Error 中

  Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；根据返回的ModelAndView，选择一个适合的ViewResolver返回给DispatcherServlet；ViewResolver 结合Model和View，来渲染视图，最后将渲染结果返回给客户端。

 几个DispatcherServlet类重要的几大组件：

    // 文件上传组件
    /** MultipartResolver used by this servlet */
    private MultipartResolver multipartResolver;

    // 资源定位组件
    /** LocaleResolver used by this servlet */
    private LocaleResolver localeResolver;

    // 主题解析组件
    /** ThemeResolver used by this servlet */
    private ThemeResolver themeResolver;

    // 处理器映射器组件集合
    /** List of HandlerMappings used by this servlet */
    private List<HandlerMapping> handlerMappings;

    // 处理器适配器组件集合
    /** List of HandlerAdapters used by this servlet */
    private List<HandlerAdapter> handlerAdapters;

    // 异常处理解析器集合
    /** List of HandlerExceptionResolvers used by this servlet */
    private List<HandlerExceptionResolver> handlerExceptionResolvers;

    // 视图名解析器
    /** RequestToViewNameTranslator used by this servlet */
    private RequestToViewNameTranslator viewNameTranslator;

    // 重定向及FlashMap存储组件
    /** FlashMapManager used by this servlet */
    private FlashMapManager flashMapManager;

    // 视图解析组件集合
    /** List of ViewResolvers used by this servlet */
    private List<ViewResolver> viewResolvers;

doDispatch函数的处理逻辑

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

        // 获取异步请求处理管理器，当业务逻辑复杂（或者其他原因），为了避免请求线程阻塞，需要委托给另一个线程的时候会使用该处理器来处理请求
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

            try {
                // 检查是否为文件上传请求，如果是的话则将request包装为一个MultipartHttpServletRequest（继承自HttpServletRequest）请求
                processedRequest = checkMultipart(request);

                //若与原始请求不同，说明是一个文件上传请求，否则为一个普通的请求
                multipartRequestParsed = (processedRequest != request);

                // 根据请求，获取处理器请求执行链，否则该请求不能被应用处理
                // Determine handler for the current request.
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 获取处理器适配器
                // Determine handler adapter for the current request.
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // 如果是GET或者HEAD请求，调用HandlerAdapter.getLastModified方法看看目标Controller方法在对于该请求有没有可用的lastModified逻辑，如果有的话就使用ServletWebRequest.checkNotModified逻辑判断当前lastModfied值和http header的上次缓存值，如果还没有过期就设置304头并且返回并结束整个请求流程。否则继续。
                // Process last-modified header, if supported by the handler.
                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;
                    }
                }

                // 处理请求前，先调用处理器执行链前置方法，内部主要是调用了拦截器的前置方法
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 使用处理器适配器来处理请求并返回模型视图对象
                // Actually invoke the handler.
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                // 检查异步处理是否已经开始了，如果开始了则目前的线程不再继续处理该请求，直接返回
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                // 如果模型视图对象不为null且存在视图，则设置该视图的名字
                applyDefaultViewName(processedRequest, mv);

                // 处理请求后，调用处理器执行链后置方法，内部主要是调用了拦截器的后置方法
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                // As of 4.3, we're processing Errors thrown from handler methods as well,
                // making them available for @ExceptionHandler methods and other scenarios.
                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 {
            // 如果异步请求处理管理器已开始处理该请求，则调用处理器执行链的回调函数，其内部主要是调用了AsyncHandlerInterceptor类型的拦截器
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                //关闭由于文件上传请求导致的打开的资源
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

 

REF

https://blog.csdn.net/zero__007/article/details/88650174

https://blog.csdn.net/u012777670/article/details/82701132

https://www.jianshu.com/p/9b7883c6a1a0