Spring Boot源码分析

文章目录

• Spring Boot源码分析
• • 启动类分析
  • • @SpringBootConfiguration
    • @EnableAutoConfiguration
    • @ComponentScan
  • SpringBoot启动流程
  • • 1. 准备SpringApplication
    • • 获取当前 web 应用类型
      • 设置初始化器
      • 设置监听器
      • 推导主应用程序类
    • 2. Spring Boot的运行
    • • 创建计时器并启动
      • 设置headless属性值
      • 获取运行监听器
      • 运行监听器方法
      • 准备运行时环境
      • 创建IOC容器
      • 准备IOC容器
      • 启动IOC容器
      • 完成启动
    • 3. 延伸与拓展
    • • SpringBoot中的事件推送原型(观察者模式)
      • SpringBoot如何加载yml配置文件
  • SpringBoot自动配置原理
  • • @EnableAutoConfiguration
    • • @AutoConfigurationPackage
      • • AutoConfigurationPackages.Registrar
      • AutoConfigurationImportSelector
      • • DeferredImportSelector
        • AutoConfigurationGroup
        • 获取装配类:getAutoConfigurationEntry()
        • 获取候选配置类:getCandidateConfigurations()
        • • loadFactoryNames()
          • loadSpringFactories()
    • 总结与拓展
    • • 总结
      • @ConditionalOnXXX
      • 自动装配类装配的顺序
  • 问题与思考
  • • Spring是如何处理@Import注解的？
    • • @Import注解
      • @Import注解处理
    • SPI 和 类加载器
    • • Java SPI
      • • Java SPI应用实例
        • Java SPI 原理
      • 类加载器
      • • 基本概念
        • 双亲委派机制
      • SpringBoot的SPI机制
      • • Java SPI的缺点
        • Spring SPI机制
        • Java SPI 与 Spring SPI 的区别

SpringBoot版本-2.X

启动类分析

@SpringBootApplication 标注在某个类上说明这个类是 SpringBoot 的主配置类， SpringBoot 就应该运行这个类的main方法来启动 SpringBoot 应用；

@SpringBootApplication
public class StudyProjectApplication {public static void main(String[] args) {SpringApplication.run(StudyProjectApplication.class, args);}}

当我们点进去后发现：这是一个集成注解，为什么它能集成这么多的注解的功能呢？是在于它上面的 @Inherited 注解, @Inherited 表示自动继承注解类型。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {/*** 自动装配要排除的类，功能来自于 @EnableAutoConfiguration*/@AliasFor(annotation = EnableAutoConfiguration.class)Class[] exclude() default {};/***  自动装配要排除的类名，功能来自于 @EnableAutoConfiguration*/@AliasFor(annotation = EnableAutoConfiguration.class)String[] excludeName() default {};/*** 配置扫描的包，功能来自于 @ComponentScan*/@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")String[] scanBasePackages() default {};/*** 配置扫描的class，该class所在的包都会被扫描，功能来自于 @ComponentScan*/@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")Class[] scanBasePackageClasses() default {};/*** 是否启用 @Bean 方法代理，功能来自于 @Configuration*/@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;}

@SpringBootApplication 是一个组合注解，包含了 @SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan 三个注解的功能；@SpringBootApplication 中也提供了一些配置属性，而这些属性来自于以上三个注解。

@SpringBootConfiguration

我们点进注解发现：它是 springboot 的配置类，标注在某个类上，表示这是一个 springboot的配置类。

这个注解比较简单，上面标记了 @Configuration，然后是一个属性 proxyBeanMethods()，它来自于 @Configuration。因此，@SpringBootConfiguration 并没有做什么，仅仅只是将 @Configuration 使用了 @Configuration 的功能。

@EnableAutoConfiguration

@EnableAutoConfiguration 主要 用来开启自动装配功能，在第二章SpringBoot自动装配原理中详细说明。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 将被 @SpringBootApplication 标记的类所在的包，包装成 BasePackages，然后注册到 spring 容器中；
@AutoConfigurationPackage
// 将当前项目支持的自动配置类添加到 spring 容器中；
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";/*** 可自行定义排除自动装配的类*/Class[] exclude() default {};/*** 可自行定义排除自动装配的类名*/String[] excludeName() default {};}

从代码中可以看到，

1. 该注解组合了 @AutoConfigurationPackage 注解的功能，该注解用来指定自动装配的包；
2. 该注解通过 @Import 注解引入了一个类 AutoConfigurationImportSelector，这个类是自动装配的关键；
3. 该注解提供了两个配置，用来排除指定的自动装配类，可以根据类来排除 (Class 对象)，也可以根据类名 (包名.类名) 排除。

@ComponentScan

这个注解想必大家已经很熟悉了，它指定了包扫描路径，如果不指定，就扫描所在类的包。

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

TypeExcludeFilter： 这个类表示在进行包扫描时，可以排除一些类。

AutoConfigurationExcludeFilter：用来排除自动配置类，也就是说，spring 在进行包扫描时，不会扫描自动配置类。核心源码如下：

public class AutoConfigurationExcludeFilter implements TypeFilter, BeanClassLoaderAware {private ClassLoader beanClassLoader;private volatile List autoConfigurations;@Overridepublic void setBeanClassLoader(ClassLoader beanClassLoader) {this.beanClassLoader = beanClassLoader;}@Overridepublic boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {// isConfiguration(...)：当前类是否被 @Configuration 标记// isAutoConfiguration(...)：当前类是否为自动配置类return isConfiguration(metadataReader) && isAutoConfiguration(metadataReader);}private boolean isConfiguration(MetadataReader metadataReader) {return metadataReader.getAnnotationMetadata().isAnnotated(Configuration.class.getName());}private boolean isAutoConfiguration(MetadataReader metadataReader) {// 获取所有的自动配置类，然后判断当前类是否存在于其中return getAutoConfigurations().contains(metadataReader.getClassMetadata().getClassName());}protected List getAutoConfigurations() {if (this.autoConfigurations == null) {this.autoConfigurations = SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader);}return this.autoConfigurations;}}

我们主要看 match(...) 方法，它的匹配的类为：

1. 被 @Configuration 标记；
2. 是自动配置类。（从 isAutoConfiguration(...) 可以看到，在判断是否为自动配置类上，springboot 先使用 SpringFactoriesLoader 加载所有配置类，然后再判断传入的类是否为其中之一。）

满足以上两个条件，spring 就不会对其进行扫描处理。

SpringBoot启动流程

@SpringBootApplication
public class StudyProjectApplication {public static void main(String[] args) {SpringApplication.run(StudyProjectApplication.class, args);}}

我们进入这个run方法：

public class SpringApplication {...// primarySource 就是我们传入的 StudyProjectApplication.class，// args 就是 main() 方法的参数public static ConfigurableApplicationContext run(Class primarySource, String... args) {// 将 primarySource 包装成数组，继续调用 run(...) 方法return run(new Class[] { primarySource }, args);}// primarySources 就是我们传入的 StudyProjectApplication.class 包装成的数组，// args 就是 main() 方法的参数public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {// 核心代码return new SpringApplication(primarySources).run(args);}...
}

分析关键代码： return new SpringApplication(primarySources).run(args);

这块代码需要拆开来看，可以拆成以下两部分：

• 构造方法：SpringApplication#SpringApplication(Class...)
• 实例方法：SpringApplication#run(String...)

看来，这两个方法就是 springboot 的启动所有流程了，接下来我们就来分析这两个方法。

1. 准备SpringApplication

创建SpringApplication对象

 /*** 这里就最终调用的构造方法了* resourceLoader 为 null* primarySources 为 StudyProjectApplication.class*/
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {// 1. 将传入的resourceLoader设置到成员变量，这里的值为nullthis.resourceLoader = resourceLoader;Assert.notNull(primarySources, "PrimarySources must not be null");// 2. 将传入的primarySources设置到成员变量，这里的值为 StudyProjectApplication.classthis.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));// 3. 当前的 web 应用类型，REACTIVE，NONE，SERVLETthis.webApplicationType = WebApplicationType.deduceFromClasspath();// 4. 设置初始化器，getSpringFactoriesInstances：从 META-INF/spring.factories 中获取配置setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));// 5. 设置监听器，getSpringFactoriesInstances：从 META-INF/spring.factories 中获取配置setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));// 6. 返回包含main()方法的classthis.mainApplicationClass = deduceMainApplicationClass();}

获取当前 web 应用类型

this.webApplicationType = WebApplicationType.deduceFromClasspath();

WebApplicationType.deduceFromClasspath() 方法是用来推断当前项目是什么类型的，代码如下：

public enum WebApplicationType {// 不是 web 应用NONE,// servlet 类型的 web 应用SERVLET,// reactive 类型的 web 应用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() {// classpath 中仅存在 WEBFLUX 相关类if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {return WebApplicationType.REACTIVE;}// classpath 不存在 SERVLET 相关类for (String className : SERVLET_INDICATOR_CLASSES) {if (!ClassUtils.isPresent(className, null)) {return WebApplicationType.NONE;}}// 默认 web 类型为 SERVLET// 也就是说，同时存在 WEBFLUX 与 SERVLET 相关类，最终返回的是 SERVLETreturn WebApplicationType.SERVLET;}...
}

可以看到，springboot 定义了三种项目类型：NONE(不是 web 应用)、SERVLET(servlet 类型的 web 应用)、REACTIVE(reactive 类型的 web 应用)，WebApplicationType.deduceFromClasspath() 的执行流程如下：

1. 如果 classpath 中仅存在 WEBFLUX 相关类，则表明当前项目是 reactive 类型的 web 应用，返回；
2. 如果 classpath 中不存在 SERVLET 相关类，则表明当前项目不是 web 应用，返回；
3. 如果以上条件都不满足，则表明当前项目是 servlet 类型的 web 应用。

由于 demo 引用了 spring-boot-starter-web 相关依赖，因此当前项目是 servlet 类型的 web 应用。

设置初始化器

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

这行代码分为两部分:

• 获取 ApplicationContextInitializer：getSpringFactoriesInstances(ApplicationContextInitializer.class)
• 设置初始化器：setInitializers(...)

public class SpringApplication {...// type 为 ApplicationContextInitializer.classprivate  Collection getSpringFactoriesInstances(Class type) {return getSpringFactoriesInstances(type, new Class[] {});}/*** type 为 ApplicationContextInitializer.class* parameterTypes 为 ew Class[] {}* args 为 null*/private  Collection getSpringFactoriesInstances(Class type, Class[] parameterTypes, Object... args) {ClassLoader classLoader = getClassLoader();// 从 META-INF/spring.factories 加载内容Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));// 实例化，使用的反射操作List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);// 排序，比较的是 @Order 注解，或实现的 Orderd 接口AnnotationAwareOrderComparator.sort(instances);return instances;}...
}

先从 META-INF/spring.factories 获取内容，然后使用反射进行实例化，进行排序后再返回。那么最终会有多少个 ApplicationContextInitializer 加载进来呢？

通过调试，发现一共有 7 个：对这 7 个 ApplicationContextInitializer，说明如下：

• ConfigurationWarningsApplicationContextInitializer：报告 IOC 容器的一些常见的错误配置
• ContextIdApplicationContextInitializer：设置 Spring 应用上下文的 ID
• DelegatingApplicationContextInitializer：加载 application.properties 中 context.initializer.classes 配置的类
• RSocketPortInfoApplicationContextInitializer：将 RSocketServer 实际使用的监听端口写入到 Environment 环境属性中
• ServerPortInfoApplicationContextInitializer：将内置 servlet 容器实际使用的监听端口写入到 Environment 环境属性中
• SharedMetadataReaderFactoryContextInitializer：创建一个 SpringBoot 和 ConfigurationClassPostProcessor 共用的 CachingMetadataReaderFactory 对象
• ConditionEvaluationReportLoggingListener：将 ConditionEvaluationReport 写入日志

获取到 ApplicationContextInitializer，我们再来看看 setInitializers(...) 方法：

public class SpringApplication {...public void setInitializers(Collection> initializers) {this.initializers = new ArrayList<>(initializers);}...
}

这是一个标准的 setter 方法，所做的就只是设置成员变量。

注意： 这里会把项目中所有的spring.factories中的key都存到内存里，以便后面快速找到对应的key

设置监听器

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

从形式上看，同 Initializer 一样，也是先从 META-INF/spring.factories 中加载 ApplicationListener，然后添加到成员变量中，这里我们直接看能获取到哪些 listener：

这些Listener的作用是：

• ClearCachesApplicationListener：应用上下文加载完成后对缓存做清除工作
• ParentContextCloserApplicationListener：监听双亲应用上下文的关闭事件并往自己的子应用上下文中传播
• CloudFoundryVcapEnvironmentPostProcessor：对 CloudFoundry 提供支持
• FileEncodingApplicationListener：检测系统文件编码与应用环境编码是否一致，如果系统文件编码和应用环境的编码不同则终止应用启动
• AnsiOutputApplicationListener：根据 spring.output.ansi.enabled 参数配置 AnsiOutput
• ConfigFileApplicationListener：从常见的那些约定的位置读取配置文件
• DelegatingApplicationListener：监听到事件后转发给 application.properties 中配置的 context.listener.classes 的监听器
• ClasspathLoggingApplicationListener：对环境就绪事件 ApplicationEnvironmentPreparedEvent 和应用失败事件 ApplicationFailedEvent 做出响应
• LoggingApplicationListener：配置 LoggingSystem，使用 logging.config 环境变量指定的配置或者缺省配置
• LiquibaseServiceLocatorApplicationListener：使用一个可以和 SpringBoot 可执行 jar 包配合工作的版本替换 LiquibaseServiceLocator
• BackgroundPreinitializer：使用一个后台线程尽早触发一些耗时的初始化任务

再来看看 SpringApplication#setListeners：

public void setListeners(Collection> listeners) {this.listeners = new ArrayList<>(listeners);
}

推导主应用程序类

this.mainApplicationClass = deduceMainApplicationClass();

所谓主类，就是包含 main(String[])，也就是当前 spring 应用的启动类，SpringApplication#deduceMainApplicationClass 代码如下：

private Class deduceMainApplicationClass() {try {// 获取调用栈StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();// 遍历调用栈，找 到main方法for (StackTraceElement stackTraceElement : stackTrace) {if ("main".equals(stackTraceElement.getMethodName())) {return Class.forName(stackTraceElement.getClassName());}}}catch (ClassNotFoundException ex) {// Swallow and continue}return null;
}

这里主要是通过 new RuntimeException().getStackTrace() 获取调用栈，然后遍历，得到包含 main 方法的类，得到的调用栈如下：

可以看到，main() 就包含在调用栈中了。

2. Spring Boot的运行

创建好了SpringApplication实例后，我们继续分析： 实例方法：SpringApplication#run(String...)

run方法的内容如下：

public ConfigurableApplicationContext run(String... args) {//1.创建 StopWatch 对象，并启动。StopWatch 主要用于简单统计 run 启动过程的时长。StopWatch stopWatch = new StopWatch();stopWatch.start();//准备空的ApplicationContext，以及一组异常报告器ConfigurableApplicationContext context = null;Collection exceptionReporters = new ArrayList<>();//2. 配置 headless 属性，java.awt.headless，java.awt.headless模式是系统的一种配置模式，在系统可能缺少显示设备、键盘或鼠标这些外设的情况下可以使用该模式configureHeadlessProperty();// 3. 获取监听器，也是从 META-INF/spring.factories 中获取SpringApplicationRunListeners listeners = getRunListeners(args);// starting()：首次启动run方法时立即调用。可用于非常早期的初始化（准备运行时环境之前）。// 4. 发布事件listeners.starting();try {// 封装传入的参数，args是启动Spring应用的命令行参数，该参数可以在Spring应用中被访问。如：--server.port=9000ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 5. 处理环境参数// 创建并配置当前SpringBoot应用将要使用的EnvironmentConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);// 6. 如果有配置 spring.beaninfo.ignore，则将该配置设置进系统参数configureIgnoreBeanInfo(environment);// 7.准备Banner打印器 - 就是启动Spring Boot的时候打印在console上的ASCII艺术字体Banner printedBanner = printBanner(environment);// 8. 创建applicationContextcontext = createApplicationContext();//启动错误报告的自定义回调接口//这一步的逻辑和实例化初始化器和监听器的一样，都是通过调用 getSpringFactoriesInstances 方法来获取配置的异常类名称并实例化所有的异常处理类。exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);// 9. 准备上下文，设置了一系列的属性值//这一步主要是在容器刷新之前的准备动作。包含一个非常关键的操作：将启动类注入容器，为后续开启自动化配置奠定基础。prepareContext(context, environment, listeners, applicationArguments,printedBanner);// 10. 调用 AbstractApplicationContext.refresh，启动spring容器refreshContext(context);// 11. 刷新后的处理//扩展接口，设计模式中的模板方法，默认为空实现。// 如果有自定义需求，可以重写该方法。比如打印一些启动结束log，或者一些其它后置处理afterRefresh(context, applicationArguments);// 停止 StopWatch 统计时长stopWatch.stop();// 打印 Spring Boot 启动的时长日志。if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);}// 12. 发布事件listeners.started(context);//13. 调用 runner，实现了 ApplicationRunner或CommandLineRunner 的接口//用于调用项目中自定义的执行器XxxRunner类，使得在项目启动完成后立即执行一些特定程序//Runner 运行器用于在服务启动时进行一些业务初始化操作，这些操作只在服务启动后执行一次。//Spring Boot提供了ApplicationRunner和CommandLineRunner两种服务接口callRunners(context, applicationArguments);} catch (Throwable ex) {// 如果发生异常，则进行处理，并抛出 IllegalStateException 异常handleRunFailure(context, ex, exceptionReporters, listeners);throw new IllegalStateException(ex);}//14. 发布应用上下文就绪事件//表示在前面一切初始化启动都没有问题的情况下，使用运行监听器SpringApplicationRunListener持续运行配置好的应用上下文ApplicationContext，// 这样整个Spring Boot项目就正式启动完成了。try {listeners.running(context);} catch (Throwable ex) {// 如果发生异常，则进行处理，并抛出 IllegalStateException 异常handleRunFailure(context, ex, exceptionReporters, null);throw new IllegalStateException(ex);}//返回容器return context;
}

下面进行详细分析：

创建计时器并启动

一开始，springboot 就创建了 stopWatch 实例，然后调用 StopWatch#start() 启动计时功能，关于这个类没啥好说的，它就是个计时器，这里是用来计算 springboot 启动耗时，以下日志中的时间就是由这个计时器得到的：

设置headless属性值

SpringApplication#configureHeadlessProperty 方法的相关代码如下：

public class SpringApplication {private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";...private boolean headless = true;public void setHeadless(boolean headless) {this.headless = headless;}...private void configureHeadlessProperty() {// 将 java.awt.headless 的值配置到系统变量System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));}...
}

这个方法仅仅是将 java.awt.headless 的值设置到了系统变量，设置成 true，表示启动 java.awt.headless 模式。那么它是个啥模式呢？简单来说，该模式就是系统缺少了显示设备、键盘或鼠标等情况的模式，服务器一般都是在这种情况下工作的。

获取运行监听器

SpringApplicationRunListener 依然是从 META-INF/spring.factories 中获取，那 SpringApplicationRunListener 是个啥呢？我们来看代码：

public interface SpringApplicationRunListener {/*** 首次启动run方法时立即调用。可用于非常早期的初始化。*/default void starting() {}/*** 准备好环境（Environment构建完成），但在创建ApplicationContext之前调用。*/default void environmentPrepared(ConfigurableEnvironment environment) {}/*** 在创建和构建ApplicationContext之后，但在加载之前调用。*/default void contextPrepared(ConfigurableApplicationContext context) {}/*** ApplicationContext已加载但在刷新之前调用。*/default void contextLoaded(ConfigurableApplicationContext context) {}/*** ApplicationContext已刷新，应用程序已启动，* 但尚未调用CommandLineRunners和ApplicationRunners。*/default void started(ConfigurableApplicationContext context) {}/*** 在运行方法彻底完成之前立即调用，* 刷新ApplicationContext并调用所有CommandLineRunners和ApplicationRunner。*/default void running(ConfigurableApplicationContext context) {}/*** 在运行应用程序时失败时调用。*/default void failed(ConfigurableApplicationContext context, Throwable exception) {}
}

SpringApplicationRunListener 是一个接口，定义了一系列的方法来监听 springboot 的启动过程，方法的说明已经在文档中有详细定义，如果我们需要在 springboot 的启动中的某个过程做一些事情，就可以实现 SpringApplicationRunListener 然后重写对应的方法。

通过调试，发现 springboot 获得的运行监听器如下：SpringApplication运行方法的侦听器。

运行监听器方法

回到 SpringApplication#run(java.lang.String...)，获取到运行监听器后，会立即调用 starting() 方法来发布启动事件：

// 获取监听器
SpringApplicationRunListeners listeners = getRunListeners(args);
// starting()：首次启动run方法时立即调用。可用于非常早期的初始化（准备运行时环境之前）。
listeners.starting();

进入 SpringApplicationRunListeners#starting 方法：

void starting() {for (SpringApplicationRunListener listener : this.listeners) {listener.starting();}
}

可以看到，所谓的发布事件，就是遍历所有的监听器，逐一调用其 starting() 罢了，this.listeners 就是上面获取到的所有的运行监听器。不仅如此，SpringApplicationRunListener 的其他方法如 environmentPrepared(...)、contextPrepared(...) 等都是这样的调用套路，后面看到了就不重复分析了。

准备运行时环境

接下我们来看看环境参数的处理，代码如下：

// 封装传入的参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 处理环境参数
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

进入 SpringApplication#prepareEnvironment：

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {// 获取环境，如果不存在则创建ConfigurableEnvironment environment = getOrCreateEnvironment();// 配置运行时环境configureEnvironment(environment, applicationArguments.getSourceArgs());ConfigurationPropertySources.attach(environment);//  SpringApplicationRunListener 的 environmentPrepared 方法// （Environment构建完成，但在创建ApplicationContext之前）//  配置文件加载监听器（ConfigFileApplicationListener）listeners.environmentPrepared(environment);// 环境与应用绑定bindToSpringApplication(environment);if (!this.isCustomEnvironment) {environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());}ConfigurationPropertySources.attach(environment);return environment;
}

• 获取或创建环境：

  这个方法是根据应用类型来创建对应的 Environment 实例，当前应用类型是 SERVLET。

  private ConfigurableEnvironment getOrCreateEnvironment() {if (this.environment != null) {return this.environment;}switch (this.webApplicationType) {case SERVLET:return new StandardServletEnvironment();case REACTIVE:return new StandardReactiveWebEnvironment();default:return new StandardEnvironment();}
  }
  

  StandardServletEnvironment()中包含了如下内容：

  • 系统属性，我们平时调用 System.getenv() 得到的参数；
  • 系统环境，我们平时调用 System.getProperties() 得到的参数；
  • servlet 的 servletContext 与 servletConfig.

• 配置环境

  我们继续分析，接着看看配置环境的流程，也就是 SpringApplication#configureEnvironment 方法：

  protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {if (this.addConversionService) {// 添加转换器，处理参数类型转换，如 String转Number，Integer转Enum等ConversionService conversionService = ApplicationConversionService.getSharedInstance();environment.setConversionService((ConfigurableConversionService) conversionService);}// 将启动参数添加到 environment 中configurePropertySources(environment, args);// 处理 ActiveProfiles 值configureProfiles(environment, args);
  }
  

springboot 的启动参数有啥好解析的呢？在启动 spring 项目时，我们可以这样指定参数：

java -jar xxx.jar --a1=aaa --b1=bbb

然后我们就能通过 @Value("${a1}") 获取到，关键就是在这里，可以看到，springboot 会把传入的 --a1=aaa、--b1=bbb 解析成 a1/aaa、b1/bbb 键值对的形式，保存到 Environment，后续要用到时，就可很方便地从 Environment 中获取了。

environment还有一个很重要的功能——加载配置文件，在下面章节中详细说明。

创建IOC容器

创建 ioc 容器的代码如下：

ConfigurableApplicationContext context = null;
....
// 创建applicationContext
context = createApplicationContext();

我们进入 SpringApplication#createApplicationContext 方法：

/** 默认的 ApplicationContext */
public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."+ "annotation.AnnotationConfigApplicationContext";/** servlet 应用的的 ApplicationContext */
public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";/** Reactive 应用的 ApplicationContext */
public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."+ "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";protected ConfigurableApplicationContext createApplicationContext() {Class contextClass = this.applicationContextClass;if (contextClass == null) {try {// 根据应用类型来创建不同的容器switch (this.webApplicationType) {case SERVLET:// 使用的是 AnnotationConfigServletWebServerApplicationContextcontextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);break;case REACTIVE:contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);break;default:// 默认使用的是 AnnotationConfigApplicationContextcontextClass = Class.forName(DEFAULT_CONTEXT_CLASS);}}catch (ClassNotFoundException ex) {throw new IllegalStateException(...);}}// 使用反射进行实例化return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

这个方法主要就是根据应用类型来创建不同 ApplicationContext，使用反射的方法进行实例化，各应用类型对应的 ApplicationContext 如下：

1. servlet 应用：AnnotationConfigServletWebServerApplicationContext
2. reactive 应用：AnnotationConfigReactiveWebServerApplicationContext
3. 以上都不是：AnnotationConfigApplicationContext

当前应用的类型是 servlet，因此创建的 ApplicationContext 是 AnnotationConfigReactiveWebServerApplicationContext，来看看它的构造方法：

我们进入 SpringApplication#createApplicationContext 方法：

/** 默认的 ApplicationContext */
public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."+ "annotation.AnnotationConfigApplicationContext";/** servlet 应用的的 ApplicationContext */
public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";/** Reactive 应用的 ApplicationContext */
public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."+ "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";protected ConfigurableApplicationContext createApplicationContext() {Class contextClass = this.applicationContextClass;if (contextClass == null) {try {// 根据应用类型来创建不同的容器switch (this.webApplicationType) {case SERVLET:// 使用的是 AnnotationConfigServletWebServerApplicationContextcontextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);break;case REACTIVE:contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);break;default:// 默认使用的是 AnnotationConfigApplicationContextcontextClass = Class.forName(DEFAULT_CONTEXT_CLASS);}}catch (ClassNotFoundException ex) {throw new IllegalStateException(...);}}// 使用反射进行实例化return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

这个方法主要就是根据应用类型来创建不同 ApplicationContext，使用反射的方法进行实例化，各应用类型对应的 ApplicationContext 如下：

1. servlet 应用：AnnotationConfigServletWebServerApplicationContext
2. reactive 应用：AnnotationConfigReactiveWebServerApplicationContext
3. 以上都不是：AnnotationConfigApplicationContext

当前应用的类型是 servlet，因此创建的 ApplicationContext 是 AnnotationConfigReactiveWebServerApplicationContext，来看看它的构造方法：

public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {// 用来处理 BeanDefinition 的注册private final AnnotatedBeanDefinitionReader reader;// 用来处理包的扫描private final ClassPathBeanDefinitionScanner scanner;...public AnnotationConfigServletWebServerApplicationContext() {this.reader = new AnnotatedBeanDefinitionReader(this);this.scanner = new ClassPathBeanDefinitionScanner(this);}...
}

AnnotationConfigServletWebServerApplicationContext 的构造方法还是比较简单的，只是设置了两个属性，就不多说了。不过，我们也要把目光放远一点，看看其父类的构造方法，最终在 GenericApplicationContext 的构造方法中找到这么一句：

public GenericApplicationContext() {this.beanFactory = new DefaultListableBeanFactory();
}

这行代码创建了 DefaultListableBeanFactory 并将其赋值给了 beanFactory，这表明我们在 ApplicationContext 使用的 beanFactory 就是 DefaultListableBeanFactory。

准备IOC容器

创建完 ioc 容器后，接着就是对容器进行一些准备操作，代码如下：

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

public class SpringApplication {...private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {// 将创建好的应用环境设置到IOC容器中context.setEnvironment(environment);// 设置容器的一些参数postProcessApplicationContext(context);// 应用Initializer进行初始化操作applyInitializers(context);//  监听器：SpringApplicationRunListeners的contextPrepared方法// （在创建和准备ApplicationContext之后，但在加载之前）listeners.contextPrepared(context);// 打印个日志if (this.logStartupInfo) {logStartupInfo(context.getParent() == null);logStartupProfileInfo(context);}// 获取beanFactoryConfigurableListableBeanFactory beanFactory = context.getBeanFactory();// 将运行参数作为bean注册到beanFactory中beanFactory.registerSingleton("springApplicationArguments", applicationArguments);// 将 banner 作为bean注册到beanFactory中if (printedBanner != null) {beanFactory.registerSingleton("springBootBanner", printedBanner);}if (beanFactory instanceof DefaultListableBeanFactory) {// 是否允许bean的信息被覆盖((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);}// 处理懒加载if (this.lazyInitialization) {context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());}// 获取所有资源Set