《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?

文章目录

  • 一、前言
  • 二、整体执行流程图
  • 三、内嵌Tomcat入口 --> onRefresh()
      • 1、推断Web应用类型
      • 2、创建应用上下文
      • 3、AnnotationConfigServletWebServerApplicationContext的类图
      • 4、AbstractApplicationContext#onRefresh()
        • 1> createWebServer() --> 创建WebServer
        • 2> getTomcatWebServer(tomcat) --> 构建Tomcat服务
        • 3> TomcatServletWebServerFactory#initialize()
        • 4> 执行完createWebServer()方法之后的日志输出
  • 四、真正启动Tomcat --> finishRefresh()
    • 1、启动Tomcat
      • 1)addPreviouslyRemovedConnectors()
      • 2)performDeferredLoadOnStartup()
      • 3)checkThatConnectorsHaveStarted()
    • 2、关闭Tomcat
  • 五、总结

一、前言

在前面的文章我们聊了Spring Boot的整体启动流程、自动装配、条件装配等内容:

1> 《SpringBoot启动流程一》:万字debug梳理SpringBoot如何加载并处理META-INF/spring.factories文件中的信息;
2> 《SpringBoot启动流程二》:七千字源码分析SpringApplication构造阶段;
3> 《SpringBoot启动流程三》:两万+字图文带你debug源码分析SpringApplication准备阶段(含配置文件加载时机、日志系统初始化时机);
4> 《SpringBoot启动流程四》:图文带你debug源码分析SpringApplication运行阶段和运行后阶段。
5> 《SpringBoot启动流程五》:你真的知道SpringBoot自动装配原理吗(两万字图文源码分析)

在使用springboot搭建一个web应用程序的时候,我们发现不需要自己搭建一个tomcat服务器,只需要引入spring-boot-starter-web,在应用启动时会自动启动嵌入式的tomcat作为服务器。

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>

注意:SpringBoot版本:2.3.7.RELEASE(博主写博客时最新Spring-boot版本 – 2.6.X代码逻辑几乎一样)

本文我们接着讨论Spring Boot 如何内嵌 并 启动 Tomcat的?

二、整体执行流程图

《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第1张图片

三、内嵌Tomcat入口 --> onRefresh()

《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第2张图片
从SpringApplication#run()开始往下追,追到AbstractApplicationContext#refresh()方法中,其内部会调用onRefresh()方法,这里负责开始内嵌Tomcat服务器。

在开始讨论onRefresh()方法之前,我们先找到当前Web应用的ApplicationContext具体是哪个(即AbstractApplicationContext的子类)?

下面结合整个Spring Boot的启动流程,有两点是有迹可循的:

1、推断Web应用类型

在博文 <《SpringBoot启动流程二》:七千字源码分析SpringApplication构造阶段> 中我们讨论过SpringApplication的构建过程中会推断Web应用的类型;

WebApplicationType.deduceFromClasspath();

因为Web应用类型可能在SpringApplication构造后及run方法之前,再通过setWebApplicatioinType(WebApplicationType)方法调整;又在推断Web应用类型的过程中,由于当前Spring应用上下文尚未准备,所以采用检查当前ClassLoader下基准Class的存在性来推断Web应用类型。

public enum WebApplicationType {

	NONE,
	SERVLET,
	REACTIVE;

	private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
			"org.springframework.web.context.ConfigurableWebApplicationContext" };

	private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

	private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

	private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";
    
    ....

	static WebApplicationType deduceFromClasspath() {
		// 1. 如果`DispatcherHandler`存在,并且`DispatcherServlet`和`ServletContainer`不存在时,Web应用类型为REACTIVE;
		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
			return WebApplicationType.REACTIVE;
		}
		// 2. 如果`Servlet`和`ConfigurableWebApplicationContext`不存在,则当前应用为非Web引应用,即NONE。
		for (String className : SERVLET_INDICATOR_CLASSES) {
			if (!ClassUtils.isPresent(className, null)) {
				return WebApplicationType.NONE;
			}
		}
		// 3.当Spring WebFlux和Spring Web MVC同时存在时,Web应用依旧是SERVLET。
		return WebApplicationType.SERVLET;
	}
	}
    ....
}

WEB 应用类型,一共有三种:NONE,SERVLET,REACTIVE。

deduceFromClasspath()方法利用ClassUtils.isPresent(String, ClassLoader)方法依次判断reactive.DispatcherHandlerConfigurableWebApplicationContextServletservlet.DispatcherServlet的存在性组合情况,从而判断Web 引用类型,具体逻辑如下:

  1. 如果DispatcherHandler存在,并且DispatcherServletServletContainer不存在时,即:Spring Boot仅依赖WebFlux时,Web应用类型为REACTIVE;
  2. 如果ServletConfigurableWebApplicationContext不存在,则当前应用为非Web应用,即NONE。因为这两个API是Spring Web MVC必须的依赖。
  3. 当Spring WebFlux和Spring Web MVC同时存在时,Web应用类型依旧是SERVLET。

2、创建应用上下文

在博文 <《SpringBoot启动流程三》:两万+字图文带你debug源码分析SpringApplication准备阶段 > 中 我们讨论过的SpringAppliation准备阶段的第八步会根据上面推断出的Web应用来创建相应的 ApplicationContext应用上下文对象。
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第3张图片

根据应用类型利用反射创建Spring应用上下文,可以理解为创建一个容器;就SERVLET而言:实例化AnnotationConfigServletWebServerApplicationContext。
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第4张图片

3、AnnotationConfigServletWebServerApplicationContext的类图

《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第5张图片
AnnotationConfigServletWebServerApplicationContext 继承自 ServletWebServerApplicationContext,ServletWebServerApplicationContext 又间接继承自AbstractApplicationContext,这样再回到AbstractApplicationContext#onRefresh(),我们便知道这里的应用上下文是哪个实例了。

4、AbstractApplicationContext#onRefresh()

由于AnnotationConfigServletWebServerApplicationContext类中没有重写onRefresh方法,所以从类图的最下方往上找到ServletWebServerApplicationContext#onRefresh()方法。

// ServletWebServerApplicationContext#onRefresh()
@Override
protected void onRefresh() {
    //创建主题对象,不用在意
	super.onRefresh();
	try {
        //开始创建web服务
		createWebServer();
	}
	catch (Throwable ex) {
		throw new ApplicationContextException("Unable to start web server", ex);
	}
}

方法逻辑:

  1. 首先调用父类AbstractApplicationContext的onRefresh()方法,创建一个主题对象(无需特意关注)。
  2. 接着调用自己的createWebServer()方法创建WebServer。

下面接着看createWebServer()方法做了什么?

1> createWebServer() --> 创建WebServer

private void createWebServer() {
	// 第一次进来,默认webServer 是 null
	WebServer webServer = this.webServer;
	// 第一次进行,默认servletContext 是 null
	ServletContext servletContext = getServletContext();
	if (webServer == null && servletContext == null) {
		// 从BeanFactory中获取ServletWebServerFactory的实现类
		ServletWebServerFactory factory = getWebServerFactory();
		// 获取servletContextInitializer(getSelfInitializer()方法会初始化Tomcat对象),获取webServer(完成内嵌Tomcat的API调用)
		// todo 注意getSelfInitializer()返回一个lambdab表达式,其中的内容不会执行,而是在启动TomcatEmbeddedContext时才会执行lambda
		this.webServer = factory.getWebServer(getSelfInitializer());
		getBeanFactory().registerSingleton("webServerGracefulShutdown",
				new WebServerGracefulShutdownLifecycle(this.webServer));
		getBeanFactory().registerSingleton("webServerStartStop",
				new WebServerStartStopLifecycle(this, this.webServer));
	}
	else if (servletContext != null) {
		try {
			getSelfInitializer().onStartup(servletContext);
		}
		catch (ServletException ex) {
			throw new ApplicationContextException("Cannot initialize servlet context", ex);
		}
	}
	// 根据上下文的配置属性 替换servlet相关的属性资源
	initPropertySources();
}

方法逻辑:

进入到方法的时候,webServer和servletContext均为null。

  1. 首先从BeanFactory中获取ServletWebServerFactory的实现类;
  2. 然后根据获取到的ServletWebServerFactory,进而获取Servlet上下文初始化器servletContextInitializer、获取WebServer。

    在获取servletContextInitializer时,返回的是一个lambda表达式,lambda表达式中的内容(即:初始化Tomcat对象)在启动TomcatEmbeddedContext时才会执行。

  3. 根据上下文的配置属性 替换servlet相关的属性资源;

(1 从BeanFactory中获取ServletWebServerFactory:

protected ServletWebServerFactory getWebServerFactory() {
	// Use bean names so that we don't consider the hierarchy
	String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
	if (beanNames.length == 0) {
		throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing "
				+ "ServletWebServerFactory bean.");
	}
	if (beanNames.length > 1) {
		throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
				+ "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
	}
	return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

getWebServerFactory()方法会从BeanFactory中获取所有ServletWebServerFactory接口的实现类,如果存在多个,则抛异常。

ServletWebServerFactory接口有四个主要的实现类:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第6张图片
其中默认的 Web 环境就是 TomcatServletWebServerFactory,而UndertowServletWebServerFactory用于响应式编程。
在这里插入图片描述
本文debug应用时用的正是默认的Web环境 --> TomcatServletWebServerFactory

(2 获取Servlet上下文初始化器servletContextInitializer:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第7张图片
返回一个lambda表达式,在后面启动TomcatEmbeddedContext时才会执行lambda。

(3 获取WebServer:

接着进入到TomcatServletWebServerFactory # getWebServer() 方法:

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
	// 走进这里时,initializers还没有执行
	if (this.disableMBeanRegistry) {
		Registry.disableRegistry();
	}
	// 完成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);
	connector.setThrowOnFailure(true);
	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中,其中会把上面获取到的servletContextInitializer绑定到tomcatEmbeddedContext。
	prepareContext(tomcat.getHost(), initializers);
	// 构建tomcatWebServer
	return getTomcatWebServer(tomcat);
}

方法逻辑:

  1. 首先完成Tomcat的API调用,把需要的对象创建好、参数设置好;
    而Tomcat有两个核心功能:<处理 Socket 连接,负责网络字节流与 Request 和 Response 对象的转化>、<加载和管理 Servlet,以及具体处理 Request 请求>。而针对这两个功能,Tomcat 设计了两个核心组件来分别完成这两件事,即:连接器Connector和容器Container(包括:Engine、Host、Context、Wrapper)。
    所以,其中最重要的两件事是:

    1> 把连接器 Connector 对象添加到 Tomcat 中;
    2> 配置容器引擎,configureEngine(tomcat.getEngine());

  2. 准备tomcatEmbeddedContext并将其设置到tomcat中,其中会把上面获取到的servletContextInitializer绑定到tomcatEmbeddedContext。
  3. 构建tomcatWebServer。

下面我们着重讨论如何构建Tomcat服务的?

2> getTomcatWebServer(tomcat) --> 构建Tomcat服务

整个构建Tomcat服务的代码执行流程如下:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第8张图片
其中牵扯到Tomcat其他组件(StandardServer、StandardService、StandardEngine、MapperListener、Connector)的初始化,整个生命周期流转如下:

《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第9张图片

3> TomcatServletWebServerFactory#initialize()

初始化Tomcat服务详细代码如下:

private void initialize() throws WebServerException {
	logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
	synchronized (this.monitor) {
		try {
			// 将engineName和instanceId用-拼接到一起
			addInstanceIdToEngineName();

			Context context = findContext();
			context.addLifecycleListener((event) -> {
				if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
					// Remove service connectors so that protocol binding doesn't
					// happen when the service is started.
					// 删除Connectors,以便再启动服务时不发生协议绑定,点进去看一下
					removeServiceConnectors();
				}
			});

			// 启动服务触发初始化监听器
			this.tomcat.start();

			// 在主线程中重新抛出失败异常
			rethrowDeferredStartupExceptions();

			try {
				ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
			}
			catch (NamingException ex) {
				// Naming is not enabled. Continue
			}

			// Unlike Jetty, all Tomcat threads are daemon threads. We create a
			// blocking non-daemon to stop immediate shutdown
			// 所有的tomcat线程都是守护线程,所以创建一个阻塞非守护线程来避免立即关闭
			startDaemonAwaitThread();
		}
		catch (Exception ex) {
			// 出现异常时,停止Tomcat
			stopSilently();
			destroySilently();
			throw new WebServerException("Unable to start embedded Tomcat", ex);
		}
	}
}

4> 执行完createWebServer()方法之后的日志输出

《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第10张图片
从日志输出来看,createWebServer() 方法看似是用来启动web服务的,并没有真正启动 Tomcat,只是通过ServletWebServerFactory 创建了一个 WebServer,初始化了一堆设置(包括:Port、Service、Engine、embeddedWebApplicationContext)。真正的启动发生在AbstractApplicationContext#finishRefresh()中。

四、真正启动Tomcat --> finishRefresh()

代码整理执行流程如下:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第11张图片
WebServerStartStopLifecycle类负责处理WebServer(Tomcat)的启动和关闭;

1、启动Tomcat

WebServerStartStopLifecycle#start()代码执行流程如下:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第12张图片
TomcatWebServer#start()详细代码如下:

@Override
public void start() throws WebServerException {
	synchronized (this.monitor) {
		if (this.started) {
			return;
		}
		try {
			// 添加之前移除的connector,绑定service和Connector
			addPreviouslyRemovedConnectors();
			// 获取当前Tomcat绑定的Connector
			Connector connector = this.tomcat.getConnector();
			// 默认会走进去
			if (connector != null && this.autoStart) {
				// 启动时执行延迟加载
				performDeferredLoadOnStartup();
			}
			// 检查connector启动状态是否为失败,失败抛出异常
			checkThatConnectorsHaveStarted();
			this.started = true;
			// Tomcat启动成功之后打印日志
			logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
					+ getContextPath() + "'");
		}
		catch (ConnectorStartFailedException ex) {
			stopSilently();
			throw ex;
		}
		catch (Exception ex) {
			PortInUseException.throwIfPortBindingException(ex, () -> this.tomcat.getConnector().getPort());
			throw new WebServerException("Unable to start embedded Tomcat server", ex);
		}
		finally {
			Context context = findContext();
			ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
		}
	}
}

方法逻辑:

  1. 首先添加之前移除的connector,绑定service和Connector;
  2. 获取到当前Tomcat绑定的Connector,接着进行执行延迟加载启动;
  3. 然后 检查connector启动状态是否为失败,失败抛出异常,否则打印Tomcat启动成功日志。

1)addPreviouslyRemovedConnectors()

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) {
				// connector添加到tomcat service中
				service.addConnector(connector);
				if (!this.autoStart) {
					// 如果不是自动启动,则暂停connector
					stopProtocolHandler(connector);
				}
			}
			// 添加完成后移除connector
			this.serviceConnectors.remove(service);
		}
	}
}

2)performDeferredLoadOnStartup()

private void performDeferredLoadOnStartup() {
	try {
		for (Container child : this.tomcat.getHost().findChildren()) {
			if (child instanceof TomcatEmbeddedContext) {
				// 延迟加载启动
				((TomcatEmbeddedContext) child).deferredLoadOnStartup();
			}
		}
	}
	catch (Exception ex) {
		if (ex instanceof WebServerException) {
			throw (WebServerException) ex;
		}
		throw new WebServerException("Unable to start embedded Tomcat connectors", ex);
	}
}

3)checkThatConnectorsHaveStarted()

private void checkThatConnectorsHaveStarted() {
	checkConnectorHasStarted(this.tomcat.getConnector());
	for (Connector connector : this.tomcat.getService().findConnectors()) {
		checkConnectorHasStarted(connector);
	}
}

TomcatWebServer#start()方法执行完之后的日志输出:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第13张图片

2、关闭Tomcat

《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第14张图片
在refreshContext()方法中会通过AbstractApplicationContext#registerShutdownHook()方法注册一个shutdownhook线程,当JVM退出时,确保后续Spring应用上下文所管理的Bean能够在标准的Spring生命周期中回调,从而合理的销毁Bean所依赖的资源(即:注册一个关闭webServer的钩子函数,而钩子函数可以完成关闭的功能)。
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第15张图片
我们知道应用的上下文实例是ServletWebServerApplicationContext,而它重写了其父类AbstractApplicationContext中的doClose()方法,所以进入到ServletWebServerApplicationContext#doClose()方法;
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第16张图片
发布一个事件之后,调用其父类AbstractApplicationContext#doClose()方法;

整体代码执行流程如下:
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第17张图片
最后进入到WebServerStartStopLifecycle#stop():
《SpringBoot启动流程六》:源码分析SpringBoot如何内嵌并启动Tomcat服务器的?_第18张图片

五、总结

在SpringApplication的运行阶段会通过refreshContext()方法进行上下文的刷新操作,其会进入到AbstractApplicationContext#refresh()方法中,进而调用onRefresh()方法内嵌Tomcat,进行Tomcat的初始化,在finishRefresh()方法中进行Tomcat的启动。

1> 创建WebServer:

  • 从BeanFactory中获取ServletWebServerFactory的实现类TomcatServletWebServerFactory ,然后通过其获取到WebServer;
  • 在获取WebServer的同时,初始化相关的Tomcat对象,包括:Connector、Container。

2> 启动WebServer:

  • 通过生命周期回调的方式将Tomcat和Connector绑定、延时加载启动Connector、启动成功后打印Tomcat启动成功日志。

你可能感兴趣的