DispatchServlet从源码角度看是如何工作的

前言

本篇文章重点看了init阶段，springmvc代码量大，有些部分存在理解不透得情况，本文作为自身平常学习记录，不建议大家阅读学习。

首先贴张网上看到得概览图，下图有一个地方我认为是错的，就是第4步和第7步得执行者和接收者应该是DispatchServlet，其他得都没什么问题。

分析

首先从图中可以看出，DispatchServlet实现了Servlet接口，从本质上来看还是一个Servlet。那么一个Servlet的生命周期是

初始化init方法

处理请求阶段service方法

结束阶段destroy方法

因此我们先看DispatchServlet的init方法，DispatchServlet的init方法在HttpServletBean中实现。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public final void init() throws ServletException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Initializing servlet '" + this.getServletName() + "'");
        }

        PropertyValues pvs = new HttpServletBean.ServletConfigPropertyValues(this.getServletConfig(), this.requiredProperties);           //获取init-param标签中的属性和值并保存到PropertyValues类中
        if (!pvs.isEmpty()) {
            try {
                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
                ResourceLoader resourceLoader = new ServletContextResourceLoader(this.getServletContext());
                bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.getEnvironment()));
                this.initBeanWrapper(bw);
                bw.setPropertyValues(pvs, true);         //把一些相关配置保存到BeanWrapper中
            } catch (BeansException var4) {
                if (this.logger.isErrorEnabled()) {
                    this.logger.error("Failed to set bean properties on servlet '" + this.getServletName() + "'", var4);
                }

                throw var4;
            }
        }

        this.initServletBean();            //调用initServletBean方法，该方法在FrameWorkServlet中实现
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Servlet '" + this.getServletName() + "' configured successfully");
        }

    }

FrameworkServlet.class->initServletBean()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected final void initServletBean() throws ServletException {
        this.getServletContext().log("Initializing Spring FrameworkServlet '" + this.getServletName() + "'");
        if (this.logger.isInfoEnabled()) {
            this.logger.info("FrameworkServlet '" + this.getServletName() + "': initialization started");
        }

        long startTime = System.currentTimeMillis();

        try {
            this.webApplicationContext = this.initWebApplicationContext();    //调用initWebApplicationContext()
            this.initFrameworkServlet();          //调用this.initFrameworkServlet()
        } catch (ServletException var5) {
            this.logger.error("Context initialization failed", var5);
            throw var5;
        } catch (RuntimeException var6) {
            this.logger.error("Context initialization failed", var6);
            throw var6;
        }

        if (this.logger.isInfoEnabled()) {
            long elapsedTime = System.currentTimeMillis() - startTime;
            this.logger.info("FrameworkServlet '" + this.getServletName() + "': initialization completed in " + elapsedTime + " ms");
        }

    }

FrameworkServlet.class->initWebApplicationContext()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
protected WebApplicationContext initWebApplicationContext() {
        WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());     //获取ServletContext中的WebApplicationContext.class.getName() + ".ROOT",也就是根上下文
        WebApplicationContext wac = null;
        if (this.webApplicationContext != null) {                //如果this.webApplicationContext被spring依赖注入的话那么就!=null，这里检查是否已被依赖注入
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;
                if (!cwac.isActive()) {
                    if (cwac.getParent() == null) {
                        cwac.setParent(rootContext);
                    }

                    this.configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }

        if (wac == null) {
            wac = this.findWebApplicationContext();      //这个不知道是检查啥的，内部代码看起来也像是检查是否有已存在的webApplicationContext
        }

        if (wac == null) {
            wac = this.createWebApplicationContext(rootContext);    //创建新的子节点的webApplicationContext，并把rootContext作为父节点，完成了对ApplicationContext的初始化，注册，封装bean的工作
        }

        if (!this.refreshEventReceived) {
            this.onRefresh(wac);                        
        }

        if (this.publishContext) {
            String attrName = this.getServletContextAttributeName();
            this.getServletContext().setAttribute(attrName, wac);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Published WebApplicationContext of servlet '" + this.getServletName() + "' as ServletContext attribute with name [" + attrName + "]");
            }
        }

        return wac;
    }

FrameworkServlet->configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
       if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
           if (this.contextId != null) {
               wac.setId(this.contextId);
           } else {
               wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(this.getServletContext().getContextPath()) + '/' + this.getServletName());
           }
       }

       wac.setServletContext(this.getServletContext());
       wac.setServletConfig(this.getServletConfig());
       wac.setNamespace(this.getNamespace());
       wac.addApplicationListener(new SourceFilteringListener(wac, new FrameworkServlet.ContextRefreshListener()));
       ConfigurableEnvironment env = wac.getEnvironment();
       if (env instanceof ConfigurableWebEnvironment) {
           ((ConfigurableWebEnvironment)env).initPropertySources(this.getServletContext(), this.getServletConfig());
       }

       this.postProcessWebApplicationContext(wac);
       this.applyInitializers(wac); 
       wac.refresh();                     //完成applicationContext的初始化，注册，封装bean的工作
   }

AbstractApplicationContext.class->refresh()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void refresh() throws BeansException, IllegalStateException {
       synchronized(this.startupShutdownMonitor) {
           this.prepareRefresh();
           ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();                     //获取bean factory，读取xml中内容封装为beanFactory，不同的webApplicationContext对应的配置文件不一样，根的是application.xml，dispatchServlet的是spring.xml，当然这些文件名都可以自己指定。
           this.prepareBeanFactory(beanFactory);

           try {
               this.postProcessBeanFactory(beanFactory);
               this.invokeBeanFactoryPostProcessors(beanFactory);
               this.registerBeanPostProcessors(beanFactory);
               this.initMessageSource();
               this.initApplicationEventMulticaster();
               this.onRefresh();
               this.registerListeners();
               this.finishBeanFactoryInitialization(beanFactory);    //bean初始化，把xml中描述得类转换为对象实例化。
               this.finishRefresh();
           } catch (BeansException var9) {
               if (this.logger.isWarnEnabled()) {
                   this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
               }

               this.destroyBeans();
               this.cancelRefresh(var9);
               throw var9;
           } finally {
               this.resetCommonCaches();
           }

       }
   }

DispatchServlet.class->initHandlerMappings(ApplicationContext context)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private void initHandlerMappings(ApplicationContext context) {
       this.handlerMappings = null;
       if (this.detectAllHandlerMappings) {
           Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);                     //根据bean的是否是HandlerMapping类型的来找出handleMapping实现类，并放入this.handlerMappings中
           if (!matchingBeans.isEmpty()) {
               this.handlerMappings = new ArrayList(matchingBeans.values());
               AnnotationAwareOrderComparator.sort(this.handlerMappings);
           }
       } else {
           try {
               HandlerMapping h
               m = (HandlerMapping)context.getBean("handlerMapping", HandlerMapping.class);
               this.handlerMappings = Collections.singletonList(hm);
           } catch (NoSuchBeanDefinitionException var3) {
           }
       }

       if (this.handlerMappings == null) {
           this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
           if (this.logger.isDebugEnabled()) {
               this.logger.debug("No HandlerMappings found in servlet '" + this.getServletName() + "': using default");
           }
       }

   }

初始化完毕后初始化adapter等一系列东西。然后根据设定类和url的对应关系，比如我使用的是注解开发@RequestMapping和@Controller，那么这些被注解的类会被划分为url和类的对应关系存放在map中。

AbstractHandlerMethodMapping ->initHandlerMethods()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//注解开发
 protected void initHandlerMethods() {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Looking for request mappings in application context: " + this.getApplicationContext());
        }

        String[] beanNames = this.detectHandlerMethodsInAncestorContexts ? BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.obtainApplicationContext(), Object.class) : this.obtainApplicationContext().getBeanNamesForType(Object.class);     //获取context中所有bean类名
        String[] var2 = beanNames;
        int var3 = beanNames.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String beanName = var2[var4];
            if (!beanName.startsWith("scopedTarget.")) {
                Class beanType = null;

                try {
                    beanType = this.obtainApplicationContext().getType(beanName);
                } catch (Throwable var8) {
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Could not resolve target class for bean with name '" + beanName + "'", var8);
                    }
                }

                if (beanType != null && this.isHandler(beanType)) {   //是否被@Controller或@RequestMapping注释
                    this.detectHandlerMethods(beanName);     //this.mappingLookup存放mapping和handlerMethod的对应关系，this.urlLookup存放url和mapping对应关系。
                }
            }
        }

        this.handlerMethodsInitialized(this.getHandlerMethods());
    }

然后开始servlet的第二个周期—service。

DispatchServlet得service由FrameworkServlet实现。

1
2
3
4
5
6
7
8
9
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (HttpMethod.PATCH != httpMethod && httpMethod != null) {
            super.service(request, response);      //super.service(request,response)由HttpServlet实现
        } else {
            this.processRequest(request, response);
        }

    }

HttpServlet.class->service(HttpServletRequest req, HttpServletResponse resp)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       String method = req.getMethod();
       long lastModified;
       if (method.equals("GET")) {
           lastModified = this.getLastModified(req);
           if (lastModified == -1L) {
               this.doGet(req, resp);
           } else {
               long ifModifiedSince = req.getDateHeader("If-Modified-Since");
               if (ifModifiedSince < lastModified / 1000L * 1000L) {
                   this.maybeSetLastModified(resp, lastModified);
                   this.doGet(req, resp);
               } else {
                   resp.setStatus(304);
               }
           }
       } else if (method.equals("HEAD")) {
           lastModified = this.getLastModified(req);
           this.maybeSetLastModified(resp, lastModified);
           this.doHead(req, resp);
       } else if (method.equals("POST")) {
           this.doPost(req, resp);   //如果是post就进入dopost，其他方法相同
       } else if (method.equals("PUT")) {
           this.doPut(req, resp);
       } else if (method.equals("DELETE")) {
           this.doDelete(req, resp);
       } else if (method.equals("OPTIONS")) {
           this.doOptions(req, resp);
       } else if (method.equals("TRACE")) {
           this.doTrace(req, resp);
       } else {
           String errMsg = lStrings.getString("http.method_not_implemented");
           Object[] errArgs = new Object[]{method};
           errMsg = MessageFormat.format(errMsg, errArgs);
           resp.sendError(501, errMsg);
       }

   }

最后进入DispatchServlet得doDispatch，无论哪种方法都需要在此处被拦截

DispatchServlet.class->doDispatch(HttpServletRequest request, HttpServletResponse response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    mappedHandler = this.getHandler(processedRequest);    //获取request得HandlerExecutionChain,HandlerExecutionChain中包括处理handle和拦截器。
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());       //获取当前handle得处理适配器，一共有三种适配器，见下图。
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if (this.logger.isDebugEnabled()) {
                            this.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;
                    }

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());             //通过适配器执行handle得方法，返回modleandview。
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }

service包括后面阶段我认为比init阶段要简单不少，因此描述比较少。

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

huahua<br><br>虚心学习，不断进步。