java 解析并生成 XML

在 java 中使用 Dom4j 解析 XML

　　对 XML 文件的解析，通常使用的是 Dom4j 和 jdom 作为XML解析工具。

　　在此只介绍下 Dom4j 对 XML 文件的解析使用方法。

　　1. 明白了解 XML 文件的树结构

　　2. 了解 DOM4J 的一些接口

1. XML 文件的树结构（附:XML :http://www.w3school.com.cn/xml/xml_tree.asp）

　　XML 文档形成一种树结构

　　XML 文档必须包含根元素。该元素是所有其他元素的父元素。

　　XML 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。

　　所有元素均可拥有子元素：

1 <root>
2   <child>
3     <subchild>.....</subchild>
4   </child>
5 </root>

　　父、子以及同胞等术语用于描述元素之间的关系。父元素拥有子元素。相同层级上的子元素成为同胞（兄弟或姐妹）。

　　所有元素均可拥有文本内容和属性（类似 HTML 中）。

实例:

java 解析并生成 XML

　　上图表示下面的 XML 中的一本书：

 1 <bookstore>
 2 <book category="COOKING">
 3   <title lang="en">Everyday Italian</title> 
 4   <author>Giada De Laurentiis</author> 
 5   <year>2005</year> 
 6   <price>30.00</price> 
 7 </book>
 8 <book category="CHILDREN">
 9   <title lang="en">Harry Potter</title> 
10   <author>J K. Rowling</author> 
11   <year>2005</year> 
12   <price>29.99</price> 
13 </book>
14 <book category="WEB">
15   <title lang="en">Learning XML</title> 
16   <author>Erik T. Ray</author> 
17   <year>2003</year> 
18   <price>39.95</price> 
19 </book>
20 </bookstore>

　　例子中的根元素是 <bookstore>。文档中的所有 <book> 元素都被包含在 <bookstore> 中。

　　<book> 元素有 4 个子元素：<title>、< author>、<year>、<price>。

　　所以，对 XML 文件的解析，无非就是从 XML 文件中获取到根元素与子元素。

　　对此 Dom4j 已经对一些需要使用的方法进行了封装。

2. 了解DOM4J的一些接口 (附:http://www.blogjava.net/i369/articles/154264.html)

读取并解析XML文档：

1  // 从文件读取XML，输入文件名，返回XML文档
2     public Document read(String fileName) throws MalformedURLException, DocumentException {
3        SAXReader reader = new SAXReader();
4        Document document = reader.read(new File(fileName));
5        return document;
6     }

　　其中，reader的read方法是重载的，可以从InputStream, File, Url等多种不同的源来读取。得到的Document对象就带表了整个XML。

　　2. 取得 root 结点

　　 1 public Element getRootElement(Document doc){ 2 return doc.getRootElement(); 3 } 4

　　使用 getRootElement 直接可以返回root结点.

　　3. 遍历 XML 树

　　DOM4J提供至少3种遍历节点的方法,在此只取两种方法进行记录.

　　1) 枚举

 1  // 枚举所有子节点
 2     for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
 3        Element element = (Element) i.next();
 4        // do something
 5     }
 6     // 枚举名称为foo的节点
 7     for ( Iterator i = root.elementIterator(foo); i.hasNext();) {
 8        Element foo = (Element) i.next();
 9        // do something
10     }
11     // 枚举属性
12     for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
13        Attribute attribute = (Attribute) i.next();
14        // do something
15     }

　　2) 递归

 1     public void treeWalk() {
 2        treeWalk(getRootElement());
 3     }
 4     public void treeWalk(Element element) {
 5        for (int i = 0, size = element.nodeCount(); i < size; i++)     {
 6            Node node = element.node(i);
 7            if (node instanceof Element) {
 8               treeWalk((Element) node);
 9            } else { // do something....
10            }
11        }
12 }

　　附:

*Attribute*	Attribute定义了XML的属性
*Branch*	Branch为能够包含子节点的节点如XML元素(Element)和文档(Docuemnts)定义了一个公共的行为，
*CDATA*	CDATA 定义了XML CDATA 区域
*CharacterData*	CharacterData是一个标识借口，标识基于字符的节点。如CDATA，Comment, Text.
*Comment*	Comment 定义了XML注释的行为
*Document*	定义了XML文档
*DocumentType*	DocumentType 定义XML DOCTYPE声明
*Element*	Element定义XML 元素
*ElementHandler*	ElementHandler定义了 Element 对象的处理器
*ElementPath*	被 ElementHandler 使用，用于取得当前正在处理的路径层次信息
*Entity*	Entity定义 XML entity
*Node*	Node为所有的dom4j中XML节点定义了多态行为
*NodeFilter*	NodeFilter 定义了在dom4j节点中产生的一个滤镜或谓词的行为（predicate）
*ProcessingInstruction*	ProcessingInstruction 定义 XML 处理指令.
*Text*	Text 定义XML 文本节点.
*Visitor*	Visitor 用于实现Visitor模式.
*XPath*	XPath 在分析一个字符串后会提供一个XPath 表达式

实例:附:)http://www.cnblogs.com/nerxious/archive/2013/05/04/3060263.html

　　在使用过程中需要下载: DOM4J*点击下载

　　首先我们需要出创建一个xml文档，然后才能对其解析

　　XML文档:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <HD>
 3     <disk name="C">
 4         <capacity>8G</capacity>
 5         <directories>200</directories>
 6         <files>1580</files>
 7     </disk>
 8 
 9     <disk name="D">
10         <capacity>10G</capacity>
11         <directories>500</directories>
12         <files>3000</files>
13     </disk>
14 </HD>

示例一：用List列表的方式来解析xml

 1 package dom;
 2 
 3 import java.io.File;
 4 import java.util.List;
 5 import org.dom4j.Document;
 6 import org.dom4j.Element;
 7 import org.dom4j.io.SAXReader;
 8 
 9 
10 public class Demo {
11 
12     public static void main(String[] args) throws Exception {
13         SAXReader reader = new SAXReader();
14         File file = new File("test.xml");
15         Document document = reader.read(file);
16         Element root = document.getRootElement();
17         List<Element> childElements = root.elements();
18         for (Element child : childElements) {
19             //未知属性名情况下
20             /*List<Attribute> attributeList = child.attributes();
21             for (Attribute attr : attributeList) {
22                 System.out.println(attr.getName() + ": " + attr.getValue());
23             }*/
24 
25             //已知属性名情况下
26             System.out.println("name: " + child.attributeValue("name"));
27 
28             //未知子元素名情况下
29             /*List<Element> elementList = child.elements();
30             for (Element ele : elementList) {
31                 System.out.println(ele.getName() + ": " + ele.getText());
32             }
33             System.out.println();*/
34 
35             //已知子元素名的情况下
36             System.out.println("capacity: " + child.elementText("capacity"));
37             System.out.println("directories: " + child.elementText("directories"));
38             System.out.println("files: " + child.elementText("files"));
39             //这行是为了格式化美观而存在
40             System.out.println();
41         }
42     }
43 
44 }

示例二：使用Iterator迭代器的方式来解析xml

 1 package dom;
 2 
 3 import java.io.File;
 4 import java.util.Iterator;
 5 import org.dom4j.Document;
 6 import org.dom4j.Element;
 7 import org.dom4j.io.SAXReader;
 8 
 9 public class Demo1 {
10     public static void main(String[] args) throws Exception {
11         SAXReader reader = new SAXReader();
12         Document document = reader.read(new File("test.xml"));
13         Element root = document.getRootElement();
14 
15         Iterator it = root.elementIterator();
16         while (it.hasNext()) {
17             Element element = (Element) it.next();
18 
19             //未知属性名称情况下
20             /*Iterator attrIt = element.attributeIterator();
21             while (attrIt.hasNext()) {
22                 Attribute a  = (Attribute) attrIt.next();
23                 System.out.println(a.getValue());
24             }*/
25 
26             //已知属性名称情况下
27             System.out.println("name: " + element.attributeValue("name"));
28 
29             //未知元素名情况下
30             /*Iterator eleIt = element.elementIterator();
31             while (eleIt.hasNext()) {
32                 Element e = (Element) eleIt.next();
33                 System.out.println(e.getName() + ": " + e.getText());
34             }
35             System.out.println();*/
36 
37             //已知元素名情况下
38             System.out.println("capacity: " + element.elementText("capacity"));
39             System.out.println("directories: " + element.elementText("directories"));
40             System.out.println("files: " + element.elementText("files"));
41             System.out.println();
42         }
43     }
44 }

示例三：创建xml文档并输出到文件

 1 package dom;
 2 
 3 import java.io.File;
 4 import java.io.FileOutputStream;
 5 
 6 import org.dom4j.Document;
 7 import org.dom4j.DocumentHelper;
 8 import org.dom4j.Element;
 9 import org.dom4j.io.OutputFormat;
10 import org.dom4j.io.XMLWriter;
11 
12 
13 public class Demo2 {
14     public static void main(String[] args) throws Exception {
15         Document doc = DocumentHelper.createDocument();
16         //增加根节点
17         Element HD = doc.addElement("HD");
18         //增加子元素
19         Element disk = HD.addElement("disk");
20         Element capacity1 = disk.addElement("capacity");
21         Element directories1 = disk.addElement("directories");
22         Element files1 = disk.addElement("files");
23 
24         Element disk2 = HD.addElement("disk");
25         Element capacity2 = disk2.addElement("capacity");
26         Element directories2 = disk2.addElement("directories");
27         Element files2 = disk2.addElement("files");
28 
29 
30 
31         //为子节点添加属性
32         disk.addAttribute("name", "C");
33         //为元素添加内容
34         capacity1.setText("8G");
35         directories1.setText("2000");
36         files1.setText("1580");
37 
38         disk2.addAttribute("name", "D");
39         //为元素添加内容
40         capacity1.setText("10G");
41         directories1.setText("500");
42         files1.setText("3000");
43 
44         //实例化输出格式对象
45         OutputFormat format = OutputFormat.createPrettyPrint();
46         //设置输出编码
47         format.setEncoding("UTF-8");
48         //创建需要写入的File对象
49         File file = new File("D:" + File.separator + "test.xml");
50         //生成XMLWriter对象，构造函数中的参数为需要输出的文件流和格式
51         XMLWriter writer = new XMLWriter(new FileOutputStream(file), format);
52         //开始写入，write方法中包含上面创建的Document对象
53         writer.write(doc);
54     }
55 }

对 XML 文件的解析和对生成 XML 文件,关键在于对 XML 树结构的理解.

java 解析并生成 XML

在 java 中使用 Dom4j 解析 XML

相关推荐