理解SpringMVC-------DispatchServle

在web.xml中，可以找到这么一段配置文件，它的作用是将DispatchServlet作为一个servlet加载到servlet容器中
其中，<url-pattern>是将某一类请求转交给这个servlet进行处理

<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
     //是否开启异步支持
    <!--<async-supported>true</async-supported>-->
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

然后我们开始解析一下DispatchServlet具体做了些什么事情

1）加载DispatcherServlet.properties中的属性

private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";

...

static {
  // Load default strategy implementations from properties file.
  // This is currently strictly internal and not meant to be customized
  // by application developers.
  try {
      ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
      defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
  }
  catch (IOException ex) {
      throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
  }
}

找到DispatcherServlet.properties，其中内容如下

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
  org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
  org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
  org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
  org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
  org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

所以我们可以知道，这个DispatcherServlet.properties的作用是将默认实现类的路径以键值对的形式加载进来
LocaleResolver(本地化解析器，AcceptHeaderLocaleResolver)
ThemeResolver(主题解析器，FixedThemeResolver)
HandlerMapping(映射处理器，BeanNameUrlHandlerMapping)
HandlerAdapter(处理适配器，多个)
ViewResolver(视图解析器，InternalResourceViewResolver)
RequestToViewNameTranslator(将请求名称转化为视图名称，DefaultRequestToViewNameTranslator)

2）初始化加载SpringMVC框架下需要配置的基本的bean

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

这里的作用是将SpringMVC框架所需的各个基本的bean初始化，并加载到容器中

3）重写doService()方法

DispatchServlet实际上继承于FrameworkServlet，并且在其具体实现中重写了doService()方法。
doService()主要是将一些全局属性set到request中，具体的请求处理则调用并在doDispatch()中处理

4）doDipatch()将请求处理后转发到Controller

/**
* Process the actual dispatching to the handler.
* <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
* The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
* to find the first that supports the handler class.
* <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
* themselves to decide which methods are acceptable.
* @param request current HTTP request
* @param response current HTTP response
* @throws Exception in case of any kind of processing failure
*/
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {

  //获取当前要处理的request
  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);

        // Determine handler for the current request.
        //获取HandlerExecutionChain，其中包含了private HandlerInterceptor[] interceptors，即拦截器的一个数组
        mappedHandler = getHandler(processedRequest);
        if (mappedHandler == null || mappedHandler.getHandler() == null) {
            noHandlerFound(processedRequest, response);
            return;
        }

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

        // Process last-modified header, if supported by the handler.
        //从request中获取HTTP请求方法
        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;
        }

        // Actually invoke the handler.
        //返回处理后的modelView
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

        //判断是否是异步请求
        if (asyncManager.isConcurrentHandlingStarted()) {
            return;
        }

        //如果view为空，返回一个默认的view
        applyDefaultViewName(processedRequest, mv);
        //处理拦截器的后置方法postHandle
        mappedHandler.applyPostHandle(processedRequest, response, mv);
      }
      catch (Exception ex) {
        dispatchException = ex;
      }
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  }
  catch (Exception ex) {
      triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  }
  catch (Error err) {
      triggerAfterCompletionWithError(processedRequest, response, mappedHandler, 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);
        }
      }
  }
}