首页 > 编程语言 > Spring框架读取property属性文件常用5种方法
2020
10-10

Spring框架读取property属性文件常用5种方法

1、方式一：通过spring框架 PropertyPlaceholderConfigurer 工具实现

<bean id="propertyConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="ignoreUnresolvablePlaceholders" value="true"/>
    <property name="locations">
      <value>classpath:conf/jdbc.properties</value>
    </property>
    <property name="fileEncoding">
      <value>UTF-8</value>
    </property>
    <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
  </bean>
  
  <!-- 数据源配置 -->
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
     destroy-method="close">
    <property name="driverClassName" value="${database.connection.driver}"/>
    <property name="url" value="${database.connection.url}"/>
    <property name="username" value="${database.connection.username}"/>
    <property name="password" value="${database.connection.password}"/>
  </bean>
  <!-- DAL客户端接口实现->
  <bean id="dalClient" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>

2、方式二：简化配置

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
  ">
  <context:property-placeholder location="classpath:conf/jdbc.properties" ignore-unresolvable="true"/>
  <!-- 数据源配置 -->
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
     destroy-method="close">
    <property name="driverClassName" value="${database.connection.driver}"/>
    <property name="url" value="${database.connection.url}"/>
    <property name="username" value="${database.connection.username}"/>
    <property name="password" value="${database.connection.password}"/>
  </bean>
  <!-- DAL客户端接口实现-->
  <bean id="dalClient" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <!--备注：如果${} 这种写法无法读取到，或者编译出错，则增加ignore-unresolvable="true"的属性信息，并添加上文的 命名空间信息-->
  
  jdbc.properties文件：
  database.connection.driver=com.mysql.jdbc.Driver
  database.connection.url=jdbc:mysql://*.*.*.*:3306/mysql?characterEncoding=utf-8
  database.connection.username=*
  database.connection.password=*

上述配置理解：

1）ignore-unresolvable属性的示意：

<xsd:documentation><![CDATA[
Specifies if failure to find the property value to replace a key should be ignored.
Default is "false", meaning that this placeholder configurer will raise an exception
if it cannot resolve a key. Set to "true" to allow the configurer to pass on the key
to any others in the context that have not yet visited the key in question.
]]>

翻译后：指定是否应忽略未能找到用于替换键的属性值。默认值为“false”，表示如果它无法解析密钥，此占位符配置程序将引发异常。设置为“true”以允许配置程序传递密钥对于上下文中尚未访问相关密钥的任何其他用户。

2) 为简化 PropertyPlaceholderConfigurer 的使用，Spring提供了<context:property-placeholder location="classpath:jdbc.properties" />元素,启用它后，开发者便不用配置PropertyPlaceholderConfigurer对象了。

PropertyPlaceholderConfigurer内置的功能非常丰富，如果它未找到${xxx}中定义的xxx键，它还会去JVM系统属性(System.getProperty())和环境变量(System.getenv())中寻找。其通过启用systemPropertiesMode和searchSystemEnvironment属性，开发者能够控制这一行为。context:property-placeholder大大的方便了我们数据库的配置。这样就可以为spring配置的bean的属性设置值了。

备注：spring容器中最多只能定义一个 context:property-placeholder，否则会报错：Could not resolve placeholder XXX,但如果想引入多个属性文件怎么办那，可以使用通配符：<context:property-placeholder location="classpath*:conf*.properties"/>

3、方式三：通过对spring PropertyPlaceholderConfigurer bean工厂后置处理器的实现，在java程序中进行属性文件的读取

<bean id="propertyConfigurer" class="com.weblearn.utils.PropertyConfigurer">
    <property name="locations">
      <list>
        <value>classpath:conf/web-sys-relation.properties</value>
        <value>classpath:conf/jdbc.properties</value>
        <value>classpath:conf/main-setting-web.properties</value>
      </list>
    </property>
    <property name="fileEncoding" value="UTF-8"/>
  </bean>
  <!-- DAL客户端接口实现-->
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
     destroy-method="close">
    <property name="driverClassName" value="${database.connection.driver}"/>
    <property name="url" value="${database.connection.url}"/>
    <property name="username" value="${database.connection.username}"/>
    <property name="password" value="${database.connection.password}"/>
  </bean>
  
  <bean id="dalClient" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
public class PropertyConfigurer extends PropertyPlaceholderConfigurer {
    /* 
      PropertyPlaceholderConfigurer 是个bean工厂后置处理器的实现，也就是 BeanFactoryPostProcessor 接口的一个实现。
      在Spring中，使用PropertyPlaceholderConfigurer可以在XML配置文件中加入外部属性文件，当然也可以指定外部文件的编码。PropertyPlaceholderConfigurer可以将上下文
    （配置文 件）中的属性值放在另一个单独的标准java Properties文件中去。在XML文件中用${key}替换指定的properties文件中的值。这样的话，只需要对properties文件进
    行修改，而不用对xml配置文件进行修改。
      引入外部文件后，就可以在xml中用${key}替换指定的properties文件中的值，通常项目中都会将jdbc的配置放在properties文件中。
      在启动容器时，初始化bean时，${key}就会替换成properties文件中的值。
    */

    //存取properties配置文件key-value结果
    private Properties props;

    @Override
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
        throws BeansException {
      super.processProperties(beanFactoryToProcess, props);
      this.props = props;
    }

    public String getProperty(String key) {
      return this.props.getProperty(key);
    }

    public String getProperty(String key, String defaultValue) {
      return this.props.getProperty(key, defaultValue);
    }

    public Object setProperty(String key, String value) {
      return this.props.setProperty(key, value);
    }

  }

  @Controller
  @RequestMapping("/")
  public class TestController {
    @Autowired
    PropertyConfigurer propertyConfigurer;

    @RequestMapping("/index.do")
    public String getIndex(HttpServletRequest request, HttpServletResponse response, Model model) {
      Map map = new HashMap<String, Object>();
      map.put("orderNo", "111");

      String address1 = propertyConfigurer.getProperty("static.picture.address1");
      String resRoot = propertyConfigurer.getProperty("resRoot");
      String envName = propertyConfigurer.getProperty("database.connection.username");
      String keyzjbceshi = propertyConfigurer.getProperty("keyceshi");


      map.put("address1", address1);
      map.put("resRoot", resRoot);
      map.put("envName", envName);
      map.put("keyzjbceshi", keyzjbceshi);

      model.addAllAttributes(map);
      return "index/index.ftl";
    }
  }

4、方式四：通过ClassPathResource类进行属性文件的读取使用

public class ReadPropertiesUtils1 {
    private static final Logger LOGGER = LoggerFactory.getLogger(ReadPropertiesUtils1.class);

    private static Properties props = new Properties();

    static {
      ClassPathResource cpr = new ClassPathResource("conf/ref-system-relation.properties");// 会重新加载spring框架
      try {
        props.load(cpr.getInputStream());
      } catch (IOException exception) {
        LOGGER.error("ReadPropertiesUtils1 IOException", exception);
      }
    }

    private ReadPropertiesUtils1() {

    }

    public static String getValue(String key) {
      return (String) props.get(key);
    }

    public static void main(String[] args) {
      System.out.println("static.picture.address1>>>"+ ReadPropertiesUtils1.getValue("static.picture.address1"));
      System.out.println("static.picture.address2>>>"+ ReadPropertiesUtils1.getValue("static.picture.address2"));
    }

  }

5、方式五：通过ContextClassLoader进行属性文件的读取使用 

public class ReadPropertiesUtils2 {
    private static final Logger LOGGER = LoggerFactory.getLogger(ReadPropertiesUtils2.class);

    public static String getValue(String key) {
      Properties properties = new Properties();
      try {
        InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("conf/ref-system-relation.properties");
        properties.load(inputStream);
      } catch (FileNotFoundException e) {
        LOGGER.error("conf/web-sys-relation.properties文件没有找到异常", e);
      } catch (IOException e) {
        LOGGER.error("IOException", e);
      }
      return properties.getProperty(key);
    }

    public static void main(String[] args) {
      System.out.println("static.picture.address1>>>" + ReadPropertiesUtils2.getValue("static.picture.address1"));
      System.out.println("static.picture.address2>>>" + ReadPropertiesUtils2.getValue("static.picture.address2"));
    }
  }

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持自学编程网。

编程技巧