學習Tomcat（七）之Spring內嵌Tomcat

御狐神發表於2021-10-12

前面的文章中，我們介紹了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

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

Spring Boot 內嵌容器 Tomcat / Undertow
2021-09-09
Spring BootTomcat
[Web Server]Tomcat調優之SpringBoot內嵌Tomcat原始碼分析
2023-04-07
WebServerTomcatSpring Boot原始碼
【Spring】內嵌Tomcat&去Xml&除錯Mvc
2020-06-28
SpringTomcatXML除錯MVC
Spring Boot移除內嵌Tomcat，使用非web方式啟動
2021-02-26
Spring BootTomcatWeb
Netweaver的埠號和Spring boot內嵌的Tomcat埠
2020-03-14
Spring BootTomcat
spring-boot定製和最佳化內嵌的Tomcat
2021-09-09
SpringbootTomcat
精盡Spring Boot原始碼分析 - 內嵌Tomcat容器的實現
2021-07-01
Spring Boot原始碼Tomcat
SpringBoot原始碼學習4——SpringBoot內嵌Tomcat啟動流程原始碼分析
2023-05-15
Spring Boot原始碼Tomcat
學習Tomcat（一）之容器概覽
2021-09-13
Tomcat
SpringBoot原始碼解析-內嵌Tomcat容器的啟動
2019-04-01
Spring Boot原始碼Tomcat
學習Tomcat（三）之容器聯結器
2021-09-17
Tomcat
學習Tomcat（四）之Engine和Host容器
2021-09-23
Tomcat
Tomcat&Servlet學習
2020-12-29
TomcatServlet
Tomcat學習筆記
2021-10-08
Tomcat筆記
tomcat深入學習(二)(1) ---- tomcat初始化
2020-11-10
Tomcat
Spring Boot 學習系列（11）—tomcat引數配置建
2018-11-01
Spring BootTomcat
Tomcat學習總結1
2012-10-27
Tomcat
springboot學習筆記：6.內建tomcat啟動和外部tomcat部署總結
2018-01-22
Spring Boot筆記Tomcat
java web視訊學習-Tomcat
2019-02-27
JavaWebTomcat
淺談Tomcat之Tomcat結構
2018-02-13
Tomcat
#Tomcat學習(3)#Tomcat多例項配置和反向代理叢集配置
2020-10-22
Tomcat
Tomcat 學習進階歷程之Tomcat架構與核心類分析
2017-05-04
Tomcat架構
Spring Boot 揭祕與實戰（五）伺服器篇 – 內嵌的伺服器 Tomcat剖析 | 掘金技術徵文
2019-03-04
Spring Boot伺服器Tomcat
Spring Boot 揭祕與實戰（五）伺服器篇 - 內嵌的伺服器 Tomcat剖析 | 掘金技術徵文
2016-12-22
Spring Boot伺服器Tomcat
hive學習筆記之七：內建函式
2021-07-06
Hive筆記函式
spring boot 配置外接tomcat
2020-06-03
Spring BootTomcat
學習Tomcat，我們應該懂的
2020-04-05
Tomcat
(七) Spring學習總結
2021-06-18
Spring
大飛帶你深入理解Tomcat(七)
2018-07-03
Tomcat
Tomcat 學習筆記(3) – Host 主機配置
2014-11-06
Tomcat筆記
JavaWeb學習筆記——Tomcat資料來源
2016-05-14
JavaWeb筆記Tomcat
狂神說Java Web學習筆記_Tomcat
2024-04-08
JavaWeb筆記Tomcat
spring boot 部署到線上tomcat
2016-11-12
Spring BootTomcat
Tomcat 7 的七大新特性
2013-04-03
Tomcat
關於inline view內嵌檢視的學習
2013-09-23
inlineView
tomcat + spring mvc 原理（一）：tomcat原理綜述和靜態架構
2020-02-17
TomcatSpringMVC架構
Java學習筆記-Day52 JavaWeb、Tomcat、Servlet
2020-12-23
Java筆記WebTomcatServlet
JNDI學習（一） Tomcat7 配置JNDI （JDBC datasource）
2016-12-19
TomcatJDBC