详解PropertyPlaceholderConfigurer、PropertyOverrideConfigurer等对属性配置文件Properties的加载和使用【享学Spring】(上)

// @since 1.2.2
public abstract class PropertiesLoaderSupport {
  @Nullable
  protected Properties[] localProperties;
  protected boolean localOverride = false;
  // 外部配置 Resource[]
  @Nullable
  private Resource[] locations;
  private boolean ignoreResourceNotFound = false;
  @Nullable
  private String fileEncoding;
  // 从流中读取 Properties / xml  // 外来属性加载工具
  private PropertiesPersister propertiesPersister = new DefaultPropertiesPersister();
  public void setProperties(Properties properties) {
    this.localProperties = new Properties[] {properties};
  }
  public void setPropertiesArray(Properties... propertiesArray) {
    this.localProperties = propertiesArray;
  }
  public void setLocation(Resource location) {
    this.locations = new Resource[] {location};
  }
  public void setLocations(Resource... locations) {
    this.locations = locations;
  }
  public void setLocations(Resource... locations) {
    this.locations = locations;
  }
  ... // 省略get/set
  // 下面是提供给子类实现的方法们~~~~~~~~~
  protected Properties mergeProperties() throws IOException {
    Properties result = new Properties();
    // localOverride默认是false  若是true，提前先加载外部化配置
    if (this.localOverride) {
      // Load properties from file upfront, to let local properties override.
      loadProperties(result);
    }
    if (this.localProperties != null) {
      for (Properties localProp : this.localProperties) {
        // 厉害了 属性合并  把Properties合并进map  localProp本地会覆盖掉后面的result~~
        CollectionUtils.mergePropertiesIntoMap(localProp, result);
      }
    }
    // 若是false，再装载一次  把它放进result里面~~~外部配置覆盖当前的result嘛~
    if (!this.localOverride) {
      // Load properties from file afterwards, to let those properties override.
      loadProperties(result);
    }
    return result;
  }
  // 加载外部配置~~~~~~~ 从Resource读取进来~  借助的还是PropertiesLoaderUtils
  protected void loadProperties(Properties props) throws IOException {
    if (this.locations != null) {
      for (Resource location : this.locations) {
        PropertiesLoaderUtils.fillProperties(props, new EncodedResource(location, this.fileEncoding), this.propertiesPersister);
      }
    }
  }
}

public class PropertiesFactoryBean extends PropertiesLoaderSupport
    implements FactoryBean<Properties>, InitializingBean {
  // 默认它是单例的
  private boolean singleton = true;
  @Nullable
  private Properties singletonInstance;
  public final void setSingleton(boolean singleton) {
    this.singleton = singleton;
  }
  ...
  // 只有singleton为true时候，才会创建一个缓存着~~~
  @Override
  public final void afterPropertiesSet() throws IOException {
    if (this.singleton) {
      this.singletonInstance = createProperties();
    }
  }
  // 通过合并本地属性  来得到一个Properties~~~~
  protected Properties createProperties() throws IOException {
    return mergeProperties();
  }
  @Override
  @Nullable
  public final Properties getObject() throws IOException {
    if (this.singleton) {
      return this.singletonInstance;
    }
    else {
      return createProperties();
    }
  }
  @Override
  public Class<Properties> getObjectType() {
    return Properties.class;
  }
}

<bean id="prop" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="locations"><!-- 这里是PropertiesFactoryBean类，它也有个locations属性，也是接收一个数组，跟上面一样
    <array>
      <value>classpath:jdbc.properties</value>
    </array>
  </property>
 </bean>

@Value("#{prop['datasource.url']}")  // 用@Value("${datasource.url}") 这样是读取不到的  此处务必要注意

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

 <!-- 与上面的配置等价，下面的更容易理解  这个beanName写不写无所谓 -->
 <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations"> <!-- PropertyPlaceholderConfigurer类中有个locations属性，接收的是一个数组，即我们可以在下面配好多个properties文件 -->
    <array>
      <value>classpath:jdbc.properties</value>
    </array>
  </property>
 </bean>

@Configuration
public class RootConfig {
    @Bean
    public PropertiesFactoryBean prop() {
        PropertiesFactoryBean prop = new PropertiesFactoryBean();
        prop.setLocation(new ClassPathResource("jdbc.properties"));
        return prop;
    }
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RootConfig.class})
public class TestSpringBean {
    @Value("#{prop['datasource.url']}")
    private String url;
    @Test
    public void test1() {
        System.out.println(url); //jdbc:mysql://localhost:3306/jedi?zeroDateTimeBehavior=convertToNull
    }
}

// @since 02.10.2003
public abstract class PropertyResourceConfigurer extends PropertiesLoaderSupport implements BeanFactoryPostProcessor, PriorityOrdered {
  private int order = Ordered.LOWEST_PRECEDENCE;  // default: same as non-Ordered
  // 处理每个Bean~~~
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    try {
      // 合并本地属性和外部指定的属性文件资源中的属性 
      Properties mergedProps = mergeProperties();
      // 将属性的值做转换(仅在必要的时候做)  
      convertProperties(mergedProps);
      // 对容器中的每个bean定义进行处理，也就是替换每个bean定义中的属性中的占位符  
      // 该方法为抽象方法，子类去处理~~~
      processProperties(beanFactory, mergedProps);
    } catch (IOException ex) {
      throw new BeanInitializationException("Could not load properties", ex);
    }
  }
  protected void convertProperties(Properties props) {
    Enumeration<?> propertyNames = props.propertyNames();
    while (propertyNames.hasMoreElements()) {
      String propertyName = (String) propertyNames.nextElement();
      String propertyValue = props.getProperty(propertyName);
      // convertProperty是个空实现，子类不复写就不会有转换的动作~~~~
      String convertedValue = convertProperty(propertyName, propertyValue);
      // 转成功了  说明就不会相等了  那就set进去覆盖之前的~~
      if (!ObjectUtils.nullSafeEquals(propertyValue, convertedValue)) {
        props.setProperty(propertyName, convertedValue);
      }
    }
  }
}