JavaSE_Java DOM 操作 xml

1、前言

DOM XML Parser介绍

DOM 是 W3C 处理 XML 的标准 API，它是许多其它与 XML 处理相关的标准的基础，不仅是 Java，其它诸如 JavaScript，PHP，MS .NET 等等语言都实现了该标准，成为了应用最为广泛的 XML 处理方式。当然，为了能提供更多更加强大的功能，Java 对于 DOM 直接扩展工具类有很多，比如很多 Java 程序员耳熟能详的 JDOM，DOM4J 等等，它们基本上属于对 DOM 接口功能的扩充，保留了很多 DOM API 的特性，许多原本的 DOM 程序员甚至都没有任何障碍就熟练掌握了另外两者的使用，直观、易于操作的方式使它深受广大 Java 程序员的喜爱。

DOM XML Parser优缺点

实现 W3C 标准，有多种编程语言支持这种解析方式，并且这种方法本身操作上简单快捷，十分易于初学者掌握。其处理方式是将 XML 整个作为类似树结构的方式读入内存中以便操作及解析，因此支持应用程序对 XML 数据的内容和结构进行修改，但是同时由于其需要在处理开始时将整个 XML 文件读入到内存中去进行分析，因此其在解析大数据量的 XML 文件时会遇到类似于内存泄露以及程序崩溃的风险，请对这点多加注意。

适用范围：小型 XML 文件解析、需要全解析或者大部分解析 XML、需要修改 XML 树内容以生成自己的对象模型

2、XML DOM节点树

XML DOM将XML文档作为树结构，树结构称为一个节点树。所有的节点可以通过树访问，它们的内容可以被修改或删除，也可以建立新的元素。节点树用于显示节点集和它们之间的联系。下图呈现的是books.XML文件的节点树。

常用的几个对象：

1）Element类：

是Node类最主要的子对象，被广泛使用，在元素中可以包含属性，因而Element中有存取其属性的方法。

2）Node类：

Node对象是DOM中最基本的对象，代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象，而是使用Node对象的子对象Element,Attr,Text等。

3）NodeList类：

代表了一个包含一个或者多个Node的列表，根据操作可以将其简化的看做为数组。

各个类的API  .... 好吧， 作为程序猿我只关心这个。。。  

来了解点Java DOM 的 API:
1.解析器工厂类：DocumentBuilderFactory

创建的方法：DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

2.解析器：DocumentBuilder

创建方法：通过解析器工厂类来获得 DocumentBuilder db = dbf.newDocumentBuilder();

3.文档树模型Document

创建方法：

a.通过xml文档 

Document doc = db.parse("bean.xml");  

b.将需要解析的xml文档转化为输入流 

 InputStream is = new FileInputStream("bean.xml");

 Document doc = db.parse(is); 

Document对象代表了一个XML文档的模型树，所有的其他Node都以一定的顺序包含在Document对象之内，排列成一个树状结构，以后对XML文档的所有操作都与解析器无关，

直接在这个Document对象上进行操作即可；

 包含的方法：

4.节点列表类NodeList

NodeList代表了一个包含一个或者多个Node的列表，根据操作可以将其简化的看做为数组

5.节点类Node

Node对象是DOM中最基本的对象，代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象，而是使用Node对象的子对象Element,Attr,Text等

6.元素类Element

是Node类最主要的子对象，在元素中可以包含属性，因而Element中有存取其属性的方法

7.属性类Attr

代表某个元素的属性，虽然Attr继承自Node接口，但因为Attr是包含在Element中的，但并不能将其看做是Element的子对象，因为Attr并不是DOM树的一部分

基本的知识就到此结束，更加具体的大家可以参阅JDK API文档

3、DOM XML Parser 解析XML文件

下面给出一段用于解析的 books.xml片段：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!-- Edited by XMLSpy -->  
3. <bookstore>  
4.     <book category="cooking">  
5.         <title lang="en">Everyday Italian</title>  
6.         <author>Giada De Laurentiis</author>  
7.         <year>2005</year>  
8.         <price>30.00</price>  
9.     </book>  
10.     <book category="children">  
11.         <title lang="en">Harry Potter</title>  
12.         <author>J K. Rowling</author>  
13.         <year>2005</year>  
14.         <price>29.99</price>  
15.     </book>  
16.     <book category="web">  
17.         <title lang="en">XQuery Kick Start</title>  
18.         <author>James McGovern</author>  
19.         <author>Per Bothner</author>  
20.         <author>Kurt Cagle</author>  
21.         <author>James Linn</author>  
22.         <author>Vaidyanathan Nagarajan</author>  
23.         <year>2003</year>  
24.         <price>49.99</price>  
25.     </book>  
26.     <book category="web" cover="paperback">  
27.         <title lang="en">Learning XML</title>  
28.         <author>Erik T. Ray</author>  
29.         <year>2003</year>  
30.         <price>39.95</price>  
31.     </book>  
32. </bookstore>  

Book.java：该对象是一个实体Bean，其字段信息对应着xml文件里的元素字段，由于篇幅有限，读者自行生成get、set方法 。

[java] view plain copy

1. package com.andieguo.xmldemo;  
2.   
3. public class Book {  
4.     private String category;  
5.     private String titleLang;  
6.     private String title;  
7.     private String author;  
8.     private Integer year;  
9.     private Double price;  
10.       
11.       
12.     @Override  
13.     public String toString() {  
14.         return "Book [category=" + category + ", titleLang=" + titleLang + ", title=" + title + ", author=" + author + ", year=" + year + ", price=" + price + "]";  
15.     }  
16.     //生成字段的get、set方法  
17. }  

ReadXMLFile.java ：解析XML文件并存入List<Book>集合。

[java] view plain copy

1. package com.andieguo.xmldemo;  
2.   
3. import java.io.File;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. import javax.xml.parsers.DocumentBuilder;  
8. import javax.xml.parsers.DocumentBuilderFactory;  
9.   
10. import org.w3c.dom.Document;  
11. import org.w3c.dom.Element;  
12. import org.w3c.dom.Node;  
13. import org.w3c.dom.NodeList;  
14.   
15. public class ReadXMLFile {  
16.   
17.     public static void main(String[] args) {  
18.         File file = new File("src/com/andieguo/xmldemo/books.xml");//books.xml文件应放在和ReadXMLFile.java同级的文件夹下  
19.         List<Book> books = readXMLFile(file);  
20.         for (Book book : books) {  
21.             System.out.println(book.toString());  
22.         }  
23.     }  
24.   
25.     public static List<Book> readXMLFile(File file) {  
26.         List<Book> lists = new ArrayList<Book>();  
27.         try {  
28.   
29.             DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
30.             DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();  
31.             Document doc = dBuilder.parse(file);  
32.             NodeList bookList = doc.getElementsByTagName("book");  
33.             for (int i = 0; i < bookList.getLength(); i++) {  
34.                 Node bookNode = bookList.item(i);  
35.                 if (bookNode.getNodeType() == Node.ELEMENT_NODE) {  
36.                     Element bookElement = (Element) bookNode;  
37.                     Book book = new Book();  
38.                     book.setCategory(bookElement.getAttribute("category"));  
39.                     Element titleElement = (Element) bookElement.getElementsByTagName("title").item(0);  
40.                     book.setTitle(titleElement.getTextContent());  
41.                     book.setTitleLang(titleElement.getAttribute("lang"));  
42.                     NodeList authorList = bookElement.getElementsByTagName("author");  
43.                     String author = "";  
44.                     for (int j = 0; j < authorList.getLength(); j++) {  
45.                         author = author + authorList.item(j).getTextContent() + "/";  
46.                     }  
47.                     author = author.substring(0, author.length() - 1);  
48.                     book.setAuthor(author);  
49.                     book.setYear(Integer.valueOf(bookElement.getElementsByTagName("year").item(0).getTextContent()));  
50.                     book.setPrice(Double.valueOf(bookElement.getElementsByTagName("price").item(0).getTextContent()));  
51.                     lists.add(book);  
52.                 }  
53.   
54.             }  
55.         } catch (Exception e) {  
56.             e.printStackTrace();  
57.         }  
58.         return lists;  
59.     }  
60. }  

运行程序后的效果图：

4、DOM XML Parser 遍历XML文件

LoopXMLFile.java：通过迭代遍历xml文件

[java] view plain copy

1. package com.andieguo.xmldemo;  
2.   
3. import java.io.File;  
4.   
5. import javax.xml.parsers.DocumentBuilder;  
6. import javax.xml.parsers.DocumentBuilderFactory;  
7.   
8. import org.w3c.dom.Document;  
9. import org.w3c.dom.NamedNodeMap;  
10. import org.w3c.dom.Node;  
11. import org.w3c.dom.NodeList;  
12.   
13. public class LoopXMLFile {  
14.     public static void main(String[] args) {  
15.         loopXMLFile();  
16.     }  
17.       
18.     private static void loopXMLFile(){  
19.         try {  
20.             File file = new File("src/com/andieguo/xmldemo/books.xml");  
21.             DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
22.             DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();  
23.             Document doc = dBuilder.parse(file);  
24.             if(doc.hasChildNodes()){  
25.                 printNote(doc.getChildNodes());  
26.             }  
27.         } catch (Exception e) {  
28.             e.printStackTrace();  
29.         }  
30.     }  
31.       
32.     private static void printNote(NodeList nodeList){  
33.         for(int i=0; i<nodeList.getLength();i++){  
34.             Node node = nodeList.item(i);  
35.             if(node.getNodeType() == Node.ELEMENT_NODE){  
36.                 System.out.println("<"+node.getNodeName()+">");  
37.                 System.out.println(node.getTextContent());  
38.                 if(node.hasAttributes()){  
39.                     NamedNodeMap nodeMap = node.getAttributes();  
40.                     for(int j=0;j<nodeMap.getLength();j++){  
41.                         Node nd = nodeMap.item(j);  
42.                         System.out.println(nd.getNodeName()+"="+nd.getNodeValue());  
43.                     }  
44.                 }  
45.                 if(node.hasChildNodes()){  
46.                     printNote(node.getChildNodes());  
47.                 }  
48.                 System.out.println("<" + node.getNodeName() + "/>");  
49.             }  
50.               
51.               
52.         }  
53.     }  
54. }  

5、DOM XML Parser 创建XML文件

CreateXMLFile.java：

将集合List<Book>中的数据填充构建的XML文件中，读者可结合第2节 XML DOM树图来理解整个XML文件节点的生成、添加构建过程。

特别注意：

对于XML文件中的元素<year>2500</year>而言，2500不是<year>元素的值，而是<year>元素的一个TextNode节点，所以才有year.appendChild(doc.createTextNode(books.get(i).getYear().toString()));这样的语句存在。

[java] view plain copy

1. package com.andieguo.xmldemo;  
2.   
3. import java.io.File;  
4. import java.util.List;  
5.   
6. import javax.xml.parsers.DocumentBuilder;  
7. import javax.xml.parsers.DocumentBuilderFactory;  
8. import javax.xml.transform.Transformer;  
9. import javax.xml.transform.TransformerFactory;  
10. import javax.xml.transform.dom.DOMSource;  
11. import javax.xml.transform.stream.StreamResult;  
12.   
13. import org.w3c.dom.Document;  
14. import org.w3c.dom.Element;  
15.   
16. public class CreateXMLFile {  
17.   
18.     public static void main(String[] args) {  
19.         File file = new File("src/com/andieguo/xmldemo/books.xml");//books.xml文件应放在和CreateXMLFile.java同级的文件夹下  
20.         List<Book> books = ReadXMLFile.readXMLFile(file);  
21.         createXMLFile(books);  
22.     }  
23.       
24.     public static void createXMLFile(List<Book> books) {  
25.         Document doc;  
26.         Element bookstore;  
27.         Element book;  
28.         Element title;  
29.         Element author;  
30.         Element year;  
31.         Element price;  
32.         try {  
33.             // 得到DOM解析器的工厂实例  
34.             DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
35.             // 从DOM工厂中获得DOM解析器  
36.             DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();  
37.             // 创建文档树模型对象  
38.             doc = dbBuilder.newDocument();  
39.             if (doc != null) {  
40.                 bookstore = doc.createElement("bookstore");  
41.                 for (int i = 0; i < books.size(); i++) {  
42.                     book = doc.createElement("book");  
43.                     //设置元素book的属性值  
44.                     book.setAttribute("category", books.get(i).getCategory());  
45.                     //创建名称为title的元素  
46.                     title = doc.createElement("title");  
47.                     //创建文本节点并作为子节点添加到title元素中  
48.                     title.appendChild(doc.createTextNode(books.get(i).getTitle()));  
49.                     //设置元素title的属性值  
50.                     title.setAttribute("lang", books.get(i).getTitleLang());  
51.                     //将title子元素添加到book中  
52.                     book.appendChild(title);  
53.                     String[] strAuthor = books.get(i).getAuthor().split("/");  
54.                     for(int j=0;j<strAuthor.length;j++){  
55.                         author = doc.createElement("author");  
56.                         author.appendChild(doc.createTextNode(strAuthor[j]));  
57.                         book.appendChild(author);//将多个author子元素添加到book中  
58.                     }  
59.                     year = doc.createElement("year");  
60.                     year.appendChild(doc.createTextNode(books.get(i).getYear().toString()));  
61.                     book.appendChild(year);//将year子元素添加到book中  
62.                     price = doc.createElement("price");  
63.                     price.appendChild(doc.createTextNode(books.get(i).getPrice().toString()));  
64.                     book.appendChild(price);//将price子元素添加到book中  
65.                     bookstore.appendChild(book); //将book作为子元素添加到树的根节点bookstore  
66.                 }  
67.                 doc.appendChild(bookstore);//添加到文档树中  
68.                   
69.                 TransformerFactory transformerFactory = TransformerFactory.newInstance();  
70.                 Transformer transformer = transformerFactory.newTransformer();  
71.                 DOMSource source = new DOMSource(doc);  
72.                 StreamResult result = new StreamResult(new File("src/com/andieguo/xmldemo/createbooks.xml"));  
73.                
74.                 transformer.transform(source, result);  
75.             }  
76.         } catch (Exception e) {  
77.             e.printStackTrace();  
78.         }  
79.     }  
80. }  

运行程序后的效果图：

 参考：

Java 处理 XML 的三种主流技术及介绍

http://www.ibm.com/developerworks/cn/xml/dm-1208gub/

XML DOM Node Tree

http://www.w3schools.com/dom/dom_nodetree.asp

How To Read XML File In Java – (DOM Parser)

http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser/

How To Create XML File In Java – (DOMParser)

http://www.mkyong.com/java/how-to-create-xml-file-in-java-dom/

org.w3c.dom(Java dom)解析XML文档

http://www.cnblogs.com/shenliang123/archive/2012/05/11/2495252.html

文章主体

http://blog.csdn.net/andie_guo/article/details/24844351