文章目录
- run方法核心流程
- SpringApplicationRunListener监听器
- 监听器的配置与加载
- SpringApplicationRunListener源码解析
- 实现类EventPublishingRunListener
- 初始化ApplicationArguments
- 初始化ConfigurableEnvironment
- 获取或创建环境
- 配置环境
- 打印Banner
- Spring应用上下文的创建
- Spring应用上下文的准备
- Spring应用上下文的刷新
- 调用ApplicationRunner和CommandLineRunner
run方法核心流程
在分析和学习整个run方法的源代码及操作之前，我们先通过下图所示的流程图来看一下SpringApplication调用的run方法处理的核心操作都包含哪些。
上面的流程图可以看出，SpringApplication在run方法中重点做了以下操作。
- 获取监听器和参数配置。
- 打印Banner信息。
- 创建并初始化容器。
- 监听器发送通知。
当然，除了核心操作，run方法运行过程中还涉及启动时长统计、异常报告、启动日志、异常处理等辅助操作。
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
this.configureHeadlessProperty();
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting();
Collection exceptionReporters;
try {
// 创建 ApplicationArguments 对象
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 加载属性配置
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
this.configureIgnoreBeanInfo(environment);
// 打印banner
Banner printedBanner = this.printBanner(environment);
// 创建容器
context = this.createApplicationContext();
// 异常报告器
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
// 准备容器
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// 初始化容器
this.refreshContext(context);
// 初始化容器后
this.afterRefresh(context, applicationArguments);
// 停止时长统计
stopWatch.stop();
// 打印日志
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
}
// 通知监听器容器启动完成
listeners.started(context);
this.callRunners(context, applicationArguments);
} catch (Throwable var10) {
// 异常处理
this.handleRunFailure(context, var10, exceptionReporters, listeners);
throw new IllegalStateException(var10);
}
try {
// 通知监听器：容器正在运行
listeners.running(context);
return context;
} catch (Throwable var9) {
// 异常处理
this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var9);
}
}
SpringApplicationRunListener监听器
监听器的配置与加载
SpringApplicationRunListeners 可以理解为一个SpringApplicationRunListener的容器，它将SpringApplicationRunListener的集合以构造方法传入，并赋值给其listeners成员变量，然后提供了针对listeners 成员变量的各种遍历操作方法，比如，遍历集合并调用对应的starting、started、running等方法。
SpringApplicationRunListeners 的构建很简单，SpringApplication中getRunListeners方法代码如下：
private SpringApplicationRunListeners getRunListeners(String[] args) {
Class<?>[] types = new Class[]{SpringApplication.class, String[].class};
return new SpringApplicationRunListeners(logger, this.getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
}
SpringApplicationRunListeners构造方法的第二个参数便是SpringApplicationRunListener的集合，SpringApplication中调用构造方法时该参数是通过getSpringFactoriesInstances方法获取（都是一样的套路）的，代码如下：
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
// 获取类加载器
ClassLoader classLoader = this.getClassLoader();
// 加载监听器，并放入set中
Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
// 实例化监听器
List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
// 排序
AnnotationAwareOrderComparator.sort(instances);
return instances;
}
通过方法名便可得知，getSpringFactoriesInstances是用来获取factories配置文件中的注册类，并进行实例化操作。
关于通过SpringFactoriesLoader获取META-INF/spring.factories中对应的配置，构造方法章节已经多次提到，这里不再赞述。SpringApplicationRunListener的注册配置位于spring-boot项目中的spring.factories文件内，SpringBoot默认仅有一个监听器进行了注册，关于其功能后面会专门讲到。
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) {
List<T> instances = new ArrayList(names.size());
Iterator var7 = names.iterator();
while(var7.hasNext()) {
String name = (String)var7.next();
try {
Class<?> instanceClass = ClassUtils.forName(name, classLoader);
Assert.isAssignable(type, instanceClass);
Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
T instance = BeanUtils.instantiateClass(constructor, args);
instances.add(instance);
} catch (Throwable var12) {
throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, var12);
}
}
return instances;
}
在上面的代码中，实例化监听器时需要有一个默认的构造方法，且构造方法的参数为Class<？>[]parameterTypes。我们向上追踪该参数的来源，会发现该参数的值为Class数组，数组的内容依次为SpringApplication.class和String[].class。也就是说，SpringApplicationRunListener的实现类必须有默认的构造方法，且构造方法的参数必须依次为SpringApplication和String[]类型。
SpringApplicationRunListener源码解析
接口SpringApplicationRunListener是SpringApplication的run方法监听器。上节提到了 SpringApplicationRunListener通过SpringFactoriesLoader加载，并且必须声明一个公共构造函数，该函数接收SpringApplication实例和String[]的参数，而且每次运行都会创建一个新的实例。
SpringApplicationRunListener提供了一系列的方法，用户可以通过回调这些方法，在启动各个流程时加入指定的逻辑处理。
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);
}
public void starting() {
Iterator var1 = this.listeners.iterator();
while(var1.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var1.next();
listener.starting();
}
}
public void environmentPrepared(ConfigurableEnvironment environment) {
Iterator var2 = this.listeners.iterator();
while(var2.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
listener.environmentPrepared(environment);
}
}
public void contextPrepared(ConfigurableApplicationContext context) {
Iterator var2 = this.listeners.iterator();
while(var2.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
listener.contextPrepared(context);
}
}
public void contextLoaded(ConfigurableApplicationContext context) {
Iterator var2 = this.listeners.iterator();
while(var2.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
listener.contextLoaded(context);
}
}
public void started(ConfigurableApplicationContext context) {
Iterator var2 = this.listeners.iterator();
while(var2.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
listener.started(context);
}
}
public void running(ConfigurableApplicationContext context) {
Iterator var2 = this.listeners.iterator();
while(var2.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
listener.running(context);
}
}
public void failed(ConfigurableApplicationContext context, Throwable exception) {
Iterator var3 = this.listeners.iterator();
while(var3.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var3.next();
this.callFailedListener(listener, context, exception);
}
}
private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context, Throwable exception) {
try {
listener.failed(context, exception);
} catch (Throwable var6) {
if (exception == null) {
ReflectionUtils.rethrowRuntimeException(var6);
}
if (this.log.isDebugEnabled()) {
this.log.error("Error handling failed", var6);
} else {
String message = var6.getMessage();
message = message != null ? message : "no error message";
this.log.warn("Error handling failed (" + message + ")");
}
}
}
}
我们通过源代码可以看出，SpringApplicationRunListener为run方法提供了各个运行阶段的监听事件处理功能。
下图展示了在整个run方法的生命周期中SpringApplicationRunListener的所有方法所处的位置，该图可以帮助我们更好地学习run方法的运行流程。在前面run方法的代码中已经看到相关监听方法被调用，后续的源代码中也将涉及对应方法的调用，我们可参考此图以便理解和加深记忆。
实现类EventPublishingRunListener
EventPublishingRunListener是SpringBoot中针对SpringApplicationRunListener接口的唯一内建实现。EventPublishingRunListener使用内置的SimpleApplicationEventMulticaster来广播在上下文刷新之前触发的事件。
默认情况下，SpringBoot在初始化过程中触发的事件也是交由EventPublishingRunListener来代理实现的。
SpringBoot完成基本的初始化之后，会遍历SpringApplication的所有ApplicationListener实例，并将它们与SimpleApplicationEventMulticaster进行关联，方便SimpleApplicationEventMulticaster后续将事件传递给所有的监听器。
EventPublishingRunListener针对不同的事件提供了不同的处理方法，但它们的处理流程基本相同。
public void contextLoaded(ConfigurableApplicationContext context) {
ApplicationListener listener;
for(Iterator var2 = this.application.getListeners().iterator(); var2.hasNext(); context.addApplicationListener(listener)) {
listener = (ApplicationListener)var2.next();
if (listener instanceof ApplicationContextAware) {
((ApplicationContextAware)listener).setApplicationContext(context);
}
}
this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
}
contextLoaded方法在发布事件之前做了两件事：第一，遍历application的所有监听器实现类，如果该实现类还实现了ApplicationContextAware接口，则将上下文信息设置到该监听器内；第二，将application中的监听器实现类全部添加到上下文中。最后一步才是调用事件广播。
也正是这个方法形成了不同事件广播形式的分水岭，在此方法之前执行的事件广播都是通过multicastEvent来进行的，而该方法之后的方法则均采用publishEvent来执行。这是因为只有到了contextLoaded方法之后，上下文才算初始化完成，才可通过它的publishEvent方法来进行事件的发布。
初始化ApplicationArguments
监听器启动之后，紧接着便是执行ApplicationArguments对象的初始化，ApplicationArguments是用于提供访问运行SpringApplication时的参数。
ApplicationArguments的初始化过程非常简单，只是调用了它的实现类DefaultApplicationArguments并传入main方法中的args参数。
在DefaultApplicationArguments中将参数args封装为Source对象，Source对象是基于Spring框架的SimpleCommandLinePropertySource来实现的。
初始化ConfigurableEnvironment
完成ApplicationArguments参数的准备之后，便开始通过prepareEnvironment方法对ConfigurableEnvironment对象进行初始化操作。
ConfigurableEnvironment接口继承自Environment接口和ConfigurablePropertyResolver，最终都继承自接口PropertyResolverConfigurableEnvironment接口的主要作用是提供当前运行环境的公开接口，比如配置文件profiles各类系统属性和变量的设置、添加、读取、合并等功能。
通过ConfigurableEnvironment接口中方法定义，可以更清楚地了解它的功能，代码如下：
public interface ConfigurableEnvironment extends Environment, ConfigurablePropertyResolver {
void setActiveProfiles(String... var1);
void addActiveProfile(String var1);
void setDefaultProfiles(String... var1);
MutablePropertySources getPropertySources();
Map<String, Object> getSystemProperties();
Map<String, Object> getSystemEnvironment();
void merge(ConfigurableEnvironment var1);
}
通过接口提供的方法，我们可以看出ConfigurableEnvironment就是围绕着这个“环境”来提供相应的功能，这也是为什么我们也将它称作“环境”。
了解了ConfigurableEnvironment的功能及方法，我们回归到SpringApplication的流程看相关源代码。run方法中调用prepareEnvironment方法相关代码如下：
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
ConfigurableEnvironment environment = this.getOrCreateEnvironment();
this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
listeners.environmentPrepared((ConfigurableEnvironment)environment);
this.bindToSpringApplication((ConfigurableEnvironment)environment);
if (!this.isCustomEnvironment) {
environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
}
ConfigurationPropertySources.attach((Environment)environment);
return (ConfigurableEnvironment)environment;
}
通过以上代码可知，prepareEnvironment进行了以下的操作：
- 获取或创建环境。
- 配置环境。
- ConfigurationPropertySources附加到指定环境：将ConfigurationPropertySources附加到指定环境中的第一位，并动态跟踪环境的添加或删除（当前版本新增了该行代码，与最后一步操作相同）。
- 设置listener监听事件：前面章节已经讲过，此处主要针对准备环境的监听。
- 绑定环境到SpringApplication：将环境绑定到name为“spring.main”的目标上。
- 转换环境：判断是否是定制的环境，如果不是定制的，则将环境转换为StandardEnvironment。此时判断条件isCustomEnvironment默认为false，在后面的操作中会将其设置为true，如果为true则不再会进行此转换操作。
- ConfigurationPropertySources附加到指定环境：将ConfigurationPropertySources附加到指定环境中的第一位，并动态跟踪环境的添加或删除操作。
获取或创建环境
SpringApplication类中通过getOrCreateEnvironment方法来获取或创建环境。在该方法中首先判断环境是否为null，如果不为null则直接返回；如果为null，则根据前面推断出来的WebApplicationType类型来创建指定的环境。
配置环境
在获得环境变量对象之后，开始对环境变量和参数进行相应的设置，主要包括转换服务的设置、PropertySources的设置和activeProfiles的设置。
打印Banner
完成环境的基本处理之后，下面就是控制台Banner的打印了。SpringBoot的Banner打印是一个比较酷炫的功能，但又显得有些华而不实，特别是打印图片时启动速度会变慢。
private Banner printBanner(ConfigurableEnvironment environment) {
if (this.bannerMode == Mode.OFF) {
return null;
} else {
ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader : new DefaultResourceLoader(this.getClassLoader());
SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter((ResourceLoader)resourceLoader, this.banner);
return this.bannerMode == Mode.LOG ? bannerPrinter.print(environment, this.mainApplicationClass, logger) : bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}
}
上面的代码中展示了Banner的开启及打印位置的设置。程序通过Banner.Mode枚举值来判断是否开启Banner打印，此项参数可以在SpringBoot入口nmain方法中通过setBannerMode方法来设置，也可以通过application.properties中的spring.main.banner-mode进行设置。
SpringApplicationBannerPrinter类承载了Banner初始化及打印的核心功能，比如默认如何获取Banner信息、如何根据约定优于配置来默认获得Banner的内容、Banner支持的文件格式等。
而具体打印的信息是由Banner接口的实现类来完成的，比如默认情况下使用SpringBootBanner来打印SpringBoot的版本信息及简单的图形。当然还有通过资源文件打印的ResourceBanner，通过图片打印的ImageBanner等方法。
Spring应用上下文的创建
SpringBoot创建Spring的应用上下文时，如果未指定要创建的类，则会根据之前推断出的类型来进行默认上下文类的创建。
在SpringBoot中通过SpringApplication类中的createApplicationContext来进行应用上下文的创建，代码如下：
protected ConfigurableApplicationContext createApplicationContext() {
// 获取容器的类变量
Class<?> contextClass = this.applicationContextClass;
// 如果为null，则根据Web应用类型按照默认类进行创建
if (contextClass == null) {
try {
switch(this.webApplicationType) {
case SERVLET:
contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
break;
case REACTIVE:
contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
break;
default:
contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
}
} catch (ClassNotFoundException var3) {
throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
}
}
return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
Spring应用上下文的准备
我们在上一节完成了应用上下文的创建工作，SpringApplication继续通过prepareContext方法来进行应用上下文的准备工作。
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
// 设置应用上下文环境
context.setEnvironment(environment);
// 设置应用上下文后置处理
this.postProcessApplicationContext(context);
// 初始化context
this.applyInitializers(context);
// 通知监听器上下文准备阶段
listeners.contextPrepared(context);
// 打印 profile
if (this.logStartupInfo) {
this.logStartupInfo(context.getParent() == null);
this.logStartupProfileInfo(context);
}
// 获取 ConfigurableListableBeanFactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
// 获取全部配置源
Set<Object> sources = this.getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
// 将获取到的配置源加载到context中
this.load(context, sources.toArray(new Object[0]));
// 通知监听器 context 加载完成
listeners.contextLoaded(context);
}
Spring应用上下文的刷新
Spring应用上下文的刷新，是通过调用SpringApplication中的refreshContext方法来完成的。SpringApplication中refreshContext方法相关代码如下：
private void refreshContext(ConfigurableApplicationContext context) {
this.refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
} catch (AccessControlException var3) {
}
}
}
protected void refresh(ApplicationContext applicationContext) {
Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
((AbstractApplicationContext)applicationContext).refresh();
}
其中refresh方法调用的是AbstractApplicationContext中的refresh方法，该类属于spring-context包。AbstractApplicationContext的refresh方法更多的是Spring相关的内容。
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
this.invokeBeanFactoryPostProcessors(beanFactory);
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
this.finishBeanFactoryInitialization(beanFactory);
this.finishRefresh();
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
}
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches();
}
}
}
在上面的代码中，调用finishRefresh方法初始化容器的生命周期处理器并发布容器的生命周期事件之后，Spring应用上下文正式开启，SpringBoot核心特性也随之启动。完成refreshContext方法操作之后，调用afterRefresh方法。
完成以上操作之后，调用SpringApplicationRunListeners的started方法，通知监听器容器启动完成，并调用ApplicationRunner和CommandLineRunner的运行方法。
调用ApplicationRunner和CommandLineRunner
ApplicationRunner和CommandLineRunner是通过 SpringApplication类的callRunners方法来完成的，具体代码如下：
private void callRunners(ApplicationContext context, ApplicationArguments args) {
List<Object> runners = new ArrayList();
runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
AnnotationAwareOrderComparator.sort(runners);
Iterator var4 = (new LinkedHashSet(runners)).iterator();
while(var4.hasNext()) {
Object runner = var4.next();
if (runner instanceof ApplicationRunner) {
this.callRunner((ApplicationRunner)runner, args);
}
if (runner instanceof CommandLineRunner) {
this.callRunner((CommandLineRunner)runner, args);
}
}
}
以上代码，首先从context中获得类型为ApplicationRunner和CommandLineRunner的Bean，将它们放入List列表中并进行排序。然后再遍历调用其run方法，并将ApplicationArguments参数传入。
SpringBoot提供这两个接口的目的，是为了我们在开发的过程中，通过它们来实现在容器启动时执行一些操作，如果有多个实现类，可通过@Order注解或实现Ordered接口来控制执行顺序。
这两个接口都提供了一个run方法，但不同之处在于：ApplicationRunner中run方法的参数为ApplicationArguments，而CommandLineRunner接口中run方法的参数为String数组。
以上方法执行完成后，会通过SpringApplicationRunListeners的running方法通知监听器：容器此刻已处于运行状态。至此，SpringApplication的run方法执行完毕。
