springboot 源码解析之ApplicationContextInitializer

springboot版本2.1.6

ApplicationContextInitializer

根据名字，这个类是springboot的初始化器，在容器启动时进行一些初始化的工作。

首先提出三个问题

1 ApplicationContextInitializer 是如何工作的，

2 Springboot框架默认的初始化器都有哪些，他们都干了什么

3 自定义一个ApplicationContextInitializer

 

问题1

执行 Spring Application的run() 方法，在创建Spring Application 对象时加载了各个ApplicationContextInitializer 对象，

 

SpringApplication.class
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
   return new SpringApplication(sources).run(args);
}

public SpringApplication(Object... sources) {
   initialize(sources);
}

private void initialize(Object[] sources) {
   if (sources != null && sources.length > 0) {
      this.sources.addAll(Arrays.asList(sources));
   }
   this.webEnvironment = deduceWebEnvironment();
   // 在这里加载 自动配置的ApplicationContextInitializer 对象
   setInitializers((Collection) getSpringFactoriesInstances(
         ApplicationContextInitializer.class));
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   this.mainApplicationClass = deduceMainApplicationClass();
}

public void setInitializers(
      Collection<? extends ApplicationContextInitializer<?>> initializers) {
   this.initializers = new ArrayList<ApplicationContextInitializer<?>>();
   this.initializers.addAll(initializers);
}

这个getSpringFactoriesInstances()方法，非常重要，框架自动配置主要就是通过它实现的，它最终读取的是各个包下的 META-INF/spring.factories 文件中配置的类，在这里它将装载ApplicationContextInitializer 实现类

举一个auto configuration包下的例子。

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

根据这个配置文件，系统将加载两个ApplicationContextInitializer的实现类SharedMetadataReaderFactoryContextInitializer和AutoConfigurationReportLoggingInitializer。当然系统中存在多个spring boot依赖包，也就存在多个META-INF/spring.factories文件，最终会加载多个ApplicationContextInitializer的实现类。

以AutoConfigurationReportLoggingInitializer为例看看它是如何工作的。

AutoConfigurationReportLoggingInitializer.class

@Override // 这个方法是继承ApplicationContextInitializer接口的方法
public void initialize(ConfigurableApplicationContext applicationContext) {
   this.applicationContext = applicationContext;
   applicationContext.addApplicationListener(new AutoConfigurationReportListener());
   if (applicationContext instanceof GenericApplicationContext) {
      // Get the report early in case the context fails to load
      this.report = ConditionEvaluationReport
            .get(this.applicationContext.getBeanFactory());
   }
}

阅读源码时如果看到@Override注解, 则要提高注意, 它很可能就是外部调用的入口,

回到SpringApplication.class

SpringApplication.class
public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.started();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
      Banner printedBanner = printBanner(environment);
      context = createApplicationContext();
      analyzers = new FailureAnalyzers(context);
      // 这里执行了各个ApplicationContextInitializer
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

private void prepareContext(ConfigurableApplicationContext context,
      ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
      ApplicationArguments applicationArguments, Banner printedBanner) {
   context.setEnvironment(environment);
   postProcessApplicationContext(context);
   applyInitializers(context);
   listeners.contextPrepared(context);
   if (this.logStartupInfo) {
      logStartupInfo(context.getParent() == null);
      logStartupProfileInfo(context);
   }

   // Add boot specific singleton beans
   context.getBeanFactory().registerSingleton("springApplicationArguments",
         applicationArguments);
   if (printedBanner != null) {
      context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
   }

   // Load the sources
   Set<Object> sources = getSources();
   Assert.notEmpty(sources, "Sources must not be empty");
   load(context, sources.toArray(new Object[sources.size()]));
   listeners.contextLoaded(context);
}

// 这里是最终调用的地方
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);
   }
}

问题2

系统中自动配置的ApplicationContextInitializer实现, 打一个断点就能看到, 根据依赖的jar 不同, 加载的实现类也不一样

org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer, -- 加载CachingMetadataReaderFactoryPostProcessor.class 处理器

org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer, -- 加载AutoConfigurationReportListener.class 监听器

org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer, -- 加载ConfigurationWarningsPostProcessor.class 处理器

org.springframework.boot.context.ContextIdApplicationContextInitializer, -- 设置容器 Id

org.springframework.boot.context.config.DelegatingApplicationContextInitializer, -- 获取配置文件中context.initializer.classes 定义的初始化器, 并执行 注意这个配置文件的value 是类的全限定名

org.springframework.boot.context.web.ServerPortInfoApplicationContextInitializer -- 添加监听器, 当服务器启动时将端口等添加进 spring 容器

 

问题3

在搞清楚原理后, 实现过程简直轻而易举

实现自己的初始化器, 首先定义一个ApplicationContextInitializer , 例如

public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("====== 启动自定义初始化器 ======");
    }
}

这里先定义简单点, 打印一句话,

然后在resources 目录下添加 META-INF/spring.factories 并写入我们自定义的类全限定名

 

org.springframework.context.ApplicationContextInitializer=\
com.example.autoconfiguration.MyApplicationContextInitializer

 

启动后观察日志 , 操作成功

 

当然在配置文件中配置 context.initializer.classes 也可以实现 自定义类的注入, 这种方式就是前边提到的 DelegatingApplicationContextInitializer 实现的,

最后还有一种代码中添加自定义初始化器的方法 , 三种方法哪种都可以

public static void main(String[] args) {
    SpringApplication.run(ExampleApplication.class, args);
    SpringApplication springApplication = new SpringApplication(SmeltApplication.class, args);
    springApplication.addInitializers(new MyApplicationContextInitializer());
    springApplication.run(args);
}