Java耐久化XML文件配置解析

目录

前言选择一个格式XML 根底创建一个示例配置文件使用 Java 解析 XML

使用 Java 访问 XML 的值

使用 Java 更新 XML如何保证配置不出问题

前言

当你编写一个应用时，你通常都会希望用户可以定制化他们和应用交互的方式，以及应用与系统停止交互的方式。这种方式通常被称为 “偏好preference” 或者 “设置setting”，它们被保管在一个 “偏好文件” 或者 “配置文件” 中，有时也直接简称为 “配置config”。配置文件可以有很多种格式，包括 INI、JSON、YAML 和 XML。每一种编程语言解析这些格式的方式都不同。本文主要讨论，当你在使用 Java 编程语言 来编写软件时，实现耐久化配置的方式。

选择一个格式

编写配置文件是一件相当复杂的事情。我曾经试过把配置项使用逗号分隔保管在一个文本文件里，也试过把配置项保管在非常详细的 YAML 和 XML 中。对于配置文件来说，最重要是要有一致性和规律性，它们使你可以简单快速地编写代码，从配置文件中解析出数据；同时，当用户决定要做出修改时，很方便地保管和更新配置。
目前有 几种流行的配置文件格式。对于大多数常见的配置文件格式，Java 都有对应的库library。在本文中，我将使用 XML 格式。对于一些项目，你可能会选择使用 XML，因为它的一个突出特点是可以为包含的数据提供大量相关的元数据，而在另外一些项目中，你可能会因为 XML 的冗长而不选择它。在 Java 中使用 XML 是非常容易的，因为它默认包含了许多强健的 XML 库。

XML 根底

讨论 XML 可是一个大话题。我有一本关于 XML 的书，它有超越 700 页的内容。幸运的是，使用 XML 并不需要非常理解它的诸多特性。就像 HTML 一样，XML 是一个带有开端和完毕标志的分层标志语言，每一个标志（标签）内可以包含零个或更多数据。下面是一个 XML 的简单示例片段：

1. <xml>
2.   <node>
3.     <element>Penguin</element>
4.   </node>
5. </xml>

复制代码

在这个 自我描绘的self-descriptive 例子中，XML 解析器使用了以下几个概念：

文档Document：<xml> 标签标志着一个 文档 的开端，</xml> 标签标志着这个文档的完毕。节点Node：<node> 标签代表了一个 节点。元素Element：<element>Penguin</element> 中，从开头的 < 到最后的 > 表示了一个 元素。内容Content： 在 <element> 元素里，字符串 Penguin 就是 内容。

不论你信不信，只要理解了以上几个概念，你就可以开端编写、解析 XML 文件了。

创建一个示例配置文件

要学习如何解析 XML 文件，只需要一个极简的示例文件就够了。假设如今有一个配置文件，里面保管的是关于一个图形界面窗口的属性：

1. <xml>
2.   <window>
3.     <theme>Dark</theme>
4.     <fullscreen>0</fullscreen>
5.     <icons>Tango</icons>
6. </window>
7. </xml>

复制代码

创建一个名为 ~/.config/DemoXMLParser 的目录：

1. $ mkdir ~/.config/DemoXMLParser

复制代码

在 Linux 中，~/.config 目录是寄存配置文件的默认位置，这是在 自由桌面工作组 的规范中定义的。假设你正在使用一个不遵守 自由桌面工作组Freedesktop规范的操作系统，你也仍然可以使用这个目录，只不过你需要自己创建这些目录了。
复制 XML 的示例配置文件，粘贴并保管为 ~/.config/DemoXMLParser/myconfig.xml 文件。

使用 Java 解析 XML

假设你是 Java 的初学者，你可以先阅读我写的 面向 Java 入门开发者的 7 个小技巧。一旦你对 Java 比较熟悉了，翻开你最喜欢的集成开发工具（IDE），创建一个新工程。我会把我的新工程命名为 myConfigParser。
刚开端先不要太关注依赖导入和异常捕获这些，你可以先尝试用 javax 和 java.io 包里的规范 Java 扩展来实例化一个解析器。假设你使用了 IDE，它会提示你导入适宜的依赖。假设没有，你也可以在文章稍后的部分找到完好的代码，里面就有完好的依赖列表。

1. Path configPath = Paths.get(System.getProperty("user.home"), ".config", "DemoXMLParser");
2. File configFile = new File(configPath.toString(), "myconfig.xml");
3. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
4. DocumentBuilder builder = null;
5. builder = factory.newDocumentBuilder();
6. Document doc = null;
7. doc = builder.parse(configFile);
8. doc.getDocumentElement().normalize();

复制代码

这段示例代码使用了 java.nio.Paths 类来找到用户的主目录，然后在拼接上默认配置文件的途径。接着，它用 java.io.File 类来把配置文件定义为一个 File 对象。
紧接着，它使用了 javax.xml.parsers.DocumentBuilder 和 javax.xml.parsers.DocumentBuilderFactory 这两个类来创建一个内部的文档构造器，这样 Java 程序就可以导入并解析 XML 数据了。
最后，Java 创建一个叫 doc 的文档对象，并且把 configFile 文件加载到这个对象里。通过使用 org.w3c.dom 包，它读取并规范化了 XML 数据。
根本上就是这样啦。理论上来讲，你已经完成了数据解析的工作。可是，假设你不可以访问数据的话，数据解析也没有多少用处嘛。所以，就让我们再来写一些查询，从你的配置中读取重要的属性值吧。

使用 Java 访问 XML 的值

从你已经读取的 XML 文档中获取数据，其实就是要先找到一个特定的节点，然后遍历它包含的所有元素。通常我们会使用多个循环语句来遍历节点中的元素，但是为了坚持代码可读性，我会尽可能少地使用循环语句：

1. NodeList nodes = doc.getElementsByTagName("window");
2. for (int i = 0; i < nodes.getLength(); i++) {
3. Node mynode = nodes.item(i);
4. System.out.println("Property = " + mynode.getNodeName());
5. if (mynode.getNodeType() == Node.ELEMENT_NODE) {
6.    Element myelement = (Element) mynode;
7.    System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
8.    System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
9.    System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
10. }
11. }

复制代码

这段示例代码使用了 org.w3c.dom.NodeList 类，创建了一个名为 nodes 的 NodeList 对象。这个对象包含了所有名字匹配字符串 window 的子节点，实际上这样的节点只要一个，因为本文的示例配置文件中只配置了一个。
紧接着，它使用了一个 for 循环来遍历 nodes 列表。详细过程是：根据节点呈现的顺序逐个取出，然后交给一个 if-then 子句处置。这个 if-then 子句创建了一个名为 myelement 的 Element 对象，其中包含了当前节点下的所有元素。你可以使用例如 getChildNodes 和 getElementById 方法来查询这些元素，项目中还 记录了 其他查询方法。
在这个示例中，每个元素就是配置的键。而配置的值贮存在元素的内容中，你可以使用 .getTextContent 方法来提取出配置的值。
在你的 IDE 中运行代码（或者运行编译后的二进制文件）：

1. $ java ./DemoXMLParser.java
2. Property = window
3. Theme = Dark
4. Fullscreen = 0
5. Icon set = Tango

复制代码

下面是完好的代码示例：

1. package myConfigParser;
2. import java.io.File;
3. import java.io.IOException;
4. import java.nio.file.Path;
5. import java.nio.file.Paths;
6. import javax.xml.parsers.DocumentBuilder;
7. import javax.xml.parsers.DocumentBuilderFactory;
8. import javax.xml.parsers.ParserConfigurationException;
9. import org.w3c.dom.Document;
10. import org.w3c.dom.Element;
11. import org.w3c.dom.NamedNodeMap;
12. import org.w3c.dom.Node;
13. import org.w3c.dom.NodeList;
14. import org.xml.sax.SAXException;
15. public class ConfigParser {
16.         public static void main(String[] args) {
17.                 Path configPath = Paths.get(System.getProperty("user.home"), ".config", "DemoXMLParser");
18.                 File configFile = new File(configPath.toString(), "myconfig.xml");
19.                 DocumentBuilderFactory factory =
20.                 DocumentBuilderFactory.newInstance();
21.                 DocumentBuilder builder = null;
22.                 try {
23.                         builder = factory.newDocumentBuilder();
24.                 } catch (ParserConfigurationException e) {
25.                         e.printStackTrace();
26.                 }
27.                 Document doc = null;
28.                 try {
29.                         doc = builder.parse(configFile);
30.                 } catch (SAXException e) {
31.                         e.printStackTrace();
32.                 } catch (IOException e) {
33.                         e.printStackTrace();
34.                 }
35.         doc.getDocumentElement().normalize();
36.         NodeList nodes = doc.getElementsByTagName("window");
37.         for (int i = 0; i < nodes.getLength(); i++) {
38.            Node mynode = nodes.item(i);
39.            System.out.println("Property = " + mynode.getNodeName());
40.            if (mynode.getNodeType() == Node.ELEMENT_NODE) {
41.                Element myelement = (Element) mynode;
42.                System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
43.                System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
44.                System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
45.            } // close if
46.         } // close for
47.     } // close method
48. } //close class

复制代码

使用 Java 更新 XML

用户时不时地会改变某个偏好项，这时候 org.w3c.dom 库就可以协助你更新某个 XML 元素的内容。你只需要选择这个 XML 元素，就像你读取它时那样。不过，此时你不再使用 .getTextContent 方法，而是使用 .setTextContent 方法。

1. updatePref = myelement.getElementsByTagName("fullscreen").item(0);
2. updatePref.setTextContent("1");
3. System.out.println("Updated fullscreen to " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());

复制代码

这么做会改变应用程序内存中的 XML 文档，但是还没有把数据写回到磁盘上。配合使用 javax 和 w3c 库，你就可以把读取到的 XML 内容写回到配置文件中。

1. TransformerFactory transformerFactory = TransformerFactory.newInstance();
2. Transformer xtransform;
3. xtransform = transformerFactory.newTransformer();
4. DOMSource mydom = new DOMSource(doc);
5. StreamResult streamResult = new StreamResult(configFile);
6. xtransform.transform(mydom, streamResult);

复制代码

这么做会没有警告地写入转换后的数据，并覆盖掉之前的配置。
下面是完好的代码，包括更新 XML 的操作：

1. package myConfigParser;
2. import java.io.File;
3. import java.io.IOException;
4. import java.nio.file.Path;
5. import java.nio.file.Paths;
6. import javax.xml.parsers.DocumentBuilder;
7. import javax.xml.parsers.DocumentBuilderFactory;
8. import javax.xml.parsers.ParserConfigurationException;
9. import javax.xml.transform.Transformer;
10. import javax.xml.transform.TransformerException;
11. import javax.xml.transform.TransformerFactory;
12. import javax.xml.transform.dom.DOMSource;
13. import javax.xml.transform.stream.StreamResult;
14. import org.w3c.dom.Document;
15. import org.w3c.dom.Element;
16. import org.w3c.dom.Node;
17. import org.w3c.dom.NodeList;
18. import org.xml.sax.SAXException;
19. public class ConfigParser {
20.         public static void main(String[] args) {
21.                 Path configPath = Paths.get(System.getProperty("user.home"), ".config", "DemoXMLParser");
22.                 File configFile = new File(configPath.toString(), "myconfig.xml");
23.                 DocumentBuilderFactory factory =
24.                 DocumentBuilderFactory.newInstance();
25.                 DocumentBuilder builder = null;
26.                 try {
27.                         builder = factory.newDocumentBuilder();
28.                 } catch (ParserConfigurationException e) {
29.                         // TODO Auto-generated catch block
30.                         e.printStackTrace();
31.                 }
32.                 Document doc = null;
33.                 try {
34.                         doc = builder.parse(configFile);
35.                 } catch (SAXException e) {
36.                         // TODO Auto-generated catch block
37.                         e.printStackTrace();
38.                 } catch (IOException e) {
39.                         // TODO Auto-generated catch block
40.                         e.printStackTrace();
41.                 }
42.         doc.getDocumentElement().normalize();
43.         Node updatePref = null;
44. //        NodeList nodes = doc.getChildNodes();
45.         NodeList nodes = doc.getElementsByTagName("window");
46.         for (int i = 0; i < nodes.getLength(); i++) {
47.            Node mynode = nodes.item(i);
48.            System.out.println("Property = " + mynode.getNodeName());
49.            if (mynode.getNodeType() == Node.ELEMENT_NODE) {
50.                Element myelement = (Element) mynode;
51.                System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
52.                System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
53.                System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
54.                updatePref = myelement.getElementsByTagName("fullscreen").item(0);
55.                updatePref.setTextContent("2");
56.                System.out.println("Updated fullscreen to " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());         
57.            } // close if
58.         }// close for
59.         // write DOM back to the file
60.         TransformerFactory transformerFactory = TransformerFactory.newInstance();
61.         Transformer xtransform;
62.         DOMSource mydom = new DOMSource(doc);
63.         StreamResult streamResult = new StreamResult(configFile);
64.         try {
65.                 xtransform = transformerFactory.newTransformer();
66.                 xtransform.transform(mydom, streamResult);
67.         } catch (TransformerException e) {
68.                 e.printStackTrace();
69.         }
70.     } // close method
71. } //close class

复制代码

如何保证配置不出问题

编写配置文件看上去是一个还挺简单的任务。一开端，你可能会用一个简单的文本格式，因为你的应用程序只要寥寥几个配置项而已。但是，随着你引入了更多的配置项，读取或者写入错误的数据可能会给你的应用程序带来意料之外的错误。一种协助你坚持配置过程安全、不出错的方法，就是使用类似 XML 的规范格式，然后依靠你用的编程语言的内置功能来处置这些复杂的事情。
这也正是我喜欢使用 Java 和 XML 的原因。每当我试图读取错误的配置值时，Java 就会提醒我。通常，这是由于我在代码中试图获取的节点，并不存在于我期望的 XML 途径中。XML 这种高度构造化的格式协助了代码坚持可靠性，这对用户和开发者来说都是有好处的。
via: https://opensource.com/article/21/7/parsing-config-files-java
以上就是Java耐久化XML文件配置解析的详细内容，更多关于Java耐久化XML文件配置的资料请关注网站其它相关文章！