SpringBoot內建tomcat啟動過程及原理

語言: CN / TW / HK

作者:李巖科

1 背景

SpringBoot是一個框架,一種全新的程式設計規範,他的產生簡化了框架的使用,同時也提供了很多便捷的功能,比如內建tomcat就是其中一項,他讓我們省去了搭建tomcat容器,生成war,部署,啟動tomcat。因為內建了啟動容器,應用程式可以直接通過 Maven 命令將專案編譯成可執行的 jar 包,通過 java -jar 命令直接啟動,不需要再像以前一樣,打包成 War 包,然後部署在 Tomcat 中。那麼內建tomcat是如何實現的呢

2 tomcat啟動過程及原理

2.1 下載一個springboot專案

在這裡下載一個專案https://start.spring.io/ 也可以在idea新建SpringBoot-Web工程.

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

點選 pom.xml會有 tomcat依賴

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.1.2.RELEASE</version>
<scope>compile</scope>
</dependency>

2.2 從啟動入口開始一步步探索

點選進入run方法

public static ConfigurableApplicationContext run(Class<?> primarySource,
String... args) {
return run(new Class<?>[] { primarySource }, args);
}

//繼續點選進入run方法
public static ConfigurableApplicationContext run(Class<?>[] primarySources,
String[] args) {
return new SpringApplication(primarySources).run(args);
}

進入到這個run方法之後就可以看到,我們認識的一些初始化事件。主要的過程也是在這裡完成的。

2.3 原始碼程式碼流程大致是這樣

/**
* Run the Spring application, creating and refreshing a new
* {@link ApplicationContext}.
* @param args the application arguments (usually passed from a Java main method)
* @return a running {@link ApplicationContext}
*/
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
/**1、配置系統屬性*/
configureHeadlessProperty();
/**2.獲取監聽器*/
SpringApplicationRunListeners listeners = getRunListeners(args);
/**釋出應用開始啟動事件 */
listeners.starting();
try {
/** 3.初始化引數 */
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
/** 4.配置環境*/
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);

configureIgnoreBeanInfo(environment);
Banner printedBanner = printBanner(environment);
/**5.建立應用上下文*/
context = createApplicationContext();
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
/**6.預處理上下文*/
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);

/**6.重新整理上下文*/
refreshContext(context);
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
/** 8.釋出應用已經啟動事件 */
listeners.started(context);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}

try {
/** 9.釋出應用已經啟動完成的監聽事件 */
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}

程式碼中主要就是通過 switch 語句,根據 webApplicationType 的型別來建立不同的 ApplicationContext:

  • DEFAULT_SERVLET_WEB_CONTEXT_CLASS:Web型別,例項化 AnnotationConfigServletWebServerApplicationContext
  • DEFAULT_REACTIVE_WEB_CONTEXT_CLASS:響應式Web型別,例項化 AnnotationConfigReactiveWebServerApplicationContext
  • DEFAULT_CONTEXT_CLASS:非Web型別,例項化 AnnotationConfigApplicationContext

2.4 建立完應用上下文之後,我們在看重新整理上下文方法

一步步通過斷點點選方法進去檢視,我們看到很熟悉程式碼spring的相關程式碼。

@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//初始化前的準備工作,主要是一些系統屬性、環境變數的校驗,比如Spring啟動需要某些環境變數,可以在這個地方進行設定和校驗
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.
//準備bean工廠 註冊了部分類
prepareBeanFactory(beanFactory);

try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
//註冊bean工廠後置處理器,並解析java程式碼配置bean定義
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
//註冊bean後置處理器,並不會執行後置處理器,在後面例項化的時候執行
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
//初始化事件監聽多路廣播器
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
//待子類實現,springBoot在這裡實現建立內建的tomact容器
onRefresh();

// Check for listener beans and register them.
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
finishRefresh();
}

catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}

// Destroy already created singletons to avoid dangling resources.
destroyBeans();

// Reset 'active' flag.
cancelRefresh(ex);

// Propagate exception to caller.
throw ex;
}

finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}

2.5 onRefresh() 方法是呼叫其子類實現的

也就是 ServletWebServerApplicationContext

/** 得到Servlet工廠 **/
this.webServer = factory.getWebServer(getSelfInitializer());

其中 createWebServer() 方法是用來啟動web服務的,但是還沒有真正啟動 Tomcat,只是通過ServletWebServerFactory 建立了一個 WebServer,繼續來看這個 ServletWebServerFactory:

this.webServer = factory.getWebServer(getSelfInitializer()); 這個方法可以看出TomcatServletWebServerFactory的實現。相關Tomcat的實現。

2.6 TomcatServletWebServerFactory 的 getWebServer() 方法

清晰的看到new 出來了一個Tomcat.

2.7 Tomcat建立之後,繼續分析Tomcat的相關設定和引數

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {

/** 1、建立Tomcat例項 **/
Tomcat tomcat = new Tomcat();
//建立Tomcat工作目錄
File baseDir = (this.baseDirectory != null) ? this.baseDirectory
: createTempDir("tomcat");
tomcat.setBaseDir(baseDir.getAbsolutePath());
Connector connector = new Connector(this.protocol);
tomcat.getService().addConnector(connector);
customizeConnector(connector);
/** 2、給建立好的tomcat設定聯結器connector **/
tomcat.setConnector(connector);
/** 3.設定不自動部署 **/
tomcat.getHost().setAutoDeploy(false);
/** 4.配置Tomcat容器引擎 **/
configureEngine(tomcat.getEngine());
for (Connector additionalConnector : this.additionalTomcatConnectors) {
tomcat.getService().addConnector(additionalConnector);
}
/**準備Tomcat的StandardContext,並新增到Tomcat中*/
prepareContext(tomcat.getHost(), initializers);
/** 將建立好的Tomcat包裝成WebServer返回**/
return getTomcatWebServer(tomcat);
}

2.8 繼續點選getTomcatWebServer方法,找到initialize()方法,可以看到tomcat.start();啟動tomcat服務方法。

// Start the server to trigger initialization listeners
//啟動tomcat服務
this.tomcat.start();
//開啟阻塞非守護程序
startDaemonAwaitThread();

//Tomcat.java

2.9 TomcatWebServer.java 控制檯會列印這句話

Tomcat started on port(s): 8080 (http) with context path ‘’

3 總結

SpringBoot的啟動主要是通過例項化SpringApplication來啟動的,啟動過程主要做了如下幾件事情:

配置系統屬性、獲取監聽器,釋出應用開始啟動事件、初始化引數、配置環境、建立應用上下文、預處理上下文、重新整理上下文、再次重新整理上下文、釋出應用已經啟動事件、釋出應用啟動完成事件。而啟動 Tomcat 是重新整理上下文 這一步。

Spring Boot 建立 Tomcat 時,會先建立一個上下文,將 WebApplicationContext 傳給 Tomcat;

啟動 Web 容器,需要呼叫 getWebserver(),因為預設的 Web 環境就是 TomcatServletWebServerFactory,所以會建立 Tomcat 的 Webserver,這裡會把根上下文作為引數給 TomcatServletWebServerFactory 的 getWebServer();啟動 Tomcat,呼叫 Tomcat 中 Host、Engine 的啟動方法。

3.1 Tomcat相關名稱介紹