精尽Spring Boot源码分析 - 支持外部 Tomcat 容器的实现

该系列文章是笔者在学习 spring boot 过程中总结下来的，里面涉及到相关源码，可能对读者不太友好，请结合我的源码注释 spring boot 源码分析 github 地址 进行阅读

spring boot 版本：2.2.x

最好对 spring 源码有一定的了解，可以先查看我的 《死磕 spring 之 ioc 篇 - 文章导读》 系列文章

如果该篇内容对您有帮助，麻烦点击一下“推荐”，也可以关注博主，感激不尽~

该系列其他文章请查看：《精尽 spring boot 源码分析 - 文章导读》

概述

我们知道 spring boot 应用能够被打成 war 包，放入外部 tomcat 容器中运行。你是否知道 spring boot 是如何整合 spring mvc 的呢？

在上一篇 《spring boot 内嵌 tomcat 容器的实现》 文章中分析了 spring boot 白打成 jar 包后是如何创建 tomcat 容器并启动的，那么这篇文章主要告诉你 spring boot 应用被打成 war 包后放入外部 tomcat 容器是如何运行的。

如何使用

在我们的 spring boot 项目中通常会引入 spring-boot-starter-web 这个依赖，该模块提供全栈的 web 开发特性，包括 spring mvc 依赖和 tomcat 容器，我们将内部 tomcat 的 starter 模块排除掉，如下：

<packaging>war</packaging>

<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>javax.servlet</groupid>
    <artifactid>javax.servlet-api</artifactid>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

然后启动类这样写：

@springbootapplication
public class application extends springbootservletinitializer {

    // 可不写
    public static void main(string[] args) {
        springapplication.run(demoapplication.class, args);
    }

    @override
    protected springapplicationbuilder configure(springapplicationbuilder builder) {
        return builder.sources(application.class);
    }
}

这样你打成 war 包就可以放入外部的 servlet 容器中运行了。

实现原理

原理在分析 spring mvc 源码的时候讲过，参考我的 《精尽spring mvc源码分析 - 寻找遗失的 web.xml》 这篇文章

借助于 servlet 3.0 的一个新特性，新增的一个 javax.servlet.servletcontainerinitializer 接口，在 servlet 容器启动时会通过 java 的 spi 机制从 meta-inf/services/javax.servlet.servletcontainerinitializer 文件中找到这个接口的实现类，然后调用它的 onstartup(..) 方法。

在 spring 的 spring-web 模块中该文件是这么配置的：

org.springframework.web.springservletcontainerinitializer

一起来看看这个类：

@handlestypes(webapplicationinitializer.class)
public class springservletcontainerinitializer implements servletcontainerinitializer {

	@override
	public void onstartup(@nullable set<class<?>> webappinitializerclasses, servletcontext servletcontext)
			throws servletexception {

		list<webapplicationinitializer> initializers = new linkedlist<>();

		if (webappinitializerclasses != null) {
			for (class<?> waiclass : webappinitializerclasses) {
				// be defensive: some servlet containers provide us with invalid classes,
				// no matter what @handlestypes says...
				if (!waiclass.isinterface() && !modifier.isabstract(waiclass.getmodifiers()) &&
						webapplicationinitializer.class.isassignablefrom(waiclass)) {
					try {
						initializers.add((webapplicationinitializer)
								reflectionutils.accessibleconstructor(waiclass).newinstance());
					} catch (throwable ex) {
						throw new servletexception("failed to instantiate webapplicationinitializer class", ex);
					}
				}
			}
		}

		if (initializers.isempty()) {
			servletcontext.log("no spring webapplicationinitializer types detected on classpath");
			return;
		}

		servletcontext.log(initializers.size() + " spring webapplicationinitializers detected on classpath");
		annotationawareordercomparator.sort(initializers);
		for (webapplicationinitializer initializer : initializers) {
			initializer.onstartup(servletcontext);
		}
	}
}

通过 @handlestypes 注解指定只处理 webapplicationinitializer 类型的类

这个过程很简单，实例化所有 webapplicationinitializer 类型的对象，然后依次调用它们的 onstartup(servletcontext) 方法

通过打断点你会发现，有一个 demoapplication 就是我们的启动类

这也就是为什么如果你的 spring boot 应用需要打成 war 包放入外部 tomcat 容器运行的时候，你的启动类需要继承 springbootservletinitializer 这个抽象类，因为这个抽象类实现类 webapplicationinitializer 接口，我们只需要继承它即可

springbootservletinitializer

org.springframework.boot.web.servlet.support.springbootservletinitializer 抽象类，实现了 webapplicationinitializer 接口，目的就是支持你将 spring boot 应用打包成 war 包放入外部的 servlet 容器中运行

public abstract class springbootservletinitializer implements webapplicationinitializer {

	protected log logger; // don't initialize early

	private boolean registererrorpagefilter = true;

	protected final void setregistererrorpagefilter(boolean registererrorpagefilter) {
		this.registererrorpagefilter = registererrorpagefilter;
	}

	@override
	public void onstartup(servletcontext servletcontext) throws servletexception {
		// logger initialization is deferred in case an ordered
		// logservletcontextinitializer is being used
		this.logger = logfactory.getlog(getclass());
		// <1> 创建一个 webapplicationcontext 作为 root spring 应用上下文
		webapplicationcontext rootappcontext = createrootapplicationcontext(servletcontext);
		if (rootappcontext != null) {
			// <2> 添加一个 contextloaderlistener 监听器，会监听到 servletcontext 的启动事件
			// 因为 spring 应用上下文在上面第 `1` 步已经准备好了，所以这里什么都不用做
			servletcontext.addlistener(new contextloaderlistener(rootappcontext) {
				@override
				public void contextinitialized(servletcontextevent event) {
					// no-op because the application context is already initialized
				}
			});
		} else {
			this.logger.debug("no contextloaderlistener registered, as createrootapplicationcontext() did not "
					+ "return an application context");
		}
	}
}

在 onstartup(servletcontext) 方法中就两步：

1. 调用 createrootapplicationcontext(servletcontext) 方法，创建一个 webapplicationcontext 作为 root spring 应用上下文
2. 添加一个 contextloaderlistener 监听器，会监听到 servletcontext 的启动事件，因为 spring 应用上下文在上面第 1 步已经准备好了，所以这里什么都不用做

第 1 步是不是和 spring mvc 类似，同样创建一个 root webapplicationcontext 作为 spring 应用上下文的父对象

createrootapplicationcontext 方法

createrootapplicationcontext(servletcontext) 方法，创建一个 root webapplicationcontext 对象，如下：

protected webapplicationcontext createrootapplicationcontext(servletcontext servletcontext) {
    // <1> 创建一个 springapplication 构造器
    springapplicationbuilder builder = createspringapplicationbuilder();
    // <2> 设置 `mainapplicationclass`，主要用于打印日志
    builder.main(getclass());
    // <3> 从 servletcontext 上下文中获取最顶部的 root applicationcontext 应用上下文
    applicationcontext parent = getexistingrootwebapplicationcontext(servletcontext);
    // <4> 如果已存在 root applicationcontext，则先置空，因为这里会创建一个 applicationcontext 作为 root
    if (parent != null) {
        this.logger.info("root context already created (using as parent).");
        servletcontext.setattribute(webapplicationcontext.root_web_application_context_attribute, null);
        // <4.1> 添加一个 applicationcontextinitializer 初始器，
        // 用于设置现在要创建的 root applicationcontext 应用上下文的父容器为 `parent`
        builder.initializers(new parentcontextapplicationcontextinitializer(parent));
    }
    /**
     * <5> 添加一个 applicationcontextinitializer 初始器
     * 目的是往 servletcontext 上下文中设置 root applicationcontext 为现在要创建的 root applicationcontext 应用上下文
     * 并将这个 servletcontext 保存至 applicationcontext 中，参考 {@link servletwebserverapplicationcontext#createwebserver()} 方法，
     * 如果获取到了 servletcontext 那么直接调用其 {@link servletwebserverapplicationcontext#selfinitialize} 方法来注册各个 servlet、filter
     * 例如 {@link dispatcherservlet}
     */
    builder.initializers(new servletcontextapplicationcontextinitializer(servletcontext));
    // <6> 设置要创建的 root applicationcontext 应用上下文的类型（servlet）
    builder.contextclass(annotationconfigservletwebserverapplicationcontext.class);
    // <7> 对 springapplicationbuilder 进行扩展
    builder = configure(builder);
    // <8> 添加一个 applicationlistener 监听器
    // 用于将 servletcontext 中的相关属性关联到 environment 环境中
    builder.listeners(new webenvironmentpropertysourceinitializer(servletcontext));
    // <9> 构建一个 springapplication 对象，用于启动 spring 应用
    springapplication application = builder.build();
    // <10> 如果没有设置 `source` 源对象，那么这里尝试设置为当前 class 对象，需要有 `@configuration` 注解
    if (application.getallsources().isempty()
            && mergedannotations.from(getclass(), searchstrategy.type_hierarchy).ispresent(configuration.class)) {
        application.addprimarysources(collections.singleton(getclass()));
    }
    // <11> 因为 springapplication 在创建 applicationcontext 应用上下文的过程中需要优先注册 `source` 源对象，如果为空则抛出异常
    assert.state(!application.getallsources().isempty(),
            "no springapplication sources have been defined. either override the "
                    + "configure method or add an @configuration annotation");
    // ensure error pages are registered
    if (this.registererrorpagefilter) {
        // <12> 添加一个错误页面 filter 作为 `sources`
        application.addprimarysources(collections.singleton(errorpagefilterconfiguration.class));
    }
    // <13> 调用 `application` 的 `run` 方法启动整个 spring boot 应用
    return run(application);
}

过程如下：

1. 创建一个 springapplication 构造器，目的就是启动 spring 应用咯

   protected springapplicationbuilder createspringapplicationbuilder() {
       return new springapplicationbuilder();
   }
   

2. 设置 mainapplicationclass，也就是你的启动类，主要用于打印日志

3. 从 servletcontext 上下文中获取最顶部的 root applicationcontext 应用上下文 parent，通常这里没有父对象，所以为空

4. 如果 parent 不为空，则先 servletcontext 中的该属性置空，因为这里会创建一个 applicationcontext 作为 root

   1. 添加一个 applicationcontextinitializer 初始器，用于设置现在要创建的 root applicationcontext 应用上下文的父容器为 parent

5. 添加一个 applicationcontextinitializer 初始器，目的是往 servletcontext 上下文中设置 root applicationcontext 为现在要创建的 root applicationcontext 应用上下文，并将这个 servletcontext 保存至 applicationcontext 中

   注意，这个对象很关键，会将当前 servletcontext 上下文对象设置到 applicationcontext 对象里面，那么后续就不会再创建 spring boot 内嵌的 tomcat 了

6. 设置要创建的 root applicationcontext 应用上下文的类型（servlet）

7. 对 springapplicationbuilder 进行扩展，调用 configure(springapplicationbuilder) 方法，这也就是为什么我们的启动类可以重写该方法，通常不用做什么

8. 添加一个 applicationlistener 监听器，用于将 servletcontext 中的相关属性关联到 environment 环境中

9. 构建一个 springapplication 对象 application，用于启动 spring 应用

10. 如果没有设置 source 源对象，那么这里尝试设置为当前 class 对象，需要有 @configuration 注解

11. 因为 springapplication 在创建 applicationcontext 应用上下文的过程中需要优先注册 source 源对象，如果为空则抛出异常

12. 添加一个错误页面 filter 作为 sources

13. 调用 application 的 run 方法启动整个 spring boot 应用

整个过程不复杂，springapplication 相关的内容在前面的 《springapplication 启动类的启动过程》文章中已经分析过，这里的关键在于第 5 步

添加的 servletcontextapplicationcontextinitializer 会将当前 servletcontext 上下文对象设置到 applicationcontext 对象里面

servletcontextapplicationcontextinitializer

public class servletcontextapplicationcontextinitializer
		implements applicationcontextinitializer<configurablewebapplicationcontext>, ordered {

	private int order = ordered.highest_precedence;

	private final servletcontext servletcontext;

	private final boolean addapplicationcontextattribute;

	public servletcontextapplicationcontextinitializer(servletcontext servletcontext) {
		this(servletcontext, false);
	}

	public servletcontextapplicationcontextinitializer(servletcontext servletcontext,
			boolean addapplicationcontextattribute) {
		this.servletcontext = servletcontext;
		this.addapplicationcontextattribute = addapplicationcontextattribute;
	}

	public void setorder(int order) {
		this.order = order;
	}

	@override
	public int getorder() {
		return this.order;
	}

	@override
	public void initialize(configurablewebapplicationcontext applicationcontext) {
		// 将这个 servletcontext 上下文对象设置到 applicationcontext 中
		applicationcontext.setservletcontext(this.servletcontext);
		if (this.addapplicationcontextattribute) {
			this.servletcontext.setattribute(webapplicationcontext.root_web_application_context_attribute,
					applicationcontext);
		}
	}
}

可以看到会将这个 servletcontext 上下文对象设置到 applicationcontext 中

那么我们回顾到上一篇 《spring boot 内嵌 tomcat 容器的实现》 文章的 1. onrefresh 方法小节调用的 createwebserver() 方法，如下：

// servletwebserverapplicationcontext.java
private void createwebserver() {
    // <1> 获取当前 `webserver` 容器对象，首次进来为空
    webserver webserver = this.webserver;
    // <2> 获取 `servletcontext` 上下文对象
    servletcontext servletcontext = getservletcontext();
    // <3> 如果 webserver 和 servletcontext 都为空，则需要创建一个
    // 使用 spring boot 内嵌 tomcat 容器则会进入该分支
    if (webserver == null && servletcontext == null) {
        // <3.1> 获取 servlet 容器工厂对象（默认为 tomcat）`factory`
        servletwebserverfactory factory = getwebserverfactory();
        /**
         * <3.2> 先创建一个 {@link servletcontextinitializer} servlet 上下文初始器，实现也就是当前类的 {@link this#selfinitialize(servletcontext)} 方法
         * 至于为什么不用 servlet 3.0 新增的 {@link javax.servlet.servletcontainerinitializer} 这个类，我在
         * [精尽spring mvc源码分析 - 寻找遗失的 web.xml](https://www.cnblogs.com/lifullmoon/p/14122704.html)有提到过
         *
         * <3.3> 从 `factory` 工厂中创建一个 webserver 容器对象
         * 例如创建一个 {@link tomcatwebserver} 容器对象，并初始化 `servletcontext` 上下文，创建 {@link tomcat} 容器并启动
         * 启动过程异步触发了 {@link org.springframework.boot.web.embedded.tomcat.tomcatstarter#onstartup} 方法
         * 也就会调用这个传入的 {@link servletcontextinitializer} 的 {@link #selfinitialize(servletcontext)} 方法
         */
        this.webserver = factory.getwebserver(getselfinitializer());
    }
    // <4> 否则，如果 servletcontext 不为空，说明使用了外部的 servlet 容器（例如 tomcat）
    else if (servletcontext != null) {
        try {
            /** 那么这里主动调用 {@link this#selfinitialize(servletcontext)} 方法来注册各种 servlet、filter */
            getselfinitializer().onstartup(servletcontext);
        }
        catch (servletexception ex) {
            throw new applicationcontextexception("cannot initialize servlet context", ex);
        }
    }
    // <5> 将 servletcontext 的一些初始化参数关联到当前 spring 应用的 environment 环境中
    initpropertysources();
}

我们看到上面第 4 步，如果从当前 spring 应用上下文获取到了 servletcontext 对象，不会走上面的第 3 步，也就是不创建 spring boot 内嵌的 tomcat

主动调用它的 getselfinitializer() 方法来往这个 servletcontext 对象中注册各种 servlet、filter 和 eventlistener 对象，包括 spring mvc 中的 dispatcherservlet 对象，该方法参考上一篇 《spring boot 内嵌 tomcat 容器的实现》 文章的 2. selfinitialize 方法 小节

总结

本文分析了 spring boot 应用被打成 war 包后是如何支持放入外部 tomcat 容器运行的，原理也比较简单，借助 spring mvc 中的 springservletcontainerinitializer 这个类，它实现了 servlet 3.0 新增的 javax.servlet.servletcontainerinitializer 接口

1. 通过 java 的 spi 机制，在 meta-inf/services/javax.servlet.servletcontainerinitializer 文件中写入 springservletcontainerinitializer 这个类，那么在 servlet 容器启动的时候会调用这个类的 onstartup(..) 方法，会找到 webapplicationinitializer 类型的对象，并调用他们的 onstartup(servletcontext) 方法

2. 在我们的 spring boot 应用中，如果需要打成 war 包放入外部 tomcat 容器运行，启动类则需要继承 springbootservletinitializer 抽象类，它实现了 webapplicationinitializer 接口

3. 在 springbootservletinitializer 中会创建一个 webapplicationcontext 作为 root spring 应用上下文，同时会将 servletcontext 对象设置到 spring 应用上下文中

4. 这样一来，因为已经存在 servletcontext 对象，那么不会再创建 spring boot 内嵌的 tomcat 容器，而是对 servletcontext 进行一些初始化工作

好了，到这里关于 spring boot 启动 spring 应用的整个主流程，包括内嵌 tomcat 容器的实现，以及支持运行在外部 servlet 容器的实现都分析完了

那么接下来，我们一起来看看 @springbootapplication 这个注解，也就是 @enableautoconfiguration 自动配置注解的实现原理