编程方式取得Spring上下文的Properties

在spring初始化时，可以使用Properties配置器把properties文件装载到Spring的上下文中。

1. ...
2. xmlns:context="http://www.springframework.org/schema/context"
3. xsi:schemaLocation=“http://www.springframework.org/schema/context
4. http://www.springframework.org/schema/context/spring-context-3.0.xsd”
5. ...
6. <context:property-placeholder location="classpath:dataSource.properties" />

这样在Spring的配置文件中可以用表达式来获得load进来的properties内容，例如：

1. <property name="url" value="${url}" />
2. <property name="username" value="${username}" />
3. <property name="password" value="${password}" />

有时候我们在程序中也需要用到这些配置，那么如何取值，显然不能使用${}方式的。

这时要决定用什么方式来获取properties了，最方便的当然是直接读取文件，此处省略。

如果程序一定要用通过Spring加载的properties，那么我们首先要得到Context了。

1、FileSystemXmlApplicationContext——从指定的目录中加载：

1. ApplicationContext context = new FileSystemXmlApplicationContext("applicationContext.xml");

2、ClassPathXmlApplicationContext——从classpath路径加载：

1. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

3、参照http://blog.csdn.net/dqatsh/article/details/3469278， 通过web.xml来获取Context。

4、在servlet中获取。

1. ServletContext servletContext = servlet.getServletContext();
2. WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

然后可以通过相应的bean去访问需要的properties（spring配置文件中${}方式设置到bean里）的值，这里不记录。

用PropertyPlaceholderConfigurer在加载上下文的时候暴露properties

1. <bean id="configBean"
2. class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
3. <property name="location">
4. <value>hello.properties</value>
5. </property>
6. </bean>

表明PropertyPlaceholderConfigurer是承担properties读取任务的类。

下面的类继承PropertyPlaceholderConfigurer，通过重写processProperties方法把properties暴露出去了。

1. import java.util.HashMap;
2. import java.util.Map;
3. import java.util.Properties;
4. import org.springframework.beans.BeansException;
5. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
6. import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
7. public class CustomizedPropertyConfigurer extends PropertyPlaceholderConfigurer {
8. private static Map<String, Object> ctxPropertiesMap;
9. @Override
10. protected void processProperties(ConfigurableListableBeanFactory beanFactory,
11. Properties props)throws BeansException {
12. super.processProperties(beanFactory, props);
13. //load properties to ctxPropertiesMap
14. ctxPropertiesMap = new HashMap<String, Object>();
15. for (Object key : props.keySet()) {
16. String keyStr = key.toString();
17. String value = props.getProperty(keyStr);
18. ctxPropertiesMap.put(keyStr, value);
19. }
20. }
21. //static method for accessing context properties
22. public static Object getContextProperty(String name) {
23. return ctxPropertiesMap.get(name);
24. }
25. }

这样此类即完成了PropertyPlaceholderConfigurer的任务，同时又提供了上下文properties访问的功能。

于是在Spring配置文件中把PropertyPlaceholderConfigurer改成CustomizedPropertyConfigurer

1. <!-- use customized properties configurer to expose properties to program -->
2. <bean id="configBean"
3. class="com.payment.taobaoNavigator.util.CustomizedPropertyConfigurer">
4. <property name="location" value="classpath:dataSource.properties" />
5. </bean>
6. 如果有多个配置文件就要这样写：
7. <bean id="configBean"
8. 　　class="com.payment.taobaoNavigator.util.CustomizedPropertyConfigurer">
9. <property name="locations">
10. <list>
11. <value>classpath:文件1.properties </value>
12. <value>classpath:文件2.properties </value>
13. <value>classpath:文件3.properties </value>
14. </list>
15. </property>
16. </bean>

最后在程序中我们便可以使用CustomizedPropertyConfigurer.getContextProperty()来取得上下文中的properties的值了。