spring boot 支持目前主流的 servlet 容器，包括 tomcat、jetty、undertow，可以在我们的项目中方便地集成这些 servlet 容器，减少了开发、运维的工作量。而传统的应用开发，需要经过繁锁的操作步骤：安装 tomcat –> 修改 tomcat 配置 –> 部署 war 包 –> 启动 tomcat –> 运维……，这个工作量不小，尤其是集群部署、应用迁移的时候。而采用 spring boot 之后，一切变得如此简单，打包 –> java -jar –> 运维，只需要一个 jar 包便可以随意部署安装。这篇文章，将对 spring boot 集成 tomcat 的源码进行分析，探索其内部的原理
SPI
在分析源码前，我们先来了解下 spring 的 SPI 机制。我们知道，jdk 为了方便应用程序进行扩展，提供了默认的 SPI 实现（ServiceLoader），dubbo 也有自己的 SPI。spring 也是如此，他为我们提供了SpringFactoriesLoader，允许开发人员通过META-INF/spring.factories文件进行扩展，下面举一个例子方便理解
假如，我想要往 spring 容器中添加一个ApplicationContextInitializer做一些初始化工作，我们可以借助 spring 提供的这个 SPI 功能完成这个需求。
首先，在项目中创建META-INF/spring.factories文件，文件内容如下所示：
org.springframework.context.ApplicationContextInitializer=\
我们再写个 test case，便可以通过 SPI 的方式获取我们定义的ApplicationContextInitializer。看似很简单的一个功能，但是 spring boot 正是利用这个强大的扩展点，在 spring framework 的基础上为我们集成了常用的开源框架
?
1
2
3
4
5
@Test
public void testSpringSpi() {
List<ApplicationListener> listeners = SpringFactoriesLoader.loadFactories( ApplicationListener.class,
ClassUtils.getDefaultClassLoader() );
System.out.println( listeners );
我们再来看看这个SpringFactoriesLoader，关键代码如下所示，它通过读取META-INF/spring.factories文件，并且查找方法参数指定的 class，然后创建对应的实例对象，并且返回。此外，还支持排序，可以使用以下几种方式进行排序
org.springframework.core.Ordered：实现该接口
org.springframework.core.annotation.Order：注解
javax.annotation.Priority：注解
?
1
2
3
4
5
6
7
8
public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
List<T> result = new ArrayList<T>(factoryNames.size());
for (String factoryName : factoryNames) {
result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
}
AnnotationAwareOrderComparator.sort(result);
return result;
接下来，我们来分析下 spring boot 是如何利用 SPI 机制集成 tomcat
SpringBoot for Tomcat
在分析 tomcat 集成的源码之前，我们先来了解下 EmbeddedServletContainer
EmbeddedServletContainer：
spring 用EmbeddedServletContainer封装了内嵌的 servlet 容器，提供了start、stop等接口用于控制容器的生命周期，并且 spring 内置了 tomcat、jetty、undertow 容器的实现，类图所下所示
我们再来看看 spring boot 中最常用的SpringBootApplication注解，原来是多个注解的综合体，而这个EnableAutoConfiguration便是 spring boot 用做自动化配置的注解
?
1
2
3
4
5
6
7
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
// code……
我们在spring-boot-autoconfigure模块可以看到大量的 SPI 配置，部分如下所示
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
原来EnableAutoConfiguration注解引入了EmbeddedServletContainerAutoConfiguration，而这个便是内嵌 servlet 容器的配置类，tomcat、jetty、undertow 都在这个类上面，通过@ConditionalOnClass注解加载不同的 servlet 容器。但是，这个类仅仅是注册了TomcatEmbeddedServletContainerFactory，不足以帮助我们解除所有的困惑。不要急，我们先来看看TomcatEmbeddedServletContainerFactory的类图。
由上面的类图可知，它实现了以下接口：
EmbeddedServletContainerFactory：它是一个工厂模式，用于创建EmbeddedServletContainer，即用于创建一个内嵌的 Servlet 容器，这个接口里面只有一个getEmbeddedServletContainer方法
ConfigurableEmbeddedServletContainer：用于配置EmbeddedServletContainer，比如说端口、上下文路径等
分析了上面两个接口，原来创建 servlet 容器的工作是由EmbeddedServletContainerFactory完成的，看下getEmbeddedServletContainer方法的调用栈。在EmbeddedWebApplicationContext中重写了GenericWebApplicationContext#onRefresh()方法，并且调用getEmbeddedServletContainer方法创建 servlet 容器，我们接下来分析这个创建过程。
关键代码如下（省略异常处理）：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
EmbeddedWebApplicationContext.java
@Override
protected void onRefresh() {
super.onRefresh();
createEmbeddedServletContainer();
}
private void createEmbeddedServletContainer() {
EmbeddedServletContainer localContainer = this.embeddedServletContainer;
ServletContext localServletContext = getServletContext();
if (localContainer == null && localServletContext == null) {
// 从容器中获取bean，如果使用tomcat则返回TomcatEmbeddedServletContainerFactory
EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
this.embeddedServletContainer = containerFactory.getEmbeddedServletContainer(getSelfInitializer());
}
else if (localServletContext != null) {
getSelfInitializer().onStartup(localServletContext);
}
initPropertySources();
我们先画出主要的流程图
由上图可知，EmbeddedWebApplicationContext在执行onRefresh方法的时候，首先调用父类的onRefresh，然后从容器中获取EmbeddedServletContainerFactory的实现类。由于我们在 classpath 下面可以获取 tomcat 的 jar 包，因此EmbeddedServletContainerAutoConfiguration会在 spring 容器中注册TomcatEmbeddedServletContainerFactory这个 bean。然后，由它创建TomcatEmbeddedServletContainer，我们来看看具体的创建过程，代码如下所示：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
TomcatEmbeddedServletContainerFactory.java
@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer… initializers) {
Tomcat tomcat = new Tomcat(); // 实例化 apache Tomcat
File baseDir = (this.baseDirectory != null ? this.baseDirectory
: createTempDir(“tomcat”));
tomcat.setBaseDir(baseDir.getAbsolutePath());
// 创建 Connector 组件，默认使用org.apache.coyote.http11.Http11NioProtocol
Connector connector = new Connector(this.protocol);
tomcat.getService().addConnector(connector);
// 支持对 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 getTomcatEmbeddedServletContainer(tomcat);
首先是实例化Tomcat对象，然后创建Connector组件，并且对Connector进行相关的参数设置，同时也允许我们通过TomcatConnectorCustomizer接口进行自定义的设置。OK，创建了Tomcat实例之后，需要创建TomcatEmbeddedServletContainer，它依赖Tomcat对象，在构造方法中便会启动 Tomcat 容器，从而完成各个组件的启动流程
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
Assert.notNull(tomcat, “Tomcat Server must not be null”);
this.tomcat = tomcat;
this.autoStart = autoStart;
initialize();
}
private void initialize() throws EmbeddedServletContainerException {
synchronized (this.monitor) {
addInstanceIdToEngineName();
// Remove service connectors to that protocol binding doesnt happen yet
removeServiceConnectors();
// Start the server to trigger initialization listeners
this.tomcat.start();
// We can re-throw failure exception directly in the main thread
rethrowDeferredStartupExceptions();
Context context = findContext();
ContextBindings.bindClassLoader(context, getNamingToken(context),
getClass().getClassLoader());
// Unlike Jetty, all Tomcat threads are daemon threads. We create a
// blocking non-daemon to stop immediate shutdown
startDaemonAwaitThread();
}
到此这篇关于SpringBoot集成tomcat详解实现过程的文章就介绍到这了,更多相关SpringBoot集成tomcat内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/weixin_37948564/article/details/129161083
声明： 猿站网有关资源均来自网络搜集与网友提供，任何涉及商业盈利目的的均不得使用，否则产生的一切后果将由您自己承担！ 本平台资源仅供个人学习交流、测试使用 所有内容请在下载后24小时内删除，制止非法恶意传播，不对任何下载或转载者造成的危害负任何法律责任！也请大家支持、购置正版！ 。本站一律禁止以任何方式发布或转载任何违法的相关信息访客发现请向站长举报，会员发帖仅代表会员个人观点，并不代表本站赞同其观点和对其真实性负责。本网站的资源部分来源于网络，如有侵权烦请发送邮件至：2697268773@qq.com进行处理。
