SpringBoot内置tomcat启动过程及原理

京东云开发者
• 阅读 459

作者:李岩科

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 从启动入口开始一步步探索

SpringBoot内置tomcat启动过程及原理

点击进入 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 方法之后就可以看到,我们认识的一些初始化事件。主要的过程也是在这里完成的。

SpringBoot内置tomcat启动过程及原理

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;
}

SpringBoot内置tomcat启动过程及原理

SpringBoot内置tomcat启动过程及原理

代码中主要就是通过 switch 语句,根据 webApplicationType 的类型来创建不同的 ApplicationContext:

  • DEFAULT_SERVLET_WEB_CONTEXT_CLASS:Web 类型,实例化 AnnotationConfigServletWebServerApplicationContext
  • DEFAULT_REACTIVE_WEB_CONTEXT_CLASS:响应式 Web 类型,实例化 AnnotationConfigReactiveWebServerApplicationContext
  • DEFAULT_CONTEXT_CLASS:非 Web 类型,实例化 AnnotationConfigApplicationContext

2.4 创建完应用上下文之后,我们在看刷新上下文方法

SpringBoot内置tomcat启动过程及原理

一步步通过断点点击方法进去查看,我们看到很熟悉代码 spring 的相关代码。

SpringBoot内置tomcat启动过程及原理

@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

SpringBoot内置tomcat启动过程及原理

SpringBoot内置tomcat启动过程及原理

/** 得到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.

SpringBoot内置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 服务方法。

SpringBoot内置tomcat启动过程及原理

SpringBoot内置tomcat启动过程及原理

// Start the server to trigger initialization listeners
//启动tomcat服务
this.tomcat.start();
//开启阻塞非守护进程
startDaemonAwaitThread();

//Tomcat.java

SpringBoot内置tomcat启动过程及原理

SpringBoot内置tomcat启动过程及原理

2.9 TomcatWebServer.java 控制台会打印这句话

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

SpringBoot内置tomcat启动过程及原理

SpringBoot内置tomcat启动过程及原理

3 总结

SpringBoot 的启动主要是通过实例化 SpringApplication 来启动的,启动过程主要做了如下几件事情:

配置系统属性、获取监听器,发布应用开始启动事件、初始化参数、配置环境、创建应用上下文、预处理上下文、刷新上下文、再次刷新上下文、发布应用已经启动事件、发布应用启动完成事件。而启动 Tomcat 是刷新上下文 这一步。

Spring Boot 创建 Tomcat 时,会先创建一个上下文,将 WebApplicationContext 传给 Tomcat;

启动 Web 容器,需要调用 getWebserver (),因为默认的 Web 环境就是 TomcatServletWebServerFactory,所以会创建 Tomcat 的 Webserver,这里会把根上下文作为参数给 TomcatServletWebServerFactory 的 getWebServer ();启动 Tomcat,调用 Tomcat 中 Host、Engine 的启动方法。

3.1 Tomcat 相关名称介绍

SpringBoot内置tomcat启动过程及原理

点赞
收藏
评论区
推荐文章
Stella981 Stella981
3年前
SpringBoot中Tomcat是如何启动的
!(https://oscimg.oschina.net/oscnet/0635520b1cc748869d16a7204dc88786.png)SpringBoot一个非常突出的优点就是不需要我们额外再部署Servlet容器,它内置了多种容器的支持。我们可以通过配置来指定我们需要的容器。本文以我们平时最常使用的容器Tomcat为列来介
Stella981 Stella981
3年前
SpringBoot连接常见设置
SpringBoot集成了Servlet容器,因此我们可以方便的启动一个容器,并访问其中的接口。那么如何控制Servlet容器中的线程池呢?可以通过如下配置进行控制server:tomcat:appcectcount:1minspacethreads:1maxthreads:
Easter79 Easter79
3年前
SpringBoot打成war包,部署到Tomcat服务器
前言 SpringBoot默认达成jar包,默认使用内置的Tomcat。但考虑到项目需要打成war包部署到外部的Tomcat服务器中。把SpringBoot项目按照平常的web项目一样发布到tomcat容器下。1、修改pom.xml文件将默认的jar(默认创建项目的时候没有packaging)方式改为war。
Easter79 Easter79
3年前
Tomcat在SpringBoot中是如何启动的
!image(https://cdn.pixabay.com/photo/2017/09/29/11/57/cat2798804_1280.png)前言我们知道SpringBoot给我们带来了一个全新的开发体验,我们可以直接把web程序达成jar包,直接启动,这就得益于SpringBoot内置了容器,可以直接启动,本文将以Tomcat为例
Stella981 Stella981
3年前
SpringBoot打成war包,部署到Tomcat服务器
前言 SpringBoot默认达成jar包,默认使用内置的Tomcat。但考虑到项目需要打成war包部署到外部的Tomcat服务器中。把SpringBoot项目按照平常的web项目一样发布到tomcat容器下。1、修改pom.xml文件将默认的jar(默认创建项目的时候没有packaging)方式改为war。
Wesley13 Wesley13
3年前
Java初级开发0608面试
聊聊SpringBoot和传统的SSM的区别?SpringBoot是Spring的扩展,在Spring的基础上,简化了传统的SSM开发繁琐的配置;在部署上,SpringBoot内置了Tomcat,可以直接将项目打包成可执行的jar/war。说说你了解的Docker?
Easter79 Easter79
3年前
SpringBoot连接常见设置
SpringBoot集成了Servlet容器,因此我们可以方便的启动一个容器,并访问其中的接口。那么如何控制Servlet容器中的线程池呢?可以通过如下配置进行控制server:tomcat:appcectcount:1minspacethreads:1maxthreads:
Stella981 Stella981
3年前
Spring Boot打包war jar 部署tomcat
概述1.SpringBoot聚合工程打包war部署Tomcat2.SpringBoot打包Jar,通过Javajar直接运行.3.提供完整pom.xml测试项目至github4.项目目前了集成了SpringBootSpringdatajpaRedis集群dubbofreemarker 持续更新...
Stella981 Stella981
3年前
Jenkins
提示“反向代理设置有误”的背景1.将jenkins.war放在tomcat容器中运行2.访问Jenkins系统管理,会提示“反向代理设置有误”如何解决在tomcat上部署jenkins的确有这一问题,可以直接点击【不再显示】就可以了,不会有什么影响也可以换成javajar
Easter79 Easter79
3年前
SpringBoot中Tomcat是如何启动的
!(https://oscimg.oschina.net/oscnet/0635520b1cc748869d16a7204dc88786.png)SpringBoot一个非常突出的优点就是不需要我们额外再部署Servlet容器,它内置了多种容器的支持。我们可以通过配置来指定我们需要的容器。本文以我们平时最常使用的容器Tomcat为列来介