apache-configuration详解

2019独角兽企业重金招聘Python工程师标准>>>

https://my.oschina.net/jack230230/blog/57171

PropertiesConfiguration config = new PropertiesConfiguration("D:/sms.properties");
		FileChangedReloadingStrategy strategy =new FileChangedReloadingStrategy();
		strategy.setRefreshDelay(1000);
		config.setReloadingStrategy(strategy);
		config.addConfigurationListener(new ConfigurationListener() {
			@Override
			public void configurationChanged(ConfigurationEvent event) {
				if(!event.isBeforeUpdate()){
					String changeInfo = "config modify:isBeforeUpdate:"+event.isBeforeUpdate()+",propertyName:"+event.getPropertyName()+",propertyValue:"+
							event.getPropertyValue()+",type:"+event.getType()+",source:"+event.getSource();
					System.out.println(">>"+changeInfo);
				}
			}
		});
		for(;true;){
			Thread.sleep(1000);
			//只有在调用了config.getXXX()方法之后才会进行文件是否修改判断，即修改懒加载
			System.out.println(config.getString("sms.statusPull"));
		}	    

//只有在调用了config.getXXX()方法之后才会进行文件是否修改判断，即修改懒加载

你会了解到

• 从XML文件中获取数据

• 访问环境变量

• 连接不同类型的配置信息（基于XML的，基于环境变量的，等等）

• 在程序改变后自动重新加载配置。

  在我们的示例中将会使用XML文件和环境变量的两种方式存储一个数据库的配置信息（开发、测试、产品，等等）。接下来你将会看到具体的内容，但是首先先配置一下Maven。

Maven设置

我们的示例程序需要在pom.xml文件中添加如下依赖：

<dependencies>
    <dependency>
        <groupId>commons-configuration</groupId>
        <artifactId>commons-configuration</artifactId>
        <version>1.8</version>
    </dependency>
    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.8.0</version>
    </dependency>
    <dependency>
        <groupId>commons-jxpath</groupId>
        <artifactId>commons-jxpath</artifactId>
        <version>1.3</version>
    </dependency>
</dependencies>

简单的数据库配置

设想我们有一个简单的数据库配置信息存储在XML文件中：

<?xmlversion="1.0"encoding="UTF-8"?>
<!-- const.xml -->
<config>
    <database>
        <url>127.0.0.1</url>
        <port>1521</port>
        <login>admin</login>
        <password>pass</password>
    </database>
</config>

为了拿到url和port我们用如下的代码：

XMLConfiguration config =new XMLConfiguration("const.xml");
// 127.0.0.1
config.getString("database.url"); 
// 1521
config.getString("database.port");

XMLConfiguration是一个Apache Commons类，他可以从指定的配置文件中加载内容，并且提供一个很好的以指定的点的方式得到存储的值。例如例子中的表达式database.port映射到xml文件中的 config/database/port节点的值“1521”。当然还有很多方式获取数据。这里有一些基本的用法：

getBoolean
getByte
getDouble
getFloat
getInt
getInteger
getList
getLong
getStringArray

你可通过查看Apache Commons的JavaDoc查看更多的使用方式。

将如上配置扩展一步

设想，过了一会我们想配置多个数据库，我们可以在配置文件中这样写：

<?xmlversion="1.0"encoding="UTF-8"?>
<!-- const.xml -->
<config>
    <databases>
        <database>
            <name>dev</name>
            <url>127.0.0.1</url>
            <port>1521</port>
            <login>admin</login>
            <password>pass</password>
        </database>
        <database>
            <name>production</name>
            <url>192.23.44.100</url>
            <port>1521</port>
            <login>admin</login>
            <password>not-so-easy-pass</password>
        </database>
    </databases>
</config>

现在我们要访问url数据我们可以这样：

XMLConfiguration config =new XMLConfiguration("const.xml");
 
// 127.0.0.1
config.getString("databases.database(0).url");
 
// 192.23.44.100
config.getString("databases.database(1).url");

你可以看到这次多了参数，0代表第一个，1代表第二个。

XPath表达式

定点的访问方式没问题，但是只是在一些简单的情况下，对于复杂的真实的状况来讲，我们可能需要使用XPath表达式语言。这里的主要优点是，即便你使用了XML的高级查询，程序看起来仍然比较简洁易懂。

XMLConfiguration config =new XMLConfiguration("const.xml");
config.setExpressionEngine(new XPathExpressionEngine());
 
// 127.0.0.1
config.getString("databases/database[name = 'dev']/url");       
 
// 192.23.44.100
config.getString("databases/database[name = 'production']/url");

这里是上面两个XPath表达式查询的一个解释：

访问环境变量

在Apache Commons Configuration的帮助下你可以轻松的访问到系统的环境变量。下面是访问系统中ENV_TYPE变量的方法：

EnvironmentConfiguration config =new EnvironmentConfiguration();
config.getString("ENV_TYPE");

假设变量ENV_TYPE已经设置好了，想看上面的程序是否运行正确，你可以在控制台运行如下脚本：

echo %ENV_TYPE%        # for Windows
# or...
echo $ENV_TYPE         # for Linux/Mac OS

你将会看到ENV_TYPE的值。

联合配置

让我们总结一下我们了解的东西，下面的getDbUrl方法做如下事情：

1. 检查系统环境变量中叫做ENV_TYPE的值。
2. 如果值是dev或者produtcion就返回相应的数据库url
3. 如果变量没有配置就抛出异常。

public String getDbUrl() throws ConfigurationException {
    EnvironmentConfiguration envConfig =new EnvironmentConfiguration();
    String env = envConfig.getString("ENV_TYPE");
    if("dev".equals(env) ||"production".equals(env)) {
        XMLConfiguration xmlConfig =new XMLConfiguration("const.xml");
        xmlConfig.setExpressionEngine(new XPathExpressionEngine());
        String xpath ="databases/database[name = '"+ env +"']/url";
        return xmlConfig.getString(xpath);
    }else{
        String msg ="ENV_TYPE environment variable is "+
                     "not properly set";
        throw new IllegalStateException(msg);
    }
}

集中你的配置

对每个不同的需要配置的对象创建多个配置比较烦。假如我们想添加其他的基于XML的配置，我们会怎么搞？我们需要创建另一个XMLConfiguration对象，这会给管理带来很多麻烦。一个解决办法是把配置文件信息集中到一个单个XML文件中。下面是一个例子:

<?xmlversion="1.0"encoding="UTF-8"?>
<!-- config.xml -->
<configuration>
  <env/>
  <xmlfileName="const.xml"/>
</configuration>

你需要使用DefaultConfigurationBuilder类，最终版本的getDbUrl方法看起来像这样：

public String getDbUrl()throws ConfigurationException {
    DefaultConfigurationBuilder builder =
        new DefaultConfigurationBuilder("config.xml");
    boolean load =true;
    CombinedConfiguration config = builder.getConfiguration(load);
    config.setExpressionEngine(new XPathExpressionEngine());
    String env = config.getString("ENV_TYPE");
    if("dev".equals(env) ||"production".equals(env)) {
        String xpath ="databases/database[name = '"+ env +"']/url";
        return config.getString(xpath);
    }else{
        String msg ="ENV_TYPE environment variable is "+
                     "not properly set";
        throw new IllegalStateException(msg);
    }
}

自动重新加载

Apache Commons Configuration有很多非常酷的特性。其中一个就是当基于文件的配置变化的时候自动加载，因为我们可以设置加载策略。框架会轮询配置文件，当文件的内容发生改变时，配置对象也会刷新。你可以用程序控制：

XMLConfiguration config =new XMLConfiguration("const.xml");
ReloadingStrategy strategy =new FileChangedReloadingStrategy();
strategy.setRefreshDelay(5000);
config.setReloadingStrategy(strategy);

或者把他写到主配置文件中：

<?xmlversion="1.0"encoding="UTF-8"?>
<!-- config.xml -->
<configuration>
  <env/>
  <xmlfileName="const.xml">
    <reloadingStrategyrefreshDelay="5000"
      config-class="org.apache.commons.configuration.reloading.FileChangedReloadingStrategy"/>
  </xml>
</configuration>

每五秒框架都检查一下配置文件有没有改变。

最后

我个人用来管理需要配置的代码的时候的选择是使用Apache Commons。我希望这篇文章可以让你相信这个框架可以提供一个非常有用的接口用来访问你的静态数据。最后需要说的一点，这篇文章的内容只是这个框架的功能的一部分。此框架一些其他的有趣的功能是：

• 从不同的数据源装载配置信息，例如properties文件、ini文件、数据库等等。
• 给配置对象增加新的属性，并把它回存到文件中。
• 监听配置对象改变的事件。（这点可以让你在配置发生改变的时候及时作出处理）
• 自动解析配置文件的实际路径（不管你是把它放在程序文件夹下还是一个jar中。）

---

http://wangxin0072000.iteye.com/blog/186009
Apache Commons-configuration 学习笔记

1 如果要使用configuration这个包，首先要保证使用JDK1.2以上，还要引入如下jar包

commons-beanutils
commons-lang
commons-logging
commons-collections
commons-digester
commons-codec
commons-jxpath

2 commons-configuration最新的版本是1.5，最主要的作用是读取资源文件，每一种文件格式都有一个对应的类，如下

• properties文件--PropertiesConfiguration类
• xml文件--XMLConfiguration
• .ini文件--INIConfiguration
• .plist文件--PropertyListConfiguration
• 还可以从JNDI中读取properties--JNDIConfiguration
• 当然还可以使用system的properties--SystemConfiguration
• 等等...

3 上面已经对它做了基本的介绍，下面看看这个包怎么用吧 比如我们要读一个properties文件：在classpath下面建立目录te,之后在te下面建立

test.properties

ip=127.0.0.1  
port=8080  
id=111  
application.name = Killer App  
application.version = 1.6.2  
application.title = ${application.name} ${application.version}  
keys=cn,com,org,uk,edu,jp,hk  

java： //注意路径默认指向的是classpath的根目录

Configuration config = new PropertiesConfiguration("te/test.properties");  
String ip=config.getString("ip");  
int port=config.getInt("port");  
String title=config.getString("application.title");  

//再举个Configuration的比较实用的方法吧,在读取配置文件的时候有可能这个键值对应的值为空，那么在下面这个方法中
//你就可以为它设置默认值。比如下面这个例子就会在test.properties这个文件中找id的值，如果找不到就会给id设置值为123
//这样就保证了java的包装类不会返回空值。虽然功能很简单，但是很方便很实用。

Integer id=config.getInteger("id", new Integer(123));    

//如果在properties 文件中有如下属性keys=cn,com,org,uk,edu,jp,hk
//可以实用下面的方式读取：

String[] keys1=config.getStringArray("keys");  
List keys2=config.getList("keys");  

首先要把这个文件读到程序中，我们可以用上面的类，所有的读取文件的类都 继承自AbstractConfiguration类，
而这个类实现了Configuration接口，如果我们只有比较简单的需求，那么可以直接向上转型为Configuration类型，如果向上
转型为AbstractConfiguration类，那么可以做一些配置工作。
比如刚刚看到的 keys=cn,com,org,uk,edu,jp,hk这个例子中如果是keys=cn/com/org/uk/edu/jp/hk
那么如果还按照原来的方式读取，读到的将是"cn/com/org/uk/edu/jp/hk"这个字符串，所以要先改变分割符之后在读
即

AbstractConfiguration.setDefaultListDelimiter('/');  
Configuration config = new PropertiesConfiguration("te/Vasp.properties");  
String[] keys=config.getStringArray("keys");  
List key2=config.getList("keys");  

如果你看它的源码，你会在 AbstractConfiguration这个类中找到：

private static char defaultListDelimiter = ',';   

这下你明白了吧！

---

http://www.360doc.com/content/11/0406/16/2749105_107609102.shtml

Apache Commons Configuration 包使用

Configuration 的参数可能来自下面的资源： * Properties files * XML documents * Property list files (.plist) * JNDI * JDBC Datasource * System properties * Applet parameters * Servlet parameters 不同的配置资源能够通用 ConfigurationFactory 和 CompositeConfiguration 来混合。
其他的资源可以通过自定义 configuration 对象也能够被创建，这个自定义的对象通过继承 AbstractConfiguration 或者 AbstractFileConfiguration 来实现。
使用 Configuration

配置资源：

以下是常见的配置资源

• PropertiesConfiguration 从一个 property 文件中加载配置 .
• XMLConfiguration 从 XML 文件中加载配置信息 .
• PropertyListConfiguration 从一个 .plist 文件中加载配置信息 . XMLPropertyListConfiguration 也可以读取 XML 被 Mac OSX 使用变量 . -JNDIConfiguration 利用 jndi 树的一个键值，可以返回一个值，这个值来作为配置信息
• BaseConfiguration 访问内存中的一个配置对象 .
• HierarchicalConfiguration 一个在内存中的配置对象，这个对象可以处理复杂的数据结构 .
• SystemConfiguration 一个利用系统属性的配置信息
• ConfigurationConverter 把 java.util.Properties 或者 org.apache.collections.commons.ExtendedProperties 转化为一个 Configuration 对象 .

**混合各种配置资源 **

经常你希望提供一套基本的配置信息，而且允许用户很容易的根据他们的特有的环境覆盖他们。
一种办法就是载你的代码中队默认值进行硬编码，并且提供一个配置文件来覆盖他们。 这是做法没有一点弹性。替换做法是：运用 CompositeConfiguration 。

CompositeConfiguration config = new CompositeConfiguration();
config.addConfiguration(new SystemConfiguration());
config.addConfiguration(new PropertiesConfiguration("application.properties"));

或者通过ConfigurationFactory这个类

ConfigurationFactory factory = new ConfigurationFactory("config.xml");
Configuration config = factory.getConfiguration();

上面的config.xml是一个配置描述符。它定义了将要被装载的配置对象（资源文件），例如：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<configuration>
<system/>
<properties fileName="application.properties"/>
</configuration>

上面的意思是，我们加载了系统的配置，也加载了application.properties这个文件。 他的优先（precedence）顺序是从前到后。所以在上面的例子中，如果一个属性在系统配置中没有，他将在文件配置中查找 这将允许你在文件配置中设定默认值，而且可以在系统配置中覆盖他们。

Configuration 接口

代表不同类型配置资源的在这个package中的不同类共享一个简单的接口：Configuration。 这个接口允许你通过一个基本的方式来访问和处理配置属性。
在Configuration这个接口中的大部分方法用来处理获得的属性的数据类型。这些 方法把一个指向属性的key作为他的入参。他通过查找这个key,获得属性的值，并把它 转化为目标类型。所有的这些方法都有重载方法，可以在没有找到属性时返回一个默认值。 支持的数据类型如下：

• BigDecimal
• BigInteger
• boolean
• byte
• double
• float
• int
• long
• short
• String

这些方法都以get开头，后面是数据的类型。getString()将返回String类型， getInt()将返回int类型。
属性可以有多个值，所以也必须有返回多个值得方法。 getList() 方法可以做到这个。
为了处理属性或者他们的值,下面的方法将会提供帮助:

• addProperty() 添加一个新的属性到配置.如果这个属性已经存在,那么这个属性将变成一个多值属性,并且在多值中增加一个新的.
• clearProperty() 从配置中移除特定的属性.
• setProperty() 覆写特定的属性
• clear() 擦除所有的属性.

以下的章节将分别介绍各种不同的配置资源.

Properties files ( 属性文件 )

属性文件是一种最为流行的配置应用的手段。理所当然， Commons Configuration 支持这种资源格式，并且极大地加强了 java.util.Properties
这个类。这个部分将对 PropertiesConfiguration 作介绍。PropertiesConfiguration是Configuration接口的典型实现，而且在这部分介绍的很多功能
都被其他的各种实现所支持。这是因为他们都继承自AbstractConfiguration。这些功能在AbstractConfiguration中 已经实现。
使用PropertiesConfiguration
我们有个usergui.properties 的配置文件，内容为：

# Properties definining the GUI
colors.background = #FFFFFF
colors.foreground = #000080
window.width = 500
window.height = 300

加载这个文件的方法：

Configuration config = new PropertiesConfiguration("usergui.properties"); //文件名

如果你没有定义绝对路径，文件将按一下的路径顺序被查找：

• in the current directory 当前文件夹
• in the user home directory 用户根文件夹
• in the classpath 类路径

除了可以像上面那样在构造函数中传入一个文件名称来读取外，我们还可以调用他的 load()方法来读取。
有很多重载的变量提供来装载不同的资源。更多的内容将在File-based Configurations章节介绍。
在配置文件装载以后，你可以访问各种属性了：

String backColor = config.getString("colors.background");
Dimension size = new Dimension(config.getInt("window.width"),
config.getInt("window.height"));

Includes （文件包含）

如果一个属性以include为key,而且它的值是一个磁盘文件。这个文件将会被同时加载。

# usergui.properties
include = colors.properties
include = sizes.properties 
------
# colors.properties
colors.background = #FFFFFF
Lists and arrays

Commons Configuration 可以很容易的返回一个list类型的值，比如，你的文件中有个用都好分开的多个值。

chart colors

colors.pie = #FF0000, #00FF00, #0000FF

你不需要自己去切割字符串。你可以用下面的方法来返回一个java.util.List或者一个数组：

String[] colors = config.getStringArray("colors.pie");
List colorList = config.getList("colors.pie"); 

另一种解决方案是：你可以像下面这样定义成多行。

chart colors

colors.pie = #FF0000;
colors.pie = #00FF00;
colors.pie = #0000FF; 

addProperty() 方法和setProperty() 方法也实现了对list处理。向他们里面传入的值可以是一个list也可以是一个数组。如果传入的属性是一个字符串，他将会检查字符串中是否存在我们所定义的list分隔符。如果出现这种情况，字符串将会被切割，而且它的各个值将会被分别 当成属性值添加进来。默认的分割符是逗号。他也可以在文件被加载的时候指定。
通过setListDelimiter()方法，你就可以指定分割符。下面是个使用的例子：

// Change the list delimiter character to a slash
config.setListDelimiter('/'); //设置分割字符串 
// Now add some properties
config.addProperty("greeting", "Hello, how are you?");
config.addProperty("colors.pie",
new String[] { "#FF0000", "#00FF00", "#0000FF" });//添加时候分割字符串起作用
config.addProperty("colors.graph", "#808080/#00FFCC/#6422FF");
// Access data
String salut = config.getString("greeting");
List colPie = config.getList("colors.pie");
String[] colGraph = config.getStringArray("colors.graph");
String firstPieColor = config.getString("colors.pie");

在上面的例子中，分割符由逗号变成了斜线。
或许你会对最后一行有兴趣。这里，getString() 方法被作用在一个多值属性上，这个调用将返回这个list的第一个值。

如果你想对所有的配置对象（资源）设定分割符，你可以用AbstractConfiguration的静态方法setDefaultListDelimiter()来设定。

如果你想让某个配置对象的分隔符不起作用,你可以调用setDelimiterParsingDisabled() 方法，并向他传递true这个参数。

Note:这种list处理和字符串分割机制并不是PropertiesConfiguration所特有的, 其他的配置类也具有这种机制。

Variable Interpolation （变量篡改）

如果你对ant或者maven很熟悉的话，你或许多类似${token}这样的变量很熟悉。Commons Configuration也支持这样的
方式。例如：

application.name = Killer App
application.version = 1.6.2
application.title = ${application.name} ${application.version}

如果你要返回application.title这个属性的值，将会得到Killer App 1.6.2.和list处理一样，变量篡改的机制也被其他配置类所支持。

Saving ( 存储 )

你可以调用save()来保存你的设置：

PropertiesConfiguration config = new PropertiesConfiguration("usergui.properties");
config.setProperty("colors.background", "#000000);
config.save(); //保存文件 

你也可以把配置拷贝为另一个文件

PropertiesConfiguration config = new PropertiesConfiguration("usergui.properties");
config.setProperty("colors.background", "#000000);
config.save("usergui.backup.properties);//保存到另一个文件

更多的关于保存文件的信息请参看“File-based Configurations”的章节。

Special Characters（特殊字符）

如果在你的配置文件中需要用到特殊字符，你可以采用Java字符串相同的转义字符，如： key = This \n string \t contains , escaped \ characters \u0020

**Using a Configuration Factory （使用配置工厂） **

这部分介绍了如何利用ConfigurationFactory对象来访问多个不同的配置资源。
The configuration definition file（配置定义文件）
当我们只用一个配置文件的时候，我们可以采用对应的配置对象，比如PropertiesConfiguration于配置文件或者 XMLConfiguration于xml文件。
但是，接下来我们将要考虑多个配置资源的情况，我们需要用ConfigurationFactory来组合他们 ,ConfigurationFactory可以组合多个配置资源。然后我们就可以像访问单个资源文件一样来访问他们中的属性。首先，我们需要创建一个 xml文件来告诉工厂哪些文件将要被加载。下面是一个例：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<configuration>
<properties fileName="usergui.properties"/>
</configuration>

ConfigurationFactory的定义文件是一个普通的xml文件.根元素是configuration.他饱含的子元素制定了需要装载的配置 资源.properties是元素之一,他用来包含属性文件.
在上面的例子中,我们在属性文件相同的目录下定义了一个ConfigurationFactory的配置文件,并命名为config.xml.

Setting up a ConfigurationFactory 现在我们创建一个ConfigurationFactory并让他来读取定义文件。很简单：获得一个实例，并且在 setConfigurationFileName()中传入定义文件即可。

ConfigurationFactory factory = new ConfigurationFactory();//初始化 
URL configURL = new File("config.xml").toURL();
factory.setConfigurationFileName(configURL.toString());
Configuration config = factory.getConfiguration();

在上面的片断里面，我们向工厂里面穿入了一个娃正德URL.这也是我们所推荐的指定文件的方式。
因为这种方式提供了最有弹性的和一致的方式来处理在定义文件中的各个相关的文件。
这里我们假设配置定义文件在当前文件夹下。我们也可以加载在classpath中的文件。比如：

ConfigurationFactory factory = new ConfigurationFactory(); //初始化 
URL configURL = getClass().getResource("/config.xml");
factory.setConfigurationURL(configURL);
Configuration config = factory.getConfiguration();

Accessing properties(访问属性)

不管我们采用什么样的方式来装在配置工厂，我们最终需要调用工厂的getConfiguration()方法来返回一个配置对象.
这个实例事实上是一个CompositeConfiguration类,一个特殊的Configuration实现--可以用来包含多个配置对象.
理所当然,这个类有Configuration接口提供所有的getter方法,所以我们获得一个字符串对象仍然是如下的形势:

String backColor = config.getString("color.background");

**Multiple configuration sources(多配置资源) **

用ConfigurationFactory来处理单一资源没有什么意义.所以下面我们将要迁入一个xml文件. Overriding properties(覆盖属性)
很多应用采用通用的xml格式来作为配置资源.我们先来个简单的:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<gui-definition>
<colors>
    <background>#808080</background>
    <text>#000000</text>
    <header>#008000</header>
    <link normal="#000080" visited="#800080"/>
</colors>
<rowsPerPage>15</rowsPerPage>
</gui-definition>

然后,我们的配置定义文件需要做如下的修改:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<configuration>
<properties fileName="usergui.properties"/>
<xml fileName="gui.xml"/>
</configuration>

建立配置工厂的方法保持不变.新加入的属性可以按通用的方式来访问.

然而,郁闷的事情来了.在2个配置资源中都定义了同一个属性,而且他们又不同的值.怎么处理? 其实配置资源是从上倒下,从先导后被查找的.如果在前面的配置文件中找到,他就会立即被返回. 似乎在不同的资源中配置相同的属性没有意思.但是请考虑以下的场景: (似乎在前面的介绍中介绍过,笔者不再翻译).

Optional configuration sources(可选配置文件)

例如:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<configuration>
<properties fileName="usersettings.properties" optional="true"/>
<properties fileName="default.properties"/>
</configuration>

上面的例子中,usersettings.properties被定一位一个可选的配置文件.意思是说.如果他没有被加载
ConfigurationFactory并不会跑出异常.但是会写入一段警告信息到日至中.注意:
第二个文件中没有使用optional属性.所以它是被强制的,因而如果他不存在时候,ConfigurationFactory的 getConfiguration()方法会跑出异常.

Union configuration(合并配置) 略

Configuration definition file reference(定义文件) 比如:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<configuration>
<system/>
<jndi prefix="java:comp/env"/>
<properties fileName="test.properties"/>
<xml fileName="test.xml"/>
<properties fileName="test.properties.xml"/>
</configuration>

另外, AbstractConfiguration还支持注册监听器来监视配置资源的变化.由于时间和篇幅的限制,

XMLConfiguration //apache 处理xml 配置文件的类

PropertiesConfiguration //apache 处理 properties 配置文件的类

转载于:https://my.oschina.net/yiqifendou/blog/783304