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
的