一、SpringApplication 构造
run方法启动
public class SpringApplication {
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return new SpringApplication(primarySources).run(args);
}
public SpringApplication(Class<?>... primarySources) {
this(null, primarySources);
}
}
构造函数做了什么
public class SpringApplication {
public SpringApplication(Class<?>... primarySources) {
this(null, primarySources);
}
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
// 资源加载器, 实际是null
this.resourceLoader = resourceLoader;
// 配置类不能位null, 一般只设置一个主配置类
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
// 判断应用类型, 暂时只用管 Servlet 应用即可
this.webApplicationType = WebApplicationType.deduceFromClasspath();
// 加载 META-INF/spring.factories 文件, 注意 META-INF/spring.factories 的加载是一次性加载的
// 全部加载完毕后, 取出所有键为 BootstrapRegistryInitializer 的类
this.bootstrapRegistryInitializers = new ArrayList<>(
getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
// META-INF/spring.factories 所有键为 ApplicationContextInitializer 的类, 赋值字段 initializers
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// META-INF/spring.factories 所有键为 ApplicationListener 的类, 赋值字段 listeners
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// main 函数所在类
this.mainApplicationClass = deduceMainApplicationClass();
}
}
三种 Listener
- BootstrapRegistryInitializer：只会被调用一次，后面可以看到，最先执行，在 BootstrapContext 创建后立即执行，这时我们平时应用中使用的 ApplicationContext 都还没有创建呢，【帮助 BootstrapContext 初始化】
- ApplicationContextInitializer：在 ApplicationContext 被创建，设置了 Environment 后，未 refresh 前调用，基本上可认为在 ApplicationContext 还为初始化前调用，【帮助 ApplicationContext 初始化】
- ApplicationListener：响应各种事件，会被 EventPublishingRunListener（SpringApplicationRunListeners） 调用
- SpringApplicationRunListener：【暂略】
二、run流程
1. BootstrapContext 创建
public class SpringApplication {
private DefaultBootstrapContext createBootstrapContext() {
/// 默认启动器
DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
// 调用所有 NETA-INF/spring.factories 下找到的 BootstrapRegistryInitializer 对象的 initialize 初始化方法
// 传入 BootstrapRegistry 作为参数, 可以看下提高了哪些API
this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
return bootstrapContext;
}
}
- 创建 BootstrapRegistry 实例 DefaultBootstrapContext
- 调用 BootstrapRegistryInitializer#initialize，参数为刚刚创建的 BootstrapRegistry
2. 查找 SpringApplicationRunListener
public class SpringApplication {
private SpringApplicationRunListeners getRunListeners(String[] args) {
Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
// SpringApplicationRunListeners 封装了所有 SpringApplicationRunListener 实例
return new SpringApplicationRunListeners(logger,
// META-INF/spring.factories 内的 SpringApplicationRunListener 并创建实例
getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
// SpringApplication 的, 默认是 DefaultApplicationStartup(基本啥也没干), 应该是监控埋点, 监控启动时的各种性能指标的
// 说白了第三方可以进行扩展, 暂时略
this.applicationStartup);
}
}
下面看一下 SpringApplicationRunListener 的各个方法
public interface SpringApplicationRunListener {
/**
* 差不多当调用run方法后会立即调用，可以用于非常早期的初始化'
* BootstrapRegistryInitializer#initialize -> starting
*/
default void starting(ConfigurableBootstrapContext bootstrapContext) {
}
/**
* Environment 环境准备好之后调用, 此时 ApplicationContext 还未创建
*/
default void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
ConfigurableEnvironment environment) {
}
// -- 中间 PrintBanner, 打印了 Banner
/**
* ApplicationContext 创建后 -> setEnvironment -> ApplicationContextInitializer#initialize -> contextPrepared
* 这个执行完毕, BootstrapContext 就会 close 了
*/
default void contextPrepared(ConfigurableApplicationContext context) {
}
/**
* #contextPrepared -> BootstrapContext#close -> ApplicationContext#register(我们传入的主配置类) -> contextLoaded
* 注意此时还未 refresh
*/
default void contextLoaded(ConfigurableApplicationContext context) {
}
// -- 中间 ApplicationContext#refresh, 解析创建Bean实例了
/**
* ApplicationContext#refresh 已被调用, CommandLineRunner、ApplicationRunner 未被调用
*/
default void started(ConfigurableApplicationContext context, Duration timeTaken) {
started(context);
}
// 已废弃, 略
@Deprecated
default void started(ConfigurableApplicationContext context) {
}
/**
* CommandLineRunner、ApplicationRunner 已被调用, run 方法马上结束
*/
default void ready(ConfigurableApplicationContext context, Duration timeTaken) {
running(context);
}
// 已废弃, 略
@Deprecated
default void running(ConfigurableApplicationContext context) {
}
/**
* 在启动过程发生失败时调用, run 中发生异常(Throwable)被 catch 时调用, 表明启动失败
*/
default void failed(ConfigurableApplicationContext context, Throwable exception) {
}
}
3. 命令行参数解析
public class DefaultApplicationArguments {
public DefaultApplicationArguments(String... args) {
Assert.notNull(args, "Args must not be null");
this.source = new Source(args);
this.args = args;
}
}
private static class Source extends SimpleCommandLinePropertySource {
Source(String[] args) {
super(args);
}
}
public class SimpleCommandLinePropertySource extends CommandLinePropertySource<CommandLineArgs> {
public SimpleCommandLinePropertySource(String... args) {
super(new SimpleCommandLineArgsParser().parse(args));
}
}
public abstract class CommandLinePropertySource<T> extends EnumerablePropertySource<T> {
public static final String COMMAND_LINE_PROPERTY_SOURCE_NAME = "commandLineArgs";
public static final String DEFAULT_NON_OPTION_ARGS_PROPERTY_NAME = "nonOptionArgs";
private String nonOptionArgsPropertyName = DEFAULT_NON_OPTION_ARGS_PROPERTY_NAME;
public CommandLinePropertySource(T source) {
super(COMMAND_LINE_PROPERTY_SOURCE_NAME, source);
}
}
public abstract class EnumerablePropertySource<T> extends PropertySource<T> {
public EnumerablePropertySource(String name, T source) {
super(name, source);
}
}
public abstract class PropertySource<T> {
public PropertySource(String name, T source) {
this.name = name;
this.source = source;
}
}
/**
* 解析 String数组, 这个数组一般是命令函参数
* 解析 --开头的 类型的为 【option arguments】, 大致理解为键值对形式的
* 其他一般的非 --开头的键值对形式的存储在另一个List中
* 注意: IDEA 里面 VM options 里配置的是 -Dproperty=val 的被 System.getProperty 获取的属性, Program Arguments 才是命令行的
*
* 【注意等号两侧不能有空格, 否则作为两个参数解析(连续的是一个)】
* 【注意下面的引号表示这是一个字符串】
* --foo ---> 键foo, 值null
* --foo ---> 键foo, 值 ""(空串)
* --foo="" ---> 键foo, 值 ""(空串)
* --foo=bar ---> 键foo, 值bar
* --foo="bar" ---> 键foo, 值bar
* --foo="bar then baz" ---> 键foo, 值"bar then baz"
* --foo=bar,then,baz ---> 键foo, 值"bar then baz"
* --foo=bar --foo=baz --foo=biz ---> 键foo, 值有三个, bar、baz、biz, List存储值的(非Set)
* --->
* --->
* --->
*/
class SimpleCommandLineArgsParser {
public CommandLineArgs parse(String... args) {
CommandLineArgs commandLineArgs = new CommandLineArgs();
for (String arg : args) {
if (arg.startsWith("--")) {
String optionText = arg.substring(2);
String optionName;
String optionValue = null;
int indexOfEqualsSign = optionText.indexOf('=');
if (indexOfEqualsSign > -1) {
optionName = optionText.substring(0, indexOfEqualsSign);
optionValue = optionText.substring(indexOfEqualsSign + 1);
}
else {
optionName = optionText;
}
if (optionName.isEmpty()) {
throw new IllegalArgumentException("Invalid argument syntax: " + arg);
}
// 键值对象形式存储在 Map<String, List<String>> optionArgs
commandLineArgs.addOptionArg(optionName, optionValue);
}
else {
// 非键值对形式的存储在 List<String> nonOptionArgs
commandLineArgs.addNonOptionArg(arg);
}
}
return commandLineArgs;
}
}
- 命令行参数形式与解析，略
- 应该是每一种 Property 都应该有其名称，命令行的就是 commandLineArgs
DefaultApplicationArguments的继承关系比较简单，继承ApplicationArguments，就是最顶层的接口了，下面列出API，就不解释了
public interface ApplicationArguments {
// 原始未解析的数组形式的
String[] getSourceArgs();
Set<String> getOptionNames();
boolean containsOption(String name);
List<String> getOptionValues(String name);
List<String> getNonOptionArgs();
}
但是Source的继承关系比较复杂，但还好都是单继承形式的 Source -> SimpleCommandLinePropertySource -> CommandLinePropertySource -> EnumerablePropertySource -> PropertySource
暂时略，使用到再回来
4. Environment 准备
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
// Create and configure the environment
// Servlet 应用创建了 ApplicationServletEnvironment 对象, 内部已经读取了 System.properties 和 System.env
// 内部层层向上的初始化很复杂
ConfigurableEnvironment environment = getOrCreateEnvironment();
// getSourceArgs 得到的是未处理过的命令行参数, String[] 类型, 基本上就是main函数的 args
// 解析命令行参数并将其作为 PropertySource 添加进入 Environment
configureEnvironment(environment, applicationArguments.getSourceArgs());
// 将所有PropertySource封装为一个 ConfigurationPropertySourcesPropertySource, 优先级最高, 键为 configurationProperties
ConfigurationPropertySources.attach(environment);
// 调用所有 SpringApplicationRunListener 的 environmentPrepared, 表示启动环境准备好了
// SpringApplicationRunListeners 持有所有 SpringApplicationRunListener
// 有一个 SpringApplicationRunListener 为 EventPublishingRunListener, 它(持有SpringApplication, 而 SpringApplication 在创建时又初始化并持有所有 ApplicationListener)分发各种事件给 ApplicationListener
// 可以看一下 ApplicationListener 的API, 很简单, 只响应事件
// 有一个 ApplicationListener 为 EnvironmentPostProcessorApplicationListener, 它只响应环境相关事件, 持有 META-INF/spring.factories 下的所有 EnvironmentPostProcessor
// 有一个 EnvironmentPostProcessor 为 SystemEnvironmentPropertySourceEnvironmentPostProcessor, 它在 environmentPrepared 时 替换 systemEnvironment 为 OriginAwareSystemEnvironmentPropertySource, 名称不变
// 有一个 EnvironmentPostProcessor 为 ConfigDataEnvironmentPostProcessor, 读取我们的配置文件的
listeners.environmentPrepared(bootstrapContext, environment);
// 移动名为 defaultProperties 的 PropertySource, 默认是没有这个 PropertySource 的
DefaultPropertiesPropertySource.moveToEnd(environment);
Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
"Environment prefix cannot be set via properties.");
// 绑定环境中spring.main开头属性绑定到SpringApplication对象中, 实际就是设置一些 SpringApplication 的属性, 比如 spring.main.xxx=log
bindToSpringApplication(environment);
if (!this.isCustomEnvironment) {
environment = new EnvironmentConverter(getClassLoader())
// 这里实际没转
.convertEnvironmentIfNecessary(environment,
// 根据运行类型, 如Servlet的WEB
deduceEnvironmentClass());
}
// 再来一次, 保证名为 configurationProperties 的优先级最高, 且含所有 PropertySource
ConfigurationPropertySources.attach(environment);
return environment;
}
getOrCreateEnvironment 先略
configureEnvironment 解析命令行参数加入 Environment，名称为 commandLineArgs 的命令行参数 PropertySource
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
// 默认 true
if (this.addConversionService) {
// 转换器?干什么的
environment.setConversionService(new ApplicationConversionService());
}
// 读取命令行参数(--开头的)
configurePropertySources(environment, args);
// 配置profile, 内部实现为空
configureProfiles(environment, args);
}
protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
// 得到 MutablePropertySources 对象
// 四个 servletConfigInitParams 、 servletContextInitParams 、 systemProperties 、systemEnvironment
MutablePropertySources sources = environment.getPropertySources();
// false, defaultProperties 为null, 还未初始化
if (!CollectionUtils.isEmpty(this.defaultProperties)) {
DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
}
// addCommandLineProperties 添加命令行参数, 默认为true, 且有命令行参数才添加
if (this.addCommandLineProperties && args.length > 0) {
// commandLineArgs, 每个 PropertySource 都是有其名称的
String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
// 没有
if (sources.contains(name)) {
PropertySource<?> source = sources.get(name);
CompositePropertySource composite = new CompositePropertySource(name);
composite.addPropertySource(
new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
composite.addPropertySource(source);
sources.replace(name, composite);
}
else {
// addFirst, 那么命令行参数的优先级显然更高, new SimpleCommandLinePropertySource 进行解析了
// add的类型只要求是 PropertySource
sources.addFirst(new SimpleCommandLinePropertySource(args));
}
}
}
ConfigurationPropertySources.attach，PropertySource 封装
将所有 PropertySource 封装在 名为 configurationProperties 的 PropertySource 中，实际有 PropertySource 的变化必然会体现在 sources 中，而它持有 sources 引用作为 source
public static void attach(Environment environment) {
Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
// 五个 命令行 > servletConfigInitParams >servletContextInitParams >systemProperties >systemEnvironment
MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
// getAttached 是判断是否已经有名为 configurationProperties 这个 PropertySource, 有则获取
PropertySource<?> attached = getAttached(sources);
// ? 看下面创建 PropertySource 时将 sources 作为 source 了, 二次进入如果没有意外 getSource 必然和 sources 相等
if (attached != null && attached.getSource() != sources) {
sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
attached = null;
}
if (attached == null) {
// 封装为 ConfigurationPropertySourcesPropertySource, SpringConfigurationPropertySources 持有 sources
// 内部暂时没有做什么解析
sources.addFirst(new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
new SpringConfigurationPropertySources(sources)));
}
}
listeners.environmentPrepared(bootstrapContext, environment)
环境准备，调用 SpringApplicationRunListeners，而 SpringApplicationRunListeners 持有所有 SpringApplicationRunListener，也就是调用 所有 SpringApplicationRunListener#environmenPrepared
有一个 SpringApplicationRunListener 为 EventPublishingRunListener，它持有 SpringApplication 实例，通过这个实例间接持有所有 ApplicationListener 实例，EventPublishingRunListener 分发事件，ApplicationListener 监听事件
class SpringApplicationRunListeners {
// SpringApplicationRunListener 的其他方法都是这样调用的, 不过是下面硬编码的字符串不同, 还有调用 listener. 的方法不同
void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
doWithListeners("spring.boot.application.environment-prepared",
(listener) -> listener.environmentPrepared(bootstrapContext, environment));
}
private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
doWithListeners(stepName, listenerAction, null);
}
private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
Consumer<StartupStep> stepAction) {
// SpringApplication 创建时传过来的, 对启动过程进行监控, 默认的几乎没有实现
StartupStep step = this.applicationStartup.start(stepName);
// SpringApplicationRunListener 监听器执行
this.listeners.forEach(listenerAction);
if (stepAction != null) {
stepAction.accept(step);
}
step.end();
}
}
EventPublishingRunListener -> SpringApplicationRunListener
先略过它的实现，它持有 SpringApplication 实例，构造时获取了 SpringApplication 构造函数时获取的所有 ApplicationListener
内部持有一个事件分发/广播器 SimpleApplicationEventMulticaster，由它持有 SpringApplication ，并广播一个事件
环境 Environment 初始化相关
public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
ConfigurableEnvironment environment) {
// SimpleApplicationEventMulticaster
this.initialMulticaster.multicastEvent(
// 事件对象
new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
}
}
EnvironmentPostProcessorApplicationListener -> ApplicationListener
根据名称就知道是 Environment 相关的
public class EnvironmentPostProcessorApplicationListener implements SmartApplicationListener, Ordered {
// 支持的事件
public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
// 环境准备 -> 准备好了 -> run 失败
return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(eventType)
|| ApplicationPreparedEvent.class.isAssignableFrom(eventType)
|| ApplicationFailedEvent.class.isAssignableFrom(eventType);
}
private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
ConfigurableEnvironment environment = event.getEnvironment();
SpringApplication application = event.getSpringApplication();
// getEnvironmentPostProcessors 略具体逻辑, 大致是获取 META-INF/spring.factories 的 所有 EnvironmentPostProcessor
for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
event.getBootstrapContext())) {
postProcessor.postProcessEnvironment(environment, application);
}
}
}
ConfigDataEnvironmentPostProcessor --> EnvironmentPostProcessor
加载 ConfigData 配置数据到 Environment，我们配置的东西就会被加载进去
比较复杂，略
RandomValuePropertySourceEnvironmentPostProcessor -> EnvironmentPostProcessor
随机数的
5. 打印 Banner
直接略
private Banner printBanner(ConfigurableEnvironment environment) {
// banner模式，可以是console、log、off, 默认 CONSOLE, 前一步 prepareEnvironment 有读取配置
if (this.bannerMode == Banner.Mode.OFF) {
return null;
}
ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader
: new DefaultResourceLoader(null);
// this.banner 一般默认为 null, 好像是 fallbackBanner, 就是没有其他选择才使用这个 ?
SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);
// spring.banner.image.location /(若没配置则) 类路径下 banner.gif、jpg、png
// 若上面没有则 spring.banner.location / (若没配置则) 类路径下 banner.txt
if (this.bannerMode == Mode.LOG) {
return bannerPrinter.print(environment, this.mainApplicationClass, logger);
}
return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}
6. 创建 SpringContext 容器
public class SpringApplication {
protected ConfigurableApplicationContext createApplicationContext() {
// AnnotationConfigServletWebServerApplicationContext
return this.applicationContextFactory.create(this.webApplicationType);
}
}
public interface ApplicationContextFactory {
ApplicationContextFactory DEFAULT = (webApplicationType) -> {
try {
switch (webApplicationType) {
case SERVLET:
// Servlet 的这个 !!!
return new AnnotationConfigServletWebServerApplicationContext();
case REACTIVE:
return new AnnotationConfigReactiveWebServerApplicationContext();
default:
// 诶, Spring常用的这个
return new AnnotationConfigApplicationContext();
}
}
};
}
// 这里内部的初始化基本就是 Spring 中 AnnotationConfigApplicationContext 初始化的那套了, 这里就不说了
public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
implements AnnotationConfigRegistry {
public AnnotationConfigServletWebServerApplicationContext() {
// 内部注册的重要的 ConfigurationClassPostProcessor
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
}
context.setApplicationStartup(this.applicationStartup);
7. SpringContext 容器准备
待续 .....
private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
// 环境设置
context.setEnvironment(environment);
// 预处理, 实际基本啥也没做, 添加了一个 ConversionService, 暂略
postProcessApplicationContext(context);
// ApplicationContextInitializer#initialize 调用 !!!
applyInitializers(context);
// 发布上下文准备完成事件到所有监听器
listeners.contextPrepared(context);
// Bootstrap 环境关闭
bootstrapContext.close(context);
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// Add boot specific singleton beans
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
// 注册命令行参数Bean
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
// 注册Banner的Bean
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory) beanFactory)
.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
// Load the sources
// 传入的主配置类
Set<Object> sources = getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
// 加载Bean到上下文, 说白了就是向 SpringWeb 的 Application#register 注册所有主配置类的 BD
load(context, sources.toArray(new Object[0]));
// 发送上下文加载完成事件
listeners.contextLoaded(context);
}
8. refresh
public class SpringApplication {
private void refreshContext(ConfigurableApplicationContext context) {
// 注册钩子, 在JVM退出时执行
if (this.registerShutdownHook) {
// 添加：Runtime.getRuntime().addShutdownHook()
// 移除：Runtime.getRuntime().removeShutdownHook(this.shutdownHook)
shutdownHook.registerApplicationContext(context);
}
// ApplicationContext真正开始初始化容器和创建bean的阶段
refresh(context);
}
protected void refresh(ConfigurableApplicationContext applicationContext) {
// 这里暂略, 里面不仅有传统的 AnnotationConfigApplicationContext#refresh 的那一套
applicationContext.refresh();
}
}
protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
// 空壳方法
}
9. ApplicationRunner 和 CommandLineRunner
public class SpringApplication {
// 结束时间
Duration timeTakeToStartup = Duration.ofNanos(System.nanoTime() - startTime);
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakeToStartup);
}
// 应用程序启动事件
listeners.started(context, timeTakeToStartup);
// 执行实现ApplicationRunner、CommandLineRunner的run方法
callRunners(context, applicationArguments);
// ---------------------
private void callRunners(ApplicationContext context, ApplicationArguments args) {
List<Object> runners = new ArrayList<>();
// ApplicationContext 中取出来的, 什么时候放入的, 待续 .......
runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
AnnotationAwareOrderComparator.sort(runners);
for (Object runner : new LinkedHashSet<>(runners)) {
if (runner instanceof ApplicationRunner) {
callRunner((ApplicationRunner) runner, args);
}
if (runner instanceof CommandLineRunner) {
callRunner((CommandLineRunner) runner, args);
}
}
}
}
10. 完成
public class SpringApplication {
catch (Throwable ex) {
handleRunFailure(context, ex, listeners);
throw new IllegalStateException(ex);
}
try {
Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
// 应用准备好了
listeners.ready(context, timeTakenToReady);
}
catch (Throwable ex) {
handleRunFailure(context, ex, null);
throw new IllegalStateException(ex);
}
return context;
// ---------------------------------------
private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception,
SpringApplicationRunListeners listeners) {
try {
try {
handleExitCode(context, exception);
if (listeners != null) {
// 这里 SpringApplicationRunListeners
listeners.failed(context, exception);
}
}
finally {
reportFailure(getExceptionReporters(context), exception);
if (context != null) {
context.close();
}
}
}
catch (Exception ex) {
logger.warn("Unable to close ApplicationContext", ex);
}
ReflectionUtils.rethrowRuntimeException(exception);
}
}