阅读须知
- 版本：2.0.4
- 文章中使用/* */注释的方法会做深入分析
正文
我们知道，在使用Spring boot搭建web工程时，我们不需要自己搭建一个tomcat服务器，只需要引入spring-boot-starter-web，在应用启动时会自动启动嵌入版的tomcat作为应用服务器，下面我们来分析这个过程。
之前我们分析了Spring boot的启动流程和自动配置流程，而嵌入tomcat的启动同样需要依赖一个配置ServletWebServerFactoryAutoConfiguration，我们来看一下这个配置的内容：
@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
@Bean
public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(
ServerProperties serverProperties) {
return new ServletWebServerFactoryCustomizer(serverProperties);
}
@Bean
@ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")
public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(
ServerProperties serverProperties) {
return new TomcatServletWebServerFactoryCustomizer(serverProperties);
}
public static class BeanPostProcessorsRegistrar
implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) {
if (this.beanFactory == null) {
return;
}
registerSyntheticBeanIfMissing(registry,
"webServerFactoryCustomizerBeanPostProcessor",
WebServerFactoryCustomizerBeanPostProcessor.class);
registerSyntheticBeanIfMissing(registry,
"errorPageRegistrarBeanPostProcessor",
ErrorPageRegistrarBeanPostProcessor.class);
}
private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry,
String name, Class<?> beanClass) {
if (ObjectUtils.isEmpty(
this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
beanDefinition.setSynthetic(true);
registry.registerBeanDefinition(name, beanDefinition);
}
}
}
}
配置中主要做这么几件事，导入了内部类BeanPostProcessorsRegistrar，它实现了ImportBeanDefinitionRegistrar，作用我们在之前的文章中已经介绍过，我们可以实现ImportBeanDefinitionRegistrar来注册额外的BeanDefinition。导入了ServletWebServerFactoryConfiguration.EmbeddedTomcat配置（我们主要关注tomcat相关的配置）。注册了ServletWebServerFactoryCustomizer、TomcatServletWebServerFactoryCustomizer两个WebServerFactoryCustomizer类型的bean。我们来分别看一下上面提到的这些类的作用，首先来看内部类BeanPostProcessorsRegistrar：
ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar：
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) {
if (this.beanFactory == null) {
return;
}
registerSyntheticBeanIfMissing(registry,
"webServerFactoryCustomizerBeanPostProcessor",
WebServerFactoryCustomizerBeanPostProcessor.class);
registerSyntheticBeanIfMissing(registry,
"errorPageRegistrarBeanPostProcessor",
ErrorPageRegistrarBeanPostProcessor.class);
}
这里注册了两个BeanDefinition，WebServerFactoryCustomizerBeanPostProcessor和ErrorPageRegistrarBeanPostProcessor，它们都实现了BeanPostProcessor，后面我们会介绍它们的作用。
ServletWebServerFactoryConfiguration.EmbeddedTomcat：
@Configuration
@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
public static class EmbeddedTomcat {
@Bean
public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
return new TomcatServletWebServerFactory();
}
}
这个配置很简单，就是注册了一个TomcatServletWebServerFactory类型的bean。
最后剩下两个WebServerFactoryCustomizer类型的bean，任何WebServerFactoryCustomizer类型的bean都可以收到WebServerFactory的回调，所以我们可以实现WebServerFactoryCustomizer来定义WebServerFactory。ServletWebServerFactoryCustomizer的作用是将ServerProperties的属性配置设置到ConfigurableServletWebServerFactory的对应属性上，这里主要设置的是一些通用的属性，上面注册的TomcatServletWebServerFactory就实现了ConfigurableServletWebServerFactory。而TomcatServletWebServerFactoryCustomizer则是为TomcatServletWebServerFactory设置了一些它需要的特有属性。
在分析Spring boot启动流程时，我们看到Spring boot会根据是否能够成功加载一些关键的类来确认web应用类型，而我们通常的web应用类型为WebApplicationType.SERVLET，接下来就会根据这个类型来创建ApplicationContext（对Spring boot启动流程不了解的童鞋可以参考：Spring boot启动流程源码解析）：
SpringApplication：
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
// DEFAULT_WEB_CONTEXT_CLASS = "org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext"
contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Unable create a default ApplicationContext, "
+ "please specify an ApplicationContextClass",
ex);
}
}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
所以在refresh上下文时调用的就是AnnotationConfigServletWebServerApplicationContext的refresh方法，在Spring源码解析之ApplicationContext这篇文章中我们分析了整个Spring上下文的初始化流程，主要分析的就是refresh方法，AnnotationConfigServletWebServerApplicationContext对refresh流程做了扩展，我们来看扩展实现：
ServletWebServerApplicationContext：
protected void onRefresh() {
super.onRefresh();
try {
/* 创建web服务 */
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}
ServletWebServerApplicationContext：
private void createWebServer() {
WebServer webServer = this.webServer;
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
// 获取ServletWebServerFactory，这里就会获取到上文中注册bean TomcatServletWebServerFactory
ServletWebServerFactory factory = getWebServerFactory();
/* 获取ServletContextInitializer，获取WebServer */
this.webServer = factory.getWebServer(getSelfInitializer());
}
else if (servletContext != null) {
try {
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context",
ex);
}
}
// 替换Servlet相关的属性资源
initPropertySources();
}
ServletWebServerApplicationContext：
// ServletContextInitializer用于以编程方式配置Servlet 3.0+
private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
return this::selfInitialize;
}
private void selfInitialize(ServletContext servletContext) throws ServletException {
// 使用给定的完全加载的ServletContext准备WebApplicationContext
prepareWebApplicationContext(servletContext);
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
ExistingWebApplicationScopes existingScopes = new ExistingWebApplicationScopes(
beanFactory);
// 使用给定BeanFactory注册特定于Web的作用域（“request”，“session”，“globalSession”，“application”）
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory,
getServletContext());
existingScopes.restore();
// 使用给定BeanFactory注册特定于Web的环境bean（“contextParameters”，“contextAttributes”）
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory,
getServletContext());
for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
beans.onStartup(servletContext);
}
}
TomcatServletWebServerFactory：
public WebServer getWebServer(ServletContextInitializer... initializers) {
// 这里主要是一些embed tomcat的api调用
Tomcat tomcat = new 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);
tomcat.setConnector(connector);
tomcat.getHost().setAutoDeploy(false);
configureEngine(tomcat.getEngine());
for (Connector additionalConnector : this.additionalTomcatConnectors) {
tomcat.getService().addConnector(additionalConnector);
}
// 准备TomcatEmbeddedContext并设置到tomcat中
prepareContext(tomcat.getHost(), initializers);
/* 构建TomcatWebServer */
return getTomcatWebServer(tomcat);
}
TomcatServletWebServerFactory：
protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
return new TomcatWebServer(tomcat, getPort() >= 0);
}
public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
Assert.notNull(tomcat, "Tomcat Server must not be null");
this.tomcat = tomcat;
this.autoStart = autoStart;
/* 初始化 */
initialize();
}
TomcatWebServer：
private void initialize() throws WebServerException {
TomcatWebServer.logger
.info("Tomcat initialized with port(s): " + getPortsDescription(false));
synchronized (this.monitor) {
try {
// egnineName拼接instanceId
addInstanceIdToEngineName();
Context context = findContext();
context.addLifecycleListener((event) -> {
if (context.equals(event.getSource())
&& Lifecycle.START_EVENT.equals(event.getType())) {
/* 删除Connectors，以便在启动服务时不发生协议绑定 */
removeServiceConnectors();
}
});
// 启动服务触发初始化侦听器
this.tomcat.start();
// 我们可以直接在主线程中重新抛出失败异常
rethrowDeferredStartupExceptions();
try {
ContextBindings.bindClassLoader(context, context.getNamingToken(),
getClass().getClassLoader());
}
catch (NamingException ex) {
// 未启用命名，继续
}
// 与Jetty不同，所有Tomcat线程都是守护线程。我们创建一个阻塞非守护线程来避免立即关闭
startDaemonAwaitThread();
}
catch (Exception ex) {
// 异常停止tomcat
stopSilently();
throw new WebServerException("Unable to start embedded Tomcat", ex);
}
}
}
TomcatWebServer：
private void removeServiceConnectors() {
for (Service service : this.tomcat.getServer().findServices()) {
Connector[] connectors = service.findConnectors().clone();
// 将将要移除的connector放到缓存中暂存
this.serviceConnectors.put(service, connectors);
for (Connector connector : connectors) {
// 移除connector
service.removeConnector(connector);
}
}
}
这里涉及到一些embed tomcat的api调用，读者可以先去了解一下相关API。
下面我们再看另一个扩展refresh流程的方法：
ServletWebServerApplicationContext：
protected void finishRefresh() {
// 首先调用父类的finishRefresh方法，这个过程我们在上文提供的文章中分析过
super.finishRefresh();
/* 启动WebServer */
WebServer webServer = startWebServer();
if (webServer != null) {
// 发布WebServer初始化完成事件
publishEvent(new ServletWebServerInitializedEvent(webServer, this));
}
}
ServletWebServerApplicationContext：
private WebServer startWebServer() {
WebServer webServer = this.webServer;
if (webServer != null) {
/* 启动WebServer */
webServer.start();
}
return webServer;
}
TomcatWebServer：
public void start() throws WebServerException {
synchronized (this.monitor) {
if (this.started) {
return;
}
try {
/* 添加之前移除的connector */
addPreviouslyRemovedConnectors();
Connector connector = this.tomcat.getConnector();
if (connector != null && this.autoStart) {
/* 延迟加载启动 */
performDeferredLoadOnStartup();
}
// 检查connector启动状态是否为失败，失败抛出异常
checkThatConnectorsHaveStarted();
this.started = true;
TomcatWebServer.logger
.info("Tomcat started on port(s): " + getPortsDescription(true)
+ " with context path '" + getContextPath() + "'");
}
catch (ConnectorStartFailedException ex) {
// 异常停止tomcat
stopSilently();
throw ex;
}
catch (Exception ex) {
throw new WebServerException("Unable to start embedded Tomcat server",
ex);
}
finally {
Context context = findContext();
// context解绑ClassLoader
ContextBindings.unbindClassLoader(context, context.getNamingToken(),
getClass().getClassLoader());
}
}
}
TomcatWebServer：
private void addPreviouslyRemovedConnectors() {
Service[] services = this.tomcat.getServer().findServices();
for (Service service : services) {
// 从上面移除connector添加的缓存中取出connector
Connector[] connectors = this.serviceConnectors.get(service);
if (connectors != null) {
for (Connector connector : connectors) {
// 添加到tomcat service中
service.addConnector(connector);
if (!this.autoStart) {
// 如果不是自动启动，则暂停connector
stopProtocolHandler(connector);
}
}
// 添加完成后移除
this.serviceConnectors.remove(service);
}
}
}
TomcatWebServer：
private void performDeferredLoadOnStartup() {
try {
for (Container child : this.tomcat.getHost().findChildren()) {
if (child instanceof TomcatEmbeddedContext) {
/* 延迟加载启动 */
((TomcatEmbeddedContext) child).deferredLoadOnStartup();
}
}
}
catch (Exception ex) {
TomcatWebServer.logger.error("Cannot start connector: ", ex);
throw new WebServerException("Unable to start embedded Tomcat connectors",
ex);
}
}
TomcatEmbeddedContext：
public void deferredLoadOnStartup() {
// 一些较旧的Servlet框架（例如Struts，BIRT）使用Thread上下文类加载器在此阶段创建servlet实例
// 如果他们这样做然后尝试初始化它们，那么类加载器可能已经改变了
// 所以将调用包装在loadOnStartup中我们认为它将成为运行时的主要webapp类加载器
ClassLoader classLoader = getLoader().getClassLoader();
ClassLoader existingLoader = null;
if (classLoader != null) {
existingLoader = ClassUtils.overrideThreadContextClassLoader(classLoader);
}
if (this.overrideLoadOnStart) {
// 早期版本的Tomcat使用了返回void的版本
// 如果使用该版本，则不会调用我们重写的loadOnStart方法，并且原来的方法已经运行
// 在Web应用程序部署描述符中加载并初始化标记为“load on startup”的所有servlet
super.loadOnStartup(findChildren());
}
if (existingLoader != null) {
ClassUtils.overrideThreadContextClassLoader(existingLoader);
}
}
最后我们来看在应用上下文关闭时调用的扩展：
ServletWebServerApplicationContext：
protected void onClose() {
super.onClose();
/* 停止并释放WebServer */
stopAndReleaseWebServer();
}
ServletWebServerApplicationContext：
private void stopAndReleaseWebServer() {
WebServer webServer = this.webServer;
if (webServer != null) {
try {
/* 停止WebServer */
webServer.stop();
this.webServer = null;
}
catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
}
TomcatWebServer：
public void stop() throws WebServerException {
synchronized (this.monitor) {
boolean wasStarted = this.started;
try {
this.started = false;
try {
// 停止tomcat
stopTomcat();
// 销毁服务，调用后对象不能再次使用
this.tomcat.destroy();
}
catch (LifecycleException ex) {
}
}
catch (Exception ex) {
throw new WebServerException("Unable to stop embedded Tomcat", ex);
}
finally {
if (wasStarted) {
containerCounter.decrementAndGet();
}
}
}
}
到这里，整个Spring boot内嵌tomcat的流程就分析完了。
