四种方法解析XML文档：Dom、SAX、JDOM、dom4j

四种方法解析XML文档：Dom、SAX、JDOM、dom4j         

     

1、了解XML：

        XML，即可扩展标记语言（Extensible Markup Language），标准通用标记语言的子集，一种用于标记电子文件使其具有结构性的标记语言。它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 它非常适合万维网传输，提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。它和JSON都是一种数据交换格式。

作用：解析XML文档，创建XML文档。

 

2、什么是可扩展标记语言？

· 可扩展标记语言是一种很像超文本标记语言的标记语言。

· 它的设计宗旨是传输数据，而不是显示数据。

· 它的标签没有被预定义。您需要自行定义标签。

· 它被设计为具有自我描述性。

· 它是W3C的推荐标准。

3、解析XML文档的四种方式： 四种方法解析XML文档：Dom、SAX、JDOM、dom4j          

            第一种： DOM的全称是Document Object Model，也即文档对象模型。在应用程序中，基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称作随机访问机制。

第一种：DOM的XML文件读取:

1.DocumentBuilderFactory.newInstance()  创建DocumentBuilderFactory的对象

2.DocumentBuilder    获得具体的DOM解析器。

3. Parse(  new File() )  获取文档xml路径。

—————看注释

准备ＸＭＬ文档：

[java]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <Languages cat="it">  
3.     <lan id="1">  
4.         <name>Java</name>  
5.         <ide>Eclipse</ide>  
6.     </lan>  
7.     <lan id="2">  
8.         <name>Swift</name>  
9.         <ide>Xcode</ide>  
10.     </lan>  
11.     <lan id="3">  
12.         <name>C#</name>  
13.         <ide>Visual Studio</ide>  
14.     </lan>  
15. </Languages>  

 看看ＤＯＭ解析的例子：

[java]  view plain  copy

 print ?

1. package dom;  
2. import java.io.File;  
3. import java.io.IOException;  
4.   
5. import javax.xml.parsers.DocumentBuilder;  
6. import javax.xml.parsers.DocumentBuilderFactory;  
7. import javax.xml.parsers.ParserConfigurationException;  
8.   
9. import org.w3c.dom.Document;  
10. import org.w3c.dom.Element;  
11. import org.w3c.dom.Node;  
12. import org.w3c.dom.NodeList;  
13. import org.xml.sax.SAXException;  
14.   
15. /* 
16.  * DOM  Class  Reader 
17.  *  
18.  */  
19. public class ReaderXML {  
20.     public static void main(String[] args) {  
21.         try {  
22.               
23.             //1。获取DOM 解析器的工厂实例。  
24.             DocumentBuilderFactory factory  = DocumentBuilderFactory.newInstance();  
25.             //2。获得具体的DOM解析器。  
26.             DocumentBuilder builder = factory.newDocumentBuilder();  
27.               
28.             //3。获取文件  
29.             Document document = builder.parse(new File("languages.xml"));  
30.   
31.                         //4。获取根元素  
32.             Element root = document.getDocumentElement();  
33.             System.out.println("cat="+root.getAttribute("cat"));  
34.             //5。获取根节点[有多个节点]  
35.             NodeList list = root.getElementsByTagName("lan");  
36.               
37.             for (int i = 0; i < list.getLength(); i++) {  
38.                 //Node lan = list.item(i);  
39.                 //System.out.println("id="+lan.getNodeType());  
40.                 System.out.println("---------------");  
41.                 Element lan =  (Element) list.item(i);  
42.                 System.out.println("id=" + lan.getAttribute("id"));  
43.                   
44.                 //获取子节点集合  
45.                 NodeList clist = lan.getChildNodes();  
46.                 for (int j = 0; j < clist.getLength(); j++) {  
47.                     //获取下标  
48.                     Node c = clist.item(j);  
49.                     //把空格删除[获取属性名和值]  
50.                     if (c instanceof Element) {  
51.                         System.out.println(c.getNodeName()+"="+c.getTextContent());  
52.                     }  
53.                 }  
54.             }  
55.                                   
56.         } catch (ParserConfigurationException e) {  
57.             e.printStackTrace();  
58.         } catch (SAXException e) {  
59.             e.printStackTrace();  
60.         } catch (IOException e) {  
61.             e.printStackTrace();  
62.         }  
63.     }  
64.   
65. }  

 

第一种：DOM 的XML文件创建：

1.DocumentBuilderFactory.newInstance()  获取DOM 解析器的工厂实例。

2. DocumentBuilder  获得具体的DOM解析器。

3.创建一个xml文档，获得Document对象（根结点）（createElement）。

4. 创建根元素、根结点、setAttribute ("根结点名");

5. 添加根节点的值：setTextContent(“Value”);

6.子节点添加到根节点：appendChild(“根结点”);

7.输出：TransformerFactory ！

[java]  view plain  copy

 print ?

1. package dom;  
2.   
3. import java.io.File;  
4. import java.io.StringWriter;  
5.   
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.   
15. import org.w3c.dom.Document;  
16. import org.w3c.dom.Element;  
17.   
18.   
19.   
20. /* 
21.  * DOM Class Great 
22.  *  
23.  */  
24. public class Creat_XML {  
25.   public static void main(String [] ags){  
26.         
27.      try {  
28.            
29.      DocumentBuilderFactory factory =  DocumentBuilderFactory.newInstance();  
30.      DocumentBuilder builder = factory.newDocumentBuilder();  
31.            
32.          Document document = builder.newDocument();   
33.      //创建属性名、赋值  
34.          Element root = document.createElement("Languages");  
35.          root.setAttribute("cat", "it");  
36.   
37.                  //创建第一个根节点、赋值  
38.          Element lan = document.createElement("lan");  
39.          lan.setAttribute("id", "1");  
40.          Element name = document.createElement("name");  
41.          name.setTextContent("java");  
42.          Element ide = document.createElement("IDE");  
43.          ide.setTextContent("Eclipse");  
44.          lan.appendChild(name);  
45.          lan.appendChild(ide);  
46.          <span style="font-size:14px;"></span><pre name="code" class="java">                 //创建第二个根节点、赋值  
47.          Element lan2 = document.createElement("lan");  
48.          lan2.setAttribute("id", "2");  
49.          Element name2 = document.createElement("name");  
50.          name2.setTextContent("Swift");  
51.          Element ide2 = document.createElement("ide");  
52.          ide2.setTextContent("XCode");  
53.          lan2.appendChild(name2);  
54.          lan2.appendChild(ide2);  
55.            
56.                  //添加到属性中、  
57.          root.appendChild(lan);  
58.                  root.appendChild(lan2);      
59.                  document.appendChild(root);  
60.            
61.                 //定义了用于处理转换指令，以及执行从源到结果的转换的  
62.         TransformerFactory transformerFactory = TransformerFactory.newInstance();  
63.         Transformer transformer = transformerFactory.newTransformer();  
64.         transformer.setOutputProperty("encoding", "UTF-8");  
65.               
66.         StringWriter writer = new StringWriter();  
67.         transformer.transform(new DOMSource(document), new StreamResult(writer));  
68.         System.out.println(writer.toString());  
69.               
70.         transformer.transform(new DOMSource(document), new StreamResult(new File("newxml.xml")));     
71.           
72.           
73.           
74.           
75.           
76.     } catch (ParserConfigurationException | TransformerException e) {  
77.         e.printStackTrace();  
78.     }  
79.   }  
80. }  

             第二种：dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的，dom4j是一个十分优秀的JavaXML API，具有性能优异、功能强大和极其易使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面还可以找到一篇文章，对主流的Java XML API进行的性能、功能和易用性的评测，所以可以知道dom4j无论在哪个方面都是非常出色的。如今可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这已经是必须使用的jar包， Hibernate也用它来读写配置文件。

下载：dom4j架包

 

第二种：Dom4j创建XML步骤：

1. 设置根节点： DocumentHelper.createElement("根节点名");

2. 读取doucment元素：DocumentHelper.createDocument(root);

3.添加根节点：addAttribute("name", "value");  

4. 添加字节点、赋值：addElement("name");  setText("value");

5. 添加到根节点：XMLWriter xmlWriter = new XMLWriter();  xmlWriter.write(document);  

 

[java]  view plain  copy

 print ?

1. package dom4j;  
2.   
3. import java.io.FileOutputStream;  
4. import org.dom4j.Document;  
5. import org.dom4j.DocumentHelper;  
6. import org.dom4j.Element;  
7. import org.dom4j.io.OutputFormat;  
8. import org.dom4j.io.XMLWriter;  
9.   
10.   
11. public class Greate_dom4j {  
12.         public static void main(String[] args) throws Exception    
13.         {    
14.             // 创建文档并设置文档的根元素节点   
15.             Element root = DocumentHelper.createElement("books");  
16.             Document doucment = DocumentHelper.createDocument(root);  
17.             //根节点  
18.             root.addAttribute("name","bookvalue");  
19.             //子节点  
20.             Element element1 = root.addElement("author1 ");  
21.             element1.addAttribute( "name", "James1" );  
22.             element1.addAttribute( "location1", "UK1" );  
23.             element1.addText( "James Strachan1" );  
24.               
25.             Element element = root.addElement("author2 ");  
26.             element.addAttribute( "name", "chen" );  
27.             element.addAttribute( "kenken", "ZK" );  
28.             element.addText( "chen kenken" );  
29.             //添加  
30.             XMLWriter xmlwriter2 = new XMLWriter();  
31.             xmlwriter2.write(doucment);  
32.             //创建文件  
33.             OutputFormat format = new OutputFormat();  
34.   
35.             FileOutputStream file = new FileOutputStream("books.xml");  
36.             XMLWriter xml = new XMLWriter(file);  
37.               
38.             xml.close();  
39.         }  
40.   
41.           
42.     }    

第二种：Dom4j读取XML步骤：

1.获取SAM接口：SAXReader saxReader = new SAXReader();  

2.获取XML文档：  Document doc =  saxReader.read(new File("name.xml"));

3.获取根节点：Element root = doc.getRootElement();

4.获取子节点：root.elementIterator();

5.获取孙节点： attributeIterator();

[java]  view plain  copy

 print ?

1. package dom4j;  
2. import java.io.File;  
3. import java.util.Iterator;  
4. import java.util.List;  
5.   
6. import org.dom4j.Attribute;  
7. import org.dom4j.Document;  
8. import org.dom4j.Element;  
9. import org.dom4j.io.SAXReader;  
10.   
11.   
12. /* 
13.  * dom4j Class Reader 
14.  *  
15.  */  
16.   
17. public class Rreader_dom4j{  
18.     public static void main(String[] args) throws Exception{  
19.           
20.         //1.获取SAM接口：  
21.         SAXReader saxReader = new SAXReader();  
22.         //2.获取XML文件：  
23.         Document doc = saxReader.read(new File("newxml.xml"));  
24.         //3.获取根节点：  
25.         Element root = doc.getRootElement();          
26.         System.out.println("根节点: " + root.getName());         
27.           
28.         System.out.println("----------------");  
29.           
30.         //获取子节点  
31.         Iterator<?> it = root.elementIterator();  
32.         while(it.hasNext()){  
33.             Element elem = (Element) it.next();  
34.             //获取属性名属性值  
35.             List<Attribute> li = elem.attributes();  
36.             for (Attribute att : li ) {  
37.                 System.out.println(att.getName() + "  " + att.getValue() );  
38.             }  
39.                       
40.             //获取子节的子节点  
41.             Iterator<?> ite = elem.elementIterator();  
42.             while(ite.hasNext()){  
43.                 Element child = (Element) ite.next();  
44.                 System.out.println(child.getName() + "  " + child.getStringValue());  
45.             }  
46.               
47.             System.out.println("----------------");  
48.         }  
49.   
50.           
51.     }  
52. }  

          第三种：JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念等），把SAX和DOM的功能有效地结合起来。

          JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下，这些API函数被最大限度的优化。

JDOM读取XML：

[java]  view plain  copy

 print ?

1. package com.jdom;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.InputStreamReader;  
8. import java.io.UnsupportedEncodingException;  
9. import java.util.List;  
10. import org.jdom2.Attribute;  
11. import org.jdom2.Document;  
12. import org.jdom2.Element;  
13. import org.jdom2.JDOMException;  
14. import org.jdom2.input.SAXBuilder;  
15.   
16.   
17. /** 
18.  * JDOM Class Reader 
19.  *  
20.  */  
21. public class ReaderJDom {  
22.     public static void main(String[] args) {  
23.       
24.         try {  
25.               
26.             //1.创建一个SAXBuilder的对象  
27.             SAXBuilder saxBuilder = new SAXBuilder();  
28.             //2.创建一个输入流，将xml文件加载到输入流中  
29.             InputStream in = new FileInputStream("Book.xml");             
30.             InputStreamReader isr = new InputStreamReader(in, "UTF-8");   
31.             //3.通过saxBuilder的build方法，将输入流加载到saxBuilder中  
32.             Document document = saxBuilder.build(isr);             
33.             //4.通过document对象获取xml文件的根节点  
34.             Element rootElement = document.getRootElement();  
35.             //5.获取根节点下的子节点的List集合  
36.             List<Element> elementList = rootElement.getChildren();  
37.               
38.             for (Element element : elementList) {  
39.                 // 解析文件的属性集合  
40.                 List<Attribute> list = element.getAttributes();  
41.                 for (Attribute attr : list) {  
42.                     // 获取属性名  
43.                     String attrName = attr.getName();  
44.                     // 获取属性值  
45.                     String attrValue = attr.getValue();  
46.                     System.out.println(attrName +"="+ attrValue);  
47.                       
48.                     // 对book节点的子节点的节点名以及节点值的遍历  
49.                     List<Element> listChild = element.getChildren();  
50.                     for (Element child : listChild) {  
51.                         System.out.println(child.getName() +"="+child.getValue());  
52.                     }     
53.                       
54.                 }  
55.                 System.out.println("——————————————————————");  
56.             }  
57.               
58.           
59.             }catch (FileNotFoundException e) {  
60.                     e.printStackTrace();  
61.             }catch (UnsupportedEncodingException e) {  
62.                 e.printStackTrace();  
63.             }catch (JDOMException e) {  
64.                 e.printStackTrace();  
65.             } catch (IOException e) {  
66.                 e.printStackTrace();  
67.             }  
68.     }  
69. }  

JDOM创建xml：

[java]  view plain  copy

 print ?

1. package com.jdom;  
2.   
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7.   
8. import org.jdom2.Document;  
9. import org.jdom2.Element;  
10. import org.jdom2.output.Format;  
11. import org.jdom2.output.XMLOutputter;  
12.   
13. /** 
14.  * Create Class 
15.  *  
16.  */  
17. public class CreateJDom {  
18.     public static void main(String[] args) {  
19.           
20.         //1.生成一个根节点  
21.         Element rss = new Element("Languages");  
22.         //2.为节点添加属性  
23.         rss.setAttribute("Cat","it");  
24.         //3.生成一个document对象  
25.         Document document = new Document(rss);  
26.           
27.         //添加元素  
28.         Element lan = new Element("lan");  
29.         lan.setAttribute("id","1");  
30.         Element name = new Element("name");  
31.         name.setText("java");  
32.         lan.addContent(name);  
33.           
34.         Element IDE = new Element("IDE");  
35.         IDE.setText("eclipse");  
36.         lan.addContent(IDE);  
37.         rss.addContent(lan);  
38.           
39.         //添加元素  
40.         Element lan2 = new Element("lan");  
41.         lan2.setAttribute("id","1");  
42.         Element name2 = new Element("name");  
43.         name2.setText("C#");  
44.         lan.addContent(name2);  
45.           
46.         Element IDE2 = new Element("IDE");  
47.         IDE2.setText("Visual Studio");  
48.         lan2.addContent(IDE2);  
49.         rss.addContent(lan2);  
50.   
51.           
52.         //格式   换行、编码  
53.         Format format = Format.getCompactFormat();  
54.         format.setIndent("");    
55.         format.setEncoding("GBK");  
56.           
57.         //4.创建XMLOutputter的对象  
58.         XMLOutputter outputer = new XMLOutputter(format);  
59.         try {  
60.               
61.             //5.利用outputer将document对象转换成xml文档  
62.             outputer.output(document, new FileOutputStream(new File("Booknews.xml")));  
63.                   
64.                               
65.             } catch (FileNotFoundException e) {  
66.                 e.printStackTrace();  
67.             } catch (IOException e) {  
68.                 e.printStackTrace();  
69.             }  
70.         }  
71. }  

           第四种：SAX的全称是Simple APIs for XML，也即XML简单应用程序接口。与DOM不同，SAX提供的访问模式是一种顺序模式，这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时，会触发一系列事件，并激活相应的事件处理函数，应用程序通过这些事件处理函数实现对XML文档的访问，因而SAX接口也被称作事件驱动接口。