本文详细介绍了如何在SpringBoot中使用spring.factories配置ApplicationContextInitializer，包括其在初始化流程中的作用，源码解析，以及默认扩展实现，如ContextIdApplicationContextInitializer和ConditionEvaluationReportLoggingListener的工作原理。
所有调试均使用SpringBoot 2.4.5版本。
这一章首先来理解下SpringBoot的spring.factories中的 org.springframework.context.ApplicationListener 配置。这个部分实现比较简单，权当热热身。
一、初始化加载器使用
ApplicationListener接口允许在Spring刷新IOC容器(大名鼎鼎的applicationContext.refresh方法)之前，进行自定义的初始化工作。我们可以创建一个SpringBoot工程来简单测试一下：(注意版本用2.4.5)
1、创建一个自定义启动器。这里只打印出SpringBoot的配置信息
package com.roy.applicationContextInitializer;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
@Override
public void initialize(ConfigurableApplicationContext context) {
//获取系统属性
System.out.println("==== systemProperties ===========");
context.getEnvironment().getSystemProperties().forEach((key,value) -> {
System.out.println(key +"==="+value);
});
System.out.println("==== systemProperties end ===========");
//获取系统环境变量
// context.getEnvironment().getSystemEnvironment().forEach((key,value) -> {
// System.out.println(key +"==="+value);
// });
}
}
2、在启动类中添加这个初始化器
@SpringBootApplication
public class P1Application implements CommandLineRunner {
public static void main(String[] args) {
final SpringApplication application = new SpringApplication(P1Application.class);
//添加应用初始化器
application.addInitializers(new MyApplicationContextInitializer());
application.run(args);
}
@Autowired
private ApplicationContext applicationContext;
@Override
public void run(String... args) throws Exception {
System.out.println(applicationContext.getId());
}
}
3、直接执行这个main方法。然后就可以在控制台看到打印出来的系统属性。 --注意他的执行时间是非常靠前的。
这样就添加了一个自定义的初始化器。
可以自己尝试下在这一步可以添加一些什么东西。通常可以添加一些ApplicationListener(事件监听器),BeanFactoryPostProcessor(Bean后处理器),ProtocolResolver(协议处理器，可以用来加载自定义配置文件)。
另外，卖个小关子。示例中main方法中打印出了applicationContext的ID，结果是在application.properties配置文件中的spring.application.name属性。可是这个时候还没有进行统一配置加载，想一下是怎么来的？
4、这里了解了初始化器是什么东西后，就可以回到我们的正题，使用spring.factories扩展机制来配置ApplicationContextInitializer。
在classpath下添加META-INF/spring.factories文件，在文件中添加配置内容：
org.springframework.context.ApplicationContextInitializer=\
com.roy.applicationContextInitializer.MyApplicationContextInitializer
然后就可以把main方法中application.addInitializers这一行代码给注释掉，再启动main方法。
可以看到依然会打印出所有的系统属性。其实也就是说我们自定义的这个MyApplicationContextInitializer已经通过spring.factories文件配置的方式添加到了applicationContext当中。
二、核心机制解读
了解这个机制了之后再来看看源码中是怎么来处理spring.factories文件当中的ApplicationContextInitializer配置的。这个代码跟踪比较简单，就不再去画图什么的了。
1、加载spring.factories的配置：
在SpringApplication的构造方法中就会去添加这些初始化器。
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.sources = new LinkedHashSet();
this.bannerMode = Mode.CONSOLE;
this.logStartupInfo = true;
this.addCommandLineProperties = true;
this.addConversionService = true;
this.headless = true;
this.registerShutdownHook = true;
this.additionalProfiles = Collections.emptySet();
this.isCustomEnvironment = false;
this.lazyInitialization = false;
this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
this.applicationStartup = ApplicationStartup.DEFAULT;
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
this.webApplicationType = WebApplicationType.deduceFromClasspath();
this.bootstrapRegistryInitializers = this.getBootstrapRegistryInitializersFromSpringFactories();
this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class)); <=======重点在这里
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = this.deduceMainApplicationClass();
}
跟踪这个getSpringFactoriesInstances方法，就可以回到我们第一节中介绍了的SpringBoot的属性加载机制了。
2、执行初始化器
这个初始化器的执行顺序是相当靠前的，在SpringApplication的run方法中就直接执行了。
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
ConfigurableApplicationContext context = null;
this.configureHeadlessProperty();
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
this.configureIgnoreBeanInfo(environment);
Banner printedBanner = this.printBanner(environment);
context = this.createApplicationContext();
context.setApplicationStartup(this.applicationStartup);
this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner); // <==== 重点在这里
this.refreshContext(context); //刷新Spring容器
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, listeners);
throw new IllegalStateException(var10);
}
try {
listeners.running(context);
return context;
} catch (Throwable var9) {
this.handleRunFailure(context, var9, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var9);
}
}
在prepareContext方法中直接就执行了这些初始化器的initialize方法
private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
context.setEnvironment(environment);
this.postProcessApplicationContext(context);
this.applyInitializers(context); //<=====重点在这里
listeners.contextPrepared(context);
bootstrapContext.close(context);
if (this.logStartupInfo) {
this.logStartupInfo(context.getParent() == null);
this.logStartupProfileInfo(context);
}
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
Set<Object> sources = this.getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
this.load(context, sources.toArray(new Object[0]));
listeners.contextLoaded(context);
}
从源码中可以看到，Initializer的执行是在打印Banner之后，而Spring的refresh方法之前。这也跟我们之前观察到的日志打印是吻合的。
这个执行顺序也说明，在初始化阶段，Spring的IOC容器是还没有创建的，所以在这个阶段，不能引用IOC容器中的Bean。
三、SpringBoot中的扩展实现
现在再来看看SpringBoot依赖中给我们提供的默认实现：
#spring-boot
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
#spring-boot-autoconfigure
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
在这其中找几个简单的实现机制来看看，例如ContextIdApplicationContextInitializer。
public class ContextIdApplicationContextInitializer
implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
//加载顺序
private int order = Ordered.LOWEST_PRECEDENCE - 10;
public void setOrder(int order) {
this.order = order;
}
@Override
public int getOrder() {
return this.order;
}
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {// <========入口方法
ContextId contextId = getContextId(applicationContext);
applicationContext.setId(contextId.getId());
applicationContext.getBeanFactory().registerSingleton(ContextId.class.getName(), contextId);
}
private ContextId getContextId(ConfigurableApplicationContext applicationContext) {
ApplicationContext parent = applicationContext.getParent();
if (parent != null && parent.containsBean(ContextId.class.getName())) {
return parent.getBean(ContextId.class).createChildId();
}
return new ContextId(getApplicationId(applicationContext.getEnvironment()));
}
private String getApplicationId(ConfigurableEnvironment environment) {
String name = environment.getProperty("spring.application.name");// <========
return StringUtils.hasText(name) ? name : "application";
}
/**
* The ID of a context.
*/
static class ContextId {
private final AtomicLong children = new AtomicLong();
private final String id;
ContextId(String id) {
this.id = id;
}
ContextId createChildId() {
return new ContextId(this.id + "-" + this.children.incrementAndGet());
}
String getId() {
return this.id;
}
}
}
可以看到，这个初始化器中做的事情并不复杂，就是解析SpringBoot的应用名。然后将携带应用名信息的ContextId对象注入到IOC容器当中。前面卖的那个小关子是不是就有了答案？
再看一个ConditionEvaluationReportLoggingListener。这个是用来处理SpringBoot的启动错误报告的。每次SpringBoot应用启动失败会打印出一大堆的堆栈错误信息，就会经过他处理的(当然，完整的处理机制不是这么简单)。
public class ConditionEvaluationReportLoggingListener
implements ApplicationContextInitializer<ConfigurableApplicationContext> {
private final Log logger = LogFactory.getLog(getClass());
private ConfigurableApplicationContext applicationContext;
private ConditionEvaluationReport report;
private final LogLevel logLevelForReport;
public ConditionEvaluationReportLoggingListener() {
this(LogLevel.DEBUG);
}
public ConditionEvaluationReportLoggingListener(LogLevel logLevelForReport) {
Assert.isTrue(isInfoOrDebug(logLevelForReport), "LogLevel must be INFO or DEBUG");
this.logLevelForReport = logLevelForReport;
}
private boolean isInfoOrDebug(LogLevel logLevelForReport) {
return LogLevel.INFO.equals(logLevelForReport) || LogLevel.DEBUG.equals(logLevelForReport);
}
public LogLevel getLogLevelForReport() {
return this.logLevelForReport;
}
@Override
public void initialize(ConfigurableApplicationContext applicationContext) { //<=====加载入口
this.applicationContext = applicationContext;
applicationContext.addApplicationListener(new ConditionEvaluationReportListener());//注册事件监听器
if (applicationContext instanceof GenericApplicationContext) {
// Get the report early in case the context fails to load
this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory());
}
}
//监听事件的处理方法
protected void onApplicationEvent(ApplicationEvent event) {
ConfigurableApplicationContext initializerApplicationContext = this.applicationContext;
if (event instanceof ContextRefreshedEvent) {
if (((ApplicationContextEvent) event).getApplicationContext() == initializerApplicationContext) {
logAutoConfigurationReport();
}
}
else if (event instanceof ApplicationFailedEvent
&& ((ApplicationFailedEvent) event).getApplicationContext() == initializerApplicationContext) {
logAutoConfigurationReport(true);
}
}
private void logAutoConfigurationReport() {
logAutoConfigurationReport(!this.applicationContext.isActive());
}
public void logAutoConfigurationReport(boolean isCrashReport) {
if (this.report == null) {
if (this.applicationContext == null) {
this.logger.info("Unable to provide the conditions report due to missing ApplicationContext");
return;
}
this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory());
}
if (!this.report.getConditionAndOutcomesBySource().isEmpty()) {
if (getLogLevelForReport().equals(LogLevel.INFO)) {
if (this.logger.isInfoEnabled()) {
this.logger.info(new ConditionEvaluationReportMessage(this.report));
}
else if (isCrashReport) {
logMessage("info");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug(new ConditionEvaluationReportMessage(this.report));
}
else if (isCrashReport) {
logMessage("debug");
}
}
}
}
private void logMessage(String logLevel) {
this.logger.info(String.format("%n%nError starting ApplicationContext. To display the "
+ "conditions report re-run your application with '" + logLevel + "' enabled."));
}
private class ConditionEvaluationReportListener implements GenericApplicationListener {
@Override
public int getOrder() {
return Ordered.LOWEST_PRECEDENCE;
}
@Override
public boolean supportsEventType(ResolvableType resolvableType) {
Class<?> type = resolvableType.getRawClass();
if (type == null) {
return false;
}
return ContextRefreshedEvent.class.isAssignableFrom(type)
|| ApplicationFailedEvent.class.isAssignableFrom(type);
}
@Override
public boolean supportsSourceType(Class<?> sourceType) {
return true;
}
@Override
public void onApplicationEvent(ApplicationEvent event) {
ConditionEvaluationReportLoggingListener.this.onApplicationEvent(event);
}
}
}
从核心的initialize方法入手，就能看到他的处理逻辑主要是在初始化阶段注册了一个事件监听器，监听所有的ApplicationEvent。
关于事件监听器，其实是属于Spring的功能了。后面也会有一个章节来讲解SpringBoot针对事件监听器的处理。
其他的一些实现，就不再多贴了，有兴趣大家可以自己去看看。
通过这个章节，也希望能够理解SpringBoot的这种"无业务微核心+拔插式扩展"的设计思路。这种思路能够帮助我们更全面能深入的理解庞大的SpringBoot。另外，了解这些设计思路，也能作为应用开发的扩展点。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
