Spring源码分析.properties文件读取及占位符${...}替换源码解析
Posted 五月的仓颉
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring源码分析.properties文件读取及占位符${...}替换源码解析相关的知识，希望对你有一定的参考价值。
前言
我们在开发中常遇到一种场景，Bean里面有一些参数是比较固定的，这种时候通常会采用配置的方式，将这些参数配置在.properties文件中，然后在Bean实例化的时候通过Spring将这些.properties文件中配置的参数使用占位符"${...}"替换的方式读入并设置到Bean的相应参数中。
这种做法最典型的就是JDBC的配置，本文就来研究一下.properties文件读取及占位符"${}"替换的源码，首先从代码入手，定义一个DataSource，模拟一下JDBC四个参数：
1 public class DataSource { 2 3 /** 4 * 驱动类 5 */ 6 private String driveClass; 7 8 /** 9 * jdbc地址 10 */ 11 private String url; 12 13 /** 14 * 用户名 15 */ 16 private String userName; 17 18 /** 19 * 密码 20 */ 21 private String password; 22 23 public String getDriveClass() { 24 return driveClass; 25 } 26 27 public void setDriveClass(String driveClass) { 28 this.driveClass = driveClass; 29 } 30 31 public String getUrl() { 32 return url; 33 } 34 35 public void setUrl(String url) { 36 this.url = url; 37 } 38 39 public String getUserName() { 40 return userName; 41 } 42 43 public void setUserName(String userName) { 44 this.userName = userName; 45 } 46 47 public String getPassword() { 48 return password; 49 } 50 51 public void setPassword(String password) { 52 this.password = password; 53 } 54 55 @Override 56 public String toString() { 57 return "DataSource [driveClass=" + driveClass + ", url=" + url + ", userName=" + userName + ", password=" + password + "]"; 58 } 59 60 }
定义一个db.properties文件：
1 driveClass=0 2 url=1 3 userName=2 4 password=3
定义一个properties.xml文件：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:aop="http://www.springframework.org/schema/aop" 5 xmlns:tx="http://www.springframework.org/schema/tx" 6 xsi:schemaLocation="http://www.springframework.org/schema/beans 7 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 8 http://www.springframework.org/schema/aop 9 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 10 11 <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 12 <property name="location" value="properties/db.properties"></property> 13 </bean> 14 15 <bean id="dataSource" class="org.xrq.spring.action.properties.DataSource"> 16 <property name="driveClass" value="${driveClass}" /> 17 <property name="url" value="${url}" /> 18 <property name="userName" value="${userName}" /> 19 <property name="password" value="${password}" /> 20 </bean> 21 22 </beans>
写一段测试代码：
1 public class TestProperties { 2 3 @Test 4 public void testProperties() { 5 ApplicationContext ac = new ClassPathXmlApplicationContext("spring/properties.xml"); 6 7 DataSource dataSource = (DataSource)ac.getBean("dataSource"); 8 System.out.println(dataSource); 9 } 10 11 }
运行结果就不贴了，很明显，下面就来分析一下Spring是如何将properties文件中的属性读入并替换"${}"占位符的。
PropertyPlaceholderConfigurer类解析
在properties.xml文件中我们看到了一个类PropertyPlaceholderConfigurer，顾名思义它就是一个属性占位符配置器，看一下这个类的继承关系图：
看到从这张图上，我们能分析出来的最重要的一点就是PropertyPlaceholderConfigurer是BeanFactoryPostProcessor接口的实现类，想见Spring上下文必然是在Bean定义全部加载完毕后且Bean实例化之前通过postProcessBeanFactory方法一次性地替换了占位符"${}"。
.properties文件读取源码解析
下面来看一下postProcessBeanFactory方法实现：
1 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 2 try { 3 Properties mergedProps = mergeProperties(); 4 5 // Convert the merged properties, if necessary. 6 convertProperties(mergedProps); 7 8 // Let the subclass process the properties. 9 processProperties(beanFactory, mergedProps); 10 } 11 catch (IOException ex) { 12 throw new BeanInitializationException("Could not load properties", ex); 13 } 14 }
跟一下第3行的mergeProperties方法：
1 protected Properties mergeProperties() throws IOException { 2 Properties result = new Properties(); 3 4 if (this.localOverride) { 5 // Load properties from file upfront, to let local properties override. 6 loadProperties(result); 7 } 8 9 if (this.localProperties != null) { 10 for (Properties localProp : this.localProperties) { 11 CollectionUtils.mergePropertiesIntoMap(localProp, result); 12 } 13 } 14 15 if (!this.localOverride) { 16 // Load properties from file afterwards, to let those properties override. 17 loadProperties(result); 18 } 19 20 return result; 21 }
第2行的方法new出一个Properties，名为result，这个result会随着之后的代码传入，.properties文件中的数据会写入result中。
OK，接着看，代码进入第17行的方法，通过文件加载.properties文件：
1 protected void loadProperties(Properties props) throws IOException { 2 if (this.locations != null) { 3 for (Resource location : this.locations) { 4 if (logger.isInfoEnabled()) { 5 logger.info("Loading properties file from " + location); 6 } 7 InputStream is = null; 8 try { 9 is = location.getInputStream(); 10 11 String filename = null; 12 try { 13 filename = location.getFilename(); 14 } catch (IllegalStateException ex) { 15 // resource is not file-based. See SPR-7552. 16 } 17 18 if (filename != null && filename.endsWith(XML_FILE_EXTENSION)) { 19 this.propertiesPersister.loadFromXml(props, is); 20 } 21 else { 22 if (this.fileEncoding != null) { 23 this.propertiesPersister.load(props, new InputStreamReader(is, this.fileEncoding)); 24 } 25 else { 26 this.propertiesPersister.load(props, is); 27 } 28 } 29 } 30 catch (IOException ex) { 31 if (this.ignoreResourceNotFound) { 32 if (logger.isWarnEnabled()) { 33 logger.warn("Could not load properties from " + location + ": " + ex.getMessage()); 34 } 35 } 36 else { 37 throw ex; 38 } 39 } 40 finally { 41 if (is != null) { 42 is.close(); 43 } 44 } 45 } 46 } 47 }
第9行，PropertyPlaceholderConfigurer的配置可以传入路径列表（当然这里只传了一个db.properties），第3行遍历列表，第9行通过一个输入字节流InputStream获取.properties对应的二进制数据，然后第23行的代码将InputStream中的二进制解析，写入第一个参数Properties中，Properties是JDK原生的读取.properties文件的工具。
就这样一个简单的流程，将.properties中的数据进行了解析，并写入result中（result是mergeProperties方法中new出的一个Properties）。
占位符"${...}"替换源码解析
上面看了.properties文件读取流程，接着就应当替换"${}"占位符了，还是回到postProcessBeanFactory方法：
1 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 2 try { 3 Properties mergedProps = mergeProperties(); 4 5 // Convert the merged properties, if necessary. 6 convertProperties(mergedProps); 7 8 // Let the subclass process the properties. 9 processProperties(beanFactory, mergedProps); 10 } 11 catch (IOException ex) { 12 throw new BeanInitializationException("Could not load properties", ex); 13 } 14 }
第3行合并了.properties文件（之所以叫做合并是因为多个.properties文件中可能有相同的Key）。
第6行在必要的情况下对合并的Properties进行转换，没看出有什么用。
第9行就开始替换占位符"${...}"了，要事先声明一点：BeanFactoryPostProcessor类的postProcessBeanFactory方法调用是在Bean定义解析之后，因此当前的beanFactory参数中已经有了所有的Bean定义，如果熟悉Bean解析流程的朋友对这一点应该很清楚。跟一下第9行的processProperties方法：
1 protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props) 2 throws BeansException { 3 4 StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props); 5 BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver); 6 7 String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames(); 8 for (String curName : beanNames) { 9 // Check that we\'re not parsing our own bean definition, 10 // to avoid failing on unresolvable placeholders in properties file locations. 11 if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) { 12 BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName); 13 try { 14 visitor.visitBeanDefinition(bd); 15 } 16 catch (Exception ex) { 17 throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage()); 18 } 19 } 20 } 21 22 // New in Spring 2.5: resolve placeholders in alias target names and aliases as well. 23 beanFactoryToProcess.resolveAliases(valueResolver); 24 25 // New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes. 26 beanFactoryToProcess.addEmbeddedValueResolver(valueResolver); 27 }
第4行new出一个PlaceholderResolvingStringValueResolver，传入Properties，顾名思义这是一个持有.properties文件配置的字符串值解析器。
第5行BeanDefinitionVistor，传入上面的StringValueResolver，顾名思义这是一个Bean定义访问工具，持有字符串值解析器，想见可以通过BeanDefinitionVistor访问Bean定义，在遇到需要解析的字符串的时候使用构造函数传入的StringValueResolver解析字符串。
第7行通过BeanFactory获取所有Bean定义的名称。
第8行开始遍历所有Bean定义的名称，注意第11行的第一个判断"!(curName.equals(this.beanName)"，this.beanName指的是PropertyPlaceholderConfigurer，意为PropertyPlaceholderConfigurer本身不会去解析占位符"${...}"。
着重跟14行的代码，BeanDefinitionVistor的visitBeanDefinition方法，传入BeanDefinition：
1 public void visitBeanDefinition(BeanDefinition beanDefinition) { 2 visitParentName(beanDefinition); 3 visitBeanClassName(beanDefinition); 4 visitFactoryBeanName(beanDefinition); 5 visitFactoryMethodName(beanDefinition); 6 visitScope(beanDefinition); 7 visitPropertyValues(beanDefinition.getPropertyValues()); 8 ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues(); 9 visitIndexedArgumentValues(cas.getIndexedArgumentValues()); 10 visitGenericArgumentValues(cas.getGenericArgumentValues()); 11 }
看到这个方法轮番访问<bean>定义中的parent、class、factory-bean、factory-method、scope、property、constructor-arg属性，但凡遇到需要"${...}"就进行解析。我们这里解析的是property标签中的"${...}"，因此跟一下第7行的代码：
1 protected void visitPropertyValues(MutablePropertyValues pvs) { 2 PropertyValue[] pvArray = pvs.getPropertyValues(); 3 for (PropertyValue pv : pvArray) { 4 Object newVal = resolveValue(pv.getValue()); 5 if (!ObjectUtils.nullSafeEquals(newVal, pv.getValue())) { 6 pvs.add(pv.getName(), newVal); 7 } 8 } 9 }
获取属性数组进行遍历，第4行的代码对属性值进行解析获取新属性值，第5行判断新属性值与原属性值不等，第6行的代码用新属性值替换原属性值。因此跟一下第4行的resolveValue方法：
1 protected Object resolveValue(Object value) { 2 if (value instanceof BeanDefinition) { 3 visitBeanDefinition((BeanDefinition) value); 4 } 5 else if (value instanceof BeanDefinitionHolder) { 6 visitBeanDefinition(((BeanDefinitionHolder) value).getBeanDefinition()); 7 } 8 else if (value instanceof RuntimeBeanReference) { 9 RuntimeBeanReference ref = (RuntimeBeanReference) value; 10 String newBeanName = resolveStringValue(ref.getBeanName()); 11 if (!newBeanName.equals(ref.getBeanName())) { 12 return new RuntimeBeanReference(newBeanName); 13 } 14 } 15 else if (value instanceof RuntimeBeanNameReference) { 16 RuntimeBeanNameReference ref = (RuntimeBeanNameReference) value; 17 String newBeanName = resolveStringValue(ref.getBeanName()); 18 if (!newBeanName.equals(ref.getBeanName())) { 19 return new RuntimeBeanNameReference(newBeanName); 20 } 21 } 22 else if (value instanceof Object[]) { 23 visitArray((Object[]) value); 24 } 25 else if (value instanceof List) { 26 visitList((List) value); 27 } 28 else if (value instanceof Set) { 29 visitSet((Set) value); 30 } 31 else if (value instanceof Map) { 32 visitMap((Map) value); 33 } 34 else if (value instanceof TypedStringValue) { 35 TypedStringValue typedStringValue = (TypedStringValue) value; 36 String stringValue = typedStringValue.getValue(); 37 if (stringValue != null) { 38 String visitedString = resolveStringValue(stringValue); 39 typedStringValue.setValue(visitedString); 40 } 41 } 42 else if (value instanceof String) { 43 return resolveStringValue((String) value); 44 } 45 return value; 46 }
这里主要对value类型做一个判断，我们配置文件里面配置的是字符串，因此就看字符串相关代码，即34行的判断进去，其余的差不多，可以自己看一下源码是怎么做的。第35~第36行的代码就是获取属性值，第38行的代码resolveStringValue方法解析字符串：
1 protected String resolveStringValue(String strVal) { 2 if (this.valueResolver == null) { 3 throw new IllegalStateException("No StringValueResolver specified - pass a resolver " + 4 "object into the constructor or override the \'resolveStringValue\' method"); 5 } 6 String resolvedValue = this.valueResolver.resolveStringValue(strVal); 7 // Return original String if not modified. 8 return (strVal.equals(resolvedValue) ? strVal : resolvedValue); 9 }
继续跟第6行的方法，valueResolver前面说过了，是传入的一个PlaceholderResolvingStringValueResolver，看一下resolveStringValue方法实现：
1 public String resolveStringValue(String strVal) throws BeansException { 2 String value = this.helper.replacePlaceholders(strVal, this.resolver); 3 return (value.equals(nullValue) ? null : value); 4 }
第2行的replacePlaceholders方法顾名思义，替换占位符，它位于PropertyPlaceholderHelper类中，跟一下这个方法：
1 public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) { 2 Assert.notNull(value, "Argument \'value\' must not be null."); 3 return parseStringValue(value, placeholderResolver, new HashSet<String>()); 4 }
继续跟第3行的parseStringValue方法，即追踪到了替换占位符的核心代码中：
1 protected String parseStringValue( 2 String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) { 3 4 StringBuilder buf = new StringBuilder(strVal); 5 6 int startIndex = strVal.indexOf(this.placeholderPrefix); 7 while (startIndex != -1) { 8 int endIndex = findPlaceholderEndIndex(buf, startIndex); 9 if (endIndex != -1) { 10 String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex); 11 if (!visitedPlaceholders.add(placeholder)) { 12 throw new IllegalArgumentException( 13 "Circular placeholder reference \'" + placeholder + "\' in property definitions"); 14 } 15 // Recursive invocation, parsing placeholders contained in the placeholder key. 16 placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders); 17 18 // Now obtain the value for the fully resolved key... 19 String propVal = placeholderResolver.resolvePlaceholder(placeholder); 20 if (propVal == null && this.valueSeparator != null) { 21 int separatorIndex = placeholder.indexOf(this.valueSeparator); 22 if (separatorIndex != -1) { 23 String actualPlaceholder = placeholder.substring(0, separatorIndex); 24 String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length()); 25 propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder); 26 if (propVal == null) { 27 propVal = defaultValue; 28 } 29 } 30 } 31 if (propVal != null) { 32 // Recursive invocation, parsing placeholders contained in the 33 // previously resolved placeholder value. 34 propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders); 35 buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal); 36 if (logger.isTraceEnabled()) { 37 logger.trace("Resolved placeholder \'" + placeholder + "\'"); 38 } 39 startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length()); 40 } 41 else if (this.ignoreUnresolvablePlaceholders) { 42 // Proceed with unprocessed value. 43 startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length()); 44 } 45 else { 46 throw new IllegalArgumentException("Could not resolve placeholder \'" + placeholder + "\'"); 47 } 48 49 visitedPlaceholders.remove(placeholder); 50 } 51 else { 52 startIndex = -1; 53 } 54 } 55 56 return buf.toString(); 57 }
过一下此流程：
- 获取占位符前缀"${"的位置索引startIndex
- 占位符前缀"${"存在，从"${"后面开始获取占位符后缀"}"的位置索引endIndex
- 如果占位符前缀位置索引startIndex与占位符后缀的位置索引endIndex都存在，截取中间的部分placeHolder
- 从Properties中获取placeHolder对应的值propVal
- 如果propVal不存在，尝试对placeHolder使用":"进行一次分割，如果分割出来有结果，那么前面一部分命名为actualPlaceholder
以上是关于Spring源码分析.properties文件读取及占位符${...}替换源码解析的主要内容，如果未能解决你的问题，请参考以下文章