『SpringBoot 源码分析』run() 方法执行流程：（1）初始化 SpringApplication 、上下文环境、应用上下文

• 基于 2.2.9.RELEASE
• 问题：当方法进行了注释标记之后，springboot 又是怎么注入到容器中并创建类呢？

1. 首先创建测试主程序

package com.lagou;@SpringBootApplication//标注在类上说明这个类是`SpringBoot`的主配置类
public class SpringBootMytestApplication{public static void main(String[] args) {SpringApplication.run(SpringBootMytestApplication.class, args);}
}

2. 创建测试 Controller

package com.lagou.controller;@RestController
public class TestController {@RequestMapping("/test")public String test(){System.out.println("源码环境构建成功...");return "源码环境构建成功";}
}

SpringApplication 初始化过程

1. SpringApplication 的初始化过程就是从 run() 开始的

public class SpringBootMytestApplication{public static void main(String[] args) {// 1. 调用 SpringApplication 的 run() 方法SpringApplication.run(SpringBootMytestApplication.class, args);}
}

2. 在真正执行 run() 方法之前，首先需要初始化 SpringApplication()

public class SpringApplication {...public SpringApplication(Class<?>... primarySources) {// this(null, primarySources);}public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {// 2. 初始化 SpringApplication()return new SpringApplication(primarySources).run(args);}public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {// 1. 调用重载方法。其中 primarySource = SpringBootMytestApplication.classreturn run(new Class<?>[] { primarySource }, args);}
}

3. 执行 SpringApplication() 初始化时，首先设置资源加载器为 null，同时将 primarySources 转换为 List 存到属性中，然后开始推断应用启动的类型

public class SpringApplication {...public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {// 设置资源加载器为 nullthis.resourceLoader = resourceLoader;// 断言加载资源类不能为 nullAssert.notNull(primarySources, "PrimarySources must not be null");// 将 primarySources 数组转换为 List，最后放到 LinkedHashSet 集合中this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));// 1. 推断应用类型，后面会根据类型初始化对应的环境。常用的一般都是 servlet 环境 this.webApplicationType = WebApplicationType.deduceFromClasspath();...}
}

• 推断应用启动类型的时候，首先判断 classpath 下面是否存在 org.springframework.web.reactive.DispatcherHandler，如果存在，则把应用设置为 REACTIVE 类型。如果不存在，则继续判断 classpath 下面是否存在 javax.servlet.Servlet 或者 org.springframework.web.context.ConfigurableWebApplicationContext，不存在就设置应用类型为 None，否则默认是 SERVLET

public enum WebApplicationType {NONE,SERVLET,REACTIVE;private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet","org.springframework.web.context.ConfigurableWebApplicationContext" };...static WebApplicationType deduceFromClasspath() {// 1. classpath 下必须存在 org.springframework.web.reactive.DispatcherHandlerif (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {return WebApplicationType.REACTIVE;}for (String className : SERVLET_INDICATOR_CLASSES) {// 2. classpath 环境下不存在 javax.servlet.Servlet 或者 org.springframework.web.context.ConfigurableWebApplicationContextif (!ClassUtils.isPresent(className, null)) {return WebApplicationType.NONE;}}return WebApplicationType.SERVLET;}
}

4. 推断完程序的应用类型之后吗，就开始设置初始化器

public class SpringApplication {...public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {...// 1. 初始化 classpath 下 META-INF/spring.factories 中已配置的 ApplicationContextInitializersetInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));...}public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {// 2. 设置参数this.initializers = new ArrayList<>(initializers);}
}

• 其中，初始化器的设置主要思路是从 META-INF/spring.factories 找到所有 key 为 org.springframework.context.ApplicationContextInitializer 的实现类，然后逐一初始化，并按照 org.springframework.core.annotation.Order 注解排序

public class SpringApplication {...private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {return getSpringFactoriesInstances(type, new Class<?>[] {});}/*** 通过指定的 classloader 从 META-INF/spring.factories 获取指定的 Spring 的工厂实例*/private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {ClassLoader classLoader = getClassLoader();// 1. 通过指定的 classLoader 从 META-INF/spring.factories 的资源文件中，// 读取 key 为 type.getName() 的 valueSet<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));// 2. 创建工厂实例List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);// 4. 对 Spring 工厂实例排序（org.springframework.core.annotation.Order 注解指定的顺序）AnnotationAwareOrderComparator.sort(instances);return instances;}private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,ClassLoader classLoader, Object[] args, Set<String> names) {// 反射创建对象List<T> instances = new ArrayList<>(names.size());for (String name : names) {try {Class<?> instanceClass = ClassUtils.forName(name, classLoader);Assert.isAssignable(type, instanceClass);Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);// 3. 对象实例化T instance = (T) BeanUtils.instantiateClass(constructor, args);instances.add(instance);}catch (Throwable ex) {throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);}}return instances;}
}

5. 设置完初始化器之后，开始设置监听器。同样是调用 getSpringFactoriesInstances() 的工作流程，首先去 META-INF/spring.factories 找到所有 key 为 org.springframework.context.ApplicationListener 的实现类，逐一初始化，并按照 org.springframework.core.annotation.Order 注解排序

public class SpringApplication {...public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {...// 1. 初始化 classpath 下 META-INF/spring.factories 中已配置的 ApplicationListenersetListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));...}public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {// 2. 设置参数this.listeners = new ArrayList<>(listeners);}
}

6. 然后根据调用栈，找到 main 入口，获取到主程序类，设置到 mainApplicationClass 属性中，并返回

public class SpringApplication {...public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {...// 1. 根据调用栈，推断出 main 方法的类名this.mainApplicationClass = deduceMainApplicationClass();...}private Class<?> deduceMainApplicationClass() {try {StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();for (StackTraceElement stackTraceElement : stackTrace) {if ("main".equals(stackTraceElement.getMethodName())) {return Class.forName(stackTraceElement.getClassName());}}}catch (ClassNotFoundException ex) {// Swallow and continue}return null;}
}

7. 总结
   

获取启动监听器

1. 当完成初始化 SpringApplication 后，开始真正执行 run() 方法

public class SpringApplication {...public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {// 两件事：// 初始化 SpringApplication// 1. 执行 run() 方法return new SpringApplication(primarySources).run(args);}
}

2. 首先初始化 StopWatch 监控程序运行时间，然后开始获取运行时监听器

public class SpringApplication {...public ConfigurableApplicationContext run(String... args) {// 记录程序运行时间StopWatch stopWatch = new StopWatch();stopWatch.start();// ConfigurableApplicationContext Spring 的上下文ConfigurableApplicationContext context = null;Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();configureHeadlessProperty();// 1. 获取并动监听器SpringApplicationRunListeners listeners = getRunListeners(args);...}
}

3. 在执行 getRunListeners() 时，首先同样需要先从 META-INF/spring.factories 获取 key 为 org.springframework.boot.SpringApplicationRunListener 的实现类，然后存到属性中。其中 getSpringFactoriesInstances() 已经说明过了，就不再叙述，同时 SpringApplicationRunListener.class 和 org.springframework.context.ApplicationListener 不一样，这个是个发布器，主要是将在 SpringBoot 不同阶段广播出来的消息传递给 ApplicationListener 实现类

public class SpringApplication {private final Log log;private final List<SpringApplicationRunListener> listeners;...private SpringApplicationRunListeners getRunListeners(String[] args) {Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };// 1. SpringApplicationRunListeners 负责在 SpringBoot 启动的不同阶段，// 广播出不同的消息，传递给 ApplicationListener 监听器实现类return new SpringApplicationRunListeners(logger,getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));}
}

• 其中，SpringApplicationRunListeners 对所有 SpringApplicationRunListener.class 的实现类进行了封装

class SpringApplicationRunListeners {private final Log log;private final List<SpringApplicationRunListener> listeners;...SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners) {this.log = log;this.listeners = new ArrayList<>(listeners);}
}

• 其实实现了 SpringApplicationRunListener.class 接口的，也就只有 org.springframework.boot.context.event.EventPublishingRunListener，它初始化的时候，会把所有 org.springframework.context.ApplicationListener 存入到属性中，用于后面的广播事件给这些监听器

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {private final SpringApplication application;private final String[] args;private final SimpleApplicationEventMulticaster initialMulticaster;public EventPublishingRunListener(SpringApplication application, String[] args) {this.application = application;this.args = args;this.initialMulticaster = new SimpleApplicationEventMulticaster();for (ApplicationListener<?> listener : application.getListeners()) {this.initialMulticaster.addApplicationListener(listener);}}...
}

4. 当拿到运行时监听器之后，就开始对每个运行时监听器执行监听

public class SpringApplication {...public ConfigurableApplicationContext run(String... args) {...// 获取并启动监听器SpringApplicationRunListeners listeners = getRunListeners(args);// 1. 给 listener 发送 starting 事件回调listeners.starting();...}
}

5. 其中，所有的运行时监听器都封装在 SpringApplicationRunListeners，实际也就只有一个运行时监听器 org.springframework.boot.context.event.EventPublishingRunListener

class SpringApplicationRunListeners {private final Log log;private final List<SpringApplicationRunListener> listeners;...// 1. 在 run() 方法开始执行时，该方法就立即被调用，可用于在初始化最早期时做一些工作void starting() {for (SpringApplicationRunListener listener : this.listeners) {listener.starting();}}
}

6. 在执行 starting() 的时候，实际上就是给所有 org.springframework.context.ApplicationListener 发布一个 ApplicationStartingEvent 事件

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {...@Overridepublic void starting() {this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));}
}

7. 总结
   

构建应用上下文环境（上）

1. 首先在程序启动前配置两个文件，并且启动时添加运行时参数

• 设置 application.properties

server.port=8080

• 设置 application-prod.properties

server.port=2222

• 运行时参数设置

--spring.profiles.active=prod

2. 当完成监听器配置，并启动监听后，就需要设置应用环境上下文，从而为其他配置提供一个统一配置环境

public class SpringApplication {...public ConfigurableApplicationContext run(String... args) {...try {// 将运行时参数封装ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 1. 构造应用上下文环境ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);// 2. 处理需要忽略的 BeanconfigureIgnoreBeanInfo(environment);// 3. 打印 bannerBanner printedBanner = printBanner(environment);...}catch (Throwable ex) {...}...}
}

3. 首先执行 prepareEnvironment()，调用 getOrCreateEnvironment() 配置相应的运行时环境

public class SpringApplication {...private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {// 构建整个环境上下文(用户配置，profile)// 1. 创建并配置相应的环境ConfigurableEnvironment environment = getOrCreateEnvironment();...}
}

• 其中 getOrCreateEnvironment() 是根据之前创建 SpringApplication 时推断出来的 webApplicationType 来决定创建哪个环境，这里肯定创建的是 StandardServletEnvironment

public class SpringApplication {private WebApplicationType webApplicationType;	...private Class<? extends StandardEnvironment> deduceEnvironmentClass() {switch (this.webApplicationType) {case SERVLET:return StandardServletEnvironment.class;case REACTIVE:return StandardReactiveWebEnvironment.class;default:return StandardEnvironment.class;}}
}

4. 完成创建 StandardServletEnvironment 之后，需要根据用户配置配置 environment 系统环境

public class SpringApplication {...private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {// 构建整个环境上下文(用户配置，profile)// 创建并配置相应的环境ConfigurableEnvironment environment = getOrCreateEnvironment();// 1. 根据用户配置，配置 environment 系统环境configureEnvironment(environment, applicationArguments.getSourceArgs());...}
}

• 配置 environment 系统环境时，首先把刚刚加的 --spring.profiles.active=prod 运行时参数封装成 SimpleCommandLinePropertySource 加入环境中

public class SpringApplication {...protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {if (this.addConversionService) {ConversionService conversionService = ApplicationConversionService.getSharedInstance();environment.setConversionService((ConfigurableConversionService) conversionService);}// 1. 将 main() 的 args（即 --spring.profiles.active=prod）封装成 SimpleCommandLinePropertySource 加入环境中configurePropertySources(environment, args);...}
}

• 其中加入参数时，先从 environment 中获取 MutablePropertySources 源，然后判断是否包含名为 commandLineArgs 的属性，不包含的话，就把运行时参数封装成 SimpleCommandLinePropertySource 添加到源中

public class SpringApplication {...protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {// 1. 先获取 MutablePropertySources MutablePropertySources sources = environment.getPropertySources();if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {sources.addLast(new MapPropertySource("defaultProperties", this.defaultProperties));}if (this.addCommandLineProperties && args.length > 0) {// 2. 判断是否包含名为 commandLineArgs 的属性String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;if (sources.contains(name)) {...}else {// 3. 把运行时参数（即 --spring.profiles.active=prod）封装成 SimpleCommandLinePropertySource 添加到源中sources.addFirst(new SimpleCommandLinePropertySource(args));}}}
}

• 配置完 environment 系统环境后，就开始激活环境

public class SpringApplication {...protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {if (this.addConversionService) {ConversionService conversionService = ApplicationConversionService.getSharedInstance();environment.setConversionService((ConfigurableConversionService) conversionService);}// 将 main() 的 args（即 --spring.profiles.active=prod）封装成 SimpleCommandLinePropertySource 加入环境中configurePropertySources(environment, args);// 1. 激活相应的配置文件configureProfiles(environment, args);}
}

• 激活的时候，就是把 environment 的属性开启为对应激活的配置，这里就是 prod

public class SpringApplication {private Set<String> additionalProfiles = new HashSet<>();...protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {// 设置激活的profile信息Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles);// 1. 获取到的 activeProfiles 就是 prod		profiles.addAll(Arrays.asList(environment.getActiveProfiles()));// 2. 把对应属性设置为 prod	environment.setActiveProfiles(StringUtils.toStringArray(profiles));}
}

5. 配置环境并激活后，就需要使用监听器发布对应的环境给对应的监听器

public class SpringApplication {...private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {// 构建整个环境上下文(用户配置，profile)// 创建并配置相应的环境ConfigurableEnvironment environment = getOrCreateEnvironment();// 根据用户配置，配置 environment系统环境configureEnvironment(environment, applicationArguments.getSourceArgs());ConfigurationPropertySources.attach(environment);// 1. 启动相应的监听器，其中一个重要的监听器 ConfigFileApplicationListener 就是加载项目配置文件的监听器。listeners.environmentPrepared(environment);...}
}

• 其中，监听器的发布，交由 org.springframework.boot.context.event.EventPublishingRunListener 广播给所有的 org.springframework.context.ApplicationListener，其中，EventPublishingRunListener 会把 environment 封装成 ApplicationEnvironmentPreparedEvent，然后调用广播器广播

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {private final SpringApplication application;private final String[] args;private final SimpleApplicationEventMulticaster initialMulticaster;...@Overridepublic void environmentPrepared(ConfigurableEnvironment environment) {// 1. 通过广播器进行广播发布this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));}
}

• 广播器实际上就是先解析 ApplicationEvent 的类型，然后获取对应的 ApplicationListener 来执行监听任务

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {@Nullableprivate Executor taskExecutor;...@Overridepublic void multicastEvent(ApplicationEvent event) {multicastEvent(event, resolveDefaultEventType(event));}...@Overridepublic void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {// 1. 解析 ApplicationEvent 类型，这里是 org.springframework.boot.context.event.ApplicationEnvironmentPreparedEventResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));// 2. 线程池为空，所以不会调用线程池来执行Executor executor = getTaskExecutor();for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {if (executor != null) {executor.execute(() -> invokeListener(listener, event));}else {// 3. 对 ApplicationListener 执行监听任务invokeListener(listener, event);}}}
}

• 其中，最重要的是 ConfigFileApplicationListener 监听器，主要是用来加载项目配置文件

public class ConfigFileApplicationListener implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {...@Overridepublic void onApplicationEvent(ApplicationEvent event) {if (event instanceof ApplicationEnvironmentPreparedEvent) {// 1. 加载项目配置文件		onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);}if (event instanceof ApplicationPreparedEvent) {onApplicationPreparedEvent(event);}}
}

6. 完成系统环境预处理之后，就将环境配置返回给上文使用

public class SpringApplication {...private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {// 构建整个环境上下文(用户配置，profile)// 创建并配置相应的环境ConfigurableEnvironment environment = getOrCreateEnvironment();// 根据用户配置，配置 environment系统环境configureEnvironment(environment, applicationArguments.getSourceArgs());ConfigurationPropertySources.attach(environment);// 启动相应的监听器，其中一个重要的监听器 ConfigFileApplicationListener 就是加载项目配置文件的监听器。listeners.environmentPrepared(environment);bindToSpringApplication(environment);if (!this.isCustomEnvironment) {environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,deduceEnvironmentClass());}ConfigurationPropertySources.attach(environment);// 1. 返回环境return environment;}
}

7. 总结
   

构建应用上下文环境（下）

1. 完成上下文环境初始化后，第一步开始构建应用上下文

public class SpringApplication {...public ConfigurableApplicationContext run(String... args) {...try {// 将运行时参数封装ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 构造应用上下文环境ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);// 处理需要忽略的 BeanconfigureIgnoreBeanInfo(environment);// 打印 bannerBanner printedBanner = printBanner(environment);// 1. 刷新应用上下文前的准备阶段context = createApplicationContext();...}catch (Throwable ex) {...}...}
}

• 创建上下文也是根据 SpringApplication 初始化时的应用类型来初始化对应应用上下文，这次的类型是 SERVLET，所以创建的时候会初始化 org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext。创建是交由 BeanUtils.instantiateClass 创建

public class SpringApplication {private WebApplicationType webApplicationType;private Class<? extends ConfigurableApplicationContext> applicationContextClass;public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."+ "annotation.AnnotationConfigApplicationContext";public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";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: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);}
}

• 其中，AnnotationConfigServletWebServerApplicationContext 实现了 ConfigurableWebServerApplicationContext 接口，所以返回的时候，能够强转返回。同时，也继承了 GenericWebApplicationContext，后面的代码中会经常看到这个类
  
  • beanFactory 正是 GenericWebApplicationContext 中定义的，在 BeanUtils.instantiateClass 时，不但初始化了我们的上下文（AnnotationConfigServletWebServerApplicationContext），而且触发了 GenericWebApplicationContext 的构造函数，所以 IOC 容器也创建了
    

2. 创建完 AnnotationConfigServletWebServerApplicationContext 上下文之后，再从 META-INF/spring.factories 找到所有 key 为 org.springframework.boot.SpringBootExceptionReporter 实现类，用于报告启动的错误

public class SpringApplication {...public ConfigurableApplicationContext run(String... args) {...try {// 将运行时参数封装ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 构造应用上下文环境ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);// 处理需要忽略的 BeanconfigureIgnoreBeanInfo(environment);// 打印 bannerBanner printedBanner = printBanner(environment);// 刷新应用上下文前的准备阶段context = createApplicationContext();// 1. 实例化 SpringBootExceptionReporter.class，用来支持报告关于启动的错误exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);...}catch (Throwable ex) {...}...}
}

3. 总结