程序博客网 > 高中女神 体验知乎

Spring自定义占位符替换(PropertyPlaceholderConfigurer)

来源：互联网 发布：高中女神 体验知乎 编辑：程序博客网 时间：2024/06/06 02:19

提示：由于作者水平和时间有限，请仅以参考的态度阅读。

引言

在使用SpringMVC做Web开发的时候，为了便于统一管理配置项，常常会看到用占位符的配置方式。这样，可以将分散在spring配置文件中的配置项的值集中到一个(多个)属性文件中，方便管理。

比如定义了一个bean，属性的值使用占位符，如下(applicationContext.xml)

[html] view plain copy
  1. <bean id= "funnelData" class ="com.company.project.web.FunnelData">  
  2.        <property name="name" value="${funnel.name}" />  
  3.        <property name="value" value="${funnel.value}" />  
  4. </bean>  

接着在其他properties文件中指定占位符所代表的值，如下(bean.properties)
[plain] view plain copy
  1. funnel.name= kiseki  
  2. funnel.value=1234  

然后告诉spring这个properties文件的位置，这是通过配置PropertyPlaceholderConfigurer的bean来做到的，如下(applicationContext.xml)
[html] view plain copy
  1. <bean id= "placeHolder"  
  2.        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >  
  3.        <property name="location" >  
  4.              <value>classpath:/application.properties</value >  
  5.        </property>  
  6. </bean>  

分析

虽然在3.1开始官方文档推荐优先使用PropertySourcesPlaceholderConfigurer取代PropertyPlaceholderConfigurer，但是研究分析下PropertyPlaceholderConfigurer还是会有不少收获。spring占位符替换主要涉及到BeanFactoryPostProcessor接口和PropertyPlaceholderConfigurer、PlaceholderConfigurerSupport、PropertyResourceConfigurer三个类。



Spring提供了的一种叫做BeanFactoryPostProcessor的容器扩展机制。它允许我们在容器实例化对象之前，对容器中的BeanDefinition中的信息做一定的修改(比如对某些字段的值进行修改，这就是占位符替换的根本)。于是就需要说下BeanFactoryPostProcessor接口了，以下BeanFactoryPostProcessor的定义

[java] view plain copy
  1. public interface BeanFactoryPostProcessor {  
  2.      void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;  
  3. }  
在web项目的spring上下文初始化中，spring在实例化bean之前，会先实例化出实现了BeanFactoryPostProcessor接口的bean，并调用postProcessBeanFactory方法，对BeanFactory中的BeanDefinition进行处理。



看看PropertyPlaceholderConfigurer、PlaceholderConfigurerSupport、PropertyResourceConfigurer三个类的定义

[java] view plain copy
  1. public class PropertyPlaceholderConfigurer extends PlaceholderConfigurerSupport  
  2. public abstract class PlaceholderConfigurerSupport extends PropertyResourceConfigurer  
  3.              implements BeanNameAware, BeanFactoryAware  
  4. public abstract class PropertyResourceConfigurer extends PropertiesLoaderSupport  
  5.              implements BeanFactoryPostProcessor, PriorityOrdered  

可以看到PropertyPlaceholderConfigurer类的祖先类PropertyResourceConfigurer实现了BeanFactoryPostProcessor接口。



先看看PropertyResourceConfigurer的postProcessBeanFactory()方法

[java] view plain copy
  1. public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {  
  2.    try {  
  3.       Properties mergedProps = mergeProperties();  
  4.       // Convert the merged properties, if necessary.  
  5.       convertProperties(mergedProps);  
  6.       // Let the subclass process the properties.  
  7.       processProperties(beanFactory, mergedProps);  
  8.    } catch (IOException ex) {  
  9.       throw new BeanInitializationException("Could not load properties", ex);  
  10.    }  
  11. }  
这个方法整合好Properties，然后以BeanFactory和Properties作为参数调用PropertyPlaceholderConfigurer的processProperties方法。



接着看PropertyPlaceholderConfigurer的processProperties()方法

[java] view plain copy
  1. protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)  
  2.       throws BeansException {  
  3.    StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);  
  4.    this.doProcessProperties(beanFactoryToProcess, valueResolver);  
  5. }  
这个类就实例化了一个StringValueResolver对象，然后用BeanFactory和StringValueResolver对象调用PlaceholderConfigurerSupport#doProcessProperties()



再看PlaceholderConfigurerSupport的doProcessProperties()方法

[java] view plain copy
  1. protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,  
  2.       StringValueResolver valueResolver) {  
  3.    BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);  
  4.    String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();  
  5.    for (String curName : beanNames) {  
  6.       // Check that we're not parsing our own bean definition,  
  7.       // to avoid failing on unresolvable placeholders in properties file locations.  
  8.       if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this .beanFactory ))) {  
  9.          BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName);  
  10.          try {  
  11.             visitor.visitBeanDefinition(bd);  
  12.          } catch (Exception ex) {  
  13.             throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage());  
  14.          }  
  15.       }  
  16.    }  
  17.   
  18.    // New in Spring 2.5: resolve placeholders in alias target names and aliases as well.  
  19.    beanFactoryToProcess.resolveAliases(valueResolver);  
  20.   
  21.    // New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes.  
  22.    beanFactoryToProcess.addEmbeddedValueResolver(valueResolver);  
  23. }  
这个方法就会取出BeanFactory中的BeanDefinition，然后循环处理除了本身以外的bean的占位符替换

扩展

在了解了PropertyPlaceholderConfigurer做占位符替换的流程之后，我们应该有所启发：

1、要定制自己的占位符替换实现，入口就在BeanFactoryPostProcessor接口。实现BeanFactoryPostProcessor接口，并替换掉PropertyPlaceholderConfigurer即可。

2、占位符替换过程中，最主要的是Properties，整合出自己的Properties后，spring现成的很多代码可以继续使用。


目前我们采用Zookeeper做配置中心，用于管理多个APP实例上的配置，而基本的思路就是实现BeanFactoryPostProcessor接口，从Zookeeper上取相应节点，构造出Properties。


附上PropertyPlaceholderConfigurer的源码，可以基于该类的实现自己的 占位符替换功能（properties或缓存中）

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. /* 
  2.  * Copyright 2002-2008 the original author or authors. 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package org.springframework.beans.factory.config;  
  18.   
  19. import java.util.HashSet;  
  20. import java.util.Properties;  
  21. import java.util.Set;  
  22.   
  23. import org.springframework.beans.BeansException;  
  24. import org.springframework.beans.factory.BeanDefinitionStoreException;  
  25. import org.springframework.beans.factory.BeanFactory;  
  26. import org.springframework.beans.factory.BeanFactoryAware;  
  27. import org.springframework.beans.factory.BeanNameAware;  
  28. import org.springframework.core.Constants;  
  29. import org.springframework.util.StringUtils;  
  30. import org.springframework.util.StringValueResolver;  
  31.   
  32. /** 
  33.  * A property resource configurer that resolves placeholders in bean property values of 
  34.  * context definitions. It <i>pulls</i> values from a properties file into bean definitions. 
  35.  * 
  36.  * <p>The default placeholder syntax follows the Ant / Log4J / JSP EL style: 
  37.  * 
  38.  * <pre class="code">${...}</pre> 
  39.  * 
  40.  * Example XML context definition: 
  41.  * 
  42.  * <pre class="code"><bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> 
  43.  *   <property name="driverClassName"><value>${driver}</value></property> 
  44.  *   <property name="url"><value>jdbc:${dbname}</value></property> 
  45.  * </bean></pre> 
  46.  * 
  47.  * Example properties file: 
  48.  * 
  49.  * <pre class="code">driver=com.mysql.jdbc.Driver 
  50.  * dbname=mysql:mydb</pre> 
  51.  * 
  52.  * PropertyPlaceholderConfigurer checks simple property values, lists, maps, 
  53.  * props, and bean names in bean references. Furthermore, placeholder values can 
  54.  * also cross-reference other placeholders, like: 
  55.  * 
  56.  * <pre class="code">rootPath=myrootdir 
  57.  * subPath=${rootPath}/subdir</pre> 
  58.  * 
  59.  * In contrast to PropertyOverrideConfigurer, this configurer allows to fill in 
  60.  * explicit placeholders in context definitions. Therefore, the original definition 
  61.  * cannot specify any default values for such bean properties, and the placeholder 
  62.  * properties file is supposed to contain an entry for each defined placeholder. 
  63.  * 
  64.  * <p>If a configurer cannot resolve a placeholder, a BeanDefinitionStoreException 
  65.  * will be thrown. If you want to check against multiple properties files, specify 
  66.  * multiple resources via the "locations" setting. You can also define multiple 
  67.  * PropertyPlaceholderConfigurers, each with its <i>own</i> placeholder syntax. 
  68.  * 
  69.  * <p>Default property values can be defined via "properties", to make overriding 
  70.  * definitions in properties files optional. A configurer will also check against 
  71.  * system properties (e.g. "user.dir") if it cannot resolve a placeholder with any 
  72.  * of the specified properties. This can be customized via "systemPropertiesMode". 
  73.  * 
  74.  * <p>Note that the context definition <i>is</i> aware of being incomplete; 
  75.  * this is immediately obvious to users when looking at the XML definition file. 
  76.  * Hence, placeholders have to be resolved; any desired defaults have to be 
  77.  * defined as placeholder values as well (for example in a default properties file). 
  78.  * 
  79.  * <p>Property values can be converted after reading them in, through overriding 
  80.  * the {@link #convertPropertyValue} method. For example, encrypted values can 
  81.  * be detected and decrypted accordingly before processing them. 
  82.  * 
  83.  * @author Juergen Hoeller 
  84.  * @since 02.10.2003 
  85.  * @see #setLocations 
  86.  * @see #setProperties 
  87.  * @see #setPlaceholderPrefix 
  88.  * @see #setPlaceholderSuffix 
  89.  * @see #setSystemPropertiesModeName 
  90.  * @see System#getProperty(String) 
  91.  * @see #convertPropertyValue 
  92.  * @see PropertyOverrideConfigurer 
  93.  */  
  94. public class PropertyPlaceholderConfigurer extends PropertyResourceConfigurer  
  95.     implements BeanNameAware, BeanFactoryAware {  
  96.   
  97.     /** Default placeholder prefix: "${" */  
  98.     public static final String DEFAULT_PLACEHOLDER_PREFIX = "${";  
  99.   
  100.     /** Default placeholder suffix: "}" */  
  101.     public static final String DEFAULT_PLACEHOLDER_SUFFIX = "}";  
  102.   
  103.   
  104.     /** Never check system properties. */  
  105.     public static final int SYSTEM_PROPERTIES_MODE_NEVER = 0;  
  106.   
  107.     /** 
  108.      * Check system properties if not resolvable in the specified properties. 
  109.      * This is the default. 
  110.      */  
  111.     public static final int SYSTEM_PROPERTIES_MODE_FALLBACK = 1;  
  112.   
  113.     /** 
  114.      * Check system properties first, before trying the specified properties. 
  115.      * This allows system properties to override any other property source. 
  116.      */  
  117.     public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE = 2;  
  118.   
  119.   
  120.     private static final Constants constants = new Constants(PropertyPlaceholderConfigurer.class);  
  121.   
  122.     private String placeholderPrefix = DEFAULT_PLACEHOLDER_PREFIX;  
  123.   
  124.     private String placeholderSuffix = DEFAULT_PLACEHOLDER_SUFFIX;  
  125.   
  126.     private int systemPropertiesMode = SYSTEM_PROPERTIES_MODE_FALLBACK;  
  127.   
  128.     private boolean searchSystemEnvironment = true;  
  129.   
  130.     private boolean ignoreUnresolvablePlaceholders = false;  
  131.   
  132.     private String nullValue;  
  133.   
  134.     private String beanName;  
  135.   
  136.     private BeanFactory beanFactory;  
  137.   
  138.   
  139.     /** 
  140.      * Set the prefix that a placeholder string starts with. 
  141.      * The default is "${". 
  142.      * @see #DEFAULT_PLACEHOLDER_PREFIX 
  143.      */  
  144.     public void setPlaceholderPrefix(String placeholderPrefix) {  
  145.         this.placeholderPrefix = placeholderPrefix;  
  146.     }  
  147.   
  148.     /** 
  149.      * Set the suffix that a placeholder string ends with. 
  150.      * The default is "}". 
  151.      * @see #DEFAULT_PLACEHOLDER_SUFFIX 
  152.      */  
  153.     public void setPlaceholderSuffix(String placeholderSuffix) {  
  154.         this.placeholderSuffix = placeholderSuffix;  
  155.     }  
  156.   
  157.     /** 
  158.      * Set the system property mode by the name of the corresponding constant, 
  159.      * e.g. "SYSTEM_PROPERTIES_MODE_OVERRIDE". 
  160.      * @param constantName name of the constant 
  161.      * @throws java.lang.IllegalArgumentException if an invalid constant was specified 
  162.      * @see #setSystemPropertiesMode 
  163.      */  
  164.     public void setSystemPropertiesModeName(String constantName) throws IllegalArgumentException {  
  165.         this.systemPropertiesMode = constants.asNumber(constantName).intValue();  
  166.     }  
  167.   
  168.     /** 
  169.      * Set how to check system properties: as fallback, as override, or never. 
  170.      * For example, will resolve ${user.dir} to the "user.dir" system property. 
  171.      * <p>The default is "fallback": If not being able to resolve a placeholder 
  172.      * with the specified properties, a system property will be tried. 
  173.      * "override" will check for a system property first, before trying the 
  174.      * specified properties. "never" will not check system properties at all. 
  175.      * @see #SYSTEM_PROPERTIES_MODE_NEVER 
  176.      * @see #SYSTEM_PROPERTIES_MODE_FALLBACK 
  177.      * @see #SYSTEM_PROPERTIES_MODE_OVERRIDE 
  178.      * @see #setSystemPropertiesModeName 
  179.      */  
  180.     public void setSystemPropertiesMode(int systemPropertiesMode) {  
  181.         this.systemPropertiesMode = systemPropertiesMode;  
  182.     }  
  183.   
  184.     /** 
  185.      * Set whether to search for a matching system environment variable 
  186.      * if no matching system property has been found. Only applied when 
  187.      * "systemPropertyMode" is active (i.e. "fallback" or "override"), right 
  188.      * after checking JVM system properties. 
  189.      * <p>Default is "true". Switch this setting off to never resolve placeholders 
  190.      * against system environment variables. Note that it is generally recommended 
  191.      * to pass external values in as JVM system properties: This can easily be 
  192.      * achieved in a startup script, even for existing environment variables. 
  193.      * <p><b>NOTE:</b> Access to environment variables does not work on the 
  194.      * Sun VM 1.4, where the corresponding {@link System#getenv} support was 
  195.      * disabled - before it eventually got re-enabled for the Sun VM 1.5. 
  196.      * Please upgrade to 1.5 (or higher) if you intend to rely on the 
  197.      * environment variable support. 
  198.      * @see #setSystemPropertiesMode 
  199.      * @see java.lang.System#getProperty(String) 
  200.      * @see java.lang.System#getenv(String) 
  201.      */  
  202.     public void setSearchSystemEnvironment(boolean searchSystemEnvironment) {  
  203.         this.searchSystemEnvironment = searchSystemEnvironment;  
  204.     }  
  205.   
  206.     /** 
  207.      * Set whether to ignore unresolvable placeholders. Default is "false": 
  208.      * An exception will be thrown if a placeholder cannot be resolved. 
  209.      */  
  210.     public void setIgnoreUnresolvablePlaceholders(boolean ignoreUnresolvablePlaceholders) {  
  211.         this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;  
  212.     }  
  213.   
  214.     /** 
  215.      * Set a value that should be treated as <code>null</code> when 
  216.      * resolved as a placeholder value: e.g. "" (empty String) or "null". 
  217.      * <p>Note that this will only apply to full property values, 
  218.      * not to parts of concatenated values. 
  219.      * <p>By default, no such null value is defined. This means that 
  220.      * there is no way to express <code>null</code> as a property 
  221.      * value unless you explictly map a corresponding value here. 
  222.      */  
  223.     public void setNullValue(String nullValue) {  
  224.         this.nullValue = nullValue;  
  225.     }  
  226.   
  227.     /** 
  228.      * Only necessary to check that we're not parsing our own bean definition, 
  229.      * to avoid failing on unresolvable placeholders in properties file locations. 
  230.      * The latter case can happen with placeholders for system properties in 
  231.      * resource locations. 
  232.      * @see #setLocations 
  233.      * @see org.springframework.core.io.ResourceEditor 
  234.      */  
  235.     public void setBeanName(String beanName) {  
  236.         this.beanName = beanName;  
  237.     }  
  238.   
  239.     /** 
  240.      * Only necessary to check that we're not parsing our own bean definition, 
  241.      * to avoid failing on unresolvable placeholders in properties file locations. 
  242.      * The latter case can happen with placeholders for system properties in 
  243.      * resource locations. 
  244.      * @see #setLocations 
  245.      * @see org.springframework.core.io.ResourceEditor 
  246.      */  
  247.     public void setBeanFactory(BeanFactory beanFactory) {  
  248.         this.beanFactory = beanFactory;  
  249.     }  
  250.   
  251.   
  252.     protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)  
  253.             throws BeansException {  
  254.   
  255.         StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);  
  256.         BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);  
  257.   
  258.         String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();  
  259.         for (int i = 0; i < beanNames.length; i++) {  
  260.             // Check that we're not parsing our own bean definition,  
  261.             // to avoid failing on unresolvable placeholders in properties file locations.  
  262.             if (!(beanNames[i].equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {  
  263.                 BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(beanNames[i]);  
  264.                 try {  
  265.                     visitor.visitBeanDefinition(bd);  
  266.                 }  
  267.                 catch (BeanDefinitionStoreException ex) {  
  268.                     throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanNames[i], ex.getMessage());  
  269.                 }  
  270.             }  
  271.         }  
  272.   
  273.         // New in Spring 2.5: resolve placeholders in alias target names and aliases as well.  
  274.         beanFactoryToProcess.resolveAliases(valueResolver);  
  275.     }  
  276.   
  277.     /** 
  278.      * Parse the given String value recursively, to be able to resolve 
  279.      * nested placeholders (when resolved property values in turn contain 
  280.      * placeholders again). 
  281.      * @param strVal the String value to parse 
  282.      * @param props the Properties to resolve placeholders against 
  283.      * @param visitedPlaceholders the placeholders that have already been visited 
  284.      * during the current resolution attempt (used to detect circular references 
  285.      * between placeholders). Only non-null if we're parsing a nested placeholder. 
  286.      * @throws BeanDefinitionStoreException if invalid values are encountered 
  287.      * @see #resolvePlaceholder(String, java.util.Properties, int) 
  288.      */  
  289.     protected String parseStringValue(String strVal, Properties props, Set visitedPlaceholders)  
  290.         throws BeanDefinitionStoreException {  
  291.   
  292.         StringBuffer buf = new StringBuffer(strVal);  
  293.   
  294.         int startIndex = strVal.indexOf(this.placeholderPrefix);  
  295.         while (startIndex != -1) {  
  296.             int endIndex = findPlaceholderEndIndex(buf, startIndex);  
  297.             if (endIndex != -1) {  
  298.                 String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex);  
  299.                 if (!visitedPlaceholders.add(placeholder)) {  
  300.                     throw new BeanDefinitionStoreException(  
  301.                             "Circular placeholder reference '" + placeholder + "' in property definitions");  
  302.                 }  
  303.                 // Recursive invocation, parsing placeholders contained in the placeholder key.  
  304.                 placeholder = parseStringValue(placeholder, props, visitedPlaceholders);  
  305.                 // Now obtain the value for the fully resolved key...  
  306.                 String propVal = resolvePlaceholder(placeholder, props, this.systemPropertiesMode);  
  307.                 if (propVal != null) {  
  308.                     // Recursive invocation, parsing placeholders contained in the  
  309.                     // previously resolved placeholder value.  
  310.                     propVal = parseStringValue(propVal, props, visitedPlaceholders);  
  311.                     buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);  
  312.                     if (logger.isTraceEnabled()) {  
  313.                         logger.trace("Resolved placeholder '" + placeholder + "'");  
  314.                     }  
  315.                     startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length());  
  316.                 }  
  317.                 else if (this.ignoreUnresolvablePlaceholders) {  
  318.                     // Proceed with unprocessed value.  
  319.                     startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());  
  320.                 }  
  321.                 else {  
  322.                     throw new BeanDefinitionStoreException("Could not resolve placeholder '" + placeholder + "'");  
  323.                 }  
  324.                 visitedPlaceholders.remove(placeholder);  
  325.             }  
  326.             else {  
  327.                 startIndex = -1;  
  328.             }  
  329.         }  
  330.   
  331.         return buf.toString();  
  332.     }  
  333.   
  334.     private int findPlaceholderEndIndex(CharSequence buf, int startIndex) {  
  335.         int index = startIndex + this.placeholderPrefix.length();  
  336.         int withinNestedPlaceholder = 0;  
  337.         while (index < buf.length()) {  
  338.             if (StringUtils.substringMatch(buf, index, this.placeholderSuffix)) {  
  339.                 if (withinNestedPlaceholder > 0) {  
  340.                     withinNestedPlaceholder--;  
  341.                     index = index + this.placeholderSuffix.length();  
  342.                 }  
  343.                 else {  
  344.                     return index;  
  345.                 }  
  346.             }  
  347.             else if (StringUtils.substringMatch(buf, index, this.placeholderPrefix)) {  
  348.                 withinNestedPlaceholder++;  
  349.                 index = index + this.placeholderPrefix.length();  
  350.             }  
  351.             else {  
  352.                 index++;  
  353.             }  
  354.         }  
  355.         return -1;  
  356.     }  
  357.   
  358.     /** 
  359.      * Resolve the given placeholder using the given properties, performing 
  360.      * a system properties check according to the given mode. 
  361.      * <p>Default implementation delegates to <code>resolvePlaceholder 
  362.      * (placeholder, props)</code> before/after the system properties check. 
  363.      * <p>Subclasses can override this for custom resolution strategies, 
  364.      * including customized points for the system properties check. 
  365.      * @param placeholder the placeholder to resolve 
  366.      * @param props the merged properties of this configurer 
  367.      * @param systemPropertiesMode the system properties mode, 
  368.      * according to the constants in this class 
  369.      * @return the resolved value, of null if none 
  370.      * @see #setSystemPropertiesMode 
  371.      * @see System#getProperty 
  372.      * @see #resolvePlaceholder(String, java.util.Properties) 
  373.      */  
  374.     protected String resolvePlaceholder(String placeholder, Properties props, int systemPropertiesMode) {  
  375.         String propVal = null;  
  376.         if (systemPropertiesMode == SYSTEM_PROPERTIES_MODE_OVERRIDE) {  
  377.             propVal = resolveSystemProperty(placeholder);  
  378.         }  
  379.         if (propVal == null) {  
  380.             propVal = resolvePlaceholder(placeholder, props);  
  381.         }  
  382.         if (propVal == null && systemPropertiesMode == SYSTEM_PROPERTIES_MODE_FALLBACK) {  
  383.             propVal = resolveSystemProperty(placeholder);  
  384.         }  
  385.         return propVal;  
  386.     }  
  387.   
  388.     /** 
  389.      * Resolve the given placeholder using the given properties. 
  390.      * The default implementation simply checks for a corresponding property key. 
  391.      * <p>Subclasses can override this for customized placeholder-to-key mappings 
  392.      * or custom resolution strategies, possibly just using the given properties 
  393.      * as fallback. 
  394.      * <p>Note that system properties will still be checked before respectively 
  395.      * after this method is invoked, according to the system properties mode. 
  396.      * @param placeholder the placeholder to resolve 
  397.      * @param props the merged properties of this configurer 
  398.      * @return the resolved value, of <code>null</code> if none 
  399.      * @see #setSystemPropertiesMode 
  400.      */  
  401.     protected String resolvePlaceholder(String placeholder, Properties props) {  
  402.         return props.getProperty(placeholder);  
  403.     }  
  404.   
  405.     /** 
  406.      * Resolve the given key as JVM system property, and optionally also as 
  407.      * system environment variable if no matching system property has been found. 
  408.      * @param key the placeholder to resolve as system property key 
  409.      * @return the system property value, or <code>null</code> if not found 
  410.      * @see #setSearchSystemEnvironment 
  411.      * @see java.lang.System#getProperty(String) 
  412.      * @see java.lang.System#getenv(String) 
  413.      */  
  414.     protected String resolveSystemProperty(String key) {  
  415.         try {  
  416.             String value = System.getProperty(key);  
  417.             if (value == null && this.searchSystemEnvironment) {  
  418.                 value = System.getenv(key);  
  419.             }  
  420.             return value;  
  421.         }  
  422.         catch (Throwable ex) {  
  423.             if (logger.isDebugEnabled()) {  
  424.                 logger.debug("Could not access system property '" + key + "': " + ex);  
  425.             }  
  426.             return null;  
  427.         }  
  428.     }  
  429.   
  430.   
  431.     /** 
  432.      * BeanDefinitionVisitor that resolves placeholders in String values, 
  433.      * delegating to the <code>parseStringValue</code> method of the 
  434.      * containing class. 
  435.      */  
  436.     private class PlaceholderResolvingStringValueResolver implements StringValueResolver {  
  437.   
  438.         private final Properties props;  
  439.   
  440.         public PlaceholderResolvingStringValueResolver(Properties props) {  
  441.             this.props = props;  
  442.         }  
  443.   
  444.         public String resolveStringValue(String strVal) throws BeansException {  
  445.             String value = parseStringValue(strVal, this.props, new HashSet());  
  446.             return (value.equals(nullValue) ? null : value);  
  447.         }  
  448.     }  
  449.   
  450. }  

别人的理解：http://blog.csdn.NET/turkeyzhou/article/details/2915438

在第二编对BeanFactory的分析中，我们老能看见BeanFactoyPostProcessor的身影，那么在这一节中，我们来详细的讨论一下
BeanFactoryPostProcessor的代码结构，从中学习他的优秀之处；

BeanFactoryPostProcessor能够修改bean配置文件中的bean的定义；使得我们能够进行一些额外的处理；
在spring中，我们几乎不用自己扩展这个接口，因为他内置了很多实现，但是，我们从原理上和代码上来分析其功能的实现；

一下是他的类图实现：





拿PropertyPlaceholderConfigurer举例；


PropertyPlaceholderConfigurer的功能是这样的，我们在配置文件中配置如下Bean:

  1. <bean id="PropertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  2. <property name="order">1</property>
  3. <property name="locations">
  4. <list>
  5.  <value>userinfo.properties</value>
  6. </list>
  7. </property>
  8. </bean>

  10. <bean id="user" class="org.test.UserInfo">
  11. <property name="order" value="${db.userName}"></property>
  12. <property name="order" value="${db.password}"></property>
  13. </property>
  14. </bean>




userinfo.properties:
db.username:scott
db.password:tiger

然后在ApplicationContext下面会自动调用这个PostProcessor;把${db.userName}转换为scott；
在BeanFactory下面的话，必须手动生成以上PostProcesor对象，并且手动调用postProcessorBeanFactory(configureableBeanFactory）方法；

那么我们现在来看一下代码的实现
在PropertyResourceConfigurer中，定义了postProcessBeanFactory方法，定义了方法执行的流程，使用了模板模式；
将具体算法的实现暴露到了子类；


public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
            Properties mergedProps = mergeProperties();

            // Convert the merged properties, if necessary.
            convertProperties(mergedProps);

            // Let the subclass process the properties.
            processProperties(beanFactory, mergedProps);
        }
        catch (IOException ex) {
            throw new BeanInitializationException("Could not load properties", ex);
        }
    }


模板方法1：mergeProperties()如下：

protected Properties mergeProperties() throws IOException {
        Properties result = new Properties();

        if (this.localOverride) {
            // Load properties from file upfront, to let local properties override.
            loadProperties(result);
        }

        if (this.localProperties != null) {
            for (int i = 0; i < this.localProperties.length; i++) {
                Properties props = this.localProperties[i];
                // Use propertyNames enumeration to also catch default properties.
                for (Enumeration en = props.propertyNames(); en.hasMoreElements();) {
                    String key = (String) en.nextElement();
                    result.setProperty(key, props.getProperty(key));
                }
            }
        }

        if (!this.localOverride) {
            // Load properties from file afterwards, to let those properties override.
            loadProperties(result);
        }

        return result;
    }
在这个方法中，将加载你在构造bean的时候传入的properties值，然后存储到这个PostProcessor中，方便覆盖bean定义的元数据，如${db.username}等等；


模板方法processProperties被推到子类实现了：

protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
            throws BeansException {
        //构造一个BeanDefinition访问器（前一节已经分析过），是其内部类：
        BeanDefinitionVisitor visitor = new PlaceholderResolvingBeanDefinitionVisitor(props);

        //得到所有beanName
        String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
        for (int i = 0; i < beanNames.length; i++) {
            // Check that we're not parsing our own bean definition,
            // to avoid failing on unresolvable placeholders in properties file locations.
            if (!(beanNames[i].equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
                BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(beanNames[i]);
                try {
                    //在这段代码中会遍历所有的Bean定义的带来${}的属性，包括map ,list，String等等；
                    visitor.visitBeanDefinition(bd);
                }
                catch (BeanDefinitionStoreException ex) {
                    throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanNames[i], ex.getMessage());
                }
            }
        }
    }

内部的BeanDefinition访问器：

private class PlaceholderResolvingBeanDefinitionVisitor extends BeanDefinitionVisitor {

        private final Properties props;

        public PlaceholderResolvingBeanDefinitionVisitor(Properties props) {
            this.props = props;
        }

        protected String resolveStringValue(String strVal) throws BeansException {
            return parseStringValue(strVal, this.props, new HashSet());
        }
    }
在访问器中visitBeanDefinition(bd)会遍历此BeanDefinition的proerty,constructor等等可以设置${}的地方例如propertiy:

protected void visitPropertyValues(MutablePropertyValues pvs) {
        PropertyValue[] pvArray = pvs.getPropertyValues();
        for (int i = 0; i < pvArray.length; i++) {
            PropertyValue pv = pvArray[i];
            //分别解决每个属性字段的解析；
            Object newVal = resolveValue(pv.getValue());
            if (!ObjectUtils.nullSafeEquals(newVal, pv.getValue())) {
                pvs.addPropertyValue(pv.getName(), newVal);
            }
        }
    }
如何解析，是暴露到子类中去进行的如PropertyPlaceholderConfigurer是对${}进行外部文件的替换，我们也可以自己实现别的替换方式，如：****替换位"corey"，很无聊吧: ->;


resolveStringValue((String) value);：

protected Object resolveValue(Object value) {
        if (value instanceof BeanDefinition) {
            visitBeanDefinition((BeanDefinition) value);
        }
        else if (value instanceof BeanDefinitionHolder) {
            visitBeanDefinition(((BeanDefinitionHolder) value).getBeanDefinition());
        }
        else if (value instanceof RuntimeBeanReference) {
      RuntimeBeanReference ref = (RuntimeBeanReference) value;
      String newBeanName = resolveStringValue(ref.getBeanName());
            if (!newBeanName.equals(ref.getBeanName())) {
                return new RuntimeBeanReference(newBeanName);
            }
        }
        else if (value instanceof List) {
            visitList((List) value);
        }
        else if (value instanceof Set) {
            visitSet((Set) value);
        }
        else if (value instanceof Map) {
            visitMap((Map) value);
        }
        else if (value instanceof TypedStringValue) {
            TypedStringValue typedStringValue = (TypedStringValue) value;
            String visitdString = resolveStringValue(typedStringValue.getValue());
            typedStringValue.setValue(visitdString);
        }
        else if (value instanceof String) {
            return resolveStringValue((String) value);
        }
        return value;
    }

那＄｛userName｝举例：在PropertyPlaceholderConfigurer中：

protected String parseStringValue(String strVal, Properties props, Set visitedPlaceholders)
        throws BeanDefinitionStoreException {

        StringBuffer buf = new StringBuffer(strVal);
        
        //提取出${}中间的字符串，
        int startIndex = strVal.indexOf(this.placeholderPrefix);
        while (startIndex != -1) {
            int endIndex = buf.toString().indexOf(
                this.placeholderSuffix, startIndex + this.placeholderPrefix.length());
            if (endIndex != -1) {
                String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex);
                if (!visitedPlaceholders.add(placeholder)) {
                    throw new BeanDefinitionStoreException(
                            "Circular placeholder reference '" + placeholder + "' in property definitions");
                }
                //用System.getEnv和外部的properties文件替代了${}中间的值
                String propVal = resolvePlaceholder(placeholder, props, this.systemPropertiesMode);
                if (propVal != null) {
                    // Recursive invocation, parsing placeholders contained in the
                    // previously resolved placeholder value.
                //嵌套执行;直至无法解析；
                    propVal = parseStringValue(propVal, props, visitedPlaceholders);
                    buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Resolved placeholder '" + placeholder + "' to value [" + propVal + "]");
                    }
                    startIndex = buf.toString().indexOf(this.placeholderPrefix, startIndex + propVal.length());
                }
                else if (this.ignoreUnresolvablePlaceholders) {
                    // Proceed with unprocessed value.
                    startIndex = buf.toString().indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
                }
                else {
                    throw new BeanDefinitionStoreException("Could not resolve placeholder '" + placeholder + "'");
                }
                visitedPlaceholders.remove(placeholder);
            }
            else {
                startIndex = -1;
            }
        }

        return buf.toString();
    }


在这里，模板模式再一次展现了他的魅力，我想在这里讨论一下：PropertiesLoaderSupport和PropertyResourceConfigurer的关系，我们看见PropertiesLoaderSupport提供了properties文件的加载，在这里继承抽象类PropertiesLoaderSupport其实是达到与复用；
我们继承一个抽象类的原因有两个：
1）：与其它类功能方法之间的复用（比如这里的PropertiesLoaderSupport）；而不是从分类学上面属于一类，这样的抽象类属于工具类；这里的功能复用，有两种手段可以实现，一种是组合，一种是继承；

2）：抽象类中约定类流程，把算法的具体实现暴露给子类；

0 0
高中女神 体验知乎 高中女神 体验知乎
原创粉丝点击
热门IT博客
visio有mac版吗visio有mac版吗
stl源码剖析pdfstl源码剖析pdf
大华电子秤设置软件
现在淘宝店还好做吗
提升店铺流量软件
linux open函数详解
php会员权限
魔爪编程下载安装
日本爱知电机
黑马程序员ios
移动数据打开没有网络
js number()
手机维修哪家好 知乎
java时间戳精确到毫秒
海洋cms整合ckplayer
淘宝全球购标识没了
mac 终端 颜色
穿越时空的少女知乎
sql case when用法
连邦软件南通
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 bdsmsexslaves jav 在线 日本mv大全 小美私人影院 www.57by.cn www.xoxo998 www.x520x.com 初女模破了图片对比 www.11xhxh.com 最近地址视频(点击进入)99er5.com www.0055ee.com www. saoyy.cn 男人的天气堂66tv wwv.797.cfcom 88影视网最新电视 126.com箱登录入口 www.52xoxo.cpm 日本人的28个页码 年轻人就是猛全程不打码在线视频 好曰啪品视频免费观看 丝母足师妈袜全文阅读 小说 www2222xecnm 国产无限资源第一页2018 在线观看的资源视频 www.ta7.app番茄官网 看黄子一片wwwabc300 182tv观免费线 97总站总资源总共享免费 56pa56pa免费线视频 一七六九资源总站69rzy 野狼华人全球第一论坛 91社区论坛 2018版小鸟酱之美足丝滑 91游戏中心官网 舒淇三绝照片 毋HH伦 69大片视频免费全部 上朋友他妈中文字幕在线播放 特殊上门app 3d肉团浦手机在线播放国语 欧美高清videossex0ts\\\\/favicon.ico四虎

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里