Spring Boot 源码分析 —— ApplicationContextInitializer

1. 概述

本文，我们来补充 《精尽 Spring Boot 源码分析 —— SpringApplication》 文章，并未详细解析的 ApplicationContextInitializer 。

2. ApplicationContextInitializer

org.springframework.context.ApplicationContextInitializer ，ApplicationContext 初始化接口。代码如下：

/**
 * Callback interface for initializing a Spring {@link ConfigurableApplicationContext}
 * prior to being {@linkplain ConfigurableApplicationContext#refresh() refreshed}.
 *
 * <p>Typically used within web applications that require some programmatic initialization
 * of the application context. For example, registering property sources or activating
 * profiles against the {@linkplain ConfigurableApplicationContext#getEnvironment()
 * context's environment}. See {@code ContextLoader} and {@code FrameworkServlet} support
 * for declaring a "contextInitializerClasses" context-param and init-param, respectively.
 *
 * <p>{@code ApplicationContextInitializer} processors are encouraged to detect
 * whether Spring's {@link org.springframework.core.Ordered Ordered} interface has been
 * implemented or if the @{@link org.springframework.core.annotation.Order Order}
 * annotation is present and to sort instances accordingly if so prior to invocation.
 *
 * @author Chris Beams
 * @since 3.1
 * @param <C> the application context type
 * @see org.springframework.web.context.ContextLoader#customizeContext
 * @see org.springframework.web.context.ContextLoader#CONTEXT_INITIALIZER_CLASSES_PARAM
 * @see org.springframework.web.servlet.FrameworkServlet#setContextInitializerClasses
 * @see org.springframework.web.servlet.FrameworkServlet#applyInitializers
 */
public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {

	/**
	 * Initialize the given application context.
	 * @param applicationContext the application to configure
	 */
	void initialize(C applicationContext);

}

• 1、ApplicationContextInitializer 是 Spring Framework 3.1 版本开始提供的接口。而本文，我们是来分享 Spring Boot 中，几个 ApplicationContextInitializer 实现类。
• 2、【作用】ApplicationContextInitializer 是一个回调接口，用于 Spring ConfigurableApplicationContext 容器执行 #refresh() 方法进行初始化之前，提前走一些自定义的初始化逻辑。
• 3、【场景】它的使用场景，例如说 Web 应用中需要注册属性，或者激活 Profiles 。
• 4、【排序】它支持 Spring 的 Ordered 接口、@Order 注解，来对多个 ApplicationContextInitializer 实例进行排序，从而实现，ApplicationContextInitializer 按照顺序调用 #initialize(C applicationContext) 方法，进行初始化。

3. SpringApplication 中的使用

3.1 初始化 ApplicationContextInitializer 集合

在 SpringApplication 构造方法中，会调用 #getSpringFactoriesInstances(Class<T> type) 方法，获得 ApplicationContextInitializer 集合。代码如下：

// SpringApplication.java

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
    return getSpringFactoriesInstances(type, new Class<?>[] {});
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
        Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    // <1> 加载指定类型对应的，在 `META-INF/spring.factories` 里的类名的数组
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // <2> 创建对象们
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    // <3> 排序对象们
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

• <1> 处，加载指定 ApplicationContextInitializer 类型对应的，在 META-INF/spring.factories 里的类名的数组。
  • 假设只在 Spring MVC 的环境下，initializers 属性的结果如下图：
  • 艿艿整理了 Spring Boot 中，ApplicationContextInitializer 的实现类们，如下图所示：
• <2> 处，创建对象们。
• <3> 处，排序对象们。这个就是在 「2. ApplicationContextInitializer」 提到的【排序】。

3.2 prepareContext

在 #prepareContext(...) 方法中，即在 Spring IoC 容器初始化之前，会调用 #applyInitializers() 方法，逐个调用 ApplicationContextInitializer 的初始化方法。代码如下：

// SpringApplication.java

protected void applyInitializers(ConfigurableApplicationContext context) {
    // 遍历 ApplicationContextInitializer 数组
    for (ApplicationContextInitializer initializer : getInitializers()) {
        // 校验 ApplicationContextInitializer 的泛型非空
        Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        // 初始化 ApplicationContextInitializer
        initializer.initialize(context);
    }
}

• 比较简单，就是调用 ApplicationContextInitializer#initialize(context) 方法，进行初始化。

下面，我们来逐个看看 Spring Boot 对 ApplicationContextInitializer 的实现类们。

4. DelegatingApplicationContextInitializer

org.springframework.boot.context.config.DelegatingApplicationContextInitializer ，实现 ApplicationContextInitializer、Ordered 接口，根据环境变量配置的 context.initializer.classes 配置的 ApplicationContextInitializer 类们，交给它们进行初始化。

4.1 构造方法

// DelegatingApplicationContextInitializer.java

/**
 * 环境变量配置的属性
 */
private static final String PROPERTY_NAME = "context.initializer.classes";

/**
 * 默认优先级
 */
private int order = 0;

// ... 构造方法为空

@Override
public int getOrder() {
	return this.order;
}

• 优先级为 0 ，在 Spring Boot 默认的 ApplicationContextInitializer 实现类中，是排在最前面的。

4.2 initialize

实现 #initialize(ConfigurableApplicationContext context) 方法，代码如下：

// DelegatingApplicationContextInitializer.java

@Override
public void initialize(ConfigurableApplicationContext context) {
    // <1> 获得环境变量配置的 ApplicationContextInitializer 集合们
    ConfigurableEnvironment environment = context.getEnvironment();
    List<Class<?>> initializerClasses = getInitializerClasses(environment);
    // 如果非空，则进行初始化
    if (!initializerClasses.isEmpty()) {
        applyInitializerClasses(context, initializerClasses);
    }
}

• <1> 处，调用 #getInitializerClasses(ConfigurableEnvironment env) 方法，获得环境变量配置的 ApplicationContextInitializer 集合们。代码如下：

  // DelegatingApplicationContextInitializer.java
  
  private List<Class<?>> getInitializerClasses(ConfigurableEnvironment env) {
      // 获得环境变量配置的属性
      String classNames = env.getProperty(PROPERTY_NAME);
      // 拼装成数组，按照 ，分隔
      List<Class<?>> classes = new ArrayList<>();
      if (StringUtils.hasLength(classNames)) {
          for (String className : StringUtils.tokenizeToStringArray(classNames, ",")) {
              classes.add(getInitializerClass(className));
          }
      }
      return classes;
  }
  
  private Class<?> getInitializerClass(String className) throws LinkageError {
  	try {
  		// 获得全类名，对应的类
  		Class<?> initializerClass = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
  		Assert.isAssignable(ApplicationContextInitializer.class, initializerClass);
  		return initializerClass;
  	} catch (ClassNotFoundException ex) {
  		throw new ApplicationContextException("Failed to load context initializer class [" + className + "]", ex);
  	}
  }

• <2> 处，调用 #applyInitializerClasses(ConfigurableApplicationContext context, List<Class<?>> initializerClasses) 方法，执行初始化。代码如下：

  // DelegatingApplicationContextInitializer.java
  
  private void applyInitializerClasses(ConfigurableApplicationContext context, List<Class<?>> initializerClasses) {
      Class<?> contextClass = context.getClass();
      // 遍历 initializerClasses 数组，创建对应的 ApplicationContextInitializer 对象们 ①
      List<ApplicationContextInitializer<?>> initializers = new ArrayList<>();
      for (Class<?> initializerClass : initializerClasses) {
          initializers.add(instantiateInitializer(contextClass, initializerClass));
      }
      // 执行 ApplicationContextInitializer 们的初始化逻辑 ②
      applyInitializers(context, initializers);
  }
  
  // 被 ① 处调用
  private ApplicationContextInitializer<?> instantiateInitializer(Class<?> contextClass, Class<?> initializerClass) {
      // 断言校验
      Class<?> requireContextClass = GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
      Assert.isAssignable(requireContextClass, contextClass, String.format(
                      "Could not add context initializer [%s]"
                              + " as its generic parameter [%s] is not assignable "
                              + "from the type of application context used by this "
                              + "context loader [%s]: ",
                      initializerClass.getName(), requireContextClass.getName(), contextClass.getName()));
      // 创建 ApplicationContextInitializer 对象
      return (ApplicationContextInitializer<?>) BeanUtils.instantiateClass(initializerClass);
  }
  
  // 被 ② 处调用
  @SuppressWarnings({ "unchecked", "rawtypes" })
  private void applyInitializers(ConfigurableApplicationContext context, List<ApplicationContextInitializer<?>> initializers) {
      // 排序，无处不在的排序！
      initializers.sort(new AnnotationAwareOrderComparator());
      // 执行初始化逻辑
      for (ApplicationContextInitializer initializer : initializers) {
          initializer.initialize(context);
      }
  }

  • 虽然代码有点长，但是简单的。

5. SharedMetadataReaderFactoryContextInitializer

org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer ，实现 ApplicationContextInitializer、Ordered 接口，它会创建一个用于在 ConfigurationClassPostProcessor 和 Spring Boot 间共享的 CachingMetadataReaderFactory Bean 对象。

简化代码如下：

/**
 * {@link ApplicationContextInitializer} to create a shared
 * {@link CachingMetadataReaderFactory} between the
 * {@link ConfigurationClassPostProcessor} and Spring Boot.
 *
 * @author Phillip Webb
 * @since 1.4.0
 */

/**
 * 创建的 CachingMetadataReaderFactory 的 Bean 名字
 */
public static final String BEAN_NAME = "org.springframework.boot.autoconfigure."
        + "internalCachingMetadataReaderFactory";

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
    applicationContext.addBeanFactoryPostProcessor(new CachingMetadataReaderFactoryPostProcessor());
}

@Override
public int getOrder() {
    return 0;
}

// ... 省略 CachingMetadataReaderFactoryPostProcessor 内部类

• 看不懂这个类的具体用途，暂时先不去深究。
  分享到：
  Spring Boot 源码分析 —— ApplicationLi ... | Spring Boot 源码分析 —— ReactiveWebSe ...
  • 2019-08-16 13:16
  • 浏览 503
  • 评论(0)
  • 分类:编程语言
  • 查看更多