XML基礎+Java解析XML +幾種解析方式的性能比較


XML基礎+Java解析XML

一:XML基礎

XML是什么:

可擴展的標記語言

XML能干什么:

描述數據、存儲數據、傳輸(交換)數據。

XML與HTML區別:

目的不一樣

XML 被設計用來描述數據,其焦點是數據的內容。

HTML 被設計用來展示數據,其焦點是數據的外觀。

HTML可以不關閉標簽(即標簽可以不成對出現),但XML必須關閉標簽(即標簽必須成對出現)。

HTML中的標簽標識文本如何展示,而XML中的標簽標識文本是什么含義(什么類型的文本)。

XML文檔節點類型

u     文檔(document)

u     元素(element)

u     屬性(attribute)

u     文本(PCDATA--parsed character data)

u     注釋(comment)

u     DOCTYPE :主要驗證文檔內容的正確性

u     實體(ENTITIES)

u     CDATA(character data)

XML語法

1、聲明:<?xmlversion="1.0" encoding="UTF-8"?>

2、根節點:必須有一個根節點

3、標簽:標簽必須有結束且區分大小寫,標簽必須順序嵌套

4、屬性:必須引號引起值

5、空格會被保留,HTML空格最多保留一個

6、命名規則:命名必須見名知意

     a)名字可包含字母、數字以及其他的字符 

     b)名字不能以數字或者標點符號開始

     c)名字不能以字符“xml”(或者XML、Xml)開始

7、名字不能包含空格

8、 不應在 XML 元素名稱中使用 ":" ,這是由於它用於命名空間(namespaces)的保留字。

9、標簽優先於屬性。

10、XML 命名空間可提供避免元素命名沖突的方法。

11、CDATA:字符數據,<![CDATA[字符數據]]> ,字符數據不進行轉義

12、實體:&實體;

Xml約束

XML DTD 約束

DTD(DocType Definition 文檔類型定義)的作用是定義 XML 文檔的合法構建模塊。

它使用一系列的合法元素來定義文檔結構。用於約定XML格式。

1、DTD引用方式
  1、內部 <!DOCTYPE 根元素 [元素聲明]>

例如:

<?xml version="1.0"encoding="UTF-8" standalone="yes"?>

<!DOCTYPE 書架 [

<!ELEMENT 書架 (書+)>

<!ELEMENT 書 (書名,作者,售價)>

<!ELEMENT 書名 (#PCDATA)>

<!ELEMENT 作者 (#PCDATA)>

<!ELEMENT 售價 (#PCDATA)>

]>

<書架>

<書>

        <書名>Java就業培訓教程</書名>

        <作者>張孝祥</作者>

        <售價>39.00元</售價>

</書>

...

</書架>

  2、外部私有的 SYSTEM   一般是我們自己定義的,可能只是一個公司內部使用

<!DOCTYPE 根元素 SYSTEM "dtd文件位置">

例如:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE 書架 SYSTEM "book.dtd">

<書架>

   <書>

      <書名>java編程思想</書名>

      <作者>Brnee</作者>

      <售價>80</售價>

   </書>

</書架>

  3、外部公有的  PUBLIC   一般是一些標准,可能非常多的人用

 <!DOCTYPE 根元素 PUBLIC "命名空間""dtd文件位置">

首先根據“命名空間”去問環境要相應的dtd文件,如果有,直接提供,如果沒有再根據dtd文件位置找。

 

      例如:<!DOCTYPE web-app PUBLIC

               "-//SunMicrosystems, Inc.//DTD Web Application 2.3//EN"

               "http://java.sun.com/dtd/web-app_2_3.dtd">

2、例子:
<?xml version="1.0"?>
<!DOCTYPE note [
  <!ELEMENT note (to,from,heading,body)>
  <!ELEMENT to      (#PCDATA)>
  <!ELEMENT from    (#PCDATA)>
  <!ELEMENT heading (#PCDATA)>
  <!ELEMENT body    (#PCDATA)>
]>
<note>
  <to>Tove</to>
  <from>Jani</from>
  <heading>Reminder</heading>
  <body>Don't forget me this weekend</body>
</note>
3、參考文檔:

點擊打開鏈接

XML Schema 約束

XML Schema 是基於 XML 的 DTD 替代者。XML Schema 描述 XML 文檔的結構。XML Schema 語言也稱作 XML Schema 定義(XML Schema Definition,XSD)。

DTD不是通過XML語法定義文檔結構, 不能定義數據類型和限制Schema通過XML語法定義文檔結構,可以定義數據類型和限制

約定XML格式

  • 定義可出現在文檔中的元素
  • 定義可出現在文檔中的屬性
  • 定義哪個元素是子元素
  • 定義子元素的次序
  • 定義子元素的數目
  • 定義元素是否為空,或者是否可包含文本
  • 定義元素和屬性的數據類型
  • 定義元素和屬性的默認值以及固定值
1、為何使用Schema

XML Schema 是 DTD 的繼任者

  • XML Schema 可針對未來的需求進行擴展
  • XML Schema 更完善,功能更強大
  • XML Schema 基於 XML 編寫
  • XML Schema 支持數據類型和限制
  • XML Schema 支持命名空間
2、Schema引用方式

<users xmlns="命名空間"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="命名空間 Schema位置">

如何找Schema,和DTD一樣,首先根據命名空間問環境要,找不到再根據Schema位置找。

3、例子:

 

[html] view plain  copy
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  
  3.             <!--xs="http://www.w3.org/2001/XMLSchema" 聲名了w3c的名稱空間,方便下面調用 -->    
  4.               
  5.              targetNamespace="http://www.zhong.cn"  
  6.                       elementFormDefault="qualified">      
  7. <!--  
  8.     schema 是根元素  
  9.       
  10.     xmlns:xs="http://www.w3.org/2001/XMLSchema"                     
  11.     指明了在schema中使用的元素和數據種類來自http://www.w3.org/2001/XMLSchema名稱空間(namespace)。  
  12.     它也指定了來自"http://www.w3.org/2001/XMLSchema"名稱空間(namespace)的元素和數據種類必須帶前綴“xs:”    
  13.       
  14.     targetNamespace="http://www.zhong.cn"(將全部元素綁定給這個名稱空間)  
  15.     暗示了由這份schema(shiporder, orderperson, shipto, ....)定義的元素來自"http://www.zhong.com"名稱空間  
  16.       
  17.     xmlns="http://www.w3schools.com"   
  18.     指明了默認名稱空間(namespace)是http://www.w3schools.com.   
  19.       
  20.     elementFormDefault="qualified" (“unqualified”)將根節點綁定到名稱空間  
  21.         將所有元素綁定到名稱空間  
  22.   -->                    
  23.                         
  24.     <!--xs:element  指的是element這個元素來自於xs名稱空間 -->                   
  25.     <xs:element name="shiporder"<!-- 定義一個元素 shiporder -->  
  26.      <xs:complexType>             <!-- 類型是:復合類型(里面包含元素或者屬性) -->  
  27.       <xs:sequence>                   <!-- 元素要有順序 -->  
  28.        <xs:element name="orderperson" type="xs:string"/>          <!-- 定義一個元素 orderperson 類型為:字符串 -->  
  29.        <xs:element name="shipto" minOccurs="1" maxOccurs="1"<!-- 定義一個元素 shipto 最少出現1次,最多出現1次  -->  
  30.         <xs:complexType<!-- shipto元素也是復合類型 -->  
  31.          <xs:sequence>   <!-- 元素要有順序 -->  
  32.           <xs:element name="name" type="xs:string"/> <!-- 在shipto元素中定義一個元素 name 類型為:字符串 -->  
  33.           <xs:element name="address" type="xs:string"/>  
  34.           <xs:element name="city" type="xs:string"/>  
  35.           <xs:element name="country" type="xs:string"/>  
  36.          </xs:sequence>  
  37.         </xs:complexType>  
  38.        </xs:element>  
  39.        <xs:element name="item" maxOccurs="unbounded">  <!-- 在shiporder元素中定義一個元素 item 出現次數可以無限次 -->  
  40.         <xs:complexType>  
  41.          <xs:sequence>  
  42.           <xs:element name="title" type="xs:string"/>  
  43.           <xs:element name="note" type="xs:string" minOccurs="0"/>  
  44.           <xs:element name="quantity" type="xs:positiveInteger"/>  
  45.           <xs:element name="price" type="xs:decimal"/>  
  46.          </xs:sequence>  
  47.         </xs:complexType>  
  48.        </xs:element>  
  49.       </xs:sequence>  
  50.       <xs:attribute name="orderid" type="xs:string" use="required"/>  
  51.      </xs:complexType>  
  52.     </xs:element>   
  53. </xs:schema>  

 

 

4、參考文檔:

點擊打開鏈接

二、Java解析XML

l XML解析方式分為兩種:dom和sax

•    dom:(Document Object Model, 即文檔對象模型) 是 W3C 組織推薦的處理 XML 的一種方式。

•    sax: (Simple API for XML) 不是官方標准,但它是XML 社區事實上的標准,幾乎所有的 XML 解析器都支持它。

l XML解析器

•    Crimson、Xerces 、Aelfred2

l XML解析開發包

•    Jaxp、Jdom、dom4j

1、DOM解析

DOM是用與平台和語言無關的方式表示XML文檔的官方W3C標准。DOM是以層次結構組織的節點或信息片斷的集合。這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構,然后才能做任何工作。由於它是基於信息層次的,因而DOM被認為是基於樹或基於對象的。

DOM解析器把XML文檔轉化為一個包含其內容的樹,並可以對樹進行遍歷。

DOM是拉模型,在遍歷文檔時,會把感興趣的部分從讀取器中拉出,不需要引發事件,允許我們選擇性地處理節點。這大大提高了靈活性,以及整體效率。

JAXP(DOM解析)

l  JAXP 開發包是J2SE的一部分,它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包組成

l  在 javax.xml.parsers 包中,定義了幾個工廠類,程序員調用這些工廠類,可以得到對xml文檔進行解析的 DOM 或 SAX的解析器對象。

1、java代碼顯例:

 

[html] view plain  copy
 
  1. <?xml version="1.0" encoding="UTF-8" standalone="no"?><exam>  
  2.     <student examid="111" idcard="123">  
  3.         <name>張三</name>  
  4.         <location>廣州</location>  
  5.         <grade>100</grade>  
  6.     </student>  
  7.     <student examid="444" idcard="333">  
  8.         <name>李四</name>  
  9.         <location>大連</location>  
  10.         <grade>97</grade>  
  11.     </student>  
  12.       
  13.     <student examid="1111111" idcard="22222">  
  14.         <name>小毛</name>  
  15.         <location>廣州</location>  
  16.         <grade>23.0</grade>  
  17.     </student>  
  18.         <student examid="199" idcard="300">  
  19.         <grade>80.0</grade>  
  20.         <location>廣州</location>  
  21.         <name>鍾源茂</name>  
  22. </student>  
  23. </exam>  
[java] view plain  copy
 
  1. package com.zhong.xml.parse;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.File;  
  5. import java.io.IOException;  
  6. import java.io.InputStreamReader;  
  7.   
  8. import javax.xml.parsers.DocumentBuilder;  
  9. import javax.xml.parsers.DocumentBuilderFactory;  
  10. import javax.xml.parsers.ParserConfigurationException;  
  11. import javax.xml.transform.Transformer;  
  12. import javax.xml.transform.TransformerException;  
  13. import javax.xml.transform.TransformerFactory;  
  14. import javax.xml.transform.dom.DOMSource;  
  15. import javax.xml.transform.stream.StreamResult;  
  16.   
  17. import org.w3c.dom.Document;  
  18. import org.w3c.dom.Element;  
  19. import org.w3c.dom.Node;  
  20. import org.w3c.dom.NodeList;  
  21. import org.xml.sax.SAXException;  
  22.   
  23. public class JaxpDemo {  
  24.   
  25.     /** 
  26.      * @param args 
  27.      * @throws IOException  
  28.      */  
  29.     public static void main(String[] args) throws Exception {  
  30.   
  31.           
  32.         System.out.print("添加用戶:(a)  ");  
  33.         System.out.print("刪除用戶:(b)  ");  
  34.         System.out.println("查詢成績:(c)");  
  35.         System.out.print("請輸入操作類型:");  
  36.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
  37.         String type = br.readLine();  
  38.           
  39.         if("a".equals(type)){  
  40.               
  41.             //添加用戶  
  42.             Student student = new Student();  
  43.             System.out.print("請輸入學生姓名:");  
  44.             String name = br.readLine();  
  45.             student.setName(name);  
  46.             System.out.print("請輸入學生准考證號:");  
  47.             String examid = br.readLine();  
  48.             student.setExamid(examid);  
  49.             System.out.print("請輸入學生身份證號:");  
  50.             String idcart = br.readLine();  
  51.             student.setIdcart(idcart);  
  52.             System.out.print("請輸入學生所在地:");  
  53.             String location = br.readLine();  
  54.             student.setLocation(location);  
  55.             System.out.print("請輸入學生成績:");  
  56.             String grade = br.readLine();  
  57.             student.setGrade(grade);  
  58.               
  59.             add(student);  
  60.             System.out.println("------添加數據成功------");  
  61.         }else if("b".equals(type)){  
  62.             //刪除用戶  
  63.             System.out.print("請輸入刪除的學生姓名:");  
  64.             String name = br.readLine();  
  65.             delete(name);  
  66.             System.out.println("------已成功刪除學生信息------");  
  67.               
  68.         }else if("c".equals(type)){  
  69.             //查詢成績  
  70.             System.out.print("請輸入查詢的學生准考證號:");  
  71.             String examid = br.readLine();  
  72.             Student student = find(examid);  
  73.             System.out.println("您查詢的學生信息為:");  
  74.             System.out.println(student);  
  75.               
  76.         }else{  
  77.             System.out.println("對不起,您的操作有誤!!");  
  78.         }  
  79.     }  
  80.   
  81.     private static Student find(String examid) throws Exception {  
  82.   
  83.         Document document = getDocument();  
  84.         NodeList list = document.getElementsByTagName("student");  
  85.         for(int i=0;i<list.getLength();i++){  
  86.             Element element = (Element) list.item(i);  
  87.             String value = element.getAttribute("examid");  
  88.             if(examid.equals(value)){  
  89.                 Student student = new Student();  
  90.                 student.setExamid(examid);  
  91.                 student.setIdcart(element.getAttribute("idcart"));  
  92.                 student.setName(element.getElementsByTagName("name").item(0).getTextContent());  
  93.                 student.setLocation(element.getElementsByTagName("location").item(0).getTextContent());  
  94.                 student.setGrade(element.getElementsByTagName("grade").item(0).getTextContent());  
  95.                 return student;  
  96.             }  
  97.         }  
  98.         return null;  
  99.     }  
  100.   
  101.     private static void delete(String name) throws ParserConfigurationException, SAXException, IOException, TransformerException {  
  102.         Document document = getDocument();  
  103.         NodeList list = document.getElementsByTagName("name");  
  104.         for(int i=0;i<list.getLength();i++){  
  105.             Node node = list.item(i);  
  106.             if(node.getTextContent().equals(name)){  
  107.                 node.getParentNode().getParentNode().removeChild(node.getParentNode());  
  108.             }  
  109.         }  
  110.         writeXml(document);  
  111.     }  
  112.   
  113.     private static void add(Student student) throws Exception {  
  114.           
  115.         Document document = getDocument();  
  116.           
  117.         Element student_node = document.createElement("student");  
  118.         student_node.setAttribute("idcart", student.getIdcart());  
  119.         student_node.setAttribute("examid", student.getExamid());  
  120.           
  121.         Node name = document.createElement("name");  
  122.         name.setTextContent(student.getName());  
  123.         Node location = document.createElement("location");  
  124.         location.setTextContent(student.getLocation());  
  125.         Node grade = document.createElement("grade");  
  126.         grade.setTextContent(student.getGrade());  
  127.           
  128.         student_node.appendChild(name);  
  129.         student_node.appendChild(location);  
  130.         student_node.appendChild(grade);  
  131.           
  132.         Element root = document.getDocumentElement();  
  133.         root.appendChild(student_node);  
  134.           
  135.         writeXml(document);  
  136.     }  
  137.   
  138.     //將內存中的數據保存到XML文件中  
  139.     private static void writeXml(Document document) throws TransformerException {  
  140.           
  141.         DOMSource source = new DOMSource(document);  
  142.         StreamResult result = new StreamResult(new File("src/exam.xml"));  
  143.           
  144.         TransformerFactory factory = TransformerFactory.newInstance();  
  145.         Transformer trans = factory.newTransformer();  
  146.         trans.transform(source, result);  
  147.     }    
  148.   
  149.     //獲得操作xml文件的對象  
  150.     private static Document getDocument() throws ParserConfigurationException,  
  151.             SAXException, IOException {  
  152.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();//得到創建 DOM 解析器的工廠。  
  153.         DocumentBuilder builder = factory.newDocumentBuilder();//得到 DOM 解析器對象。  
  154.         Document document = builder.parse(new File("src/exam.xml")); //得到代表整個文檔的 Document 對象  
  155.         Element e = document.getDocumentElement();  
  156.         return document;  
  157.     }  
  158.   
  159. }  
  160.   
  161. class Student{  
  162.     private String name;  
  163.     private String examid;  
  164.     private String idcart;  
  165.     private String location;  
  166.     private String grade;  
  167.     public String getName() {  
  168.         return name;  
  169.     }  
  170.     public void setName(String name) {  
  171.         this.name = name;  
  172.     }  
  173.     public String getExamid() {  
  174.         return examid;  
  175.     }  
  176.     public void setExamid(String examid) {  
  177.         this.examid = examid;  
  178.     }  
  179.     public String getIdcart() {  
  180.         return idcart;  
  181.     }  
  182.     public void setIdcart(String idcart) {  
  183.         this.idcart = idcart;  
  184.     }  
  185.     public String getLocation() {  
  186.         return location;  
  187.     }  
  188.     public void setLocation(String location) {  
  189.         this.location = location;  
  190.     }  
  191.     public String getGrade() {  
  192.         return grade;  
  193.     }  
  194.     public void setGrade(String grade) {  
  195.         this.grade = grade;  
  196.     }  
  197.       
  198.     public String toString(){  
  199.         return "姓名:" + name + ",身份證號:" + idcart + ",准考證號:" + examid + ",地區:" + location + ",成績:" + grade;  
  200.     }  
  201. }  



 

2、DOM的基本對象有5個:Document,Node,NodeList,Element和Attr。
 2.1、Document對象

代表了整個XML的文檔,所有其它的Node,都以一定的順序包含在Document對象之內,排列成一個樹形的結構,程序員可以通過遍歷這顆樹來得到XML文檔的所有的內容,這也是對XML文檔操作的起點。我們總是先通過解析XML源文件而得到一個Document對象,然后再來執行后續的操作。此外,Document還包含了創建其它節點的方法,比如createAttribut()用來創建一個Attr對象。它所包含的主要的方法有:

createAttribute(String):用給定的屬性名創建一個Attr對象,並可在其后使用setAttributeNode方法來放置在某一個Element對象上面。

createElement(String):用給定的標簽名創建一個Element對象,代表XML文檔中的一個標簽,然后就可以在這個Element對象上添加屬性或進行其它的操作。

createTextNode(String):用給定的字符串創建一個Text對象,Text對象代表了標簽或者屬性中所包含的純文本字符串。如果在一個標簽內沒有其它的標簽,那么標簽內的文本所代表的Text對象是這個Element對象的唯一子對象。

getElementsByTagName(String):返回一個NodeList對象,它包含了所有給定標簽名字的標簽。

getDocumentElement():返回一個代表這個DOM樹的根節點的Element對象,也就是代表XML文檔根元素的那個對象。

 2.2、Node對象

是DOM結構中最為基本的對象,代表了文檔樹中的一個抽象的節點。在實際使用的時候,很少會真正的用到Node這個對象,而是用到諸如Element、Attr、Text等Node對象的子對象來操作文檔。Node對象為這些對象提供了一個抽象的、公共的根。雖然在Node對象中定義了對其子節點進行存取的方法,但是有一些Node子對象,比如Text對象,它並不存在子節點,這一點是要注意的。Node對象所包含的主要的方法有:

appendChild(org.w3c.dom.Node):為這個節點添加一個子節點,並放在所有子節點的最后,如果這個子節點已經存在,則先把它刪掉再添加進去。

getFirstChild():如果節點存在子節點,則返回第一個子節點,對等的,還有getLastChild()方法返回最后一個子節點。

getNextSibling():返回在DOM樹中這個節點的下一個兄弟節點,對等的,還有getPreviousSibling()方法返回其前一個兄弟節點。

getNodeName():根據節點的類型返回節點的名稱。

getNodeType():返回節點的類型。

getNodeValue():返回節點的值。

hasChildNodes():判斷是不是存在有子節點。

hasAttributes():判斷這個節點是否存在有屬性。

getOwnerDocument():返回節點所處的Document對象。

insertBefore(org.w3c.dom.Node new,org.w3c.dom.Node ref):在給定的一個子對象前再插入一個子對象。

removeChild(org.w3c.dom.Node):刪除給定的子節點對象。

replaceChild(org.w3c.dom.Node new,org.w3c.dom.Node old):用一個新的Node對象代替給定的子節點對象。

 2.3、NodeList對象

顧名思義,就是代表了一個包含了一個或者多個Node的列表。可以簡單的把它看成一個Node的數組,我們可以通過方法來獲得列表中的元素:

getLength():返回列表的長度。

item(int):返回指定位置的Node對象。

 2.4、Element對象

代表的是XML文檔中的標簽元素,繼承於Node,亦是Node的最主要的子對象。在標簽中可以包含有屬性,因而Element對象中有存取其屬性的方法,而任何Node中定義的方法,也可以用在Element對象上面。

getElementsByTagName(String):返回一個NodeList對象,它包含了在這個標簽中其下的子孫節點中具有給定標簽名字的標簽。

getTagName():返回一個代表這個標簽名字的字符串。

getAttribute(String):返回標簽中給定屬性名稱的屬性的值。在這兒需要主要的是,應為XML文檔中允許有實體屬性出現,而這個方法對這些實體屬性並不適用。這時候需要用到getAttributeNodes()方法來得到一個Attr對象來進行進一步的操作。

getAttributeNode(String):返回一個代表給定屬性名稱的Attr對象。

 2.5、Attr對象

代表了某個標簽中的屬性。Attr繼承於Node,但是因為Attr實際上是包含在Element中的,它並不能被看作是Element的子對象,因而在DOM中Attr並不是DOM樹的一部分,所以Node中的getParentNode(),getPreviousSibling()和getNextSibling()返回的都將是null。也就是說,Attr其實是被看作包含它的Element對象的一部分,它並不作為DOM樹中單獨的一個節點出現。這一點在使用的時候要同其它的Node子對象相區別。

 

2、SAX解析

SAX是Simple API forXML的縮寫,它並不是由W3C官方所提出的標准,可以說是“民間”的事實標准。實際上,它是一種社區性質的討論產物。雖然如此,在XML中對SAX的應用絲毫不比DOM少,幾乎所有的XML解析器都會支持它。

與DOM比較而言,SAX是一種輕量型的方法。我們知道,在處理DOM的時候,我們需要讀入整個的XML文檔,然后在內存中創建DOM樹,生成DOM樹上的每個Node對象。當文檔比較小的時候,這不會造成什么問題,但是一旦文檔大起來,處理DOM就會變得相當費時費力。特別是其對於內存的需求,也將是成倍的增長,以至於在某些應用中使用DOM是一件很不划算的事(比如在applet中)。這時候,一個較好的替代解決方法就是SAX。

SAX在概念上與DOM完全不同。首先,不同於DOM的文檔驅動,它是事件驅動的,也就是說,它並不需要讀入整個文檔,而文檔的讀入過程也就是SAX的解析過程。所謂事件驅動,是指一種基於回調(callback)機制的程序運行方法。(如果你對Java新的代理事件模型比較清楚的話,就會很容易理解這種機制了)  

回調:由我們在組件中定義,而不由我們調用,由容器或框架調用

SAX是推模型,它是一種靠事件驅動的模型。當它每發現一個節點就引發一個事件,而我們需要編寫這些事件的處理程序。這樣的做法很麻煩,且不靈活。

一、StAX 解析

針對於XML的流式API(StAX),是在2004年3月的JSR 173規范中引入,這是一種針對XML的流式拉分析API。StAX是JDK 6.0提供的一種新特征。

一個推模型分析器不斷地生成事件,直到XML文檔被完全分析結束。但是,拉分析由應用程序進行調整;因此,分析事件是由應用程序生成的。這意味着,使用StaX,你可以推遲分析-在分析時跳過元素並且分析多個文檔。在使用DOM API的時候,你必須把整個的XML文檔分析成一棵DOM結構,這樣也就降低了分析效率。而借助於StAX,在分析XML文檔時生成分析事件。

二、JDOM

JDOM的目的是成為Java特定文檔模型,它簡化與XML的交互並且比使用DOM實現更快。由於是第一個Java特定模型,JDOM一直得到大力推廣和 促進。正在考慮通過“Java規范請求JSR-102”將它最終用作“Java標准擴展”。從2000年初就已經開始了JDOM開發。

JDOM與DOM主要有兩方面不同。首先,JDOM僅使用具體類而不使用接口。這在某些方面簡化了API,但是也限制了靈活性。第二,API大量使用了Collections類,簡化了那些已經熟悉這些類的Java開發者的使用。 

JDOM文檔聲明其目的是“使用20%(或更少)的精力解決80%(或更多)Java/XML問題”(根據學習曲線假定為20%)。JDOM對於大多數Java/XML應用程序來說當然是有用的,並且大多數開發者發現API比DOM容易理解得多。JDOM還包括對程序行為的相當廣泛檢查以防止用戶做任何在XML中無意義的事。然而,它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情況下的錯誤)。這也許是比學習DOM或JDOM接口 都更有意義的工作。 
JDOM自身不包含解析器。它通常使用SAX2解析器來解析和驗證輸入XML文檔(盡管它還可以將以前構造的DOM表示作為輸入)。它包含一些轉換器以將 JDOM表示輸出成SAX2事件流、DOM模型或XML文本文檔。JDOM是在Apache許可證變體下發布的開放源碼。 

三、DOM4J

http://dom4j.sourceforge.NET 

雖然DOM4J代表了完全獨立的開發結果,但最初,它是JDOM的一種智能分支。它合並了許多超出基本XML文檔表示的功能,包括集成的XPath支持、 XML Schema支持以及用於大文檔或流化文檔的基於事件的處理。它還提供了構建文檔表示的選項,它通過DOM4J API和標准DOM接口具有並行訪問功能。從2000下半年開始,它就一直處於開發之中。 

為支持所有這些功能,DOM4J使用接口和抽象基本類方法。DOM4J大量使用了API中的Collections類,但是在許多情況下,它還提供一些替 代方法以允許更好的性能或更直接的編碼方法。直接好處是,雖然DOM4J付出了更復雜的API的代價,但是它提供了比JDOM大得多的靈活性。 

在添加靈活性、XPath集成和對大文檔處理的目標時,DOM4J的目標與JDOM是一樣的:針對Java開發者的易用性和直觀操作。它還致力於成為比 JDOM更完整的解決方案,實現在本質上處理所有Java/XML問題的目標。在完成該目標時,它比JDOM更少強調防止不正確的應用程序行為。

DOM4J是一個非常非常優秀的JavaXML API,具有性能優異、功能強大和極端易用使用的特點,同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的Java軟件都在使用DOM4J來讀寫XML,特別值得一提的是連Sun的JAXM也在用DOM4J. 

代碼顯例:

用dom4j解析xml要導入dom4j.jar

下載:點擊打開鏈接

 

[html] view plain  copy
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <exam>  
  3.     <student examid="111" idcard="123">  
  4.         <name>張三</name>  
  5.         <location>廣州</location>  
  6.         <grade>100</grade>  
  7.     </student>  
  8.     <student examid="444" idcard="333">  
  9.         <name>李四</name>  
  10.         <location>大連</location>  
  11.         <grade>97</grade>  
  12.     </student>  
  13.       
  14.     <student examid="1111111" idcard="22222">  
  15.         <name>小毛</name>  
  16.         <location>廣州</location>  
  17.         <grade>23.0</grade>  
  18.     </student>  
  19.         <student examid="199" idcard="300">  
  20.         <grade>80.0</grade>  
  21.         <location>廣州</location>  
  22.         <name>鍾源茂</name>  
  23. </student>  
  24. </exam>  

 

[java] view plain  copy
 
  1. package cn.zhong.dao;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.File;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.InputStreamReader;  
  8. import java.util.Iterator;  
  9. import java.util.List;  
  10.   
  11. import javax.xml.parsers.ParserConfigurationException;  
  12.   
  13. import org.dom4j.Document;  
  14. import org.dom4j.DocumentException;  
  15. import org.dom4j.Element;  
  16. import org.dom4j.io.SAXReader;  
  17. import org.dom4j.io.XMLWriter;  
  18. import org.junit.Test;  
  19. import org.xml.sax.SAXException;  
  20.   
  21. public class Dom4j_demo {  
  22.   
  23.     public static void main(String[] args) throws IOException,  
  24.             ParserConfigurationException, SAXException, DocumentException {  
  25.         System.out.println("添加學生 (a) 查找學生 (b) 刪除學生 (c)");  
  26.         System.out.print("請輸入想要的操作:");  
  27.   
  28.         BufferedReader buf = new BufferedReader(  
  29.                 new InputStreamReader(System.in));  
  30.         String value = buf.readLine();  
  31.         if (value.equalsIgnoreCase("a")) {  
  32.             try {  
  33.                 System.out.print("請輸入學生姓名:");  
  34.                 String name = buf.readLine();  
  35.   
  36.                 System.out.print("請輸入學生准考證號:");  
  37.                 String examid = buf.readLine();  
  38.   
  39.                 System.out.print("請輸入學生身份證號:");  
  40.                 String idcard = buf.readLine();  
  41.   
  42.                 System.out.print("請輸入學生所在地:");  
  43.                 String location = buf.readLine();  
  44.   
  45.                 System.out.print("請輸入學生成績:");  
  46.                 String grade = buf.readLine();  
  47.   
  48.                 Student student = new Student();  
  49.                 student.setExamid(examid);  
  50.                 student.setGrade(Double.parseDouble(grade));  
  51.                 student.setIdcard(idcard);  
  52.                 student.setLocation(location);  
  53.                 student.setName(name);  
  54.   
  55.                 // StudentDaoByJaxp sd = new StudentDaoByJaxp();  
  56.                 // sd.appUser(student);  
  57.                 Dom4j_demo dj = new Dom4j_demo();  
  58.                 dj.appUser(student);  
  59.   
  60.                 System.out.println("恭喜你,添加成功");  
  61.                 dj.appUser(student);  
  62.   
  63.             } catch (IOException e) {  
  64.                 System.out.println("輸入有誤,添加失敗,請重新輸入");  
  65.             }  
  66.   
  67.         } else if (value.equalsIgnoreCase("b")) {  
  68.             System.out.print("請輸入想查找的學生准考證號:");  
  69.             String examid = buf.readLine();  
  70.             Dom4j_demo dj = new Dom4j_demo();  
  71.             Student s = dj.selectUser(examid);  
  72.   
  73.             if (s != null) {  
  74.                 System.out.println("你要查找的學生的信息如下:");  
  75.                 System.out.println("姓名:" + s.getName());  
  76.                 System.out.println("准考證號:" + s.getExamid());  
  77.                 System.out.println("身份證號:" + s.getIdcard());  
  78.                 System.out.println("所在地:" + s.getLocation());  
  79.                 System.out.println("成績:" + s.getGrade());  
  80.             } else {  
  81.                 System.out.println("你所查找的學生不存在");  
  82.             }  
  83.   
  84.         } else if (value.equalsIgnoreCase("c")) {  
  85.   
  86.             try {  
  87.                 System.out.print("請輸入想刪除的學生姓名:");  
  88.                 String name = buf.readLine();  
  89.                 Dom4j_demo dj = new Dom4j_demo();  
  90.                 dj.deleteUser(name);  
  91.   
  92.                 System.out.println("恭喜你,刪除成功");  
  93.             } catch (Exception e) {  
  94.                 System.out.println("刪除失敗,請重新來過");  
  95.             }  
  96.         } else {  
  97.             System.out.println("請輸入正確的指令");  
  98.         }  
  99.   
  100.     }  
  101.   
  102.     // 增加學生  
  103.     @Test  
  104.     public void appUser(Student student) {  
  105.         try {  
  106.             Document document = getDocument();  
  107.             Element rootNode = document.getRootElement();  
  108.   
  109.             Element sNode = rootNode.addElement("student");  
  110.             sNode.addAttribute("examid", student.getExamid());  
  111.             sNode.addAttribute("idcard", student.getIdcard());  
  112.   
  113.             sNode.addElement("name").setText(student.getName());  
  114.             sNode.addElement("location").setText(student.getLocation());  
  115.             sNode.addElement("grade").setText(student.getGrade() + "");  
  116.   
  117.             write2Xml(document);  
  118.   
  119.         } catch (Exception e) {  
  120.   
  121.             throw new RuntimeException();  
  122.         }  
  123.     }  
  124.   
  125.     // 查找學生  
  126.     @Test  
  127.     public Student selectUser(String examid) throws DocumentException {  
  128.         Document document = getDocument();  
  129.   
  130.         Element e = (Element) document.selectSingleNode("//student[@examid='"  
  131.                 + examid + "']");  
  132.         if (e != null) {  
  133.             Student s = new Student();  
  134.             s.setExamid(e.attributeValue("examid"));  
  135.             s.setIdcard(e.attributeValue("idcard"));  
  136.   
  137.             s.setName(e.element("name").getText());  
  138.             s.setLocation(e.element("location").getText());  
  139.             s.setGrade(Double.parseDouble(e.element("grade").getText()));  
  140.   
  141.             return s;  
  142.         } else {  
  143.             return null;  
  144.         }  
  145.   
  146.         /* 
  147.          * // List list=document.getRootElement().selectNodes("student"); List 
  148.          * list=document.selectNodes("//student");//使用xpath Iterator 
  149.          * it=list.iterator(); while(it.hasNext()) { Element e=(Element) 
  150.          * it.next(); String value=e.attributeValue("examid"); 
  151.          * if(value.equals(examid)) { Student s = new Student(); 
  152.          * s.setExamid(e.attributeValue("examid")); 
  153.          * s.setIdcard(e.attributeValue("idcard")); 
  154.          *  
  155.          * s.setName(e.element("name").getText()); 
  156.          * s.setLocation(e.element("location").getText()); 
  157.          * s.setGrade(Double.parseDouble(e.element("grade").getText())); 
  158.          *  
  159.          * return s; } } 
  160.          *  
  161.          * return null; 
  162.          */  
  163.     }  
  164.   
  165.     // 刪除學生  
  166.     @Test  
  167.     public void deleteUser(String name) {  
  168.         try {  
  169.             Document document = getDocument();  
  170.             List list = document.selectNodes("//name");  
  171.             Iterator it = list.iterator();  
  172.             // Element nameNode1=(Element) it.next();  
  173.             // System.out.println(nameNode1.getText());  
  174.             while (it.hasNext()) {  
  175.                 Element nameNode = (Element) it.next();  
  176.                 String value = nameNode.getText();  
  177.                 if (value.equals(name)) {  
  178.                     // System.out.println(nameNode.getText());  
  179.                     nameNode.getParent().getParent()  
  180.                             .remove(nameNode.getParent());  
  181.                     write2Xml(document);  
  182.                     return;  
  183.                 }  
  184.             }  
  185.             throw new RuntimeException("刪除失敗");  
  186.   
  187.         } catch (Exception e) {  
  188.             throw new RuntimeException(e);  
  189.         }  
  190.     }  
  191.   
  192.     // 獲得操作xml的對象 獲得document對象     
  193.     public Document getDocument() throws DocumentException {  
  194.         SAXReader reader = new SAXReader();  
  195.         Document document = reader.read(new File("src//student.xml"));  
  196.   
  197.         /* 
  198.          * 2.解析XML形式的文本,得到document對象.               
  199.          * String text ="<members></members>"; 
  200.          * Document document =DocumentHelper.parseText(text); 
  201.          *  
  202.          * 3.主動創建document對象.               
  203.          * Document document =DocumentHelper.createDocument(); 
  204.          * //創建根節點 Element root =document.addElement("members"); 
  205.          */  
  206.   
  207.         return document;  
  208.     }  
  209.   
  210.     // 將內存中的內容寫入xml  
  211.     public void write2Xml(Document document) throws IOException {  
  212.         //1.文檔中全為英文,不設置編碼,直接寫入的形式  
  213.         XMLWriter writer = new XMLWriter(new FileOutputStream("src//student.xml"));  
  214.         writer.write(document);  
  215.         writer.close();  
  216.           
  217. //      2.文檔中含有中文,設置編碼格式寫入的形式  
  218. //      OutputFormat format = OutputFormat.createPrettyPrint(); // 指定XML編碼                     
  219. //       format.setEncoding("GBK");         
  220. //       XMLWriter writer = new XMLWriter(newFileWriter("output.xml"),format);  
  221. //       writer.write(document); writer.close();  
  222.   
  223.     }  
  224. }  
  225.   
  226. class Student {  
  227.     /* 
  228.      * <student examid="111" idcard="123" > <name>張三</name> 
  229.      * <location>廣州</location> <grade>100</grade> </student> 
  230.      */  
  231.   
  232.     private String examid;  
  233.     private String idcard;  
  234.     private String name;  
  235.     private String location;  
  236.     private double grade;  
  237.   
  238.     public String getExamid() {  
  239.         return examid;  
  240.     }  
  241.   
  242.     public void setExamid(String examid) {  
  243.         this.examid = examid;  
  244.     }  
  245.   
  246.     public String getIdcard() {  
  247.         return idcard;  
  248.     }  
  249.   
  250.     public void setIdcard(String idcard) {  
  251.         this.idcard = idcard;  
  252.     }  
  253.   
  254.     public String getName() {  
  255.         return name;  
  256.     }  
  257.   
  258.     public void setName(String name) {  
  259.         this.name = name;  
  260.     }  
  261.   
  262.     public String getLocation() {  
  263.         return location;  
  264.     }  
  265.   
  266.     public void setLocation(String location) {  
  267.         this.location = location;  
  268.     }  
  269.   
  270.     public double getGrade() {  
  271.         return grade;  
  272.     }  
  273.   
  274.     public void setGrade(double grade) {  
  275.         this.grade = grade;  
  276.     }  
  277. }  



 

3、DMO與SAX的區別

一、DOM:拉模型,把整個文檔加載到內存中
        優點:整個文檔樹在內存中,便於操作;支持刪除、修改、重新排列等多種功能;
        缺點:將整個文檔調入內存(包括無用的節點),浪費時間和空間;
        使用場合:一旦解析了文檔還需多次訪問這些數據;硬件資源充足(內存、CPU)

二、SAX:推模型,事件驅動編程,基於回調SAX ,事件驅動。當解析器發現元素開始、元素結束、文本、文檔的開始或結束等時,發送事件,程序員編寫響應這些事件的代碼,保存數據。
    優點:不用事先調入整個文檔,占用資源少;

缺點:不是持久的;事件過后,若沒保存數據,那么數據就丟了;無狀態性;從事件中只能得到文本,但不知該文本屬於哪個元素;

使用場合:數據量較大的XML文檔,占用內存高,機器內存少,無法一次加載XML到內存;只需XML文檔的少量內容,很少回頭訪問;
                          

三、JDOM:為減少DOM、SAX的編碼量,出現了JDOM;
        優點:20-80原則,極大減少了代碼量,提供常用API減少重復勞動
         使用場合:要實現的功能簡單,如解析、創建等Java程序

 但在底層,JDOM還是使用SAX(最常用)、DOM

性能比較 

1)DOM4J性能最好,連Sun的JAXM也在用DOM4J.目前許多開源項目中大量采用DOM4J,例如大名鼎鼎的hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性,那就采用DOM4J. 

2)JDOM和DOM在性能測試時表現不佳,在測試10M文檔時內存溢出。在小文檔情況下還值得考慮使用DOM和JDOM.雖然JDOM的開發者已經說明 他們期望在正式發行版前專注性能問題,但是從性能觀點來看,它確實沒有值得推薦之處。另外,DOM仍是一個非常好的選擇。DOM實現廣泛應用於多種編程語 言。它還是許多其它與XML相關的標准的基礎,因為它正式獲得W3C推薦(與基於非標准的Java模型相對),所以在某些類型的項目中可能也需要它(如在 JavaScript中使用DOM)。 

3)SAX表現較好,這要依賴於它特定的解析方式-事件驅動。一個SAX檢測即將到來的XML流,但並沒有載入到內存(當然當XML流被讀入時,會有部分文檔暫時隱藏在內存中)。 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM