SpringBoot中的Tomcat是如何启动的?
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
添加如上 Web 的依赖，Spring Boot 就帮我们内置了 Servlet 容器，默认使用的是 Tomcat，同样也支持修改，比如可以使用 jetty、Undertow 等。
因为内置了启动容器，应用程序可以直接通过 Maven 命令将项目编译成可执行的 jar 包，通过 java -jar 命令直接启动，不需要再像以前一样，打包成 War 包，然后部署在 Tomcat 中。
那么：你知道内置的 Tomcat 在 Spring Boot 中是怎么启动的吗？
从启动入口分析
如果不知道从哪开始，那么至少应该知道 Spring Boot 其实运行的就是一个 main 方法，
本文环境：Spring Boot：2.2.2.RELEASE
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
我们点进这个 SpringApplication.run() 方法：
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class[]{primarySource}, args);
}
这列的 run() 方法返回的是 ConfigurableApplicationContext 对象，我们继续跟踪这个 run() 方法：
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return (new SpringApplication(primarySources)).run(args);
}
又套了一层，继续点击这个返回的 run() 方法：
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
/*
* 1、配置属性
* 设置系统属性 java.awt.headless，为 true 则启用headless模式
* headless模式是应用的一种配置模式，在服务器缺少显示设备、键盘、鼠标等外设的情况下可以使用该模式
* 比如我们使用的Linux服务器就是缺少前述的这些设备，但是又需要使用这些设备提供的能力
*/
configureHeadlessProperty();
/*
* 2、获取监听器，发布应用开始启动事件
* 通过SpringFactoriesLoader检索META-INF/spring.factories，
* 找到声明的所有SpringApplicationRunListener的实现类并将其实例化，
* 之后逐个调用其started()方法，广播SpringBoot要开始执行了
*/
SpringApplicationRunListeners listeners = getRunListeners(args);
/* 发布应用开始启动事件 */
listeners.starting();
try {
/* 3、初始化参数 */
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
/*
* 4、配置环境，输出banner
* 创建并配置当前SpringBoot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）,
* 并遍历调用所有的SpringApplicationRunListener的environmentPrepared()方法，广播Environment准备完毕。
*/
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
configureIgnoreBeanInfo(environment);
/* 打印banner,如果在resources目录下创建了我们自己的banner就会进行打印，否则默认使用spring的 */
Banner printedBanner = printBanner(environment);
/* 5、创建应用上下文 */
context = createApplicationContext();
/* 通过SpringFactoriesLoader检索META-INF/spring.factories，获取并实例化异常分析器。 */
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
/*
* 6、预处理上下文
* 为ApplicationContext加载environment，之后逐个执行ApplicationContextInitializer的initialize()方法来进一步封装ApplicationContext，
* 并调用所有的SpringApplicationRunListener的contextPrepared()方法，【EventPublishingRunListener只提供了一个空的contextPrepared()方法】，
* 之后初始化IoC容器，并调用SpringApplicationRunListener的contextLoaded()方法，广播ApplicationContext的IoC加载完成，
* 这里就包括通过@EnableAutoConfiguration导入的各种自动配置类。
*/
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
/* 7、刷新上下文 */
refreshContext(context);
/* 8、再一次刷新上下文,其实是空方法，可能是为了后续扩展。 */
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
/* 9、发布应用已经启动的事件 */
listeners.started(context);
/*
* 遍历所有注册的ApplicationRunner和CommandLineRunner，并执行其run()方法。
* 我们可以实现自己的ApplicationRunner或者CommandLineRunner，来对SpringBoot的启动过程进行扩展。
*/
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
/* 10、发布应用已经启动完成的监听事件 */
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}
如果觉得这个方法看的云里雾里的，那么可以概括为如下几步：
- 配置系统属性
- 获取监听，发布应用开始启动时间
- 初始化输入参数
- 配置环境，输出banner
- 创建上下文
- 预处理上下文
- 刷新上下文
- 再次刷新上下文
- 发布应用已经启动事件
- 发布应用启动完成事件
而我们 Tomcat 的启动主要是在第5步创建上下文，以及第 7步刷新上下文实现的。
创建上下文
第5步中，创建上下文主要是调用的 createApplicationContext() 方法：
protected ConfigurableApplicationContext createApplicationContext() {
/** 1. 根据Web应用类型，获取对应的ApplicationContext子类 **/
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch(this.webApplicationType) {
case SERVLET:
contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
break;
case REACTIVE:
contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
break;
default:
contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
}
} catch (ClassNotFoundException var3) {
throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
}
}
/** 2. 实例化子类 **/
return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
代码中主要就是通过 switch 语句，根据 webApplicationType 的类型来创建不同的 ApplicationContext：
- SERVLET：Web类型，实例化 AnnotationConfigServletWebServerApplicationContext
- REACTIVE：响应式Web类型，实例化 AnnotationConfigReactiveWebServerApplicationContext
- default：非Web类型，实例化 AnnotationConfigApplicationContext
因为我们的应用是 Web 类型，所以实例化的是 AnnotationConfigServletWebServerApplicationContext，如下是该类的关系图（由Diagram截图）：
我们在上图的底部触发，可以看到 AnnotationConfigServletWebServerApplicationContext > ServletWebServerApplicationContext > ... AbstractApplicationContext（>表示继承），总之，最终继承到了 AbstractApplicationContext，这个类是 ApplicationContext 的抽象实现类，该抽象类实现应用上下文的一些具体操作。
至此，并没有看到 Tomcat 的相关代码，其实这一步主要就是「创建上下文」，拿到「上下文」之后需要传递给「刷新上下文」，交由刷新上下文创建 Web 服务。
刷新上下文
第7步中，刷新上下文时调用的 refreshContext(context) 方法，其中 context 就是第5步创建的上下文，方法如下：
private void refreshContext(ConfigurableApplicationContext context) {
refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
}
catch (AccessControlException ex) {
// Not allowed in some environments.
}
}
}
protected void refresh(ApplicationContext applicationContext) {
Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
((AbstractApplicationContext) applicationContext).refresh();
}
refreshContext() 方法传递的 context，经由 refresh() 方法强转成父类 AbstractApplicationContext，具体调用过程如下：
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
this.invokeBeanFactoryPostProcessors(beanFactory);
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
/** 主要关系 onRefresh() 方法 ------------- **/
this.onRefresh();
this.registerListeners();
this.finishBeanFactoryInitialization(beanFactory);
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();
}
}
}
在这个方法中我们主要关心 onRefresh() 方法，onRefresh() 方法是调用其子类实现的，也就是 ServletWebServerApplicationContext，
如下是子类的 onRefresh() 方法：
protected void onRefresh() {
super.onRefresh();
try {
this.createWebServer();
} catch (Throwable var2) {
throw new ApplicationContextException("Unable to start web server", var2);
}
}
private void createWebServer() {
WebServer webServer = this.webServer;
ServletContext servletContext = this.getServletContext();
if (webServer == null && servletContext == null) {
/** 得到Servlet工厂 **/
ServletWebServerFactory factory = this.getWebServerFactory();
this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
} else if (servletContext != null) {
try {
this.getSelfInitializer().onStartup(servletContext);
} catch (ServletException var4) {
throw new ApplicationContextException("Cannot initialize servlet context", var4);
}
}
this.initPropertySources();
}
其中 createWebServer() 方法是用来启动web服务的，但是还没有真正启动 Tomcat，只是通过ServletWebServerFactory 创建了一个 WebServer，我们继续来看这个 ServletWebServerFactory：
ServletWebServerFactory 有4个实现类，其中我们最常用的是 TomcatServletWebServerFactory和JettyServletWebServerFactory，而默认的 Web 环境就是 TomcatServletWebServerFactory。
而到这总算是看到 Tomcat 相关的字眼了。
来看一下 TomcatServletWebServerFactory 的 getWebServer() 方法：
public WebServer getWebServer(ServletContextInitializer... initializers) {
if (this.disableMBeanRegistry) {
Registry.disableRegistry();
}
/** 1、创建Tomcat实例 **/
Tomcat tomcat = new Tomcat();
File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
tomcat.setBaseDir(baseDir.getAbsolutePath());
Connector connector = new Connector(this.protocol);
connector.setThrowOnFailure(true);
tomcat.getService().addConnector(connector);
this.customizeConnector(connector);
/** 2、给创建好的tomcat设置连接器connector **/
tomcat.setConnector(connector);
/** 设置不自动部署 **/
tomcat.getHost().setAutoDeploy(false);
/** 3、配置Tomcat容器引擎 **/
this.configureEngine(tomcat.getEngine());
Iterator var5 = this.additionalTomcatConnectors.iterator();
while(var5.hasNext()) {
Connector additionalConnector = (Connector)var5.next();
tomcat.getService().addConnector(additionalConnector);
}
/**
* 准备Tomcat的StandardContext，并添加到Tomcat中，同时把initializers 注册到类型为
* TomcatStarter的ServletContainerInitializer中
**/
this.prepareContext(tomcat.getHost(), initializers);
/** 将创建好的Tomcat包装成WebServer返回**/
return this.getTomcatWebServer(tomcat);
}
public Engine getEngine() {
Service service = this.getServer().findServices()[0];
if (service.getContainer() != null) {
return service.getContainer();
} else {
Engine engine = new StandardEngine();
engine.setName("Tomcat");
engine.setDefaultHost(this.hostname);
engine.setRealm(this.createDefaultRealm());
service.setContainer(engine);
return engine;
}
}
getWebServer() 这个方法创建了 Tomcat 对象，并且做了两件重要的事情：
- 把连接器 Connector 对象添加到 Tomcat 中;
- 配置容器引擎，configureEngine(tomcat.getEngine());
首先说一下这个 Connector 连接器，Tomcat 有两个核心功能：
- 处理 Socket 连接，负责网络字节流与 Request 和 Response 对象的转化。
- 加载和管理 Servlet，以及具体处理 Request 请求。
针对这两个功能，Tomcat 设计了两个核心组件来分别完成这两件事，即：连接器(Connector)和容器(Container)。
整个过程大致就是：Connector 连接器接收连接请求，创建Request和Response对象用于和请求端交换数据，然后分配线程让Engine（也就是Servlet容器）来处理这个请求，并把产生的Request和Response对象传给Engine。当Engine处理完请求后，也会通过Connector将响应返回给客户端。
这里面提到了 Engine，这个是 Tomcat 容器里的顶级容器(Container)，我们可以通过 Container 类查看其他的子容器：Engine、Host、Context、Wrapper
4者的关系是：Engine 是最高级别的容器，Engine 子容器是 Host，Host 的子容器是 Context，Context 子容器是 Wrapper，所以这4个容器的关系就是父子关系，即：Wrapper > Context > Host > Engine （>表示继承）
至此我们了解了 Engine 这个就是个容器，然后我们再看一下这个 configureEngine(tomcat.getEngine()) 具体干了啥：
private void configureEngine(Engine engine) {
engine.setBackgroundProcessorDelay(this.backgroundProcessorDelay);
Iterator var2 = this.engineValves.iterator();
while(var2.hasNext()) {
Valve valve = (Valve)var2.next();
engine.getPipeline().addValve(valve);
}
}
其中 engine.setBackgroundProcessorDelay(this.backgroundProcessorDelay) 是指定背景线程的执行间隔，例如背景线程会在每隔多长时间后判断session是否失效之类。
再回到 getWebServer() 方法，最终 getWebServer() 方法返回了 TomcatWebServer。
return this.getTomcatWebServer(tomcat);
通过 getTomcatWebServer() 方法，继续下沉：
/**
* 构造函数实例化 TomcatWebServer
**/
public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
this.monitor = new Object();
this.serviceConnectors = new HashMap();
Assert.notNull(tomcat, "Tomcat Server must not be null");
this.tomcat = tomcat;
this.autoStart = autoStart;
this.initialize();
}
private void initialize() throws WebServerException {
/** 我们在启动 Spring Boot 时经常看到打印这句话 **/
logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false));
synchronized(this.monitor) {
try {
this.addInstanceIdToEngineName();
Context context = this.findContext();
context.addLifecycleListener((event) -> {
if (context.equals(event.getSource()) && "start".equals(event.getType())) {
this.removeServiceConnectors();
}
});
/** 启动 tomcat **/
this.tomcat.start();
this.rethrowDeferredStartupExceptions();
try {
ContextBindings.bindClassLoader(context, context.getNamingToken(), this.getClass().getClassLoader());
} catch (NamingException var5) {
}
this.startDaemonAwaitThread();
} catch (Exception var6) {
this.stopSilently();
this.destroySilently();
throw new WebServerException("Unable to start embedded Tomcat", var6);
}
}
}
至此，Tomcat 启动过程就很清晰了，总结一下。
总结
SpringBoot的启动主要是通过实例化SpringApplication来启动的，启动过程主要做了如下几件事情：
- 配置系统属性
- 获取监听，发布应用开始启动时间
- 初始化输入参数
- 配置环境，输出banner
- 创建上下文
- 预处理上下文
- 刷新上下文
- 再次刷新上下文
- 发布应用已经启动事件
- 发布应用启动完成事件
而启动 Tomcat 是在第7步 刷新上下文 这一步。
从整个流转过程中我们知道了 Tomcat 的启动主要是实例化两个组件：Connector、Container。
-
Spring Boot 创建 Tomcat 时，会先创建一个根上下文，将 WebApplicationContext 传给 Tomcat；
-
启动 Web 容器，需要调用 getWebserver()，因为默认的 Web 环境就是 TomcatServletWebServerFactory，所以会创建 Tomcat 的 Webserver，这里会把根上下文作为参数给 TomcatServletWebServerFactory 的 getWebServer()；
-
启动 Tomcat，调用 Tomcat 中 Host、Engine 的启动方法。
