Spring源码系列 — Envoriment组件

何为Envoriment

Envoriment是集成在Spring上下文容器中的核心组件，在Spring源码中由Envoriment接口抽象。

在Environment中，有两大主要概念：

• Profile：在Spring中profile是针对Bean定义而言，是Bean定义的逻辑分组。通常表现为：dev/test/production等等，对于Bean定义属于哪个profile是由XML或者Annotation配置决定；
• Properties：即键值对（Keys-Pairs），在Spring中将*.properties文件/JVM系统属性（JVM System Property）/系统环境变量（JVM Environment Variables）/Properties对象/Map对象抽象为Properties；

Envoriment的能力

Envoriment提供了获取和设置Profile的能力，可以决定生效哪些Profiles。

同时提供了操作Properties的能力，可以增加/移除整个Properties，能获取某个Key-Pair。

• Environment可以获取系统JVM属性：-Dspring.profiles.active="..."或者显示编程式setActiveProfiles("...")生效相应的profile；
• 可以通过Environment提供的getActiveProfiles和getDefaultProfiles获取profile；
• Environment可以决定Bean定义属于哪个Profile；
• Environment可以操作上下文中的Properties，提供了add/remove接口；
• Environment集成PropertyResolver，利用Spring中的Conversion服务多Properties中的属性进行类型转化；
• Environment提供了解析任意Resource资源路径中的${...}占位，支持嵌套占位解析；

上图中体现Environment是上下文ApplicationContext中的核心之一，在实现上每个ApplicationContext中都持有Environment实例：

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext, DisposableBean {

	......此处省略

	/** Environment used by this context */
	private ConfigurableEnvironment environment;

	......此处省略

}

从源码分析看Envoriment

Enviroment源码部分主要由三部分组成：

• Enviroment接口实现
• PropertyResolver属性解析器接口实现
• PropertySource和PropertySources属性源

下续UML类图中描述出Environment通过持有PropertyResolver和PropertySources实现对Properties的操作，Environment自身提供profile的存储和接口操作。

Tips：

Spring中大量使用接口继承-实现组合的模式。接口之间继承，具体实现中通过组合持有的方式达到接口隔离，实现强扩展能力。

Environment接口定义：

public interface Environment extends PropertyResolver {

	// 获取当前上下文生效应用的profile
	String[] getActiveProfiles();

	// 获取当前上下文默认的profile
	String[] getDefaultProfiles();

	// 判断是否接受某个profile，用于决定bean定义属于哪个profile
	boolean acceptsProfiles(String... profiles);

}

获取activeProfile和defaultProfile，同时能决定是否接受某个profile。

Environment中继承PropertyResolver接口：

/**
 * Interface for resolving properties against any underlying source.
 */
public interface PropertyResolver {
	// 判断源中是否包含该key的属性
	boolean containsProperty(String key);
	// 获取源中的key属性的值
	String getProperty(String key);
	// 获取并转换成目标类型
	<T> T getProperty(String key, Class<T> targetType);
	// 解析占位，主要被应用在解析resource路径中的占位、@Value注解中的占位和
	Bean定义中的占位
	String resolvePlaceholders(String text);
}

PropertyResolver用于解析潜在的源的属性。潜在源可以是多种形式：properties文件、jvm属性、jvm环境变量、map等等。

从以上可以推导出Environment具有从源中解析获取Properties的能力，或者说Environment本身就是属性解析器。

Environment接口体系中非常重要的成员是ConfigurableEnvironment，它提供了更强的处理能力：

• 设置上下文容器的profile；
• 操作Environment中properties；

/**
 * Configuration interface to be implemented by most if not all {@link Environment} types.
 * Provides facilities for setting active and default profiles and manipulating underlying
 * property sources. Allows clients to set and validate required properties, customize the
 * conversion service and more through the {@link ConfigurablePropertyResolver}
 * superinterface.
 */
public interface ConfigurableEnvironment extends Environment, ConfigurablePropertyResolver {
	// 设置有效的profile
	void setActiveProfiles(String... profiles);
	// 设置默认的profile
	void setDefaultProfiles(String... profiles);
	// 获取属性源集合，利用属性源集合可以操作Environment的properties
	MutablePropertySources getPropertySources();
	// 获取jvm系统属性
	Map<String, Object> getSystemProperties();
	// 获取环境变量
	Map<String, Object> getSystemEnvironment();
	// 合并另一个环境，主要用在父子容器中，子容器继承合并父容器的Environment
	void merge(ConfigurableEnvironment parent);
}

从javadocs和接口定义上可以看出，该Environment接口主要主要提供配置profile和properties的能力。

ConfigurableEnvironment继承了ConfigurablePropertyResolver接口，该接口是前文中的PropertyResolver的配置实现：

/**
 * Configuration interface to be implemented by most if not all {@link PropertyResolver}
 * types. Provides facilities for accessing and customizing the
 * {@link org.springframework.core.convert.ConversionService ConversionService}
 * used when converting property values from one type to another.
 */
public interface ConfigurablePropertyResolver extends PropertyResolver {
	// 设置转换服务，转换服务是Spring体系中非常重要的基础组件。用于转换解析出的property类型
	void setConversionService(ConfigurableConversionService conversionService);
	// 设置占位前缀
	void setPlaceholderPrefix(String placeholderPrefix);
	// 设置占位后缀
	void setPlaceholderSuffix(String placeholderSuffix);
	// 设置property中中key-pair分割符
	void setValueSeparator(String valueSeparator);
	// 设置是否忽略嵌套占位的解析
	void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders);
}

前文提及Environment用于解析Resource路径中的占位，如：

// 资源路径中有占位
@PropertySource("classpath:/com/${my.placeholder:default/path}/app.properties")
// 资源路径中有占位
<import resource="classpath:${custome.path}/beans2.xml"></import>

Environment可以利用properties属性解析这些占位，但是Environment实际委托ConfigurablePropertyResolver解析占位。ConfigurablePropertyResolver可以配置这些占位的前缀和后缀。

Environment可以获取properties，也是委托ConfigurablePropertyResolver解析获取，并同时提供转换服务，可以将property的值转为所需的目标类型，ConfigurablePropertyResolver提供了设置转换服务的接口。

上述中主要介绍Environment体系中定义的接口，接下来分析Environment的抽象实现AbstractEnvironment和标准实现StandardEnvironment。考虑到篇幅原因，本文只介绍Environment的核心功能：

1. Environment如何获取jvm系统属性和系统环境变量；
2. 如何实现profile决定bean属于哪个profile；
3. 设置属性properties原理；
4. 如何实现属性获取和资源路径占位解析；

1.Environment如何获取jvm系统属性和系统环境变量

StandardEnvironment是Spring上下文中标准的Environment，在非web应用中使用该Environment作为ApplicationContext的环境组件：

public class StandardEnvironment extends AbstractEnvironment {

	/** System environment property source name: {@value} */
	public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";

	/** JVM system properties property source name: {@value} */
	public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";

	@Override
	protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
		propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
	}

}

StandardEnvironment实现解析systemEnvironment系统环境变量和systemProperties系统属性作为Properties。在AbstractApplicationContext中实现：

// 获取环境Environment
@Override
public ConfigurableEnvironment getEnvironment() {
	if (this.environment == null) {
		this.environment = createEnvironment();
	}
	return this.environment;
}

// 创建StandardEnvironment实例，加载jvm系统属性和环境变量
protected ConfigurableEnvironment createEnvironment() {
	return new StandardEnvironment();
}

在非web环境中使用StandardEnvironment作为标准实现。在web环境中， 有web上下文容器覆盖createEnvironment实现，创建StandardServletEnvironment。

当调用StandardEnvironment构造器时，将调用父类AbstractEnvironment的无参构造器：

public AbstractEnvironment() {
	// 自定义属性源，customizePropertySources为抽象方法
	// 由子类实现
	customizePropertySources(this.propertySources);
	if (logger.isDebugEnabled()) {
		logger.debug("Initialized " + getClass().getSimpleName() + " with PropertySources " + this.propertySources);
	}
}

StandardEnvironment中关于customizePropertySources实现是为了加载jvm系统属性和环境变量：

@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public Map<String, Object> getSystemProperties() {
	try {
		// 调用System api获取所有的jvm系统属性
		return (Map) System.getProperties();
	}
	catch (AccessControlException ex) {
		// 如果设置了访问权限控制不能访问所有属性，则将返回惰性只读的属性map
		return (Map) new ReadOnlySystemAttributesMap() {
			@Override
			protected String getSystemAttribute(String attributeName) {
				try {
					// 只获取指定的属性
					return System.getProperty(attributeName);
				}
				catch (AccessControlException ex) {
					// 如果仍然无法访问，则返回null，表示没有该属性
					if (logger.isInfoEnabled()) {
						logger.info("Caught AccessControlException when accessing system property '" +
								attributeName + "'; its value will be returned [null]. Reason: " + ex.getMessage());
					}
					return null;
				}
			}
		};
	}
}

@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public Map<String, Object> getSystemEnvironment() {
	// 如果设置禁止访问环境变量，将返回空。抑制访问环境变量可以通过
	系统属性spring.getenv.ignore设置：true/false，默认是非抑制
	if (suppressGetenvAccess()) {
		return Collections.emptyMap();
	}
	try {
		// 调用System api获取返回所有的环境变量
		return (Map) System.getenv();
	}
	catch (AccessControlException ex) {
		// 同jvm系统属性一样，惰性只读特定的环境变量
		return (Map) new ReadOnlySystemAttributesMap() {
			@Override
			protected String getSystemAttribute(String attributeName) {
				try {
					return System.getenv(attributeName);
				}
				catch (AccessControlException ex) {
					if (logger.isInfoEnabled()) {
						logger.info("Caught AccessControlException when accessing system environment variable '" +
								attributeName + "'; its value will be returned [null]. Reason: " + ex.getMessage());
					}
					return null;
				}
			}
		};
	}
}

2.如何实现profile并决定bean属于哪个profile

在Spring中设置profile可以使Spring应用契合多环境：dev/test/pro等等。其中关键点在于：

• 让Spring应用知道当前处于什么环境，这可以有系统启动时携带参数：系统属性等设置决定，则该环境为Spring应用有效的profile；
• 当前配置的Bean是属于哪个环境（profile）

Spring容器在解析Bean时会将Bean定义中的profile作为参数传递给Environment，由Environment决定该profile是否可以被当前环境接受。这系列的逻辑由Environment的acceptsProfiles接口承担实现，因为Environment持有当前上下文容器的所有profile（active和default），AbstractEnvironment中实现：

@Override
public boolean acceptsProfiles(String... profiles) {
	// 断言输入profile是否为空
	Assert.notEmpty(profiles, "Must specify at least one profile");
	// 循环遍历每个profile
	for (String profile : profiles) {
		// bean中profile可以以"!"形式表示非
		if (StringUtils.hasLength(profile) && profile.charAt(0) == '!') {
			// 该profile不是有效的profile，返回true
			if (!isProfileActive(profile.substring(1))) {
				return true;
			}
		}
		// 不是以"!"开头，且是当前有效profile，则返回true
		else if (isProfileActive(profile)) {
			return true;
		}
	}
	return false;
}

再继续阅读isProfileActive实现，该方法重要完成参数的profile是否在当前上下文容器有效的profile中：

protected boolean isProfileActive(String profile) {
	// 校验profile合法性
	validateProfile(profile);
	// 惰性加载当前容器的有效的profile，可能存在多个
	Set<String> currentActiveProfiles = doGetActiveProfiles();
	// 判断参数profile是否在有效profile中，返回true/false
	return (currentActiveProfiles.contains(profile) ||
			(currentActiveProfiles.isEmpty() && doGetDefaultProfiles().contains(profile)));
}

doGetActiveProfiles主要是惰性Properties中获取有效的profile：

protected Set<String> doGetActiveProfiles() {
	// 同步修改，防并发
	synchronized (this.activeProfiles) {
		// 如果有效的profiles空，则加载
		if (this.activeProfiles.isEmpty()) {
			// 解析property，获取有效的profiles
			String profiles = getProperty(ACTIVE_PROFILES_PROPERTY_NAME);
			if (StringUtils.hasText(profiles)) {
				// 设置有效的profile
				setActiveProfiles(StringUtils.commaDelimitedListToStringArray(
						StringUtils.trimAllWhitespace(profiles)));
			}
		}
		return this.activeProfiles;
	}
}

该方法中核心的调用是getProperty加载当前上下文有效的profile。在Spring中有效的上下文激活方式：

• 在属性文件中配置属性：spring.profiles.active=dev
• 在启动时使用jvm参数：-Dspring.profiles.active=dev
• env.setActiveProfiles("dev")

getProperty方法中获取属性spring.profiles.active的值作为有效的profile：

@Override
public String getProperty(String key) {
	// 属性解析器解析获取spring.profiles.active属性
	return this.propertyResolver.getProperty(key);
}

@Override
public String getProperty(String key) {
	// 获取属性值并类型转换为String
	return getProperty(key, String.class);
}

以上的getProperty都是AbstractPropertyResolver实现，getProperty(key, String.class)在PropertySourcesPropertyResolver实现：

@Override
public <T> T getProperty(String key, Class<T> targetValueType) {
	return getProperty(key, targetValueType, true);
}

// resolveNestedPlaceholders是否解析嵌套占位参数
protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
	// 判断属性源是否为空
	if (this.propertySources != null) {
		// 遍历每个属性源
		for (PropertySource<?> propertySource : this.propertySources) {
			if (logger.isTraceEnabled()) {
				logger.trace("Searching for key '" + key + "' in PropertySource '" +
						propertySource.getName() + "'");
			}
			// 获取属性源中的key的值
			Object value = propertySource.getProperty(key);
			// 如果值不为空
			if (value != null) {
				// 如果支持嵌套解析且值是String类型
				if (resolveNestedPlaceholders && value instanceof String) {
					// 解析占位
					value = resolveNestedPlaceholders((String) value);
				}
				logKeyFound(key, propertySource, value);
				// 使用转换服务进行转换value为目标类型
				return convertValueIfNecessary(value, targetValueType);
			}
		}
	}
	if (logger.isDebugEnabled()) {
		logger.debug("Could not find key '" + key + "' in any property source");
	}
	// 无属性源，返回null
	return null;
}

上述流程中，获取到spring.profiles.active属性后，与Bean定义的profile比较，如果在当前有效的profile中，则该bean定义会被注册为spring bean。

3.设置属性properties原理

Environment中的properties分为两种，一种是Spring框架自身加载的：jvm系统属性和系统环境变量——前文中介绍StandardEnvironment；另一种是用户应用自定义的属性加载入Environment。

在Environment中的properties被抽象成：

public abstract class PropertySource<T> {

	...省略

	protected final String name;

	protected final T source;

	...省略

	public abstract Object getProperty(String name);
}

其实现非常多，其中有MapPropertySource以Map作为source，等等。

public class MapPropertySource extends EnumerablePropertySource<Map<String, Object>> {
	public MapPropertySource(String name, Map<String, Object> source) {
		super(name, source);
	}
	@Override
	public Object getProperty(String name) {
		return this.source.get(name);
	}
	@Override
	public boolean containsProperty(String name) {
		return this.source.containsKey(name);
	}
	@Override
	public String[] getPropertyNames() {
		return StringUtils.toStringArray(this.source.keySet());
	}

}

在应用中属性源PropertySource来源非常多，有可能是Map对象，也有可能是properies属性文件，所以Spring又在PropertySource上抽象一层多属性源PropertySources，通过其保持多PropertySource：

public interface PropertySources extends Iterable<PropertySource<?>> {

	// 测试是否包含指定名称属性源
	boolean contains(String name);
	// 通过名称获取属源
	PropertySource<?> get(String name);
}

其标准实现是易变的多属性源：

public class MutablePropertySources implements PropertySources {

	// List持有多个PropertySource
	private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<PropertySource<?>>();

	// 以下都是操作PropertySource的接口，包括增加移除等操作，体现MutablePropertySources的易变性
	public void addAfter(String relativePropertySourceName, PropertySource<?> propertySource) {
		...省略
	}
	public PropertySource<?> remove(String name) {
		...省略
	}
	public void addBefore(String relativePropertySourceName, PropertySource<?> propertySource) {
		...省略
	}
	public void addFirst(PropertySource<?> propertySource) {
		...省略
	}
	public void addLast(PropertySource<?> propertySource) {
		...省略
	}
}

在AbstractEnvironment中持有MutablePropertySources达到Environment中包含properties的目的。

public abstract class AbstractEnvironment implements ConfigurableEnvironment {

	...省略

	// 持有多属性源
	private final MutablePropertySources propertySources = new MutablePropertySources(this.logger);

	// 持有属性解析器，使用上述的propertySources构造，保证解析器的属性源和其实一个
	// 属性解析器提供了：按层级搜索属性值、解析获取属性值
	private final ConfigurablePropertyResolver propertyResolver =
			new PropertySourcesPropertyResolver(this.propertySources);

	...省略
}

前文中介绍ConfigurableEnvironment时，改配置环境接口提供了获取多属性源的接口：

MutablePropertySources getPropertySources()，通过该接口获取易变的多属性源可以达到操作Environment中的属性源的操作：addBefore/addFirst/addAfter/AddLaster/remove等等操作属性源的接口。

关于设置Environment中的jvm系统属性和环境变量前文在StandardEnvironment中已经介绍。

4.如何实现属性获取

本文的第一张图中已经画出通过Environment获取属性的流程，Environment通过委托于PropertyResolver完成解析获取属性。PropertyResolver充当的角色：

• 解析获取属性，并支持类型转换；
• 按层级搜索属性：即Environment中的PropertySource具有优先级；

关于如何如何解析获取属性的原理在前文的profile原理中已经介绍了部分，这里再细化：

// AbstractEnvironment中接口实现
@Override
public String getProperty(String key) {
	// 委托PropertyResolver解析获取
	return this.propertyResolver.getProperty(key);
}

// AbstractPropertyResolver中实现
@Override
public String getProperty(String key) {
	// 调用泛型接口实现，由PropertySourcesPropertyResolver实现
	// 并指定目标类型
	return getProperty(key, String.class);
}

// PropertySourcesPropertyResolver实现<T> T getProperty(String key, Class<T> targetType)
@Override
public <T> T getProperty(String key, Class<T> targetValueType) {
	// 支持属性值中的嵌套占位解析
	return getProperty(key, targetValueType, true);
}

// PropertySourcesPropertyResolver实现，支持优先级检索、嵌套占位解析、值转换
protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
	if (this.propertySources != null) {
		// 这里的for循环遍历所有的propertySource解析key，只要获取到value就返回，实现了propertySource的优先级（层级检索）
		for (PropertySource<?> propertySource : this.propertySources) {
			if (logger.isTraceEnabled()) {
				logger.trace("Searching for key '" + key + "' in PropertySource '" +
						propertySource.getName() + "'");
			}
			Object value = propertySource.getProperty(key);
			if (value != null) {
				// 实现value值中的嵌套占位解析
				if (resolveNestedPlaceholders && value instanceof String) {
					value = resolveNestedPlaceholders((String) value);
				}
				logKeyFound(key, propertySource, value);
				// 转化value为目标类型，主要使用Spring中的转换服务
				return convertValueIfNecessary(value, targetValueType);
			}
		}
	}
	if (logger.isDebugEnabled()) {
		logger.debug("Could not find key '" + key + "' in any property source");
	}
	return null;
}

Envoriment中易忽略点

前文中一直介绍Environment能够解析获取Spring上下文中的属性源，且支持解析占位${...}，但是：

• Environment是否支持解析Spring中所有的属性源
• Environment是否支持解析Spring应用出现的任意${...}

1.支持环境相关的属性解析

Environment英文是环境的意思，所以Spring中的Environment组件的属性解析和${...}也只是和环境相关，与环境以外的属性源和${...}，Environment是不支持的。

Environment中支持的属性元PropertySource只有以下三种情况：

• Environment组件自身加载的属性源，如StandardEnvironment中加载的系统属性系统环境变量；如StandardServletEnvironment中加载的ServletContext参数和Servlet参数；
• 通过ConfigralbeEnvironment获取MutablePropertySources对象，编程式加入的属性源；
• 通过@PropertySource注解加载的.properties文件中的属性；

javadocs中描述@PropertySource：

Annotation providing a convenient and declarative mechanism for adding a {@link org.springframework.core.env.PropertySource PropertySource} to Spring's {@link org.springframework.core.env.Environment Environment}. To be used in conjunction with @{@link Configuration} classes.

该注解提供便捷声明式的将PropertySource增加的Environment中，该注解需要结合@ Configuration共同使用。如：

@Configuration
@PropertySource("classpath:/com/myco/app.properties")
public class AppConfig {

    @Autowired
    Environment env;

    @Bean
    public TestBean testBean() {
        TestBean testBean = new TestBean();
        // 通过Environment获取属性
        testBean.setName(env.getProperty("testbean.name"));
        return testBean;
    }
}

以上的java config可以将类路径上的com/myco/app.properties文件中的属性加载到Environment中，并可以通过Environment获取。

在Spring中还有另外一种加载属性的方式，但是该方式主要是为了处理${...}占位问题，并非Environment中的属性，所以无法通过Environment获取其中的属性：

<context:property-placeholder location="classpath:com/foo/jdbc.properties"/>

以上配置Spring上下文会加载com/foo/jdbc.properties并且实例化PropertySourcesPlaceholderConfigurer用于解析@Value注解中的占位和Xml中Bean定义的占位。在该PropertySourcesPlaceholderConfigurer中也持有MutablePropertySources成员用于存储Properties。所以Spring中的properties不是都能成Environment中获取的。有些与环境无关的properties属于PropertySourcesPlaceholderConfigurer。PropertySourcesPlaceholderConfigurer也实现EnvironmentAware接口，持有Environment组件，所以Spring中的properties在PropertySourcesPlaceholderConfigurer都被包含。

2.支持环境相关的占位解析

Environment中支持的占位${...}解析只与环境相关，前文中介绍只有Resource路径中的占位Environment才负责解析。

Tips：

关于@Value注解和Bean定义的占位，由PropertySourcesPlaceholderConfigurer负责解析，后续文章会详解。

填坑resolvePath

上一篇文章中留下坑点，ClassPathXmlApplicationContext在设置配置文件路径时涉及到配置文件路径的解析问题，暂时搁置到本篇文章中详解。因为资源路径的解析由Environment组件负责路径中的占位解析替换，故需要深入Environment组件后才能更好的理解配置文件路径的解析原理。

回顾上章中的解析点：

public void setConfigLocations(String... locations) {
	if (locations != null) {
		Assert.noNullElements(locations, "Config locations must not be null");
		this.configLocations = new String[locations.length];
		for (int i = 0; i < locations.length; i++) {
			// 解析配置文件路径
			this.configLocations[i] = resolvePath(locations[i]).trim();
		}
	}
	else {
		this.configLocations = null;
	}
}

解析配置文件路径的逻辑由resolvePath完成，主要是解析资源配置文件中的默认占位${...}或者自定义占位：

protected String resolvePath(String path) {
	// 获取该ApplicationContext上下文对应的Environment
	// 委托Environment解析配置文件路径
	return getEnvironment().resolveRequiredPlaceholders(path);
}

这里重点看Environment解析的细节：

// 由AbstractEnvironment中该方法实现
@Override
public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
	// 委托PropertyResolver解析
	return this.propertyResolver.resolveRequiredPlaceholders(text);
}

// 由AbstractPropertyResolver实现
@Override
public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
	// 解析需要工具类PropertyPlaceholderHelper，如果无，则创建
	if (this.strictHelper == null) {
		this.strictHelper = createPlaceholderHelper(false);
	}
	// 解析处理
	return doResolvePlaceholders(text, this.strictHelper);
}

再进一不深入解析处理doResolvePlaceholders逻辑前，先看下PropertyPlaceholderHelper工具类细节：

public class PropertyPlaceholderHelper {
	private static final Map<String, String> wellKnownSimplePrefixes = new HashMap<String, String>(4);
	static {
		wellKnownSimplePrefixes.put("}", "{");
		wellKnownSimplePrefixes.put("]", "[");
		wellKnownSimplePrefixes.put(")", "(");
	}
	// 占位符前缀
	private final String placeholderPrefix;
	// 占位符后缀
	private final String placeholderSuffix;
	private final String simplePrefix;
	// key-pair分隔符
	private final String valueSeparator;
	// 忽略解析占位的flag
	private final boolean ignoreUnresolvablePlaceholders;
}

工具类主要是帮助解析String中的占位符，需要匹配String中占位符前缀位置、后缀位置，然后截取占位符中的内容，再将内容作为PropertyResolver参数，从PropertySoures中按优先级检索属性值，再将属性值替换占位，即完成配置文件完整路径的解析。

createPlaceholderHelper方法中主要是创建工具类，指定工具类的占位前后缀：

public static final String PLACEHOLDER_PREFIX = "${";
public static final String PLACEHOLDER_SUFFIX = "}";

private String placeholderPrefix = SystemPropertyUtils.PLACEHOLDER_PREFIX;
private String placeholderSuffix = SystemPropertyUtils.PLACEHOLDER_SUFFIX;

private PropertyPlaceholderHelper createPlaceholderHelper(boolean ignoreUnresolvablePlaceholders) {
	return new PropertyPlaceholderHelper(this.placeholderPrefix, this.placeholderSuffix,
			this.valueSeparator, ignoreUnresolvablePlaceholders);
}

从以上可以看出Spring默认的占位符是${}。

// AbstractPropertyResolver中实现
private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
	// 工具类通过回调的方式完成解析，实现匿名内部类
	return helper.replacePlaceholders(text, new PropertyPlaceholderHelper.PlaceholderResolver() {
		@Override
		public String resolvePlaceholder(String placeholderName) {
			// helper负责获取占位符中的内容
			// AbstractPropertyResolver将占位符中内容作为key，解析对应的属性值
			return getPropertyAsRawString(placeholderName);
		}
	});
}

public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
	Assert.notNull(value, "'value' must not be null");
	// 解析占位属性值
	return parseStringValue(value, placeholderResolver, new HashSet<String>());
}
protected String parseStringValue(
		String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {
	StringBuilder result = new StringBuilder(value);
	// 获取占位符前缀位置
	int startIndex = value.indexOf(this.placeholderPrefix);
	如果存在占位，则解析，否则返回
	while (startIndex != -1) {
		// 获取占位符后缀位置
		int endIndex = findPlaceholderEndIndex(result, startIndex);
		// 如果存在，则继续解析，否则设置startIndex为-1，使while退出
		if (endIndex != -1) {
			// 根据前缀和后缀位置获取占位符中的内容
			String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
			String originalPlaceholder = placeholder;
			// 判断是否有循环嵌套，这里不支持循环嵌套占位
			if (!visitedPlaceholders.add(originalPlaceholder)) {
				throw new IllegalArgumentException(
						"Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
			}
			// 递归解析嵌套占位
			placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
			// 从propertySources中解析占位内容对应的实际属性值
			String propVal = placeholderResolver.resolvePlaceholder(placeholder);
			if (propVal == null && this.valueSeparator != null) {
				int separatorIndex = placeholder.indexOf(this.valueSeparator);
				if (separatorIndex != -1) {
					String actualPlaceholder = placeholder.substring(0, separatorIndex);
					String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
					propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
					if (propVal == null) {
						propVal = defaultValue;
					}
				}
			}
			if (propVal != null) {
				// 如果属性值不为空，则需要递归解析属性值中是否也有嵌套占位
				propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
				// 将获取的属性值替换占位
				result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
				if (logger.isTraceEnabled()) {
					logger.trace("Resolved placeholder '" + placeholder + "'");
				}
				startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
			}
			else if (this.ignoreUnresolvablePlaceholders) {
				// Proceed with unprocessed value.
				startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
			}
			else {
				throw new IllegalArgumentException("Could not resolve placeholder '" +
						placeholder + "'" + " in value \"" + value + "\"");
			}
			// 处理完一个占位，移除
			visitedPlaceholders.remove(originalPlaceholder);
		}
		else {
			startIndex = -1;
		}
	}
	// 返回完整的解析结果
	return result.toString();
}

关于getPropertyAsRawString从PropertySources中解析占位内容对应的属性值，这里不在详细介绍，逻辑与前文中的profile和属性解析流程一致。

通过Environment提供的Resource路径占位解析能力，从而可以得到完整的配置文件路径，Spring上下文可以根据配置文件路径，解析配置中的Bean配置，从而完成后续的Bean解析等等工作。

总结

本文介绍Spring上下文容器的核心组件Environment的能力和实现细节。Environment主要提供能力：

• profile
• Properties

主要是以上两方面的维护操作。

参考

Environment abstraction

Spring 中无处不在的 Properties

Properties with Spring