编写XML作为配置文件的高级操作库

还在使用XML仅作为简单读写的配置文件吗？其实XML还有更好更实用的操作…

概述

    在Java中使用XML可谓是极为简单，JDOM问世把Java与XML的关系更近了。但是JDOM提供对于XML简单的静态操作。如果把XML作为动态配置文件或者模块安装配置文件（至少在我开发的系统中作为），仅仅使用JDOM的方法就显得有点儿力不从心了，因此，我们要充分利用JDOM的优点开发出对XML文件的高级操作库。

    我们要开发什么样的操作库呢？首先，看下面的XML信息：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <config>
4.   <dirs>
5.     <home>/homemyuser</home>
6.     <tmp>/homemyusertmp</tmp>
7.     <var>/homemyuservar</var>
8.   </dirs>
9. </config>

    这是一个简单的配置文件，其中重复使用主目录路径信息，很麻烦不是吗？不过这里有很好的解决方案就是使用XML内部实体，如下：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <!DOCTYPE config [
4.  <!ENTITY home "/home/myuser ">
5. ]>
6. <config>
7.   <dirs>
8.     <home>&home; </home>
9.     <tmp>&home; /tmp</tmp>
10.     <var>&home; /var</var>
11.   </dirs>
12. </config>

    这是个不错的办法，通过定义实体可是替换那些重复使用的信息。不过我还是要实现自己的方法，至于它们的区别，我会在下面讲述。
变量
    因为我是程序员，看到这样的问题首先会想到"变量"这个词。为什么不使用一个特殊的元素作为变量的定义呢？OK，开始让我们实现吧。请看下面的示例：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <config>
4.   <property name="home" value="/home/myuser"/>
5.   <dirs>
6.     <!-这段可以省略了'
7.     <home>${home} </home>
8.     <property name="home" value="${home}/tmp"/>
9.     <tmp path="${dirs.home}">
10.       <tmp1>${dirs.home}/tmp1</tmp1>
11.     </tmp>
12.     <var>${home}/var</var>
13.   </dirs>
14. </config>

    在这里我使用了property元素作为变量的定义元素。咦？看懂了没有？有两个home变量啊，那该怎么解决冲突呢？正如上面显示的，使用 元素名称＋"."＋变量名称 作为该变量的定义以解决冲突如何？那就这么做吧。

    OK，配置变量规则都设计出来了该写解释器了。

因为可能以后还会增加额外的解释器，我们先定义一个解释器接口DocumentParser：

2. import org.jdom.Document;
3. public interface DocumentParser{
4.   public void parse(Document doc);
5. }

    既然接口已定义好，就该写变量解释器了。

2. / ** 
3. * property元素解释器。
4. */
5. public class DocumentPropertyParser implements DocumentParser{
6.   private Properties variables;
8.   public DocumentPropertyParser(){
9.     variables = new Properties();
10.   }
12.   public void parse(Document doc){
13.     Element element = doc.getRootElement();
14.     String path = element.getName();
15.     //解析变量并添加到variables属性对象中
16.     parseVariables(path, element);
17.     //分析元素属性和值, 替换已解析的变量.
18.     parseContent(element);
19.   }
21.   / **
22.    * 解析变量方法
23.    */
24.   private void parseVariables(String path, Element element){
25.     List subList = element.getChildren();
26.     Iterator elementI = subList.iterator();
27.     while(elementI.hasNext()){
28.       Element elementS = (Element)elementI.next();
29.       String name = elementS.getName();
31.       //处理变量, 这里忽略了property元素名称的大小写.
32.       //否则, 递归处理里面的元素.
33.       if("property".equalsIgnoreCase(name)){
35.         //获取变量名称.
36.         String propName = elementS.getAttributeValue("name");
38.         //如果变量名称不为空, 则先获取名称为value的属性.
39.         if(propName != null){
40.           String propValue = elementS.getAttributeValue("value");
42.           //如果名称为value的属性不存在, 则获取该元素的值.
43.           if(propValue == null) propValue = elementS.getText();
45.           //如果其值也不存在, 则该变量的值取空.
46.           if(propValue == null) propValue = "";
48.           //向变量列表中加入该变量信息.
49.           variables.setProperty(path + "." + propName, propValue);
50.         }
51.         //删除属性字段, 避免冲突.
52.         elementI.remove();
53.       } else{
54.         parseVariables(path + "." + name, elementS);
55.       }
56.     }
57.   }
59.   / **
60.    * 处理元素中的变量.
61.    */
62.   private void parseContent(Element element){
63.     //首先, 检查该元素属性值是否存在变量.
64.     List attributes = element.getAttributes();
65.     Iterator attributeI = attributes.iterator();
66.     while(attributeI.hasNext()){
67.       Attribute attribute = (Attribute)attributeI.next();
68.       String attributeValue = attribute.getValue();
70.       //使用字符串替换方法替换变量.
71.       Enumeration propNames = variables.propertyNames();
72.       while(propNames.hasMoreElements()){
73.         String propName = (String)propNames.nextElement();
74.         String propValue = variables.getProperty(propName);
75.         attributeValue = StrUtil.replace("${" + propName + "}",
76.                                          propValue,
77.                                          attributeValue);
78.       }
79.       
80.       //重新设置替换过的变量值.
81.       attribute.setValue(attributeValue);
82.     }
83.     //如果有子信息, 递归检索子信息, 否则检索其值.
84.     List subElements = element.getChildren();
85.     if(subElements.size() != 0){
86.       //递归检索Element.
87.       Iterator subElementI = subElements.iterator();
88.       while(subElementI.hasNext()){
89.         Element subElement = (Element)subElementI.next();
90.         parseContent(subElement);
91.       }
92.     } else{
93.       String value = element.getText();
94.       if(value != null){
95.         //覆盖变量.
96.         Enumeration propNames = variables.propertyNames();
97.         while(propNames.hasMoreElements()){
98.           String propName = (String)propNames.nextElement();
99.           String propValue = variables.getProperty(propName);
100.           value = StrUtil.replace("${" + propName + "}", propValue, value);
101.         }
102.         element.setText(value);
103.       }
104.     }
105.   }
106. }

注：StrUtil.replace方法是一般字符串替换方法，自行实现。

    OK，简单的变量解释器完工了。
    
    再想想还需要什么…

系统变量

    有时候，配置文件需要一些系统的信息作为参考（我称为系统变量），而系统信息是在运行期才可以得到的，不过我们可以通过预定义一些变量名称使在配置文件中可以提前使用，通过解释系统变量来动态为该元素赋值。例如这个配置文件：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <config>
4.   <property name="version" value="1705"/>
5.   <module version="%{system.version}.${version}" home="%{system.home}/helloword">
6.     … …
7.   </module>
8. </config>

    解析后变成了：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <config>
4.   <module version="1.0.1705" home="/home/myuser/helloworld">
5.     … …
6.   </module>
7. </config>

    这里使用了我们预定义的系统变量"system.version"和"system.home"分别表示系统版本和系统的主目录。这使得配置文件具备获取系统动态信息的能力。下面我们用Java实现系统变量解释器DocumentConstantParser：

2. public final class DocumentConstantParser implements DocumentParser{
3.   private Properties constants;
5.   public DocumentConstantParser(){
6.     constants = new Properties();
7.   }
9.   public DocumentConstantParser(Properties original){
10.     constants = new Properties(original);
11.   }
13.   //通过运行期设置预定义的变量, 配置文件可以动态读取这些信息.
14.   public void addConstant(String name, String value){
15.     constants.setProperty(name, value);
16.   }
18.   public void removeConstant(String name){
19.     constants.remove(name);
20.   }
22.   public void parse(Document doc){
23.     parseContent(doc.getRootElement());
24.   }
25.   …
26. }

因为parseContent方法跟变量解释器的几乎相同，所以节省点儿空间就不写出了。系统可以通过使用addConstant和removeConstant方法操作对XML文档预定义的变量，这使得XML的配置功能更强大了。

比较前述的使用实体，此方法易于跟系统交互，且方法简便易懂。

命令

    曾经研究过Ant，其中的<javac>等元素十分吸引我。能不能再添加一个具有命令解释能力的元素呢？答案是肯定的。
    
    我定义XML文档中的command元素作为命令的入口元素。通过实现具体命令实现执行该命令。首先，因为可能有很多命令，我们定义一个命令接口DocumentCommand：

2. public interface DocumentCommand{
4.   //检查是否接受指定名称的命令。
5.   public boolean accept(String name);
7.   //处理命令
8.   public void invoke(Document doc, Element current, DocumentCommandParser parser) 
9. throws JDOMException;
10. }

定义好了命令解释接口，就可以设计解释器了。Java代码如下：

2. public final class DocumentCommandParser implements DocumentParser{
3.   private HashSet commands;
4.   private boolean parsing;
5.   public DocumentCommandParser(){
6.     commands = new HashSet(10);
7.     parsing = false;
8.   }
10.   //添加命令解释单元
11.   public synchronized void addCommand(DocumentCommand dc){
12.     if(parsing)
13.       try{
14.         wait();
15.       }catch(InterruptedException ie){}
17.     if(commands.contains(dc))
18.       commands.remove(dc);
19.     commands.add(dc);
20.   }
22.   //删除命令解释单元
23.   public synchronized void removeCommand(DocumentCommand dc){
24.     if(parsing)
25.       try{
26.         wait();
27.       }catch(InterruptedException ie){}
28.     commands.remove(dc);
29.   }
31.   public synchronized void parse(Document doc) throws JDOMException{
32.     parsing = true;
33.     parseCommand(doc, doc.getRootElement());
34.     parsing = false;
35.     notifyAll();
36.   }
38.   private void parseCommand(Document doc, Element element) throws JDOMException{
39.     List sub = element.getChildren();
40.     for(int i = 0;i < sub.size();i++){
41.       Element subElement = (Element)sub.get(i);
43.       //检查该元素是否是命令元素, 如果不是递归解释该元素的子元素.
44.       if(!"command".equalsIgnoreCase(subElement.getName())){
45.         parseCommand(doc, subElement);
46.       } else{
48.         //删除命令元素, 避免冲突.
49.         sub.remove(i--);
51.         //获取命令名称,如果为空, 则继续.
52.         String commandName = subElement.getAttributeValue("name");
53.         if(commandName != null){
55.           //开始检索适合的命令处理器.
56.           Iterator cmdI = commands.iterator();
57.           processing:
58.           while(cmdI.hasNext()){
59.             DocumentCommand dc = (DocumentCommand)cmdI.next();
61.             //找到对应命令处理器后, 进行命令解释.
62.             if(dc.accept(commandName)){
64.               //调用命令处理方法, 如果执行成功, 删除该变量.
65.               dc.invoke(doc, subElement, this);
67.               //中断命令检索过程.
68.               break processing;
69.             }
70.           }
71.         }
72.       }
73.     }
74.   }
75. }

    终于实现了命令解释功能，下面来研究一下它的用途。
    例如，一个文件拷贝命令filecopy有两个属性，source为源文件路径，target为拷贝目的路径，通过这一命令可以实现众多功能，如组件安装时从其他空间拷贝数据到其主目录。代码如下：

2. … …
3.   <command name="filecopy" source="${home} /lib" target="%{system}/lib/module"/> 
4. … …

    这样，组件所使用到的库文件就拷贝到了系统的库中。下面是filecopy的代码：

2. public class FileCopyCommand implements com.yipsilon.util.jdom.DocumentCommand{
3.     public boolean accept(String s){
4.       
5.       //只有filecopy命令可以接受.
6.       return "filecopy".equals(s);
7.     }
9.     public void invoke(Document document, Element element, DocumentCommandParser parser){
10.       String name = element.getAttributeValue("name");     //值为: filecopy
11.       String source = element.getAttributeValue ("source"); //值为原路径
12.       String target = element.getAttributeValue ("target"); //值为目的路径
13.       FileUtil.copy(source, target);
14.       //因内容有限, 这里没有增加额外的错误检查.
15.     }
16.   }

注：FileUtil.copy是简单的文件拷贝方法, 请自行实现。

结论

    通过在XML文档中使用变量、系统变量、命令大大增强了XML作为配置信息集合的功能。通过实现不同的解释器和命令单元，可以使其功能不断增多从而实现一些以前无法实现的目的，比如作为安装文件进行环境检测、I/O操作等，既能提高开发速度，内容也好管理。

    Java与XML与生俱来，在它们的身上可以开发出很多简化开发的产品，如Ant。有时候只需要动动脑筋就可以使开发变得简单。