ApplicationContextInitializer的理解和使用

一、ApplicationContextInitializer 介绍

1.1 作用

**ApplicationContextInitializer ** 接口用于在 Spring 容器刷新之前执行的一个回调函数，通常用于向 SpringBoot 容器中注入属性。

1.2 内置实现类

DelegatingApplicationContextInitializer

使用环境属性 context.initializer.classes 指定的初始化器(initializers)进行初始化工作，如果没有指定则什么都不做。

通过它使得我们可以把自定义实现类配置在 application.properties 里成为了可能。

ContextIdApplicationContextInitializer

设置Spring应用上下文的ID,会参照环境属性。至于Id设置为什么值，将会参考环境属性：
* spring.application.name
* vcap.application.name
* spring.config.name
* spring.application.index
* vcap.application.instance_index

如果这些属性都没有，ID 使用 application。

ConfigurationWarningsApplicationContextInitializer

对于一般配置错误在日志中作出警告

ServerPortInfoApplicationContextInitializer

 将内置 servlet容器实际使用的监听端口写入到 Environment 环境属性中。这样属性 local.server.port 就可以直接通过 @Value 注入到测试中，或者通过环境属性 Environment 获取。

SharedMetadataReaderFactoryContextInitializer

创建一个 SpringBoot和ConfigurationClassPostProcessor 共用的 CachingMetadataReaderFactory对象。实现类为：ConcurrentReferenceCachingMetadataReaderFactory

ConditionEvaluationReportLoggingListener

将 ConditionEvaluationReport写入日志。

二、实现方式

首先新建三个自定义类，实现 ApplicationContextInitializer 接口

public class FirstInitializer implements ApplicationContextInitializer {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();

        Map<String, Object> map = new HashMap<>();
        map.put("key1", "First");

        MapPropertySource mapPropertySource = new MapPropertySource("firstInitializer", map);
        environment.getPropertySources().addLast(mapPropertySource);

        System.out.println("run firstInitializer");
    }

}

public class SecondInitializer implements ApplicationContextInitializer {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();

        Map<String, Object> map = new HashMap<>();
        map.put("key1", "Second");

        MapPropertySource mapPropertySource = new MapPropertySource("secondInitializer", map);
        environment.getPropertySources().addLast(mapPropertySource);

        System.out.println("run secondInitializer");
    }

}

public class ThirdInitializer implements ApplicationContextInitializer {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();

        Map<String, Object> map = new HashMap<>();
        map.put("key1", "Third");

        MapPropertySource mapPropertySource = new MapPropertySource("thirdInitializer", map);
        environment.getPropertySources().addLast(mapPropertySource);

        System.out.println("run thirdInitializer");
    }

}

2.1 在 resources/META-INF/spring.factories 中配置

org.springframework.context.ApplicationContextInitializer=com.learn.springboot.initializer.FirstInitializer

2.2 在 mian 函数中添加

@SpringBootApplication
public class SpringbootApplication {

    public static void main(String[] args) {
//        SpringApplication.run(SpringbootApplication.class, args);
        SpringApplication springApplication = new SpringApplication(SpringbootApplication.class);
        springApplication.addInitializers(new SecondInitializer());
        springApplication.run();
    }

}

2.3 在配置文件中配置

context.initializer.classes=com.learn.springboot.initializer.ThirdInitializer

运行项目，查看控制台：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.5.RELEASE)

run thirdInitializer
run firstInitializer
run secondInitializer

可以看到配置生效了，并且三种配置优先级不一样，配置文件优先级最高，spring.factories 其次，代码最后。

三、获取属性值

@RestController
public class HelloController {

    private ApplicationContext applicationContext;

    public HelloController(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @RequestMapping("/getAttributes")
    public String getAttributes() {
        String value = applicationContext.getEnvironment().getProperty("key1");
        System.out.println(value);
        return value;
    }

}

启动项目，访问http://localhost:8080/getAttributes 查看控制台输出：

Third

发现同名的 key,只会存在一个，并且只存第一次设置的值。

四、通过 @Order 注解修改执行顺序

注：@order 值越小，执行优先级越高

4.1 不同配置方式下，执行顺序

@Order(1)
public class SecondInitializer implements ApplicationContextInitializer {
    ......
}

@Order(2)
public class FirstInitializer implements ApplicationContextInitializer {
    ......
}

@Order(3)
public class ThirdInitializer implements ApplicationContextInitializer {
    ......
}

运行项目，查看控制台：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.5.RELEASE)

run thirdInitializer
run secondInitializer
run firstInitializer

可以看到通过 @Order ** 注解是可以改变spring.factories** 和代码形式的执行顺序的，但是application.properties 配置文件的优先级还是最高的。

4.2 同一配置下，执行顺序

新建实现类

@Order(1)
public class FourthInitializer implements ApplicationContextInitializer {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();

        Map<String, Object> map = new HashMap<>();
        map.put("key1", "Fourth");

        MapPropertySource mapPropertySource = new MapPropertySource("FourthInitializer", map);
        environment.getPropertySources().addLast(mapPropertySource);

        System.out.println("run fourthInitializer");
    }

}

在application.properties 文件中配置

context.initializer.classes=com.learn.springboot.initializer.ThirdInitializer,com.learn.springboot.initializer.FourthInitializer

运行项目，查看控制台：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.5.RELEASE)

run fourthInitializer
run thirdInitializer
run secondInitializer
run firstInitializer

可以看到同一配置方式， @Order 注解也可以起作用。

五、系统初始化器原理解析

5.1在 resources/META-INF/spring.factories 中配置实现原理

在 SpringApplication 初始化时通过 SpringFactoriesLoader 获取到配置在 META-INF/spring.factories 文件中的 ApplicationContextInitializer 的所有实现类.

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
	......
    // 设置系统初始化器
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
	......
}

// 获取工厂实例对象
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();
	// 使用名称并确保唯一以防止重复
	Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 创建工厂实例对象
	List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    // 对工厂实例对象列表进行排序
	AnnotationAwareOrderComparator.sort(instances);
	return instances;
}

// 创建工厂实例对象
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
		ClassLoader classLoader, Object[] args, Set<String> names) {
	List<T> instances = new ArrayList<>(names.size());
	for (String name : names) {
		try {
			Class<?> instanceClass = ClassUtils.forName(name, classLoader);
			Assert.isAssignable(type, instanceClass);
			Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
			T instance = (T) BeanUtils.instantiateClass(constructor, args);
			instances.add(instance);
		}
		catch (Throwable ex) {
			throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
		}
	}
	return instances;
}

在 run 方法中回调 ApplicationContextInitializer 接口函数

public ConfigurableApplicationContext run(String... args) {
	......
	// 准备上下文环境注入系统初始化信息
	prepareContext(context, environment, listeners, applicationArguments, printedBanner);
	......
}

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
		SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
	......
    // 应用初始化器
	applyInitializers(context);
    ......
}

protected void applyInitializers(ConfigurableApplicationContext context) {
	for (ApplicationContextInitializer initializer : getInitializers()) {
        // 判断子类是否是 ConfigurableApplicationContext 类型
		Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
				ApplicationContextInitializer.class);
		Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        // 回调 ApplicationContextInitializer接口的 initialize 方法
		initializer.initialize(context);
	}
}

获取初始化器列表

// 获取在 SpringApplication 构造函数中设置的初始化器列表
public Set<ApplicationContextInitializer<?>> getInitializers() {
	return asUnmodifiableOrderedSet(this.initializers);
}
// 对初始化器列表进行排序
private static <E> Set<E> asUnmodifiableOrderedSet(Collection<E> elements) {
	List<E> list = new ArrayList<>(elements);
	list.sort(AnnotationAwareOrderComparator.INSTANCE);
	return new LinkedHashSet<>(list);
}

5.2 在 main 函数配置实现原理

在之前我们知道 SpringApplication 初始化之后,就已经把 META-INF/spring.factories 中配置的初始化实现类添加到 initializers 列表中了，然后通过 addInitializers 方法，添加自定义的实现类：

public static void main(String[] args) {
    // SpringApplication.run(SpringbootApplication.class, args);
    SpringApplication springApplication = new SpringApplication(SpringbootApplication.class);
    springApplication.addInitializers(new ThirdInitializer());
    springApplication.run();
}

public void addInitializers(ApplicationContextInitializer<?>... initializers) {
	this.initializers.addAll(Arrays.asList(initializers));
}

5.3 在配置文件中配置实现原理

在配置文件中配置方式，主要通过内置的 DelegatingApplicationContextInitializer 实现的,它实现了 Order 方法，所以优先级最高。：

private int order = 0;	

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

然后我们看下它的 initialize方法实现：

@Override
public void initialize(ConfigurableApplicationContext context) {
    // 获取上下文环境变量
	ConfigurableEnvironment environment = context.getEnvironment();
    // 从上下文环境变量中获取指定初始化类列表
	List<Class<?>> initializerClasses = getInitializerClasses(environment);
	if (!initializerClasses.isEmpty()) {
        // 应用初始化器
		applyInitializerClasses(context, initializerClasses);
	}
}

从上下文环境变量获取指定的属性名,并实例化对象

private static final String PROPERTY_NAME = "context.initializer.classes";

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);
	}
}