本文将重点介绍SpringBoot提供给我们的另一个扩展点EnvironmentPostProcessor，它允许我们到任意的指定目录、以任意的方式加载一组配置，并赋予任意的优先级
上文对prepareEnvironment方法的configureEnvironment做了一个收尾，本文继续看第三行代码listeners.environmentPrepared
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
ConfigurableEnvironment environment = this.getOrCreateEnvironment();
this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
listeners.environmentPrepared((ConfigurableEnvironment)environment);
this.bindToSpringApplication((ConfigurableEnvironment)environment);
if (!this.isCustomEnvironment) {
environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
}
ConfigurationPropertySources.attach((Environment)environment);
return (ConfigurableEnvironment)environment;
}
这个listeners看过前文的朋友应该还有印象，里面只有一个元素EventPublishingRunListener
public void environmentPrepared(ConfigurableEnvironment environment) {
Iterator var2 = this.listeners.iterator();
while(var2.hasNext()) {
SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
listener.environmentPrepared(environment);
}
}
所以就相当于调用了EventPublishingRunListener的environmentPrepared方法，查看该方法的实现
public void environmentPrepared(ConfigurableEnvironment environment) {
this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));
}
通过内部的事件多播器发布了一个事件ApplicationEnvironmentPreparedEvent，同时将SringApplication和Environment对象传播了出去，发布的流程跟之前的ApplicationStartingEvent事件如出一辙，不再赘述
本次捕捉到该事件的监听器共有7个
其中大多数监听器是做一些边边角角的初始化工作，本文就先聚焦到其中一个比较重要的监听器ConfigFileApplicationListener，它完成了对配置文件的加载，并且引入了本文要讲的EnvironmentPostProcessor，它也是SpringBoot提供给我们的又一个扩展点
直接进入ConfigFileApplicationListener接收事件的方法onApplicationEvent
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof ApplicationEnvironmentPreparedEvent) {
this.onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent)event);
}
if (event instanceof ApplicationPreparedEvent) {
this.onApplicationPreparedEvent(event);
}
}
事件类型为ApplicationEnvironmentPreparedEvent，走第一个分支
private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
List<EnvironmentPostProcessor> postProcessors = this.loadPostProcessors();
postProcessors.add(this);
AnnotationAwareOrderComparator.sort(postProcessors);
Iterator var3 = postProcessors.iterator();
while(var3.hasNext()) {
EnvironmentPostProcessor postProcessor = (EnvironmentPostProcessor)var3.next();
postProcessor.postProcessEnvironment(event.getEnvironment(), event.getSpringApplication());
}
}
第一行loadPostProcessors到META-INF/spring.factories中加载了EnvironmentPostProcessor的实现类，加载方式与SpringApplication初始化时的流程相似，虽然调用了不同的API，但最终都通过SpringFactoriesLoader.loadFactoryNames获取了spring.factories的内容
List<EnvironmentPostProcessor> loadPostProcessors() {
return SpringFactoriesLoader.loadFactories(EnvironmentPostProcessor.class, this.getClass().getClassLoader());
}
最终找到三个类，都在spring-boot下的spring.factories中
# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,\
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor
回到onApplicationEnvironmentPreparedEvent方法，加载到EnvironmentPostProcessor的列表后，ConfigFileApplicationListener把自己也加入到了这个集合中，因为它本身也实现了EnvironmentPostProcessor接口
public class ConfigFileApplicationListener implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {
然后遍历EnvironmentPostProcessor列表，依次调用其postProcessEnvironment方法，传入Environment和SpringApplication
我们依次看下每个EnvironmentPostProcessor的实现类都做了什么事情
SpringApplicationJsonEnvironmentPostProcessor
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
MutablePropertySources propertySources = environment.getPropertySources();
propertySources.stream().map(SpringApplicationJsonEnvironmentPostProcessor.JsonPropertyValue::get).filter(Objects::nonNull).findFirst().ifPresent((v) -> {
this.processJson(environment, v);
});
}
先遍历Environment中的PropertySource，依次传给内部类JsonPropertyValue的静态方法get
public static SpringApplicationJsonEnvironmentPostProcessor.JsonPropertyValue get(PropertySource<?> propertySource) {
String[] var1 = CANDIDATES;
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
String candidate = var1[var3];
Object value = propertySource.getProperty(candidate);
if (value != null && value instanceof String && StringUtils.hasLength((String)value)) {
return new SpringApplicationJsonEnvironmentPostProcessor.JsonPropertyValue(propertySource, candidate, (String)value);
}
}
return null;
}
CANDIDATES是final变量，声明时做了初始化
private static class JsonPropertyValue {
private static final String[] CANDIDATES = new String[]{"spring.application.json", "SPRING_APPLICATION_JSON"};
也就是针对每个PropertySource，看里面有没有属性spring.application.json或者SPRING_APPLICATION_JSON，如果有的话，把它转化为JsonPropertyValue存储起来，然后取第一个，调用processJson方法
private void processJson(ConfigurableEnvironment environment, SpringApplicationJsonEnvironmentPostProcessor.JsonPropertyValue propertyValue) {
JsonParser parser = JsonParserFactory.getJsonParser();
Map<String, Object> map = parser.parseMap(propertyValue.getJson());
if (!map.isEmpty()) {
this.addJsonPropertySource(environment, new SpringApplicationJsonEnvironmentPostProcessor.JsonPropertySource(propertyValue, this.flatten(map)));
}
}
这个方法里把找到的属性对应的value转化为map，然后构造了一个JsonPropertySource，它是MapPropertySource的子类，配置的组名为spring.application.json
JsonPropertySource(SpringApplicationJsonEnvironmentPostProcessor.JsonPropertyValue propertyValue, Map<String, Object> source) {
super("spring.application.json", source);
this.propertyValue = propertyValue;
}
然后添加到Environemtn的PropertySource列表，优先级是如果列表中有jndiProperties就放在它后面，如果没有就放在systemProperties，如果都没有，就放在列表头部，作为优先级最高的配置
private void addJsonPropertySource(ConfigurableEnvironment environment, PropertySource<?> source) {
MutablePropertySources sources = environment.getPropertySources();
String name = this.findPropertySource(sources);
if (sources.contains(name)) {
sources.addBefore(name, source);
} else {
sources.addFirst(source);
}
}
private String findPropertySource(MutablePropertySources sources) {
return ClassUtils.isPresent("org.springframework.web.context.support.StandardServletEnvironment", (ClassLoader)null) && sources.contains("jndiProperties") ? "jndiProperties" : "systemProperties";
}
SystemEnvironmentPropertySourceEnvironmentPostProcessor
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
String sourceName = "systemEnvironment";
PropertySource<?> propertySource = environment.getPropertySources().get(sourceName);
if (propertySource != null) {
this.replacePropertySource(environment, sourceName, propertySource);
}
}
先从Environment中取了名为systemEnvironment的PropertySource，也就是系统的环境变量，然后调用replacePropertySource对它做了一个包装替换
private void replacePropertySource(ConfigurableEnvironment environment, String sourceName, PropertySource<?> propertySource) {
Map<String, Object> originalSource = (Map)propertySource.getSource();
SystemEnvironmentPropertySource source = new SystemEnvironmentPropertySourceEnvironmentPostProcessor.OriginAwareSystemEnvironmentPropertySource(sourceName, originalSource);
environment.getPropertySources().replace(sourceName, source);
}
systemEnvironment原先的具体类型为SystemEnvironmentPropertySource，这里替换的类型OriginAwareSystemEnvironmentPropertySource是它的子类，它额外实现了OriginLookup接口
所以SystemEnvironmentPropertySourceEnvironmentPostProcessor就是对系统环境变量做了一个包装，不影响原有的功能
CloudFoundryVcapEnvironmentPostProcessor
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
if (CloudPlatform.CLOUD_FOUNDRY.isActive(environment)) {
Properties properties = new Properties();
JsonParser jsonParser = JsonParserFactory.getJsonParser();
this.addWithPrefix(properties, this.getPropertiesFromApplication(environment, jsonParser), "vcap.application.");
this.addWithPrefix(properties, this.getPropertiesFromServices(environment, jsonParser), "vcap.services.");
MutablePropertySources propertySources = environment.getPropertySources();
if (propertySources.contains("commandLineArgs")) {
propertySources.addAfter("commandLineArgs", new PropertiesPropertySource("vcap", properties));
} else {
propertySources.addFirst(new PropertiesPropertySource("vcap", properties));
}
}
}
CLOUD_FOUNDRY {
public boolean isActive(Environment environment) {
return environment.containsProperty("VCAP_APPLICATION") || environment.containsProperty("VCAP_SERVICES");
}
},
这个postProcessor主要针对引入了CloudFound的项目，如果配置了VCAP_APPLICATION或者VCAP_SERVICES属性，就往Environment的PropertySource列表添加名为vcap的配置
CloudFound这东西我也没见有项目用过，它是一个开源的PAAS，据说是业界最早的开源云平台，不过就跟之前提到的Liquibase一样，虽然被SpringBoot默认支持了，但是至少在国内的受众还是比较少的
ConfigFileApplicationListener
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
this.addPropertySources(environment, application.getResourceLoader());
}
参数中传递的resourceLoader可以将一个指定位置的文件抽象成Resource，供后续解析使用，不过这里还是空的，因为SpringApplication创建的时候并没有对该属性作初始化
protected void addPropertySources(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
RandomValuePropertySource.addToEnvironment(environment);
(new ConfigFileApplicationListener.Loader(environment, resourceLoader)).load();
}
第一行代码往Environment中添加了一个名为random的PropertySource
public static void addToEnvironment(ConfigurableEnvironment environment) {
environment.getPropertySources().addAfter("systemEnvironment", new RandomValuePropertySource("random"));
logger.trace("RandomValuePropertySource add to Environment");
}
类型为RandomValuePropertySource，存储资源的类型指定为Random
public class RandomValuePropertySource extends PropertySource<Random> {
public static final String RANDOM_PROPERTY_SOURCE_NAME = "random";
private static final String PREFIX = "random.";
private static final Log logger = LogFactory.getLog(RandomValuePropertySource.class);
public RandomValuePropertySource(String name) {
super(name, new Random());
}
其作用是为配置文件中的部分属性提供随机数功能，比如我们想让系统运行在5000-6000内的随机端口上，就可以添加如下配置
server:
port: ${random.int[5000,6000]}
至于后面的一行代码就是真正去加载系统的配置文件了，我们后面再单独开一篇来讨论
自定义EnvironmentPostProcessor
通过上述几个内置的EnvironmentPostProcessor，我们大致了解了这个接口的作用，通过自定义这个接口的实现，可以对Environment为所欲为，甚至改变系统的默认配置，先做个实验，自定义一个EnvironmentPostProcessor，把上面添加的RandomValuePropertySource删掉，让系统失去对配置文件的随机数支持
首先正常启动项目，可以看到端口在5000-6000中随机产生
新建类MyEnvironmentPostProcessor实现EnvironmentPostProcessor 接口，将名为random的PropertySource从environment中删除
@Order(-2147483637)
public class MyEnvironmentPostProcessor implements EnvironmentPostProcessor {
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
MutablePropertySources propertySources = environment.getPropertySources();
propertySources.remove("random");
}
}
需要注意的一点是，EnvironmentPostProcessor 是一个列表，会按一定顺序执行，我们要在ConfigFileApplicationListener将random添加到environment之后删除才有效果
ConfigFileApplicationListener实现了Ordered 接口，并指定order为-2147483638
public class ConfigFileApplicationListener implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {
......
private int order = -2147483638;
......
public int getOrder() {
return this.order;
}
......
order值越小的越先执行，所以我们自己的类加上@Order注解，order设置为-2147483637，只要比ConfigFileApplicationListener 大就行
再次运行抛出异常，无法为端口生成随机数
当然这个例子只是说明EnvironmentPostProcessor给了我们很高的权限，去干预正常启动过程中的环境配置，实际中我们可以借助它来做一些公用配置的处理
假如我们有A B C三个服务，共同依赖了底层模块commom，想把一些公用的配置放在common模块中，并拥有最高的优先级，就可以在common新建一个配置文件application-common.properties，然后定义一个实现类CommonEnvironmentPostProcessor，去解析这个文件，并加载到PropertySource列表首部，当然还要注意如果想让配置的优先级最高，还要尽可能保证它最晚执行，所以order要设置的比较大
@Order(Integer.99999)
@Slf4j
public class CommonEnvironmentPostProcessor implements EnvironmentPostProcessor {
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
try {
//定义一个资源加载器
ResourceLoader resourceLoader = new DefaultResourceLoader();
//找到classpath下的application-common.properties文件，抽象成Resource
Resource resource = resourceLoader.getResource("classpath:/application-common.properties");
if (!resource.exists()) {
return;
}
Properties properties = new Properties();
//从文件中装载配置
properties.load(new InputStreamReader(resource.getInputStream()));
PropertiesPropertySource propertiesPropertySource = new PropertiesPropertySource("commonProperties", properties);
//获取environment中的配置列表
MutablePropertySources mutablePropertySources = environment.getPropertySources();
//将当前配置添加到列表首部，即拥有最高的优先级
mutablePropertySources.addFirst(propertiesPropertySource);
} catch (Exception e) {
log.error("加载公共配置失败", e);
}
}
}