SpringBoot内置tomcat启动过程及原理

电玩女神 2023-09-23 18:24 54阅读 0赞

### 1 背景 ###

SpringBoot 是一个框架，一种全新的编程规范，他的产生简化了框架的使用，同时也提供了很多便捷的功能，比如内置 tomcat 就是其中一项，他让我们省去了搭建 tomcat 容器，生成 war，部署，启动 tomcat。因为内置了启动容器，应用程序可以直接通过 Maven 命令将项目编译成可执行的 jar 包，通过 java -jar 命令直接启动，不需要再像以前一样，打包成 War 包，然后部署在 Tomcat 中。那么内置 tomcat 是如何实现的呢

### 2 tomcat 启动过程及原理 ###

2.1 下载一个 springboot 项目

在这里下载一个项目 [start.spring.io/][start.spring.io] 也可以在 idea 新建 SpringBoot-Web 工程.

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    复制代码

点击 pom.xml 会有 tomcat 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>2.1.2.RELEASE</version>
    <scope>compile</scope>
    </dependency>
    复制代码

2.2 从启动入口开始一步步探索

![format_png][]

点击进入 run 方法

public static ConfigurableApplicationContext run(Class<?> primarySource,
    String... args) {
    return run(new Class<?>[] { primarySource }, args);
    }
    
    //继续点击进入run方法
    public static ConfigurableApplicationContext run(Class<?>[] primarySources,
    String[] args) {
    return new SpringApplication(primarySources).run(args);
    }
    复制代码

进入到这个 run 方法之后就可以看到，我们认识的一些初始化事件。主要的过程也是在这里完成的。

![format_png 1][]

2.3 源码代码流程大致是这样

/**
    * Run the Spring application, creating and refreshing a new
    * {@link ApplicationContext}.
    * @param args the application arguments (usually passed from a Java main method)
    * @return a running {@link ApplicationContext}
    */
    public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    /**1、配置系统属性*/
    configureHeadlessProperty();
    /**2.获取监听器*/
    SpringApplicationRunListeners listeners = getRunListeners(args);
    /**发布应用开始启动事件 */
    listeners.starting();
    try {
    /** 3.初始化参数 */
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(
    args);
    /** 4.配置环境*/
    ConfigurableEnvironment environment = prepareEnvironment(listeners,
    applicationArguments);
    
    configureIgnoreBeanInfo(environment);
    Banner printedBanner = printBanner(environment);
    /**5.创建应用上下文*/
    context = createApplicationContext();
    exceptionReporters = getSpringFactoriesInstances(
    SpringBootExceptionReporter.class,
    new Class[] { ConfigurableApplicationContext.class }, context);
    /**6.预处理上下文*/
    prepareContext(context, environment, listeners, applicationArguments,
    printedBanner);
    
    /**6.刷新上下文*/
    refreshContext(context);
    afterRefresh(context, applicationArguments);
    stopWatch.stop();
    if (this.logStartupInfo) {
    new StartupInfoLogger(this.mainApplicationClass)
    .logStarted(getApplicationLog(), stopWatch);
    }
    /** 8.发布应用已经启动事件 */
    listeners.started(context);
    callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
    handleRunFailure(context, ex, exceptionReporters, listeners);
    throw new IllegalStateException(ex);
    }
    
    try {
    /** 9.发布应用已经启动完成的监听事件 */
    listeners.running(context);
    }
    catch (Throwable ex) {
    handleRunFailure(context, ex, exceptionReporters, null);
    throw new IllegalStateException(ex);
    }
    return context;
    }
    复制代码

![format_png 2][]

![format_png 3][]

代码中主要就是通过 switch 语句，根据 webApplicationType 的类型来创建不同的 ApplicationContext：

*  DEFAULT\_SERVLET\_WEB\_CONTEXT\_CLASS：Web 类型，实例化 AnnotationConfigServletWebServerApplicationContext
 *  DEFAULT\_REACTIVE\_WEB\_CONTEXT\_CLASS：响应式 Web 类型，实例化 AnnotationConfigReactiveWebServerApplicationContext
 *  DEFAULT\_CONTEXT\_CLASS：非 Web 类型，实例化 AnnotationConfigApplicationContext

2.4 创建完应用上下文之后，我们在看刷新上下文方法

![format_png 4][]

一步步通过断点点击方法进去查看，我们看到很熟悉代码 spring 的相关代码。

![format_png 5][]

@Override
    public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
    // Prepare this context for refreshing.
    //初始化前的准备工作，主要是一些系统属性、环境变量的校验，比如Spring启动需要某些环境变量，可以在这个地方进行设置和校验
    prepareRefresh();
    
    // Tell the subclass to refresh the internal bean factory.
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    // Prepare the bean factory for use in this context.
    //准备bean工厂 注册了部分类
    prepareBeanFactory(beanFactory);
    
    try {
    // Allows post-processing of the bean factory in context subclasses.
    postProcessBeanFactory(beanFactory);
    
    // Invoke factory processors registered as beans in the context.
    //注册bean工厂后置处理器，并解析java代码配置bean定义
    invokeBeanFactoryPostProcessors(beanFactory);
    
    // Register bean processors that intercept bean creation.
    //注册bean后置处理器，并不会执行后置处理器，在后面实例化的时候执行
    registerBeanPostProcessors(beanFactory);
    
    // Initialize message source for this context.
    initMessageSource();
    
    // Initialize event multicaster for this context.
    //初始化事件监听多路广播器
    initApplicationEventMulticaster();
    
    // Initialize other special beans in specific context subclasses.
    //待子类实现，springBoot在这里实现创建内置的tomact容器
    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();
    }
    }
    }
    复制代码

2.5 onRefresh () 方法是调用其子类实现的

也就是 ServletWebServerApplicationContext

![format_png 6][]

![format_png 7][]

/** 得到Servlet工厂 **/
    this.webServer = factory.getWebServer(getSelfInitializer());
    复制代码

其中 createWebServer () 方法是用来启动 web 服务的，但是还没有真正启动 Tomcat，只是通过 ServletWebServerFactory 创建了一个 WebServer，继续来看这个 ServletWebServerFactory：

this.webServer = factory.getWebServer (getSelfInitializer ()); 这个方法可以看出 TomcatServletWebServerFactory 的实现。相关 Tomcat 的实现。

2.6 TomcatServletWebServerFactory 的 getWebServer () 方法

清晰的看到 new 出来了一个 Tomcat.

![format_png 8][]

2.7 Tomcat 创建之后，继续分析 Tomcat 的相关设置和参数

@Override
    public WebServer getWebServer(ServletContextInitializer... initializers) {
    
    /** 1、创建Tomcat实例 **/
    Tomcat tomcat = new Tomcat();
    //创建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);
    /** 2、给创建好的tomcat设置连接器connector **/
    tomcat.setConnector(connector);
    /** 3.设置不自动部署 **/
    tomcat.getHost().setAutoDeploy(false);
    /** 4.配置Tomcat容器引擎 **/
    configureEngine(tomcat.getEngine());
    for (Connector additionalConnector : this.additionalTomcatConnectors) {
    tomcat.getService().addConnector(additionalConnector);
    }
    /**准备Tomcat的StandardContext，并添加到Tomcat中*/
    prepareContext(tomcat.getHost(), initializers);
    /** 将创建好的Tomcat包装成WebServer返回**/
    return getTomcatWebServer(tomcat);
    }
    复制代码

2.8 继续点击 getTomcatWebServer 方法，找到 initialize () 方法，可以看到 tomcat.start (); 启动 tomcat 服务方法。

![format_png 9][]

![format_png 10][]

// Start the server to trigger initialization listeners
    //启动tomcat服务
    this.tomcat.start();
    //开启阻塞非守护进程
    startDaemonAwaitThread();
    复制代码

//Tomcat.java

![format_png 11][]

![format_png 12][]

2.9 TomcatWebServer.java 控制台会打印这句话

Tomcat started on port(s): 8080 (http) with context path ‘’

![format_png 13][]

![format_png 14][]

### 3 总结 ###

SpringBoot 的启动主要是通过实例化 SpringApplication 来启动的，启动过程主要做了如下几件事情：

配置系统属性、获取监听器，发布应用开始启动事件、初始化参数、配置环境、创建应用上下文、预处理上下文、刷新上下文、再次刷新上下文、发布应用已经启动事件、发布应用启动完成事件。而启动 Tomcat 是刷新上下文 这一步。

Spring Boot 创建 Tomcat 时，会先创建一个上下文，将 WebApplicationContext 传给 Tomcat；

启动 Web 容器，需要调用 getWebserver ()，因为默认的 Web 环境就是 TomcatServletWebServerFactory，所以会创建 Tomcat 的 Webserver，这里会把根上下文作为参数给 TomcatServletWebServerFactory 的 getWebServer ()；启动 Tomcat，调用 Tomcat 中 Host、Engine 的启动方法。

3.1 Tomcat 相关名称介绍

![format_png 15][]

[start.spring.io]: https://link.juejin.cn?target=https%3A%2F%2Fwww.oschina.net%2Faction%2FGoToLink%3Furl%3Dhttps%253A%252F%252Fstart.spring.io%252F
[format_png]: https://img-blog.csdnimg.cn/img_convert/248ed2ee03c3c7b73d4f769be03b2b50.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/776cf7d09375308b7ae788b9aea6a6b9.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/a2a1c0f0930fbcf573a24775ed82d398.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/5d09f1d8dc806ac79bb623da5ffaa248.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/3c40ccd1a2f7df60913115d21891f095.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/b444a5a856bbc53cd74e990742650f38.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/d6f4309b4d2b98671ad8929e00c6d66d.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/28992f3b495b8453406d848541b8da57.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/946c8076f41a48b567f6165ea68c4370.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/d49b67083af44d72e5191125a17c0860.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/63478ed6e1d47af6dc503ff3713f1f81.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/da1ae08f8c59cde8739f58d05c34491c.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/1937f59f08b4e694efd5f62afebe4d10.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/0cc6b70e31d02e4bba2768581bb8e8b1.webp?x-oss-process=image/format,png
[format_png 14]: https://img-blog.csdnimg.cn/img_convert/13e7e58dd20ca9edcd4a3e5f7cf38706.webp?x-oss-process=image/format,png
[format_png 15]: https://img-blog.csdnimg.cn/img_convert/cd991b07e5c7f6a83ebe1a6cca9719dd.webp?x-oss-process=image/format,png