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方法：

这个会最终调用到一个同名方法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 的