1.引言
现在JavaEE开发基本离不开spring全家桶，spring面世以来极大地简化了开发过程和代码量，但是随着spring版本迭代，功能越来越丰富和强大，带来的问题就是有大量的配置文件需要去开发人员去编写 ，所以springboot 应运而生，springboot 的理念是约定大于配置，极大地缩减了配置文件的量，借助springboot的自动配置甚至可以实现0配置，快速搭建项目，同时另外一个亮点就是内置servlet容器，不用再将代码打成war包，然后再去部署到tomcat，再启动tomcat，直接将项目打成jar包启动，也是特别方便。
2.内置servlet容器的使用方法
（1）使用约定的也就是默认的容器。默认使用的是tomcat，只需要引入web的依赖就可以自动使用Tomcat作为默认的servlet容器启动项目
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>（2）使用其他的内置容器
除了tomcat ，springboot 还支持Undertow 和 Jetty，并且可以快速切换成任意一个。做法是排除tomcat，引入想要用的容器jar包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-undertow</artifactId>
</dependency><dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>（3）不使用内置容器
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!-- 移除嵌入式tomcat插件 -->
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<!--添加servlet-api依赖--->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>3.Tomcat 基本结构及其用
Tomcat中最顶层的容器是Server，代表着整个服务器，从上图中可以看出，一个Server可以包含至少一个Service，用于具体提供服务。Service主要包含两个部分：Connector和Container，是tomcat的核心。Connector用于处理连接相关的事情，并提供Socket与Request和Response相关的转化，Container用于封装和管理Servlet，以及具体处理Request请求。
一个Tomcat中只有一个Server，一个Server可以包含多个Service，一个Service只有一个Container，但是可以有多个Connectors，这是因为一个服务可以有多个连接，如同时提供Http和Https链接，也可以提供向相同协议不同端口的连接
多个 Connector 和一个 Container 就形成了一个 Service，有了 Service 就可以对外提供服务了，但是 Service必须依赖server 生存，所以整个 Tomcat 的生命周期由 Server 控制。
4.内置Tomcat启动流程
tomcat 的启动需要从main 函数入手，main 函数的run方法实际调用的是 SpringApplication 的run 方法
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
configureHeadlessProperty();
//获取应用启动的事件监听器
SpringApplicationRunListeners listeners = getRunListeners(args);
// 发布了一个spring应用启动事件
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 准备应用启动环境（StandardServletEnviroment）
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
configureIgnoreBeanInfo(environment);
//打印启动banner
Banner printedBanner = printBanner(environment);
// 根据条件创建applicationContext,这里创建的是AnnotationConfigServletWebServerApplicationContext
context = createApplicationContext();
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
//刷新上下文
refreshContext(context);
//再次刷新上下文
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
}
listeners.started(context);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}createApplicationContext(); 创建了一个 AnnotationConfigServletWebServerApplicationContext 这个context 是注解版的servletContext ，它的本质还是applicationContext，继承和实现关系如下
接下来执行refreshContext，刷新上下文，调用的是AbstractApplicationContext的refresh，这个方法已经不是在springboot 的包内了，而是在spring 中了，这个启动流程是一个模板方法
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
// 获取beanFactory，这个就是springIoc容器的祖先
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
//为容器子类添加特殊的postprocess
this.postProcessBeanFactory(beanFactory);
//执行postprocess
this.invokeBeanFactoryPostProcessors(beanFactory);
// 为Bean 添加后置处理器
this.registerBeanPostProcessors(beanFactory);
// 初始化国际化信息源
this.initMessageSource();
//初始化时间传播器
this.initApplicationEventMulticaster();
// 刷新，这个方法是留给子类扩展使用的,tomcat的启动就在这里执行
this.onRefresh();
//注册时间监听器
this.registerListeners();
//初始化单实例Bean，循环依赖，后置处理器，initMethod,awear 接口的实现,自动装配，都在这里完成，boot 在这里加载了一些默认的bean，mvc相关的，条件注解相关的，共26个
this.finishBeanFactoryInitialization(beanFactory);
//初始化和发布Bean的生命周期事件
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如何启动tomcat，子类ServletWebServerApplicationContext 复写了这个方法
protected void onRefresh() {
super.onRefresh();
try {
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}createWebServerprivate void createWebServer() {
WebServer webServer = this.webServer;
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
ServletWebServerFactory factory = getWebServerFactory();
this.webServer = factory.getWebServer(getSelfInitializer());
}
else if (servletContext != null) {
try {
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context", ex);
}
}
initPropertySources();
}先获取ServletWebServerFactory，然后通过工厂获取具体的webServer，此时获取的是TomcatServletWebServerFactory，同时这个接口的实现还有undertow和jetty的工厂。getWebServer 实现如下
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 的server，service，connector，engine 这些核心组件，然后调用 getTomcatWebServer，初始化和启动tomcat，
private void initialize() throws WebServerException {
logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
synchronized (this.monitor) {
try {
addInstanceIdToEngineName();
Context context = findContext();
context.addLifecycleListener((event) -> {
if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
// Remove service connectors so that protocol binding doesn't
// happen when the service is started.
removeServiceConnectors();
}
});
// Start the server to trigger initialization listeners
this.tomcat.start();
// We can re-throw failure exception directly in the main thread
rethrowDeferredStartupExceptions();
try {
ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
}
catch (NamingException ex) {
// Naming is not enabled. Continue
}
// Unlike Jetty, all Tomcat threads are daemon threads. We create a
// blocking non-daemon to stop immediate shutdown
startDaemonAwaitThread();
}
catch (Exception ex) {
stopSilently();
destroySilently();
throw new WebServerException("Unable to start embedded Tomcat", ex);
}
}
}
最后执行模板方法的最后一步finishRefresh，这个方法也被子类ServletWebServerApplicationContext复写了，
protected void finishRefresh() {
super.finishRefresh();
WebServer webServer = startWebServer();
if (webServer != null) {
publishEvent(new ServletWebServerInitializedEvent(webServer, this));
}
}private WebServer startWebServer() {
WebServer webServer = this.webServer;
if (webServer != null) {
webServer.start();
}
return webServer;
}此时tomcat 还没有真正启动，当执行webServer.start()时会找到context ，并且load，此时才算项目启动了
public void start() throws WebServerException {
synchronized (this.monitor) {
if (this.started) {
return;
}
try {
addPreviouslyRemovedConnectors();
Connector connector = this.tomcat.getConnector();
if (connector != null && this.autoStart) {
performDeferredLoadOnStartup();
}
checkThatConnectorsHaveStarted();
this.started = true;
logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
+ getContextPath() + "'");
}
catch (ConnectorStartFailedException ex) {
stopSilently();
throw ex;
}
catch (Exception ex) {
if (findBindException(ex) != null) {
throw new PortInUseException(this.tomcat.getConnector().getPort());
}
throw new WebServerException("Unable to start embedded Tomcat server", ex);
}
finally {
Context context = findContext();
ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
}
}
}
最后再到main函数的
listeners.started(context);
callRunners(context, applicationArguments);这两个方法，分别执行容器启动的监听器的回调，和执行 ApplicationRunner 和 ApplicationRunner 这些类型Bean的调用。至此基本描述了springboot 中tomcat 的启动过程，顺带些了一下spring Ioc容器的启动流程。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
