Spring MVC：DispatchServlet类

Spring MVC架构

　　Spring Web MVC是基于Servlet API构建的原始Web框架，从一开始就已包含在Spring框架中。传统的模型层被拆分为了业务层(Service)和数据访问层（DAO,Data Access Object）。 在 Service 下可以通过 Spring 的声明式事务操作数据访问层，而在业务层上还允许我们访问 NoSQL ，这样就能够满足异军突起的 NoSQL 的使用了，它可以大大提高互联网系统的性能。

　　M 代表 模型（Model），V 代表 视图（View），C 代表 控制器（controller）：

• 模型封装了应用程序数据，并且通常它们由 POJO 组成。

• 视图主要用于呈现模型数据，并且通常它生成客户端的浏览器可以解释的 HTML 输出。

• 控制器主要用于处理用户请求，并且构建合适的模型并将其传递到视图呈现。

一些优点：

1.在Spring MVC中，控制器可以处理所有HTTP方法的请求，这是RESTful Web服务的基础。例如，可以处理GET方法来执行读取操作，POST方法来创建资源，PUT方法来更新资源以及DELETE方法来从服务器中删除资源。从Spring 3.2开始，还可以处理PATCH请求。

2.对于REST，数据的表示非常重要，这就是为什么Spring MVC允许您通过使用 @ResponseBody 批注和各种 HttpMessgeConverter 实现方式完全绕过基于View的呈现  。通过使用此功能，您可以直接向客户端发送响应，例如，客户端所需的资源以及客户端所需的格式。

3. Spring 4.0版本添加了专用注释，@RestController使RESTful Web服务的开发更加容易。

如果使用@RestController 而不是 @Controller注释控制器类  ，则 Spring 会将消息对话应用于控制器中的所有处理程序方法。

这意味着您不需要为每个方法添加 @ResponseBody 注释。这也使您的代码更加简洁。 

4. REST Web服务和普通Web应用程序之间的主要区别之一是，REST传递资源标识URI本身中的数据，例如  /messages/101，  而Web应用程序通常使用查询参数，例如 /messages?Id=101。

如果您还记得的话，我们使用 @RequestParam 获取这些查询参数的值，但是不用担心，Spring MVC还提供了一个@PathVariable批注，可以从URL提取数据。它允许控制器处理对参数化URL的请求。

5. RESTful Web服务的另一个关键方面是表示，表示同一资源可以以不同的格式表示，例如JSON，XML，HTML等。值得庆幸的是，Spring提供了几种视图实现和视图解析器，以将数据呈现为JSON，XML，和HTML。

例如，ContentNegotiatingViewResolver 可以查看请求的文件扩展名或“接受”标头，以找出客户端资源的正确表示形式。

6.与 @ResponseBody 用于将响应转换为客户端想要的格式（通过使用 HttpMessageConverts）的注释  类似  ，Spring MVC还提供  @RequestBody 注释，该注释使用  HttpMethodConverter 实现将入站HTTP数据转换为传递到控制器的处理程序方法中的Java对象。

7.在 Spring框架还提供了一个模板类，RestTemplate，这是类似的 JdbcTemplate，并且 JmsTemplate，它可以消耗REST资源。您可以使用此类测试RESTful Web服务或开发REST客户端。

DispatchServlet

DispatchServlet 是 HTTP 请求处理程序/控制器的中央调度程序。Spring Web 模型-视图-控制（MVC）框架是围绕 DispatcherServlet 设计的。

下面是对应于 DispatcherServlet 传入 HTTP 请求的事件序列：

• 收到一个 HTTP 请求后，DispatcherServlet 根据 HandlerMapping 来选择并且调用适当的控制器
  

• 控制器接受请求（取决于使用@Controller和@RequestMapping注释请求的URL），并基于使用的 GET 或 POST 方法来调用适当的 service 方法。Service 方法将设置基于定义的业务逻辑的模型数据，并返回视图名称到 DispatcherServlet 中。

• DispatcherServlet 会从视图解析器 ViewResolver 获取帮助，为请求检取定义视图。

• 一旦确定视图，DispatcherServlet 将把模型数据传递给视图，最后呈现在浏览器中。

　　上面所提到的所有组件，即 HandlerMapping、Controller 和 ViewResolver 是 WebApplicationContext 的一部分，而 WebApplicationContext 是带有一些对 web 应用程序必要的额外特性的 ApplicationContext 的扩展。

DispatcherServlet 初始化流程

DispatcherServlet在MVC子容器初始化时会初始化这9大组件：

1. MultipartResolver：用来处理上传请求的。其处理方式就是将 request 包装成 MultipartHttpServletRequest。然后就可以用 MultipartHttpServletRequest 这个直接调用 getFile 获取的文件了。

2. LocalResolver：作用是从 request 中解析出 local，关于local大多数情况下都是用来做国际化处理的。

3. ThemeResolver：解析主题的，例如配一套properties文件供系统在不同的时候读取切换。

4. HandlerMapping：其作用就是根据 request 找到相应的处理器 Handler 和 Intecepter 拦截器。

5. HandlerAdapter：其接口的 handle 方法就是使用 handler 来处理逻辑的。

6. HandlerExceptionResolver：Spring MVC 中的异常处理组件，根据异常设置 ModelAndView，然后再将处理结果交给 render方法进行渲染。在渲染之前工作的，因此渲染过程中发生异常，HandlerExceptionResolver 是不会处理的。

7. RequestToViewNameTranslator：将request请求转换为视图名称。

8. ViewResolver：作用是将 String 类型的逻辑视图根据 local 解析为 View 视图的。

9. FlashMapManager：在redirect是进行参数传递需要用到。

    /**
     * This implementation calls {@link #initStrategies}.
     */
    @Override
    protected void onRefresh(ApplicationContext context) {
        initStrategies(context);
    }

    /**
     * Initialize the strategy objects that this servlet uses.
     * <p>May be overridden in subclasses in order to initialize further strategy objects.
     */
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

DispatcherServlet 执行流程

　　Http请求通过 HttpServlet 读取请求的内容，生成一个 HttpServletRequest 和一个 HttpServletResponse。下面这段方法将客户端请求分派到受保护的 service 方法。

    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;

        try {
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        service(request, response);
    }

　　接着来到 FrameworkServlet 的 service 方法，若是 patch 类型的方法，则单独拿出来进行处理。

    /**
     * Override the parent class implementation in order to intercept PATCH requests.
     */
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
            processRequest(request, response);
        }
        else {
            super.service(request, response);
        }
    }

　　最后回到 HttpServlet 的 service 方法中，这里使用到的设计模式是模板方法。

    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

　　然后在跳到 FrameworkServlet 的 doGet 方法中，doGet方法中用到 processRequest 方法，再看看上面对 patch 进行单独处理，可见是把将不同类型的请求合并到了processRequest 这个方法中来处理。

    @Override
    protected final void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        processRequest(request, response);
    }

　　processRequest 方法中做了三件事：

• 调用了 doService 模板方法具体处理请求。

• 将当前请求的 LocaleContext 和 ServletRequestAttributes 在处理请求前设置到了 LocaleContextHolder 和 RequestContextHolder，并在请求处理完成后恢复

• 请求处理完后发布了 ServletRequestHandledEvent 消息。

    protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        long startTime = System.currentTimeMillis();
        Throwable failureCause = null;

        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = buildLocaleContext(request);

        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

        initContextHolders(request, localeContext, requestAttributes);

        try {
            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();
            }
            logResult(request, response, failureCause, asyncManager);
            publishRequestHandledEvent(request, response, startTime, failureCause);
        }
    }

　　上面这段代码调用了 doService 的模板方法，接着走到了 DispatcherServlet 类中的 doService方法。

    @Override
    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        logRequest(request);

        // Keep a snapshot of the request attributes in case of an include,
        // to be able to restore the original attributes after the include.
        Map<String, Object> attributesSnapshot = null;
        if (WebUtils.isIncludeRequest(request)) {
            attributesSnapshot = new HashMap<>();
            Enumeration<?> attrNames = request.getAttributeNames();
            while (attrNames.hasMoreElements()) {
                String attrName = (String) attrNames.nextElement();
                if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                    attributesSnapshot.put(attrName, request.getAttribute(attrName));
                }
            }
        }

        // Make framework objects available to handlers and view objects.
        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());

        if (this.flashMapManager != null) {
            FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
            if (inputFlashMap != null) {
                request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
            }
            request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
            request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
        }

        try {
            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);
                }
            }
        }
    }

　　然后进行请求的分发 DispatcherServlet#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 {
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // 确定当前请求的handler
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);　　// 没有找到则执行此方法
                    return;
                }

                // 确定当前请求的处理程序适配器
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // 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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 调用对应handler方法
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                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 {
            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);
                }
            }
        }
    }

　　看看 getHandler 方法，遍历所有配置的 HandlerMapping 类，可以看出是支持用户配置多个 HandlerMapping 类的，


    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            for (HandlerMapping mapping : this.handlerMappings) {
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }
        return null;
    }

　　如果没有找到对应的 HandlerExecutionChain 对象，则会执行 noHandlerFound 方法返回异常。

    protected void noHandlerFound(HttpServletRequest request, HttpServletResponse response) throws Exception {
        if (pageNotFoundLogger.isWarnEnabled()) {
            pageNotFoundLogger.warn("No mapping for " + request.getMethod() + " " + getRequestUri(request));
        }
        if (this.throwExceptionIfNoHandlerFound) {
            throw new NoHandlerFoundException(request.getMethod(), getRequestUri(request),
                    new ServletServerHttpRequest(request).getHeaders());
        }
        else {
            response.sendError(HttpServletResponse.SC_NOT_FOUND);　　// 404错误
        }
    }

　　返回到 DispatcherServlet#doDispatch，找到了对应的 handler 后，就去寻找对应的 HandlerAdapter。与 HandlerMapping 类似，查找能够处理具体 Handler 的 HandlerAdapter 时同样会遍历所有配置了的 HandlerAdapter，没有找到对应的 adapter 则会抛出异常。

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        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");
    }

　　前没有什么问题发生，则按照顺序依次调用 HandlerInterceptor的 preHandle 方法，但当任一 HandlerInterceptor 的 preHandle方法返回了 false 就不再继续执行其他HandlerInterceptor 的 preHandle方法，而是直接跳转执行 triggerAfterCompletion 方法。

    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for (int i = 0; i < interceptors.length; i++) {
                HandlerInterceptor interceptor = interceptors[i];
                if (!interceptor.preHandle(request, response, this.handler)) {
                    triggerAfterCompletion(request, response, null);
                    return false;
                }
                this.interceptorIndex = i;
            }
        }
        return true;
    }

　　然后执行 mapperHandler 的 applyPostHandle 方法，应用注册拦截器的 postHandle 方法。

    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
            throws Exception {

        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for (int i = interceptors.length - 1; i >= 0; i--) {
                HandlerInterceptor interceptor = interceptors[i];
                interceptor.postHandle(request, response, this.handler, mv);
            }
        }
    }

　　最后执行 processDispatchResult 方法

    /**
     * Handle the result of handler selection and handler invocation, which is
     * either a ModelAndView or an Exception to be resolved to a ModelAndView.
     */
    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
            HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {

        boolean errorView = false;
        //判断 HandlerMapping、HandlerAdapter 处理时的异常是否有异常，有异常则进行异常处理
        if (exception != null) {
            //上述两个组件处理时的异常不为空
            //如果为 ModelAndViewDefiningException 异常，则获取一个异常视图
            if (exception instanceof ModelAndViewDefiningException) {
                logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException) exception).getModelAndView();
            }
            //如果不为 ModelAndViewDefiningException 异常，进行异常视图的获取
            else {
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
                mv = processHandlerException(request, response, handler, exception);
                errorView = (mv != null);
            }
        }

        // Did the handler return a view to render?
        //判断 mv 是否为空，不管是正常的 ModelAndView 还是异常的 ModelAndView，只要存在 mv 就进行视图渲染
        if (mv != null && !mv.wasCleared()) {
            render(mv, request, response); // 交给rander渲染
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
        //否则记录无视图
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                        "': assuming HandlerAdapter completed request handling");
            }
        }

        if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            // Concurrent handling started during a forward
            return;
        }
        //执行相关HandlerInterceptor的afterCompletion 方法
        if (mappedHandler != null) {
            mappedHandler.triggerAfterCompletion(request, response, null);
        }
    }

　　到这里之后则按着栈帧一步步弹出，DispatcherServlet 处理完 Http 请求的流程。

参考：

Spring MVC源码初探（一） FrameworkServlet

SpringMVC源码系列：九大组件小记

servlet之模板方法和多线程