前面的文章中，我們介紹了Tomcat容器的關鍵組件和類加載器，但是現在的J2EE開發中更多的是使用SpringBoot內嵌的Tomcat容器，而不是單獨安裝Tomcat應用，那么Spring是怎么和Tomcat容器進行集成？Spring和Tomcat容器的生命周期是如何同步？本文會詳細介紹Spring和Tomcat容器的集成，

SpringBoot與Tomcat

使用SpringBoot搭建一個網頁，應該是很多Spring學習者入門的案例，我們只需要在pom添加Spring的web-starter依賴，并添加對應的Controller，一鍵啟動之后就可以得到一個完整的Web應用示例，

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <version>2.1.6.RELEASE</version>
</dependency>


@RestController
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @RequestMapping("/")
    public String hello(){
        return "hello";
    }
}

既然是一個Web應用，那么該應用必定啟動了對應的Servlet容器，常見的Servlet容器有Tomcat/Undertow/jetty/netty等，SpringBoot對這些容器都有集成，本文會重點分析SpringBoot是如何集成Tomcat容器的，

如何判斷是不是Web應用

我們知道SpringBoot不一定以Web應用的形式運行，還可以以桌面程式的形式運行，那么SpringBoot在應用中如何判斷應用是不是一個Web應用程式，是不是需要啟動Tomcat容器的呢？

Spring容器在容器啟動的時候，會呼叫WebApplicationType.deduceFromClasspath()方法來推斷當前的應用程式型別，從方法名字就可以看出，該方法是通過當前專案中的類來判斷是不是Web專案的，以下為該方法的原始碼，當我們在專案中添加了spring-boot-starter-web的依賴之后，專案路徑中會包含webMvc的類，對應的Spring應用也會被識別為Web應用，

private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet", "org.springframework.web.context.ConfigurableWebApplicationContext" };

private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";

private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";

static WebApplicationType deduceFromClasspath() {
    if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null) && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
        return WebApplicationType.REACTIVE;
    }
    for (String className : SERVLET_INDICATOR_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }
    return WebApplicationType.SERVLET;
}

根據應用型別創建應用

通過專案中包含類的型別，Spring可以判斷出當前應用的型別，之后Spring就需要根據應用型別去創建對應的ApplicationContext，從下面的程式中可以看出來，對于我們關注的普通web應用，Spring會創建一個AnnotationConfigServletWebServerApplicationContext，

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
    try {
        switch (webApplicationType) {
            case SERVLET:
                return new AnnotationConfigServletWebServerApplicationContext();
            case REACTIVE:
                return new AnnotationConfigReactiveWebServerApplicationContext();
            default:
                return new AnnotationConfigApplicationContext();
            }
        }
        catch (Exception ex) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, "
            + "you may need a custom ApplicationContextFactory", ex);
        }
};

AnnotationConfigServletWebServerApplicationContext是Web應用的Spring容器，我們可以推斷，這個ApplicationContext容器中必定包含了servlet容器的初始化，去查看容器初始化的原始碼可以發現，在容器Refresh階段會初始化WebServer，原始碼如下：

@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        // Spring容器Refresh階段創建WebServer
        createWebServer(); 
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}

private void createWebServer() {
        WebServer webServer = this.webServer;
        ServletContext servletContext = getServletContext();

        // 沒有初始化好的WebServer就需要初始化一個
        if (webServer == null && servletContext == null) {
            StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");

            // 獲取ServletWebServerFactory，對于Tomcat來說獲取到的就是TomcatServletWebServerFactory
            ServletWebServerFactory factory = getWebServerFactory();
            createWebServer.tag("factory", factory.getClass().toString());

            // 創建Tomcat容器的WebServer
            this.webServer = factory.getWebServer(getSelfInitializer());
            createWebServer.end();
            getBeanFactory().registerSingleton("webServerGracefulShutdown",
                    new WebServerGracefulShutdownLifecycle(this.webServer));
            getBeanFactory().registerSingleton("webServerStartStop",
                    new WebServerStartStopLifecycle(this, this.webServer));
        }
        else if (servletContext != null) {
            try {
                getSelfInitializer().onStartup(servletContext);
            }
            catch (ServletException ex) {
                throw new ApplicationContextException("Cannot initialize servlet context", ex);
            }
        }
        initPropertySources();
    }

Tomcat的初始化

通過上面的內容，我們知道SpringBoot會在啟動的時候判斷是不是Web應用并創建對應型別的Spring容器，對于Web應用會創建Web型別的ApplicationContext，在Spring容器啟動的時候會初始化WebServer，也就是初始化Tomcat容器，本節我們會分析Tomcat容器初始化原始碼的各個步驟，

獲取ServletWebServerFactory

初始化Tomcat容器的程序中，第一步是獲取創建Tomcat WebServer的工廠類TomcatServletWebServerFactory，分析原始碼可知，Spring是直接通過Bean的型別從Spring容器中獲取ServletWebServerFactory的，所以Tomcat容器型別的SpringBoot應該在啟動時向容器中注冊TomcatServletWebServerFactory的實體作為一個Bean，

// 獲取ServletWebServerFactory關鍵代碼
factory = getWebServerFactory();

// 關鍵代碼涉及的函式
protected ServletWebServerFactory getWebServerFactory() {
    // Use bean names so that we don't consider the hierarchy
    String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
    if (beanNames.length == 0) {
        throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing "
                + "ServletWebServerFactory bean.");
    }
    if (beanNames.length > 1) {
        throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
                + "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
    }
    return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

創建WebServer的實體

拿到用于創建WebServer的ServletWebServerFactory，我們就可以開始著手創建WebServer了，創建WebServer的關鍵代碼如下所示，

// 創建WebServer的實體關鍵代碼
this.webServer = factory.getWebServer(getSelfInitializer());

創建WebServer的第一步是拿到創建時需要的引數，這個引數的型別是ServletContextInitializer，ServletContextInitializer的作用是用于初始化ServletContext，介面原始碼如下，從介面的注釋中我們就可以看到，這個引數可以用于配置servlet容器的filters，listeners等資訊，

@FunctionalInterface
public interface ServletContextInitializer {

    /**
     * Configure the given {@link ServletContext} with any servlets, filters, listeners
     * context-params and attributes necessary for initialization.
     * @param servletContext the {@code ServletContext} to initialize
     * @throws ServletException if any call against the given {@code ServletContext}
     * throws a {@code ServletException}
     */
    void onStartup(ServletContext servletContext) throws ServletException;

}

Spring是通過getSelfInitializer()方法來獲取初始化引數，查看getSelfInitializer()方法，可以發現該方法實作了如下功能：

系結SpringBoot應用程式和ServletContext；
向SpringBoot注冊ServletContext，Socpe為Application級別；
向SpringBoot背景關系環境注冊ServletContext環境相關的Bean；
獲取容器中所有的ServletContextInitializer，依次處理ServletContext，

private ServletContextInitializer getSelfInitializer() {
    return this::selfInitialize;
}

private void selfInitialize(ServletContext servletContext) throws ServletException {
    prepareWebApplicationContext(servletContext);
    registerApplicationScope(servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
    for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        beans.onStartup(servletContext);
    }
}

獲取到用于創建WebServer的引數之后，Spring就會呼叫工廠方法去創建Tomcat對應的WebServer，

    @Override
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        if (this.disableMBeanRegistry) {
            Registry.disableRegistry();
        }
        Tomcat tomcat = new Tomcat();
        File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        tomcat.getService().addConnector(connector);
        customizeConnector(connector);
        tomcat.setConnector(connector);
        tomcat.getHost().setAutoDeploy(false);
        configureEngine(tomcat.getEngine());
        for (Connector additionalConnector : this.additionalTomcatConnectors) {
            tomcat.getService().addConnector(additionalConnector);
        }
        prepareContext(tomcat.getHost(), initializers);
        return getTomcatWebServer(tomcat);
    }

Tomcat生命周期

我們在使用基于Spring MVC應用框架，只需要啟動/關閉Spring應用，就可以同步啟動/關閉Tomcat容器，那么Spring是如何做到的呢？從下面初始化Web容器的代碼可以看到，Spring容器會注冊兩個和WebServer容器相關的生命周期Bean：

容器的優雅關閉Bea——webServerGracefulShutdown，
容器的生命周期管理的Bean——webServerStartStop

    getBeanFactory().registerSingleton("webServerGracefulShutdown",
                    new WebServerGracefulShutdownLifecycle(this.webServer));
    getBeanFactory().registerSingleton("webServerStartStop",
                    new WebServerStartStopLifecycle(this, this.webServer));

Tomcat容器優雅關閉

這是SpringBoot在最新的2.X.X版本中新增的優雅停機功能，? 優雅停機指的是Java專案在停機時需要做好斷后作業，如果直接使用kill -9 方式暴力的將專案停掉，可能會導致正常處理的請求、定時任務、RMI、注銷注冊中心等出現資料不一致問題，如何解決優雅停機呢？大致需要解決如下問題：

首先要確保不會再有新的請求進來，所以需要設定一個流量擋板
保證正常處理已進來的請求執行緒，可以通過計數方式記錄專案中的請求數量
如果涉及到注冊中心，則需要在第一步結束后注銷注冊中心
停止專案中的定時任務
停止執行緒池
關閉其他需要關閉資源等等等

? SpringBoot優雅停機出現之前，一般需要通過自研方式來保證優雅停機，我也見過有專案組使用 kill -9 或者執行 shutdown腳本直接停止運行的專案，當然這種方式不夠優雅，

Spring提供Tomcat優雅關閉的核心類是WebServerGracefulShutdownLifecycle，可以等待用戶的所有請求處理完成之后再關閉Tomcat容器，我們查看WebServerGracefulShutdownLifecycle的的關機關鍵原始碼如下：

    // WebServerGracefulShutdownLifecycle停機原始碼
    @Override
    public void stop(Runnable callback) {
        this.running = false;
        this.webServer.shutDownGracefully((result) -> callback.run());
    }

    // tomcat web server shutDownGracefully原始碼
     @Override
     public void shutDownGracefully(GracefulShutdownCallback callback) {
          if (this.gracefulShutdown == null) {
               callback.shutdownComplete(GracefulShutdownResult.IMMEDIATE);
               return;
          }
          this.gracefulShutdown.shutDownGracefully(callback);
     }

此處出現了優雅關閉的工具類GracefulShutdown，Tomcat容器的GracefulShutdown原始碼如下所示，可以看到優雅關閉分為以下步驟：

關閉Tomcat容器的所有的連接器，連接器關閉之后會停止接受新的請求，
輪詢所有的Context容器，等待這些容器中的請求被處理完成，
如果強行退出，那么就不等待所有容器中的請求處理完成，
回呼優雅關閉的結果，有三種關閉結果：REQUESTS_ACTIVE有活躍請求的情況下強行關閉，IDLE所有請求完成之后關閉，IMMEDIATE沒有任何等待立即關閉容器，

final class GracefulShutdown {

    void shutDownGracefully(GracefulShutdownCallback callback) {
        logger.info("Commencing graceful shutdown. Waiting for active requests to complete");
        new Thread(() -> doShutdown(callback), "tomcat-shutdown").start();
    }

    private void doShutdown(GracefulShutdownCallback callback) {
        // 關閉Tomcat的所有的連接器，不接受新的請求
        List<Connector> connectors = getConnectors();
        connectors.forEach(this::close);
        try {
            for (Container host : this.tomcat.getEngine().findChildren()) {

                // 輪詢所有的Context容器
                for (Container context : host.findChildren()) {
                    // 判斷容器中的所有請求是不是已經結束，
                    while (isActive(context)) {

                        // 強行退出的情況下不等待所有請求處理完成
                        if (this.aborted) {
                            logger.info("Graceful shutdown aborted with one or more requests still active");
                            callback.shutdownComplete(GracefulShutdownResult.REQUESTS_ACTIVE);
                            return;
                        }
                        Thread.sleep(50);
                    }
                }
            }

        }
        catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
        logger.info("Graceful shutdown complete");
        callback.shutdownComplete(GracefulShutdownResult.IDLE);
    }
}

Spring 容器是怎么知道關閉并進行回呼的呢？本處只介紹kill -15作業原理：Spring容器在啟動的時候會向JVM注冊銷毀回呼方法，JVM在收到kill -15之后不會直接退出，而是會一一呼叫這些回呼方法，然后Spring會在這些回呼方法中進行優雅關閉，比如從注冊中心洗掉注冊資訊，優雅關閉Tomcat等等，

我是御狐神，歡迎大家關注我的微信公眾號:wzm2zsd

qrcode_for_gh_83670e17bbd7_344-2021-09-04-10-55-16

本文最先發布至微信公眾號，著作權所有，禁止轉載！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/310340.html

標籤：Java

上一篇：java springcloud 微服務設計方案

下一篇：Java集合——List，Set，Map總結筆記

學習Tomcat（七）之Spring內嵌Tomcat