继续分析springboot的启动源码，承接上文springboot 启动分析三，本文主要分析applicationContext的创建以及run方法后续的执行流程
public ConfigurableApplicationContext run(String... args) {
// 声明并实例化一个跑表，用于计算springboot应用程序启动时间
StopWatch stopWatch = new StopWatch();
// 启动跑表
stopWatch.start();
// 声明一个应用程序上下文，注意这里是一个接口声明
ConfigurableApplicationContext context = null;
// 声明一个集合，用于记录springboot异常报告
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
// 配置不在意的属性 java.awt.headless
configureHeadlessProperty();
// 获取用于监听spring应用程序run方法的监听器实例
SpringApplicationRunListeners listeners = getRunListeners(args);
// 循环启动用于run方法的监听器
listeners.starting();
try {
// 封装应用参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
// 根据SpringApplication实例化时候推断出来的应用类型 webApplicationType，
// 去获取不同的环境，然后获取配置要适用的PropertySource以及激活哪个Profile
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
// 根据环境配置需要忽略的bean的信息
configureIgnoreBeanInfo(environment);
// 根据环境配置打印banner，即根据bannerMode 枚举值，决定是否打印banner和banner打印的位置
Banner printedBanner = printBanner(environment);
// key 4 创建应用程序上下文，
context = createApplicationContext();
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[]{ConfigurableApplicationContext.class}, context);
// key 5 准备应用上下文
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
// key 6 刷新上下文
refreshContext(context);
// key 7 处理刷新上下文之后的事情
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
listeners.started(context);
callRunners(context, applicationArguments);
} catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
listeners.running(context);
} catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}
key 4 创建应用上下文 createApplicationContext()
该方法会根据SpringApplication对象（this）的webApplicationType属性返回特定的还没有刷新的上下文对象实例
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
// 判断webApplicationType 类型
switch (this.webApplicationType) {
// SERVLET类型，即AnnotationConfigServletWebServerApplicationContext
case SERVLET:
contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
break;
// REACTIVE类型 即AnnotationConfigReactiveWebServerApplicationContext
case REACTIVE:
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
// 默认类型 即AnnotationConfigApplicationContext
default:
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Unable create a default ApplicationContext, "
+ "please specify an ApplicationContextClass",
ex);
}
}
// BeanUtils 实例化上下文实例
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
本文主要介绍AnnotationConfigServletWebServerApplicationContext
针对web应用的上下文实例，另外两种这里不做介绍
AnnotationConfigServletWebServerApplicationContext
-
构造函数
public AnnotationConfigServletWebServerApplicationContext() { this.annotatedClasses = new LinkedHashSet(); // 处理有spring以及spring支持的ee规范中注解的实现类 this.reader = new AnnotatedBeanDefinitionReader(this); // 组件扫描获取BeanDefinition的实现类 this.scanner = new ClassPathBeanDefinitionScanner(this); }
实例化完成后，我们得到了一个未曾刷新过的上下文实例，继续往下看上下文的准备
key5 上下文准备
主要将上一步实例化得到的上下文对象做相应的准备，比如设置环境
private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
// 1. 设置环境
context.setEnvironment(environment);
// 2. 应用上下文的后置处理
postProcessApplicationContext(context);
// 3. 初始化
applyInitializers(context);
// 4. 应用上下文准备完成事件发布
listeners.contextPrepared(context);
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// 5. 上下文注册有关springboot特定的两个单例类springApplicationArguments 和 springBootBanner
context.getBeanFactory().registerSingleton("springApplicationArguments",
applicationArguments);
if (printedBanner != null) {
context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
}
// 6. 加载资源
Set<Object> sources = getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
load(context, sources.toArray(new Object[0]));
// 7. 应用上下文加载资源完毕事件发布
listeners.contextLoaded(context);
}
- 设置环境
将给定的环境委托给基础成员（AnnotatedBeanDefinitionReader 和 ClassPathBeanDefinitionScanner）一个注解@Bean 定义的解读器，一个ClassPath下的Bean定义（xml）的扫描器
public void setEnvironment(ConfigurableEnvironment environment) {
super.setEnvironment(environment);
this.reader.setEnvironment(environment);
this.scanner.setEnvironment(environment);
}
- 应用上下文的后置处理
就是设置一下是否有自定义的bena name生成器，以及资源加载器
protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
// 判断bean name生成器是否为空，不为空就再上下文中注册一个单例的生成器
if (this.beanNameGenerator != null) {
context.getBeanFactory().registerSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
this.beanNameGenerator);
}
// 判断资源加载器是否为空，不为空就为上下文对象设置资源加载器
if (this.resourceLoader != null) {
if (context instanceof GenericApplicationContext) {
((GenericApplicationContext) context)
.setResourceLoader(this.resourceLoader);
}
if (context instanceof DefaultResourceLoader) {
((DefaultResourceLoader) context)
.setClassLoader(this.resourceLoader.getClassLoader());
}
}
}
- 初始化
就是循环应用上下文初始化器列表，分别调用各初始化器的初始化上下文的方法，而初始化器实例列表实在SpringApplication对象new的时候就从spring.factories文件中根据ApplicationContextInitializer.class作为key获得并实例化的
spring.factories文件示例：
org.springframework.context.ApplicationContextInitializer=
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,
org.springframework.boot.context.ContextIdApplicationContextInitializer,
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
protected void applyInitializers(ConfigurableApplicationContext context) {
for (ApplicationContextInitializer initializer : getInitializers()) {
Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
initializer.getClass(), ApplicationContextInitializer.class);
Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
initializer.initialize(context);
}
}
这里看下这四个应用上下文初始化器分别做了什么
- ConfigurationWarningsApplicationContextInitializer
为缺失配置的错误提示警告
- ContextIdApplicationContextInitializer
应用上下文id初始化，如果再配置文件中设置了spring.application.name的化就取这个，否则就用默认的application作为id名
- DelegatingApplicationContextInitializer
负责从配置文件中获取context.initializer.classes属性设置的外部初始化器class列表，并实例化它们，然后再循环调用它们的初始化方法
- ServerPortInfoApplicationContextInitializer
该初始化器较为特殊，不仅实现了应用上下文初始化器接口，也实现了应用监听器接口（ApplicationListener<WebServerInitializedEvent>），说明其关心的是web服务器初始化完成事件
其初始化方法中只是将自己加入了应用上下文的监听器列表中
public void initialize(ConfigurableApplicationContext applicationContext) {
applicationContext.addApplicationListener(this);
}
而其实际的监听事件的方法就是再配置文件中的server.ports属性源总增加了local.server.port 为key，web实际监听端口为value的属性
public void onApplicationEvent(WebServerInitializedEvent event) {
String propertyName = "local." + getName(event.getApplicationContext()) + ".port";
setPortProperty(event.getApplicationContext(), propertyName,
event.getWebServer().getPort());
}
- 应用上下文准备完成事件发布
当上下文准备完毕后会进行事件发布，让关心该事件的监听器做相应的处理，实际上这里的发布器（EventPublishingRunListener）没有做任何的发布处理，覆写的方法是一个空的方法
public void contextPrepared(ConfigurableApplicationContext context) {
}
- 加载主资源类中的bean定义，并注册bean
当上下文准备完毕后，需要加载应用中的主副资源类（即调用SpringApplication的run方法时传入的主类class），以后会单独分析具体的bean加载注册的流程
- 应用上下文加载资源完毕事件（ApplicationPreparedEvent）发布
该事件的是基于一个SpringApplication启动了，且应用上下文完全准备好，但是还没有刷新的情况下发布的
跟踪断点发现这里有四个监听器是关心该事件的
-
ConfigFileApplicationListener
private void onApplicationPreparedEvent(ApplicationEvent event) { this.logger.replayTo(ConfigFileApplicationListener.class); addPostProcessors(((ApplicationPreparedEvent) event).getApplicationContext()); }
最终执行的监听方法就是向上下文中添加一个适当的后置处理器（PropertySourceOrderingPostProcessor）以处理后置的属性源
后续的几个监听器都没有好分析的，以上就是应用上下文的准备过程
总结
该文主要分析了上下文创建之后的准备过程，包括
设置环境，即将environment设置进context中
上下文的后置处理
设置一下是否有自定义的bena name生成器，以及资源加载器初始化（主要利用spring.factories文件中定义好的几个初始化器做一些初始化处理工作，包括缺失配置的错误警告，上下文id的设置等）
上下文准备完毕事件发布
注册有关springboot特定的两个单例类springApplicationArguments 和 springBootBanner
加载主资源类，即调用SpringApplication的run方法传入的class类中的所有注解@Bean，并注册这些bean
进行加载完成事件发布
后续文章会继续分析上下文的刷新过程
