转载

Spring的Property配置加载和使用过程及Environment的初始化过程

本文解析Spring源码，回答以下几个问题：

1、Spring的Property配置加载和使用过程？

2、Spring内置的Environment的初始化和使用过程？

3、常见Spring的Property相关类的关系？

对于Spring加载Property配置，有如下几个类：（按层级展示）

PropertiesLoaderSupport

PropertiesFactoryBean ！！！直接配置在xml里面，参见（1）

PropertyResourceConfigurer （implements BeanFactoryPostProcessor）

PlaceholderConfigurerSupport

PropertyPlaceholderConfigurer ！！！直接配置在xml里面（2）

PropertySourcesPlaceholderConfigurer ！！！以标签的形式配置在xml里面

例如：

（1）

< bean id = "propBean" class = "org.springframework.beans.factory.config.PropertiesFactoryBean" >

< property name = "locations" value = "classpath:jdbc.properties" />

</ bean >

使用方式：

@Value("#{propBean['filePath']}")或者@Value("#{propBean.filePath}")

（2）

< bean class = "org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >

< property name = "locations" value = "classpath:jdbc.properties" />

</ bean >

等价于<context:property-placeholder location="classpath:jdbc.properties"/>

（参见PropertyPlaceholderBeanDefinitionParser）

或者

< bean class = "org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >

< property name = "properties" ref = "propBean" />

</ bean >

使用方式：

@Value("${filePath}")

下面几者的关系？

PropertySourcesPlaceholderConfigurer

PropertySource

PropertyResolver

AbstractEnvironment

首先，PropertySource其实就是包装的具体配置，跟Properties差不多。

而PropertyResolver，就是用于对PropertySource进行特殊处理，比如解析holder、转换值的类型等。

Spring启动时，默认会new一个StandardEnvironment，这个类里面就默认添加了两个PropertySource（SystemProperties和SystemEnvironment，分别对应System.getenv和System.getProperty）

注意，可能是为了使用方便，Environment实现了PropertyResolver接口。

所以说，它们的关系实际上是，Environment启动时默认添加了一些PropertySource。

启动流程是这样的（AbstractApplicationContext）：

@Override

public void refresh() throws BeansException {

prepareRefresh();

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

prepareBeanFactory(beanFactory);

postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.

invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.

registerBeanPostProcessors(beanFactory);

initMessageSource();

initApplicationEventMulticaster();

onRefresh();

// Check for listener beans and register them.

registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.

finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.

finishRefresh();

}

可以看到，AbstractApplicationContext.refresh() >> prepareRefresh()

然后prepareRefresh会调用createEnvironment()和initPropertySources()

这两个方法实际上是一体的，子类可以重写，其作用就是初始化Environment，并初始化Environment中的PropertySources，以AbstractRefreshableWebApplicationContext为例，相关代码如下：

@Override

protected ConfigurableEnvironment createEnvironment() {

return new StandardServletEnvironment();

}

@Override

protected void initPropertySources() {

ConfigurableEnvironment env = getEnvironment();

if (env instanceof ConfigurableWebEnvironment) {

((ConfigurableWebEnvironment) env)

.initPropertySources( this .servletContext, this .servletConfig);

}

这两个方法是紧挨着执行的，如果写成下面这样，也是等价的：

@Override

protected ConfigurableEnvironment createEnvironment() {

StandardServletEnvironment env = new StandardServletEnvironment();

env.initPropertySources( this .servletContext, this .servletConfig);

return env;

}

@Override

protected void initPropertySources() {

}

另外，前面提到了new StandardEnvironment()的时候，代码如下：

private final ConfigurablePropertyResolver propertyResolver =

new PropertySourcesPropertyResolver( this .propertySources);

public AbstractEnvironment() {

customizePropertySources( this .propertySources);

}

@Override

protected void customizePropertySources(MutablePropertySources propertySources) {

propertySources.addLast(

new MapPropertySource( "systemProperties" , getSystemProperties()));

propertySources.addLast(

new SystemEnvironmentPropertySource( "systemEnvironment" , getSystemEnvironment()));

}

也就是说new出来的Environment默认是包含 System.getenv和System.getProperty 的。

同时可以看到，Environment中使用的PropertyResolver正是PropertySourcesPropertyResolver，且为private final的。

好了，看到这里，其实就知道了：如果要给Spring启动初始化之前添加额外的配置，最早的地方就是拿到AbstractEnvironment.propertySources，然后添加PropertySource，举例如下：

env.getPropertySources().addLast(new MapPropertySource("myProperties", myMap));

但是，要拿到env，就需要拿到 Application，通过 app.getEnvironment()获得。

能不能通过配置的方式，将自定义的配置传递给Environment呢？

接下来，就要学习 PropertyPlaceholderConfigurer 和 PropertySourcesPlaceholderConfigurer了。

首先，这两个类，名字差不多，功能也类似，前者在Spring 3.1以前是标配，自从3.1以后，就换成后者了。

我找到了这个类PropertyPlaceholderBeanDefinitionParser，代码如下，它的作用是：Parser for the {@code <context:property-placeholder/>} element.（这个标签是在spring-context.xsd里面定义的）

@Override

protected Class<?> getBeanClass(Element element) {

// As of Spring 3.1, the default value of system-properties-mode has changed from

// 'FALLBACK' to 'ENVIRONMENT'. This latter value indicates that resolution of

// placeholders against system properties is a function of the Environment and

// its current set of PropertySources.

if ( "ENVIRONMENT" .equals(element.getAttribute( "system-properties-mode" ))) {

return PropertySourcesPlaceholderConfigurer. class ;

}

// The user has explicitly specified a value for system-properties-mode: revert to

// PropertyPlaceholderConfigurer to ensure backward compatibility with 3.0 and earlier.

return PropertyPlaceholderConfigurer. class ;

}

根据代码注释可知，从3.1以后，<context:property-placeholder/>标签的system-properties-mode属性默认值改成了ENVIRONMENT，

那么默认就是 new的 PropertySourcesPlaceholderConfigurer类，而3.1以前用的是PropertyPlaceholderConfigurer。

找到spring-context.xsd，可以看到下面一句，证实了默认值。

<xsd:attribute name="system-properties-mode" default="ENVIRONMENT">

当然，你也可以继续使用PropertyPlaceholderConfigurer，如下：

< bean class = "org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >

< property name = "locations" value = "classpath:jdbc.properties" />

</ bean >

真正等价于：

< context:property-placeholder location = "classpath:jdbc.properties" system-properties-mode = "old" />

下面，来看看通过PropertySourcesPlaceholderConfigurer加载的配置，是如何在Spring bean初始化时使用的。

接着看上面的refresh()执行流程，

AbstractApplicationContext.invokeBeanFactoryPostProcessors() >>

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()

在这个方法中，它会找出所有BeanFactoryPostProcessor然后执行其接口方法：void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)，代码如下

if (beanFactory instanceof BeanDefinitionRegistry) {

invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

} else {

invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);

}

// Separate between BeanDefinitionRegistryPostProcessors that implement

// PriorityOrdered, Ordered, and the rest.

String[] postProcessorNames = beanFactory.getBeanNamesForType(

BeanDefinitionRegistryPostProcessor. class , true , false );

...

sortPostProcessors(beanFactory, priorityOrderedPostProcessors);

invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

可见，执行BeanFactoryPostProcessor的过程中，是分了顺序优先级的，beanFactoryPostProcessors优先执行，beanFactoryPostProcessors是从AbstractApplicationContext里面传过来的，可以通过AbstractApplicationContext.addBeanFactoryPostProcessor来添加。

其他的BeanFactoryPostProcessor是从 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class) 而来的，这就包括了

我们的PropertySourcesPlaceholderConfigurer，但是PropertyResourceConfigurer是最低优先级的，文档上说等价于 nonOrderedPostProcessors，所以它会最后执行。

如此，关系就清楚了：Spring启动时在 refresh() 的过程中，在invokeBeanFactoryPostProcessors的末尾，会调用 PropertySourcesPlaceholderConfigurer.postProcessBeanFactory() 对bean进行预处理。

然后我们再看 PropertySourcesPlaceholderConfigurer.postProcessBeanFactory() 的内部执行过程：

postProcessBeanFactory() >> protected processProperties( beanFactory, propertyResolver) >>

PlaceholderConfigurerSupport.doProcessProperties( valueResolver )

这个最终的 valueResolver 来源于上一级的 propertyResolver，而propertyResolver是在 postProcessBeanFactory()方法内部 new出来的，整个方法如下所示：

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

if ( this .propertySources == null ) {

this .propertySources = new MutablePropertySources();

if ( this .environment != null ) {

this .propertySources.addLast(

new PropertySource<Environment>( "environmentProperties" , this .environment) {

@Override

public String getProperty(String key) {

return this .source.getProperty(key);

}

);

}

PropertySource<?> localPropertySource =

new PropertiesPropertySource( "localProperties" , mergeProperties());

if ( this .localOverride) {

this .propertySources.addFirst(localPropertySource);

}

else {

this .propertySources.addLast(localPropertySource);

}

processProperties(beanFactory, new PropertySourcesPropertyResolver( this .propertySources));

this .appliedPropertySources = this .propertySources;

}

由此可知，new PropertySourcesPropertyResolver，使用的PropertySources来自于this.environment，

即PropertySourcesPlaceholderConfigurer.environment，这个environment怎么来的呢，这个最终来源应该就是AbstractApplicationContext。

所以说，这个PropertySourcesPropertyResolver实际上包含了environmentProperties和localProperties，而localProperties来源于这个方法mergeProperties()，源码如下：

protected Properties mergeProperties() throws IOException {

Properties result = new Properties();

if ( this .localOverride) {

loadProperties(result);

}

if ( this .localProperties != null ) {

for (Properties localProp : this .localProperties) {

CollectionUtils.mergePropertiesIntoMap(localProp, result);

}

if (! this .localOverride) {

// Load properties from file afterwards, to let those properties override.

loadProperties(result);

}

return result;

}

如果我们想给PropertySourcesPropertyResolver加配置，就可以重新这个mergeProperties()或者loadProperties()，但是注意，这个配置的优先级，没有Environment里面的配置的优先级高，而且Spring框架内部某些优先级高的地方只用到了Environment，不过对应用层来说，重写这个mergeProperties()应该是够用了。

如果是使用的老版本的PropertyPlaceholderConfigurer，它的源代码如下：

@Override

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory){

try {

Properties mergedProps = mergeProperties();

// Convert the merged properties, if necessary.

convertProperties(mergedProps);

// Let the subclass process the properties.

processProperties(beanFactory, mergedProps);

}

大同小异，具体不再多说。

总结：