SpringBoot-内嵌Tomcat源码剖析

于 2022-01-15 21:16:36 发布
阅读量573 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java进阶代码示例 文章标签： spring boot tomcat java
原文链接：https://kaiwu.lagou.com/
本文详细解析了SpringBoot如何默认使用Tomcat作为内置容器，并深入探讨了切换Servlet容器的方法及内置Tomcat的自动配置原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring Boot默认支持Tomcat，Jetty，和Undertow作为底层容器。
而Spring Boot默认使用Tomcat，一旦引入spring-boot-starter-web模块，就默认使用Tomcat容
器。 
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

一. Servlet容器的使用

（二）默认servlet容器

我们看看spring-boot-starter-web这个starter中有什么 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starters</artifactId>
		<version>${revision}</version>
	</parent>
	<artifactId>spring-boot-starter-web</artifactId>
	<name>Spring Boot Web Starter</name>
	<description>Starter for building web, including RESTful, applications using Spring
		MVC. Uses Tomcat as the default embedded container</description>
	<properties>
		<main.basedir>${basedir}/../../..</main.basedir>
	</properties>
	<scm>
		<url>${git.url}</url>
		<connection>${git.connection}</connection>
		<developerConnection>${git.developerConnection}</developerConnection>
	</scm>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-json</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
			<exclusions>
				<exclusion>
					<groupId>org.apache.tomcat.embed</groupId>
					<artifactId>tomcat-embed-el</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
		</dependency>
	</dependencies>
</project>

 核心就是引入了tomcat和SpringMvc

（二）切换servlet容器

那如果我么想切换其他Servlet容器呢，只需如下两步：
  • 将tomcat依赖移除掉
  • 引入其他Servlet容器依赖
引入jetty： 
<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-jdbc</artifactId>
		</dependency>

二. 内嵌Tomcat自动配置原理

在启动springboot的时候可谓是相当简单，只需要执行以下代码

 

那些看似简单的事物，其实并不简单。我们之所以觉得他简单，是因为复杂性都被隐藏了。通过上
诉代码，大概率可以提出以下几个疑问
  • SpringBoot是如何启动内置tomcat的
  • SpringBoot为什么可以响应请求，他是如何配置的SpringMvc

（一）SpringBoot启动内置tomcat流程

1、 进入SpringBoot启动类，点进@SpringBootApplication源码，如下图

 

 2、 继续点进@EnableAutoConfiguration,进入该注解，如下图

 3、进入AutoConfigurationImportSelector类源码

上图中使用@Import注解对AutoConfigurationImportSelector 类进行了引入，该类做了什么
事情呢？进入源码，首先调用selectImport()方法，在该方法中调用了
getAutoConfigurationEntry（）方法，在之中又调用了getCandidateConfigurations()方法，
getCandidateConfigurations()方法就去META-INF/spring.factory配置文件中加载相关配置类

 这个spring.factories配置文件是加载的spring-boot-autoconfigure的配置文件

 

继续打开spring.factories配置文件，找到tomcat所在的类，tomcat加载在
ServletWebServerFactoryAutoConfiguration配置类中
进入该类，里面也通过@Import注解将EmbeddedTomcat、EmbeddedJetty、
EmbeddedUndertow等嵌入式容器类加载进来了，springboot默认是启动嵌入式tomcat容器，
如果要改变启动jetty或者undertow容器，需在pom文件中去设置。如下图：

 继续进入EmbeddedTomcat类中，见下图：

 

 进入TomcatServletWebServerFactory类，里面的getWebServer（）是关键方法，如图：

 

继续进入getTomcatWebServer()等方法，一直往下跟到tomcat初始化方法，调用tomcat.start()
方法，tomcat就正式开启运行，见图

 

走到这里tomcat在springboot中的配置以及最终启动的流程就走完了，相信大家肯定有一个疑
问，上上图中的getWebServer()方法是在哪里调用的呢？上面的代码流程并没有发现
getWebServer()被调用的地方。因为getWebServer()方法的调用根本就不在上面的代码流程中，
它是在另外一个流程中被调用的

4. getWebServer()的调用分析

首先进入SpringBoot启动类的run方法：

SpringApplication.run(HppaApplication.class, args);

这个会最终调用到一个同名方法run(String… args) 

public ConfigurableApplicationContext run(String... args) {
		//记录程序运行时间
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		// ConfigurableApplicationContext Spring 的上下文
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		//【1、获取并启动监听器】
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			//【2、构造应用上下文环境】
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			//处理需要忽略的Bean
			configureIgnoreBeanInfo(environment);
			//打印banner
			Banner printedBanner = printBanner(environment);
			///【3、初始化应用上下文】
			context = createApplicationContext();
			//实例化SpringBootExceptionReporter.class，用来支持报告关于启动的错误
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			//【4、刷新应用上下文前的准备阶段】
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			//【5、刷新应用上下文】
			refreshContext(context);
			//【6、刷新应用上下文后的扩展接口】
			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;
	}

这个方法大概做了以下几件事

1. 获取并启动监听器 通过加载META-INF/spring.factories 完成了
SpringApplicationRunListener实例化工作
2. 构造容器环境，简而言之就是加载系统变量，环境变量，配置文件
3. 创建容器
4. 实例化SpringBootExceptionReporter.class，用来支持报告关于启动的错误
5. 准备容器
6. 刷新容器
7. 刷新容器后的扩展接口
那么内置tomcat启动源码，就是隐藏在上诉第六步：refreshContext方法里面，该方法最终会调
用到AbstractApplicationContext类的refresh()方法

进入org.springframework.context.support.AbstractApplicationContext#refresh 方法，如图：

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

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

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

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

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

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

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				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();
			}
		}
	}
一直点击refresh()方法，如图：
onRefresh()会调用到ServletWebServerApplicationContext中的createWebServer()

	private void createWebServer() {
		WebServer webServer = this.webServer;
		ServletContext servletContext = getServletContext();
		if (webServer == null && servletContext == null) {
			//先获取嵌入式Servlet容器工厂
			ServletWebServerFactory factory = getWebServerFactory();
			//下面这一步调用了getWebServer这个方法
			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();
	}
createWebServer()就是启动web服务，但是还没有真正启动Tomcat，既然webServer是通过
ServletWebServerFactory来获取的，那就来看看这个工厂的真面目。

可以看到，tomcat,Jetty都实现了这个getWebServer方法，我们看
TomcatServletWebServerFactory中的getWebServer(ServletContextInitializer… initializers).

 

 

最终就调用了TomcatServletWebServerFactory类的getWebServer()方法。

 

小结
springboot的内部通过 new Tomcat() 的方式启动了一个内置Tomcat。但是这里还有一个问题，
这里只是启动了tomcat，但是我们的springmvc是如何加载的呢？下一章我们讲接收，
springboot是如何自动装配springmvc的

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值