SpringBoot源码分析-启动过程经历了什么？

迈不过友情╰ 2021-09-29 01:04 367阅读 0赞

## SpringBoot源码分析-启动过程经历了什么？ ##

### 文章目录 ###

*   *  SpringBoot源码分析-启动过程经历了什么？
     *  前言
     *  启动概况
     *  测试项目
     *  项目主类分析
     *  分析执行过程
     *   *  1、SpringApplication.run 标识spring的初始执行
         *  创建应用上下文
         *  准备异常报告器
         *  准备应用上下文
     *  刷新应用上下文

## 前言 ##

[Spring Boot实战学习：1、Spring Boot介绍  
][Spring Boot_1_Spring Boot_]

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。  
有以下特点：

1.  创建独立的Spring应用程序
2.  嵌入的Tomcat，无需部署WAR文件
3.  简化Maven配置
4.  自动配置Spring
5.  提供生产就绪型功能，如指标，健康检查和外部配置

下面我们从源码的级别来探究spring boot框架的启动原理，让我们从启动过程上去理解spring boot如何通过启动来获得强大的特性的。

## 启动概况 ##

概述下主要的启动过程就是

1.  初始化环境
2.  初始化默认配置
3.  初始化各类监听器、事件
4.  创建上下文
5.  在上下文中添加默认的bean
6.  扫描文件、注解等各种类型的bean添加在上下文中
7.  实例化各个bean
8.  启动完毕

## 测试项目 ##

测试项目maven配置

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.1.5.RELEASE</version>
    		<relativePath/> 
    	</parent>
    	<groupId>com.example</groupId>
    	<artifactId>demo</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>demo</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-configuration-processor</artifactId>
    			<optional>true</optional>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>

## 项目主类分析 ##

package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class DemoApplication { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(DemoApplication.class, args);
    	}
    
    }

大家知道springboot的工程是从一个main方法进行配置开发的，应用启动也是从这里进行，起始任何的java程序都是从main方法开发，只是有时方法被隐藏了，我们看不到内部实现。

这里我们从@SpringBootApplication注解开发：

@Target(ElementType.TYPE)            // 注解的适用范围，其中TYPE用于描述类、接口（包括包注解类型）或enum声明
    @Retention(RetentionPolicy.RUNTIME)  // 注解的生命周期，保留到class文件中（三个生命周期）
    @Documented                          // 表明这个注解应该被javadoc记录
    @Inherited                           // 子类可以继承该注解
    @SpringBootConfiguration             // 继承了Configuration，表示当前是注解类
    @EnableAutoConfiguration             // 开启springboot的注解功能，springboot的四大神器之一，其借助@import的帮助
    @ComponentScan(excludeFilters = {     // 扫描路径设置（具体使用待确认）
            @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
            @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication { 
    ...
    }

该注解是一个混合注解，可以标识main类的属性，在main方法启动后，进行相应class加载时候进行对应class文件注解扫描，当扫描到相应注解时候，判断注解属性让程序做一些特定的事情。

main方法中，只有一行执行代码 SpringApplication.run(DemoApplication.class, args);  
那程序的初始化过程也应该在方法里面。

spring boot 启动日志

/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/bin/java -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:63595,suspend=y,server=n -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true -javaagent:/Users/public1/Library/Caches/IntelliJIdea2019.1/captureAgent/debugger-agent.jar -Dfile.encoding=UTF-8 -classpath "/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/charsets.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/deploy.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/jfxrt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/sunjce_provider.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/sunpkcs11.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/ext/zipfs.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/javaws.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/jce.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/jfr.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/jfxswt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/jsse.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/management-agent.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/plugin.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/resources.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/jre/lib/rt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/ant-javafx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/dt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/javafx-mx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/jconsole.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/packager.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/sa-jdi.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home/lib/tools.jar:/Users/public1/Documents/git/demo/target/classes:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-starter/2.1.5.RELEASE/spring-boot-starter-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot/2.1.5.RELEASE/spring-boot-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/spring-context/5.1.7.RELEASE/spring-context-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-autoconfigure/2.1.5.RELEASE/spring-boot-autoconfigure-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-starter-logging/2.1.5.RELEASE/spring-boot-starter-logging-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar:/Users/public1/.m2/repository/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar:/Users/public1/.m2/repository/org/apache/logging/log4j/log4j-to-slf4j/2.11.2/log4j-to-slf4j-2.11.2.jar:/Users/public1/.m2/repository/org/apache/logging/log4j/log4j-api/2.11.2/log4j-api-2.11.2.jar:/Users/public1/.m2/repository/org/slf4j/jul-to-slf4j/1.7.26/jul-to-slf4j-1.7.26.jar:/Users/public1/.m2/repository/javax/annotation/javax.annotation-api/1.3.2/javax.annotation-api-1.3.2.jar:/Users/public1/.m2/repository/org/springframework/spring-core/5.1.7.RELEASE/spring-core-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/spring-jcl/5.1.7.RELEASE/spring-jcl-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/yaml/snakeyaml/1.23/snakeyaml-1.23.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-starter-web/2.1.5.RELEASE/spring-boot-starter-web-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-starter-json/2.1.5.RELEASE/spring-boot-starter-json-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/com/fasterxml/jackson/core/jackson-databind/2.9.8/jackson-databind-2.9.8.jar:/Users/public1/.m2/repository/com/fasterxml/jackson/core/jackson-annotations/2.9.0/jackson-annotations-2.9.0.jar:/Users/public1/.m2/repository/com/fasterxml/jackson/core/jackson-core/2.9.8/jackson-core-2.9.8.jar:/Users/public1/.m2/repository/com/fasterxml/jackson/datatype/jackson-datatype-jdk8/2.9.8/jackson-datatype-jdk8-2.9.8.jar:/Users/public1/.m2/repository/com/fasterxml/jackson/datatype/jackson-datatype-jsr310/2.9.8/jackson-datatype-jsr310-2.9.8.jar:/Users/public1/.m2/repository/com/fasterxml/jackson/module/jackson-module-parameter-names/2.9.8/jackson-module-parameter-names-2.9.8.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-starter-tomcat/2.1.5.RELEASE/spring-boot-starter-tomcat-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/org/apache/tomcat/embed/tomcat-embed-core/9.0.19/tomcat-embed-core-9.0.19.jar:/Users/public1/.m2/repository/org/apache/tomcat/embed/tomcat-embed-el/9.0.19/tomcat-embed-el-9.0.19.jar:/Users/public1/.m2/repository/org/apache/tomcat/embed/tomcat-embed-websocket/9.0.19/tomcat-embed-websocket-9.0.19.jar:/Users/public1/.m2/repository/org/hibernate/validator/hibernate-validator/6.0.16.Final/hibernate-validator-6.0.16.Final.jar:/Users/public1/.m2/repository/javax/validation/validation-api/2.0.1.Final/validation-api-2.0.1.Final.jar:/Users/public1/.m2/repository/org/jboss/logging/jboss-logging/3.3.2.Final/jboss-logging-3.3.2.Final.jar:/Users/public1/.m2/repository/com/fasterxml/classmate/1.4.0/classmate-1.4.0.jar:/Users/public1/.m2/repository/org/springframework/spring-web/5.1.7.RELEASE/spring-web-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/spring-beans/5.1.7.RELEASE/spring-beans-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/spring-webmvc/5.1.7.RELEASE/spring-webmvc-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/spring-aop/5.1.7.RELEASE/spring-aop-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/spring-expression/5.1.7.RELEASE/spring-expression-5.1.7.RELEASE.jar:/Users/public1/.m2/repository/org/springframework/boot/spring-boot-configuration-processor/2.1.5.RELEASE/spring-boot-configuration-processor-2.1.5.RELEASE.jar:/Users/public1/.m2/repository/org/slf4j/slf4j-api/1.7.26/slf4j-api-1.7.26.jar:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar" com.example.demo.DemoApplication
    Connected to the target VM, address: '127.0.0.1:63595', transport: 'socket'
    
      .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::        (v2.1.5.RELEASE)
    
    2019-06-19 17:20:37.736  INFO 2330 --- [           main] com.example.demo.DemoApplication         : Starting DemoApplication on publics-MacBook-Pro.local with PID 2330 (/Users/public1/Documents/git/demo/target/classes started by public1 in /Users/public1/Documents/git/demo)
    2019-06-19 17:20:37.740  INFO 2330 --- [           main] com.example.demo.DemoApplication         : No active profile set, falling back to default profiles: default
    2019-06-19 17:25:56.321  INFO 2330 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8082 (http)
    2019-06-19 17:25:59.427  INFO 2330 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
    2019-06-19 17:25:59.428  INFO 2330 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.19]
    2019-06-19 17:26:01.090  INFO 2330 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
    2019-06-19 17:26:01.090  INFO 2330 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 8274 ms
    2019-06-19 17:26:01.266  INFO 2330 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
    2019-06-19 17:26:01.414  INFO 2330 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8082 (http) with context path ''
    2019-06-19 17:26:06.376  INFO 2330 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 1854.489 seconds (JVM running for 1936.518)

## 分析执行过程 ##

### 1、SpringApplication.run 标识spring的初始执行 ###

SpringApplication.java

/** * Static helper that can be used to run a {@link SpringApplication} from the * specified source using default settings. * @param primarySource the primary source to load * @param args the application arguments (usually passed from a Java main method) * @return the running {@link ApplicationContext} */
    	public static ConfigurableApplicationContext run(Class<?> primarySource,
    			String... args) { 
    		return run(new Class<?>[] {  primarySource }, args);
    	}

上述过程调用了`org.springframework.boot.SpringApplication`类的run方法，返回一个ConfigurableApplicationContext对象。

接下来，执行内部的run方法：

/** * Static helper that can be used to run a {@link SpringApplication} from the * specified sources using default settings and user supplied arguments. * @param primarySources the primary sources to load * @param args the application arguments (usually passed from a Java main method) * @return the running {@link ApplicationContext} */
    	public static ConfigurableApplicationContext run(Class<?>[] primarySources,
    			String[] args) { 
    		return new SpringApplication(primarySources).run(args);
    	}

这里通过创建SpringApplication对象，去执行该对象run方法，并返回了一个ConfigurableApplicationContext对象。

SpringApplication类到底是干什么呢？

接着，进入到SpringApplication类后，该类class上有说明如下：

Class that can be used to bootstrap and launch a Spring application from a Java main method. By default class will perform the following steps to bootstrap your application

*  1、Create an appropriate \{@link ApplicationContext\} instance (depending on your classpath)
 *  2、 Register a \{@link CommandLinePropertySource\} to expose command line arguments as Spring properties
 *  3、Refresh the application context, loading all singleton beans
 *  4、Trigger any \{@link CommandLineRunner\} beans

大意就是该类主要用main方法启动一个spring 应用，将会经历一下步骤去启动你的应用：  
1、通过classpath创建一个合适的ApplicationContext实例（也就是spring 容器）  
2、注册一个CommandLinePropertySource去执行命令行参数  
3、刷新应用上下文，加载单例bean  
4、触发所有的CommandLineRunner beans

ConfigurableApplicationContext类又是干什么呢？

我们查看了ConfigurableApplicationContext的类注释，还有它一些方法。  
大概知道是spring 应用的一个上下文环境配置context

/** * SPI interface to be implemented by most if not all application contexts. * Provides facilities to configure an application context in addition * to the application context client methods in the * {@link org.springframework.context.ApplicationContext} interface. * * <p>Configuration and lifecycle methods are encapsulated here to avoid * making them obvious to ApplicationContext client code. The present * methods should only be used by startup and shutdown code. * * @author Juergen Hoeller * @author Chris Beams * @since 03.11.2003 */
    public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70]

接下来是SpringApplication的run方法，这个方法做了哪些事情呢？

SpringApplication的run方法：

/** * 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) { 
        // 1、创建并启动计时监控类，用于启动耗时计算
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
    
        // 2、初始化应用上下文和异常报告集合
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    
        // 3、设置系统属性 `java.awt.headless` 的值，默认值为：true
        configureHeadlessProperty();
    
        // 4、创建所有 Spring 运行监听器并发布应用启动事件
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
    
        try { 
            // 5、初始化默认应用参数类
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
    
            // 6、根据运行监听器和应用参数来准备 Spring 环境
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            configureIgnoreBeanInfo(environment);
    
            // 7、创建 Banner 打印类
            Banner printedBanner = printBanner(environment);
    
            // 8、创建应用上下文
            context = createApplicationContext();
    
            // 9、准备异常报告器
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] {  ConfigurableApplicationContext.class }, context);
    
            // 10、准备应用上下文
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
    
            // 11、刷新应用上下文，在这里会启动web容器如tomcat 
            refreshContext(context);
    
            // 12、应用上下文刷新后置处理
            afterRefresh(context, applicationArguments);
    
            // 13、停止计时监控类，计算启动耗时。
            stopWatch.stop();
    
            // 14、输出日志记录执行主类名、时间信息
            if (this.logStartupInfo) { 
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
    
            // 15、发布应用上下文启动完成事件
            listeners.started(context);
    
            // 16、执行所有 Runner 运行器 如如果有ApplicationRunner或者CommandLineRunner类型的bean，则触发run函数，启动任务。
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) { 
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }
    
        try { 
            // 17、发布应用上下文就绪事件
            listeners.running(context);
        }
        catch (Throwable ex) { 
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
    
        // 18、返回应用上下文
        return context;
    }

下面重点介绍重要的方法执行过程：

### 创建应用上下文 ###

context = createApplicationContext();

createApplicationContext的方法如下：

/** * Strategy method used to create the {@link ApplicationContext}. By default this * method will respect any explicitly set application context or application context * class before falling back to a suitable default. * @return the application context (not yet refreshed) * @see #setApplicationContextClass(Class) */
    	protected ConfigurableApplicationContext createApplicationContext() { 
    		Class<?> contextClass = this.applicationContextClass;
    		if (contextClass == null) { 
    			try { 
    				switch (this.webApplicationType) { 
    				case SERVLET:
    					contextClass = Class.forName(DEFAULT_SERVLET_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);
    	}

该方法内部相应的静态变量如下：

/** * The class name of application context that will be used by default for non-web * environments. */
    	public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
    			+ "annotation.AnnotationConfigApplicationContext";
    
    	/** * The class name of application context that will be used by default for web * environments. */
    	public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
    			+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
    
    	/** * The class name of application context that will be used by default for reactive web * environments. */
    	public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
    			+ "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";

通过执行过程可知道，通过判断webApplicationType的类型，是获得相应web容器实现类

可能会出现三种结果：  
SERVLET 时候org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext

REACTIVE 会获得class org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext

default 会获得class：  
org.springframework.context.annotation.AnnotationConfigApplicationContext

而AnnotationConfigServletWebServerApplicationContext的一个类关系图如下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 1]

### 准备异常报告器 ###

getSpringFactoriesInstances方法

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) { 
        return getSpringFactoriesInstances(type, new Class<?>[] { });
    }
    
    // 这里的入参type就是ApplicationContextInitializer.class
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
            Class<?>[] parameterTypes, Object... args) { 
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // 使用Set保存names来避免重复元素
        Set<String> names = new LinkedHashSet<>(
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 根据names来进行实例化
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                classLoader, args, names);
        // 对实例进行排序
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

SpringFactoriesLoader.loadFactoryNames(type, classLoader)) 过程：

/** * Load the fully qualified class names of factory implementations of the * given type from {@value #FACTORIES_RESOURCE_LOCATION}, using the given * class loader. * @param factoryClass the interface or abstract class representing the factory * @param classLoader the ClassLoader to use for loading resources; can be * {@code null} to use the default * @throws IllegalArgumentException if an error occurs while loading factory names * @see #loadFactories */
    	public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) { 
    		String factoryClassName = factoryClass.getName();
    		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    	}
    
    	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { 
    		MultiValueMap<String, String> result = cache.get(classLoader);
    		if (result != null) { 
    			return result;
    		}
    
    		try { 
    			Enumeration<URL> urls = (classLoader != null ?
    					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
    					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
    			result = new LinkedMultiValueMap<>();
    			while (urls.hasMoreElements()) { 
    				URL url = urls.nextElement();
    				UrlResource resource = new UrlResource(url);
    				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
    				for (Map.Entry<?, ?> entry : properties.entrySet()) { 
    					String factoryClassName = ((String) entry.getKey()).trim();
    					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) { 
    						result.add(factoryClassName, factoryName.trim());
    					}
    				}
    			}
    			cache.put(classLoader, result);
    			return result;
    		}
    		catch (IOException ex) { 
    			throw new IllegalArgumentException("Unable to load factories from location [" +
    					FACTORIES_RESOURCE_LOCATION + "]", ex);
    		}
    	}
    
    
    //FACTORIES_RESOURCE_LOCATION
    /** * The location to look for factories. * <p>Can be present in multiple JAR files. */
    	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

这个方法会尝试从类路径的META-INF/spring.factories处读取相应配置文件，然后进行遍历，读取配置文件中Key为：org.springframework.context.ApplicationContextInitializer的value。以spring-boot-autoconfigure这个包为例，它的META-INF/spring.factories部分定义如下所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 2]

META-INF/spring.factories内容：

# Initializers
    org.springframework.context.ApplicationContextInitializer=\
    org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
    org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
    
    # Application Listeners
    org.springframework.context.ApplicationListener=\
    org.springframework.boot.autoconfigure.BackgroundPreinitializer
    
    # Auto Configuration Import Listeners
    org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
    org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener
    
    # Auto Configuration Import Filters
    org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
    org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
    org.springframework.boot.autoconfigure.condition.OnClassCondition,\
    org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition
    
    # Auto Configure
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
    org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
    org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
    org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
    org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
    org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
    org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
    org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
    org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
    org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
    org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
    org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
    org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
    org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
    org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
    org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
    org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
    org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
    org.springframework.boot.autoconfigure.reactor.core.ReactorCoreAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityRequestMatcherProviderAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
    org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
    org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
    org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
    org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
    org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
    org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration
    
    # Failure analyzers
    org.springframework.boot.diagnostics.FailureAnalyzer=\
    org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzer,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceBeanCreationFailureAnalyzer,\
    org.springframework.boot.autoconfigure.jdbc.HikariDriverConfigurationFailureAnalyzer,\
    org.springframework.boot.autoconfigure.session.NonUniqueSessionRepositoryFailureAnalyzer
    
    # Template availability providers
    org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider=\
    org.springframework.boot.autoconfigure.freemarker.FreeMarkerTemplateAvailabilityProvider,\
    org.springframework.boot.autoconfigure.mustache.MustacheTemplateAvailabilityProvider,\
    org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAvailabilityProvider,\
    org.springframework.boot.autoconfigure.thymeleaf.ThymeleafTemplateAvailabilityProvider,\
    org.springframework.boot.autoconfigure.web.servlet.JspTemplateAvailabilityProvider

### 准备应用上下文 ###

prepareContext(context,environment,listeners,applicationArguments,printedBanner);

prepareContext方法：

private void prepareContext(ConfigurableApplicationContext context,
    			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
    			ApplicationArguments applicationArguments, Banner printedBanner) { 
    		context.setEnvironment(environment);
    		postProcessApplicationContext(context);
    		applyInitializers(context);
    		listeners.contextPrepared(context);
    		if (this.logStartupInfo) { 
    			logStartupInfo(context.getParent() == null);
    			logStartupProfileInfo(context);
    		}
    		// Add boot specific singleton beans
    		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    		if (printedBanner != null) { 
    			beanFactory.registerSingleton("springBootBanner", printedBanner);
    		}
    		if (beanFactory instanceof DefaultListableBeanFactory) { 
    			((DefaultListableBeanFactory) beanFactory)
    					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    		}
    		// Load the sources
    		Set<Object> sources = getAllSources();
    		Assert.notEmpty(sources, "Sources must not be empty");
    		load(context, sources.toArray(new Object[0]));
    		listeners.contextLoaded(context);
    	}

## 刷新应用上下文 ##

这一步很重要，bean的注册，还有web容器都会在这里进行。  
refreshContext(context);

refreshContext方法：

//这里会调用refresh（context）方法
    private void refreshContext(ConfigurableApplicationContext context) { 
    		refresh(context);
    		if (this.registerShutdownHook) { 
    			try { 
    				context.registerShutdownHook();
    			}
    			catch (AccessControlException ex) { 
    				// Not allowed in some environments.
    			}
    		}
    	}
    
    
    // refresh（context方法）
    /** * Refresh the underlying {@link ApplicationContext}. * @param applicationContext the application context to refresh */
    protected void refresh(ApplicationContext applicationContext) { 
    	Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
    	((AbstractApplicationContext) applicationContext).refresh();
    }

接着refresh方法会调用AbstractApplicationContext的子类AbstractApplicationContext的refresh方法，而AbstractApplicationContext是一个抽象类，refresh定义模板方法类，在该方法是空实现的，调用方法实际调用的是子类的方法。

@Override
    	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();
    			}
    		}

比如onRefresh方法：

/** * Template method which can be overridden to add context-specific refresh work. * Called on initialization of special beans, before instantiation of singletons. * <p>This implementation is empty. * @throws BeansException in case of errors * @see #refresh() */
    	protected void onRefresh() throws BeansException { 
    		// For subclasses: do nothing by default.
    	}

这里找到了其中一个抽象类实现ServletWebServerApplicationContext  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 3]  
ServletWebServerApplicationContext下实际的refresh方法是

@Override
    	protected void onRefresh() { 
    		super.onRefresh();
    		try { 
    			createWebServer();
    		}
    		catch (Throwable ex) { 
    			throw new ApplicationContextException("Unable to start web server", ex);
    		}
    	}
    
    
       private void createWebServer() { 
    		WebServer webServer = this.webServer;
    		ServletContext servletContext = getServletContext();
    		if (webServer == null && servletContext == null) { 
    			ServletWebServerFactory factory = getWebServerFactory();
    			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();
    	}

这里ServletWebServerFactory factory = getWebServerFactory(); 获得的是org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory 工厂类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 4]

接着通过工厂类TomcatServletWebServerFactory创建了WebServer

@Override
    	public WebServer getWebServer(ServletContextInitializer... initializers) { 
    		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);
    		}
    		prepareContext(tomcat.getHost(), initializers);
    		return getTomcatWebServer(tomcat);
    	}
    
    
    	/** * Factory method called to create the {@link TomcatWebServer}. Subclasses can * override this method to return a different {@link TomcatWebServer} or apply * additional processing to the Tomcat server. * @param tomcat the Tomcat server. * @return a new {@link TomcatWebServer} instance */
    	protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { 
    		return new TomcatWebServer(tomcat, getPort() >= 0);
    	}

接下来，在创建TomcatWebServer的过程中，会对tomcat容器进行初始化，并启动servlet容器，开启web服务。

TomcatWebServer类是用来控制tomcat的，可以对web容器进行初始化。

/** * {@link WebServer} that can be used to control a Tomcat web server. Usually this class * should be created using the {@link TomcatReactiveWebServerFactory} of * {@link TomcatServletWebServerFactory}, but not directly. * * @author Brian Clozel * @author Kristine Jetzke * @since 2.0.0 */
    public class TomcatWebServer implements WebServer { 
    
    	private static final Log logger = LogFactory.getLog(TomcatWebServer.class);
    
    	private static final AtomicInteger containerCounter = new AtomicInteger(-1);
    
    	private final Object monitor = new Object();
    
    	private final Map<Service, Connector[]> serviceConnectors = new HashMap<>();
    
    	private final Tomcat tomcat;
    
    	private final boolean autoStart;
    
    	private volatile boolean started;
    
    	/** * Create a new {@link TomcatWebServer} instance. * @param tomcat the underlying Tomcat server */
    	public TomcatWebServer(Tomcat tomcat) { 
    		this(tomcat, true);
    	}
    
    	/** * Create a new {@link TomcatWebServer} instance. * @param tomcat the underlying Tomcat server * @param autoStart if the server should be started */
    	public TomcatWebServer(Tomcat tomcat, boolean autoStart) { 
    		Assert.notNull(tomcat, "Tomcat Server must not be null");
    		this.tomcat = tomcat;
    		this.autoStart = autoStart;
    		initialize();
    	}
    
    	private void initialize() throws WebServerException { 
    		logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
    		synchronized (this.monitor) { 
    			try { 
    				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.
    						removeServiceConnectors();
    					}
    				});
    
    				// Start the server to trigger initialization listeners
    				this.tomcat.start();
    
    				// We can re-throw failure exception directly in the main thread
    				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
    				startDaemonAwaitThread();
    			}
    			catch (Exception ex) { 
    				stopSilently();
    				throw new WebServerException("Unable to start embedded Tomcat", ex);
    			}
    		}
    	}

在上述的代码中创建TomcatWebServer的过程中会调用initialize();  
在初始化的方法中，this.tomcat.start(); 对tomcat容易进行启动，这也就是spring boot实现web容器如tomcat嵌入到自己的服务。

/** * Start the server. * * @throws LifecycleException Start error */
        public void start() throws LifecycleException { 
            getServer();
            server.start();
        }
    
     /** * Get the server object. You can add listeners and few more * customizations. JNDI is disabled by default. * @return The Server */
        public Server getServer() { 
    
            if (server != null) { 
                return server;
            }
    
            System.setProperty("catalina.useNaming", "false");
    
            server = new StandardServer();
    
            initBaseDir();
    
            // Set configuration source
            ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(new File(basedir), null));
    
            server.setPort( -1 );
    
            Service service = new StandardService();
            service.setName("Tomcat");
            server.addService(service);
            return server;
        }

然后在start的过程中会调用  
public abstract class LifecycleBase implements Lifecycle

/** * {@inheritDoc} */
        @Override
        public final synchronized void start() throws LifecycleException { 
    
            if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
                    LifecycleState.STARTED.equals(state)) { 
    
                if (log.isDebugEnabled()) { 
                    Exception e = new LifecycleException();
                    log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
                } else if (log.isInfoEnabled()) { 
                    log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
                }
    
                return;
            }
    
            if (state.equals(LifecycleState.NEW)) { 
                init();
            } else if (state.equals(LifecycleState.FAILED)) { 
                stop();
            } else if (!state.equals(LifecycleState.INITIALIZED) &&
                    !state.equals(LifecycleState.STOPPED)) { 
                invalidTransition(Lifecycle.BEFORE_START_EVENT);
            }
    
            try { 
                setStateInternal(LifecycleState.STARTING_PREP, null, false);
                startInternal();
                if (state.equals(LifecycleState.FAILED)) { 
                    // This is a 'controlled' failure. The component put itself into the
                    // FAILED state so call stop() to complete the clean-up.
                    stop();
                } else if (!state.equals(LifecycleState.STARTING)) { 
                    // Shouldn't be necessary but acts as a check that sub-classes are
                    // doing what they are supposed to.
                    invalidTransition(Lifecycle.AFTER_START_EVENT);
                } else { 
                    setStateInternal(LifecycleState.STARTED, null, false);
                }
            } catch (Throwable t) { 
                // This is an 'uncontrolled' failure so put the component into the
                // FAILED state and throw an exception.
                handleSubClassException(t, "lifecycleBase.startFail", toString());
            }
        }

在startInternal();方法中会调用实现类：  
org.apache.catalina.core.StandardServer的startInternal()实现方法  
在

@Override
        protected void startInternal() throws LifecycleException { 
    
            fireLifecycleEvent(CONFIGURE_START_EVENT, null);
            setState(LifecycleState.STARTING);
    
            globalNamingResources.start();
    
            // Start our defined Services
            synchronized (servicesLock) { 
                for (int i = 0; i < services.length; i++) { 
                    services[i].start();
                }
            }
    
            if (periodicEventDelay > 0) { 
                monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
                        new Runnable() { 
                            @Override
                            public void run() { 
                                startPeriodicLifecycleEvent();
                            }
                        }, 0, 60, TimeUnit.SECONDS);
            }
        }

services\[i\].start(); 这里会对容器进行启动，调用start后回到lifeCycle方法，接着调用org.apache.catalina.core.StandardService的startInternal  
org.apache.catalina.core.StandardService的startInternal

/** * Start nested components ({@link Executor}s, {@link Connector}s and * {@link Container}s) and implement the requirements of * {@link org.apache.catalina.util.LifecycleBase#startInternal()}. * * @exception LifecycleException if this component detects a fatal error * that prevents this component from being used */
        @Override
        protected void startInternal() throws LifecycleException { 
    
            if(log.isInfoEnabled())
                log.info(sm.getString("standardService.start.name", this.name));
            setState(LifecycleState.STARTING);
    
            // Start our defined Container first
            if (engine != null) { 
                synchronized (engine) { 
                    engine.start();
                }
            }
    
            synchronized (executors) { 
                for (Executor executor: executors) { 
                    executor.start();
                }
            }
    
            mapperListener.start();
    
            // Start our defined Connectors second
            synchronized (connectorsLock) { 
                for (Connector connector: connectors) { 
                    // If it has already failed, don't try and start it
                    if (connector.getState() != LifecycleState.FAILED) { 
                        connector.start();
                    }
                }
            }
        }

接着调用 engine.start(); 这里会对容器进行启动，调用start后回到lifeCycle方法，接着调用org.apache.catalina.core.StandardEngined的startInternal

org.apache.catalina.core.StandardEngined的startInternal方法如下：

@Override
        protected synchronized void startInternal() throws LifecycleException { 
    
            // Log our server identification information
            if (log.isInfoEnabled()) { 
                log.info(sm.getString("standardEngine.start", ServerInfo.getServerInfo()));
            }
    
            // Standard container startup
            super.startInternal();
        }

最后调用tomcat内部的启动方法，开启socket监听服务，实现web容器的启动。

/** * Start this component and implement the requirements * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}. * * @exception LifecycleException if this component detects a fatal error * that prevents this component from being used */
        @Override
        protected synchronized void startInternal() throws LifecycleException { 
    
            // Start our subordinate components, if any
            logger = null;
            getLogger();
            Cluster cluster = getClusterInternal();
            if (cluster instanceof Lifecycle) { 
                ((Lifecycle) cluster).start();
            }
            Realm realm = getRealmInternal();
            if (realm instanceof Lifecycle) { 
                ((Lifecycle) realm).start();
            }
    
            // Start our child containers, if any
            Container children[] = findChildren();
            List<Future<Void>> results = new ArrayList<>();
            for (int i = 0; i < children.length; i++) { 
                results.add(startStopExecutor.submit(new StartChild(children[i])));
            }
    
            MultiThrowable multiThrowable = null;
    
            for (Future<Void> result : results) { 
                try { 
                    result.get();
                } catch (Throwable e) { 
                    log.error(sm.getString("containerBase.threadedStartFailed"), e);
                    if (multiThrowable == null) { 
                        multiThrowable = new MultiThrowable();
                    }
                    multiThrowable.add(e);
                }
    
            }
            if (multiThrowable != null) { 
                throw new LifecycleException(sm.getString("containerBase.threadedStartFailed"),
                        multiThrowable.getThrowable());
            }
    
            // Start the Valves in our pipeline (including the basic), if any
            if (pipeline instanceof Lifecycle) { 
                ((Lifecycle) pipeline).start();
            }
    
            setState(LifecycleState.STARTING);
    
            // Start our thread
            if (backgroundProcessorDelay > 0) { 
                monitorFuture = Container.getService(ContainerBase.this).getServer()
                        .getUtilityExecutor().scheduleWithFixedDelay(
                                new ContainerBackgroundProcessorMonitor(), 0, 60, TimeUnit.SECONDS);
            }
        }

到这里我们看到tomcat内部启动的方法  
((Lifecycle) cluster).start();  
通过这种方式启动内部web容器。

[Spring Boot_1_Spring Boot_]: https://blog.csdn.net/yunfeng482/article/details/92808523
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70]: /images/20210923/06d2d83d4f3242e79842251bab16ad2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 1]: /images/20210923/1cb3890138dc49b5a8625ad3918cc58f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 2]: /images/20210923/553e1e5981264a63843d6c18eb81f7e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 3]: /images/20210923/15b88be6037447bd812cc70942f4d453.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bmZlbmc0ODI_size_16_color_FFFFFF_t_70 4]: /images/20210923/945073d66370460195f58873ff72c847.png