通过源码看SpringMVC的DispatcherServlet

配置SpringMVC的应用的过程和使用这在这篇博客中Spring MVC应用已经配置好了。那么，前端控制器DispatcherServlet截获请求后做了什么工作呢?DispatcherServlet又是如何分派请求的呢?
A994ln.jpg
代码位置:orglspringframeworklweb/servIetIDispatcherServlet.java

第一步初始化组件


 

      
  1. protected void initStrategies(ApplicationContextcontext){

    2.   
  2.     initMultipartResolver(context);//初始化上传文件解析器

    3.   
  3.     initLocaleResolver(context);//初始化本地化解析器

    4.   
  4.     initThemeResolver(context);//初始化主题解析器

    5.   
  5.     initHandlerMappings(context)，//初始化处理器映射器，将请求映射到处理器

    6.   
  6.     initHandlerAdapters(context);//初始化处理器适配器

    7.   
  7.     initHandlerExceptionResolvers(context);

    8.   
  8.     //初始化处理器异常解析器，如果执行过程中遇到异常将交给HandlerExceptionResolver来解析

    9.   
  9.     initRequestTOViewNameTranslator(con七ext);//初始化请求到视图名称解析器

    10.   
  10.     initViewResolvers(context);

    11.   
  11.     //初始化视图解析器，通过ViewResolver解析逻辑视图名到具体视图实现

    12.   
  12.     initFlashMapManager(context);//初始化flash映射管理器

    13.   
  13. }

    14.

initStrategies方法将在WebApplicationContext初始化后自动执行，自动扫描上下文的Bean。根据名称或类型匹配的机制查找自定义的组件，如果没有找到则会装配一套Spring的默认组件。在org.springframeworlc.web.servlet路径下有一个DispatcherServlet.properties配置文件，该文件指定了DispatcherServlet所使用的默认组件。
当然开发者希望使用自定义类型的组件，有时候也是必须的，因为上传文件组件是默认不安装的，我们再Spring配置文件中配置自定义的Bean组件即可。Spring MVC如果发现上下文中有用户自定义的组件，就不会使用默认的组件，如:。

文件上传解析器。只允许一个实例
(1)查找名为muliipartResolver、类型为MuliipartResolver的Bean作为该类型组件。
(2)如果用户没有在上下文中显式定义MuliipartResolver类型的组件，则DispatcherServlet将不会加载该类型的组件。
(3)所以我们要用到时要配置这种实例，可以看这篇文章springMVC和springBoot使用MultipartFile上传文件

第二步，服务过程
一般来说Servlet有一个服务方法doService来为Http清求提供服务，DispatcherServlet也是如此，它的doService方法如下:


 

      
  1. @Override

    2.   
  2. prctected void doService (HttpServletRequestrequest，HttpServietResponse

    3.   
  3. response) throws Exception{

    4.   
  4.       if(logger.isDebugEnabled()){

    5.   
  5.           String resumed=WebAsyncUtils.getAsyncManager(request).hasConcurrentResult()?

    6.   
  6.                   resumed“:””;

    7.   
  7.           logger.debug(“DispatcherServiet with name”，+getServletName()+”‘“+resumed+

    8.   
  8.     “processing”+request.getMethod()+“request for [“  +qetRequestUri(request)“+”]“);

    9.   
  9.        }

    10.   

    11.   
  11. //快照处理

    12.   
  12. //Keep a snapshot of the requestattributes in case of an include

    13.   
  13. //to be able to rest。rethe original attributes after the include

    14.   
  14. Map<String, Object>attributesSnapshot=null;

    15.   
  15. if  (WebUtils.isIncludeRequest(request)){

    16.   
  16.       attributesSnapshot=new HashMap<String, Object>();

    17.   
  17.       Enumeration attrNames=request.getAttributeNames();

    18.   
  18.         while  (attrNames.hasMoreElements()){

    19.   
  19.                 String attrName=(String) attrNames .nextElement();

    20.   
  20.                 if (this.cleanupAfterinclude

    21.   
  21.                     attrName.startsWith(“org.springframework.web.servlet”)){

    22.   
  22.                       attributesSnapshot.put(attrName，request.getAttribute (attrName));

    23.   
  23.                     }

    24.   
  24.               )

    25.   

    26.   
  26.       //Make framework objects available to handlers and view objects.

    27.   
  27.     //设置Web IOC容器

    28.   
  28.       request.setAttribute(WEB APPLICATION CONTEXT ATTRIBUTE,getWebApplicationContext());

    29.   
  29.     //设置国际化属性

    30.   
  30.       request.setAttribute(LOCALE RESOLVER ATTRIBUTE，this.localeResolver);

    31.   
  31.     //主题属性

    32.   
  32.       request.setAttribute(THEME RESOLVER ATTRIBUTE，七his.themeResolver);

    33.   
  33.       //主题源属性

    34.   
  34.       ….

    35.   

    36.   
  36.   try{

    37.   
  37.         //处理分发

    38.   
  38.         doDispatch(request，response);

    39.   
  39.     }

    40.   
  40.     finally{

    41.   
  41.          if(!WebAsyncUtils.getAsyncManaqer(request) .isConcurrentHandimgStarted()){

    42.   
  42.                 //Restore the original attribute snapshot，in case of an include.

    43.   
  43.                 if (attributesSnapshot!=null){

    44.   
  44.                       restoreAttributesAfterinclude(request，attributesSnapshot);

    45.   
  45.                   }

    46.   
  46.      }

    47.   
  47.     }

    48.   
  48. }

    49.

从这段源码中我们看到了快照的处理，使用快照可以更快响应用户请求，并且设置些属书!最后所有的流程都集中在了doDispatch方法中。在Spring MVC流程中这是一个最为重要的方法，因此我们还需要探索它,如:


 

      
  1. protected void doDispatch(HttpServletRequest request，HttpServletResponse

    2.   
  2. response)throws Exception{

    3.   
  3.       HttpServletRequest processedRequest=request;

    4.   
  4.       HandlerExecutionChain mappedHandler=null;

    5.   
  5.       boolean multipartRequestParsed=false;

    6.   
  6.      WebAsyncManager asyncManager=WebAsyncUtils .getAsyncManager(request);

    7.   

    8.   
  8. try{

    9.   
  9.     //模型和视图

    10.   
  10.       ModelAndView my=null;

    11.   
  11.     //错误处理

    12.   
  12.       Exception dispatchException=null;

    13.   
  13.     try{

    14.   
  14.     //文件上传处理解析器

    15.   
  15.     processedRequest=checkMultipart(request);

    16.   
  16.       //是否为文件上传请求

    17.   
  17.     multipartRequestParsed=(processedRequest!=request);

    18.   
  18.     //Determine handler for the current request.

    19.   
  19. //获取匹配的执行链

    20.   
  20.       mappedHandler=getHandler(processedRequest);

    21.   
  21. //没有处理器错误

    22.   
  22.         if (mappedHandler==null || mappedHandler .getHandler()==null){

    23.   
  23.                 noHandlerFound(processedRequest，response)

    24.   
  24.              return;

    25.   
  25.         }

    26.   
  26.   //找到对应的处理适配器(HandlerAdapter)

    27.   
  27.        HandlerAdapter ha =getHandlerAdapter(mappedHandler.getHandler());

    28.   

    29.   

    30.   
  30. //判断是http的get方法还是post方法

    31.   
  31. String method=request.getMethod();

    32.   
  32. boolean isGet=“GET”.equals(method);

    33.   
  33. //GET方法的处理

    34.   
  34. if(isGet ||“HEAD”.equals(method)){

    35.   
  35. long hastModified=ha .getLastModified(request，mappedHandler .getHandler());

    36.   
  36. if(logger .isDebugEnabled()){

    37.   
  37.     logger.debug(“Last-Modifie value for [“+getRequestUri(request)+“]iS:”+lastModified);

    38.   
  38. if(new ServletWebRequest(request,response).checkNotModified(lastModified)&&isGet){

    39.   
  39.     return;}}

    40.   

    41.   
  41. //执行拦截器的事前方法，如果返回false，则流程结束

    42.   
  42. if(!mappedHandler.applyPreHandle(processedRequest，response)){

    43.   
  43. return;

    44.   
  44. }

    45.   
  45. //执行处理器，返回ModelAndView

    46.   
  46. mv =ha .handle (processedRequest,response,mappedHandler.getHandler())

    47.   
  47. if(asyncManager.isConcurrentHandlingStarted()){

    48.   
  48.         return;

    49.   
  49. }

    50.   
  50. //如果视图为空，给子设置默认视图的名称

    51.   
  51. applyDefaultViewName(processedRequest,mv);

    52.   

    53.   
  53. //执行处理器拦截器的事后方法

    54.   
  54. mappedHandler.applyPostHandle(processedRequest,responce,mv);

    55.   

    56.   
  56. catch (Exception ex)

    57.   
  57.     //记录异常

    58.   
  58.     dispatchException=eX;

    59.   
  59. }

    60.   

    61.   
  61. catch (Throwable err)

    62.   
  62.     //记录异常

    63.   
  63. dispatchException=new NestedServletException(“Handler dispatch failed”，err);

    64.   
  64.  }

    65.

通过源码可以看出其流程是:


  • (1)通过清求找到对应的执行链，执行链包含了拦截器和开发者控制器。

  • (2）通过处理器找到对应的适配器。

  • (3)执行拦截器的事前方法，如果返回false，则流程结束，不再处理。

  • (4)通过适配器运行处理器，然后返回模型和视图。

  • (5)如果视图没有名称，则给出默认的视图名称。

  • (6)执行拦截器的事后方法。

  • (7）处理分发请求得到的数据模型和视图的渲染。

原创来源：滴一盘技术