java解析xml的幾種方式

 

java解析xml的幾種方式

 

DOM

DOM的全稱是Document ObjectModel，也即文檔對象模型。在應用程序中，基於DOM的XML分析器將一個XML文檔轉換成一個對象模型的集合（一般稱DOM樹），應用程序正是經過對這個對象模型的操做，來實現對XML文檔數據的操做。經過DOM接口，應用程序能夠在任什麼時候候訪問XML文檔中的任何一部分數據，所以，這種利用DOM接口的機制也被稱做隨機訪問機制。

DOM接口提供了一種經過分層對象模型來訪問XML文檔信息的方式，這些分層對象模型依據XML的文檔結構造成了一棵節點樹。不管XML文檔中所描述的是什麼類型的信息，即使是製表數據、項目列表或一個文檔，利用DOM所生成的模型都是節點樹的形式。也就是說，DOM強制使用樹模型來訪問XML文檔中的信息。因爲XML本質上就是一種分層結構，因此這種描述方法是至關有效的。

DOM樹所提供的隨機訪問方式給應用程序的開發帶來了很大的靈活性，它能夠任意地控制整個XML文檔中的內容。然而，因爲DOM分析器把整個XML文檔轉化成DOM樹放在了內存中，所以，當文檔比較大或者結構比較複雜時，對內存的需求就比較高。並且，對於結構複雜的樹的遍歷也是一項耗時的操做。因此，DOM分析器對機器性能的要求比較高，實現效率不十分理想。不過，因爲DOM分析器所採用的樹結構的思想與XML文檔的結構相吻合，同時鑑於隨機訪問所帶來的方便，所以，DOM分析器仍是有很普遍的使用價值的。

 

Java代碼  

1.  import java.io.File;  

2.    

3.  import javax.xml.parsers.DocumentBuilder;  

4.  import javax.xml.parsers.DocumentBuilderFactory;  

5.    

6.  import org.w3c.dom.Document;  

7.  import org.w3c.dom.Element;  

8.  import org.w3c.dom.NodeList;  

9.    

10. public class DomTest1  

11. {  

12.     public static void main(String[] args) throws Exception  

13.     {  

14.         // step 1: 得到dom解析器工廠（工做的做用是用於建立具體的解析器）  

15.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  

16.           

17. //      System.out.println("class name: " + dbf.getClass().getName());  

18.           

19.         // step 2:得到具體的dom解析器  

20.         DocumentBuilder db = dbf.newDocumentBuilder();  

21.           

22. //      System.out.println("class name: " + db.getClass().getName());  

23.           

24.         // step3: 解析一個xml文檔，得到Document對象（根結點）  

25.         Document document = db.parse(new File("candidate.xml"));  

26.           

27.         NodeList list = document.getElementsByTagName("PERSON");  

28.           

29.         for(int i = 0; i < list.getLength(); i++)  

30.         {  

31.             Element element = (Element)list.item(i);  

32.               

33.             String content = element.getElementsByTagName("NAME").item(0).getFirstChild().getNodeValue();  

34.               

35.             System.out.println("name:" + content);  

36.               

37.             content = element.getElementsByTagName("ADDRESS").item(0).getFirstChild().getNodeValue();  

38.               

39.             System.out.println("address:" + content);  

40.               

41.             content = element.getElementsByTagName("TEL").item(0).getFirstChild().getNodeValue();  

42.               

43.             System.out.println("tel:" + content);  

44.               

45.             content = element.getElementsByTagName("FAX").item(0).getFirstChild().getNodeValue();  

46.               

47.             System.out.println("fax:" + content);  

48.               

49.             content = element.getElementsByTagName("EMAIL").item(0).getFirstChild().getNodeValue();  

50.               

51.             System.out.println("email:" + content);  

52.               

53.             System.out.println("--------------------------------------");  

54.         }  

55.     }  

56. }  

Java代碼  

1.  import java.io.File;  

2.    

3.  import javax.xml.parsers.DocumentBuilder;  

4.  import javax.xml.parsers.DocumentBuilderFactory;  

5.    

6.  import org.w3c.dom.Attr;  

7.  import org.w3c.dom.Comment;  

8.  import org.w3c.dom.Document;  

9.  import org.w3c.dom.Element;  

10. import org.w3c.dom.NamedNodeMap;  

11. import org.w3c.dom.Node;  

12. import org.w3c.dom.NodeList;  

13.   

14. /** 

15.  * 使用遞歸解析給定的任意一個xml文檔而且將其內容輸出到命令行上 

16.  * @author zhanglong 

17.  * 

18.  */  

19. public class DomTest3  

20. {  

21.     public static void main(String[] args) throws Exception  

22.     {  

23.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  

24.         DocumentBuilder db = dbf.newDocumentBuilder();  

25.           

26.         Document doc = db.parse(new File("student.xml"));  

27.         //得到根元素結點  

28.         Element root = doc.getDocumentElement();  

29.           

30.         parseElement(root);  

31.     }  

32.       

33.     private static void parseElement(Element element)  

34.     {  

35.         String tagName = element.getNodeName();  

36.           

37.         NodeList children = element.getChildNodes();  

38.           

39.         System.out.print("<" + tagName);  

40.           

41.         //element元素的全部屬性所構成的NamedNodeMap對象，須要對其進行判斷  

42.         NamedNodeMap map = element.getAttributes();  

43.           

44.         //若是該元素存在屬性  

45.         if(null != map)  

46.         {  

47.             for(int i = 0; i < map.getLength(); i++)  

48.             {  

49.                 //得到該元素的每個屬性  

50.                 Attr attr = (Attr)map.item(i);  

51.                   

52.                 String attrName = attr.getName();  

53.                 String attrValue = attr.getValue();  

54.                   

55.                 System.out.print(" " + attrName + "=\"" + attrValue + "\"");  

56.             }  

57.         }  

58.           

59.         System.out.print(">");  

60.           

61.         for(int i = 0; i < children.getLength(); i++)  

62.         {  

63.             Node node = children.item(i);  

64.             //得到結點的類型  

65.             short nodeType = node.getNodeType();  

66.               

67.             if(nodeType == Node.ELEMENT_NODE)  

68.             {  

69.                 //是元素，繼續遞歸  

70.                 parseElement((Element)node);  

71.             }  

72.             else if(nodeType == Node.TEXT_NODE)  

73.             {  

74.                 //遞歸出口  

75.                 System.out.print(node.getNodeValue());  

76.             }  

77.             else if(nodeType == Node.COMMENT_NODE)  

78.             {  

79.                 System.out.print("<!--");  

80.                   

81.                 Comment comment = (Comment)node;  

82.                   

83.                 //註釋內容  

84.                 String data = comment.getData();  

85.                   

86.                 System.out.print(data);  

87.                   

88.                 System.out.print("-->");  

89.             }  

90.         }  

91.           

92.         System.out.print("</" + tagName + ">");  

93.     }  

94. }  

 

SAX：

SAX的全稱是Simple APIs for XML，也即XML簡單應用程序接口。與DOM不一樣，SAX提供的訪問模式是一種順序模式，這是一種快速讀寫XML數據的方式。當使用SAX分析器對XML文檔進行分析時，會觸發一系列事件，並激活相應的事件處理函數，應用程序經過這些事件處理函數實現對XML文檔的訪問，於是SAX接口也被稱做事件驅動接口。

       SAX 解析器採用了基於事件的模型，它在解析 XML 文檔的時候能夠觸發一系列的事件，當發現給定的tag的時候，它能夠激活一個回調方法，告訴該方法制定的標籤已經找到。SAX 對內存的要求一般會比較低，由於它讓開發人員本身來決定所要處理的tag。特別是當開發人員只須要處理文檔中所包含的部分數據時，SAX 這種擴展能力獲得了更好的體現。但用 SAX 解析器的時候編碼工做會比較困難，並且很難同時訪問同一個文檔中的多處不一樣數據

Java代碼  

1.  import java.io.File;  

2.    

3.  import javax.xml.parsers.SAXParser;  

4.  import javax.xml.parsers.SAXParserFactory;  

5.    

6.  import org.xml.sax.Attributes;  

7.  import org.xml.sax.SAXException;  

8.  import org.xml.sax.helpers.DefaultHandler;  

9.    

10. public class SaxTest1  

11. {  

12.     public static void main(String[] args) throws Exception  

13.     {  

14.         //step1： 得到SAX解析器工廠實例  

15.         SAXParserFactory factory = SAXParserFactory.newInstance();  

16.           

17.         //step2: 得到SAX解析器實例  

18.         SAXParser parser = factory.newSAXParser();  

19.           

20.         //step3: 開始進行解析  

21.         parser.parse(new File("student.xml"), new MyHandler());  

22.           

23.     }  

24. }  

25.   

26. class MyHandler extends DefaultHandler  

27. {  

28.     @Override  

29.     public void startDocument() throws SAXException  

30.     {  

31.         System.out.println("parse began");  

32.     }  

33.       

34.     @Override  

35.     public void endDocument() throws SAXException  

36.     {  

37.         System.out.println("parse finished");  

38.     }  

39.       

40.     @Override  

41.     public void startElement(String uri, String localName, String qName,  

42.             Attributes attributes) throws SAXException  

43.     {  

44.         System.out.println("start element");  

45.     }  

46.       

47.     @Override  

48.     public void endElement(String uri, String localName, String qName)  

49.             throws SAXException  

50.     {  

51.         System.out.println("finish element");  

52.     }  

53. }  

 

Java代碼  

1.  import java.io.File;  

2.  import java.util.Stack;  

3.    

4.  import javax.xml.parsers.SAXParser;  

5.  import javax.xml.parsers.SAXParserFactory;  

6.    

7.  import org.xml.sax.Attributes;  

8.  import org.xml.sax.SAXException;  

9.  import org.xml.sax.helpers.DefaultHandler;  

10.   

11. public class SaxTest2  

12. {  

13.     public static void main(String[] args) throws Exception  

14.     {  

15.         SAXParserFactory factory = SAXParserFactory.newInstance();  

16.           

17.         SAXParser parser = factory.newSAXParser();  

18.           

19.         parser.parse(new File("student.xml"), new MyHandler2());  

20.     }  

21. }  

22.   

23. class MyHandler2 extends DefaultHandler  

24. {  

25.     private Stack<String> stack = new Stack<String>();  

26.       

27.     private String name;  

28.       

29.     private String gender;  

30.       

31.     private String age;  

32.       

33.     @Override  

34.     public void startElement(String uri, String localName, String qName,  

35.             Attributes attributes) throws SAXException  

36.     {  

37.         stack.push(qName);  

38.           

39.         for(int i = 0; i < attributes.getLength(); i++)  

40.         {  

41.             String attrName = attributes.getQName(i);  

42.             String attrValue = attributes.getValue(i);  

43.               

44.             System.out.println(attrName + "=" + attrValue);  

45.         }  

46.     }  

47.       

48.     @Override  

49.     public void characters(char[] ch, int start, int length)  

50.             throws SAXException  

51.     {  

52.         String tag = stack.peek();  

53.           

54.         if("姓名".equals(tag))  

55.         {  

56.             name = new String(ch, start,length);  

57.         }  

58.         else if("性別".equals(tag))  

59.         {  

60.             gender = new String(ch, start, length);  

61.         }  

62.         else if("年齡".equals(tag))  

63.         {  

64.             age = new String(ch, start, length);  

65.         }  

66.     }  

67.       

68.     @Override  

69.     public void endElement(String uri, String localName, String qName)  

70.             throws SAXException  

71.     {  

72.         stack.pop(); //表示該元素已經解析完畢，須要從棧中彈出  

73.           

74.         if("學生".equals(qName))  

75.         {  

76.             System.out.println("姓名：" + name);  

77.             System.out.println("性別：" + gender);  

78.             System.out.println("年齡：" + age);  

79.               

80.             System.out.println();  

81.         }  

82.           

83.     }  

84. }  

 

JDOM:

JDOM是一個開源項目，它基於樹型結構，利用純JAVA的技術對XML文檔實現解析、生成、序列化以及多種操做。（http://jdom.org）

•JDOM 直接爲JAVA編程服務。它利用更爲強有力的JAVA語言的諸多特性（方法重載、集合概念等），把SAX和DOM的功能有效地結合起來。

•JDOM是用Java語言讀、寫、操做XML的新API函數。在直接、簡單和高效的前提下，這些API函數被最大限度的優化。

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 許可證變體下發布的開放源碼。 

 

jdom建立xml

Java代碼  

1.  import java.io.FileWriter;  

2.    

3.  import org.jdom.Attribute;  

4.  import org.jdom.Comment;  

5.  import org.jdom.Document;  

6.  import org.jdom.Element;  

7.  import org.jdom.output.Format;  

8.  import org.jdom.output.XMLOutputter;  

9.    

10. public class JDomTest1  

11. {  

12.     public static void main(String[] args) throws Exception  

13.     {  

14.         Document document = new Document();  

15.   

16.         Element root = new Element("root");  

17.   

18.         document.addContent(root);  

19.   

20.         Comment comment = new Comment("This is my comments");  

21.   

22.         root.addContent(comment);  

23.   

24.         Element e = new Element("hello");  

25.   

26.         e.setAttribute("sohu", "www.sohu.com");  

27.   

28.         root.addContent(e);  

29.   

30.         Element e2 = new Element("world");  

31.   

32.         Attribute attr = new Attribute("test", "hehe");  

33.   

34.         e2.setAttribute(attr);  

35.   

36.         e.addContent(e2);  

37.   

38.         e2.addContent(new Element("aaa").setAttribute("a", "b")  

39.                 .setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));  

40.   

41.           

42.         Format format = Format.getPrettyFormat();  

43.           

44.         format.setIndent("    ");  

45. //      format.setEncoding("gbk");  

46.           

47.         XMLOutputter out = new XMLOutputter(format);  

48.   

49.         out.output(document, new FileWriter("jdom.xml"));  

50.           

51.     }  

52. }  

 

JDOM解析xml

Java代碼  

1.  import java.io.File;  

2.  import java.io.FileOutputStream;  

3.  import java.util.List;  

4.    

5.  import org.jdom.Attribute;  

6.  import org.jdom.Document;  

7.  import org.jdom.Element;  

8.  import org.jdom.input.SAXBuilder;  

9.  import org.jdom.output.Format;  

10. import org.jdom.output.XMLOutputter;  

11.   

12. public class JDomTest2  

13. {  

14.     public static void main(String[] args) throws Exception  

15.     {  

16.         SAXBuilder builder = new SAXBuilder();  

17.           

18.         Document doc = builder.build(new File("jdom.xml"));  

19.           

20.         Element element = doc.getRootElement();  

21.           

22.         System.out.println(element.getName());  

23.           

24.         Element hello = element.getChild("hello");  

25.           

26.         System.out.println(hello.getText());  

27.           

28.         List list = hello.getAttributes();  

29.           

30.         for(int i = 0 ;i < list.size(); i++)  

31.         {  

32.             Attribute attr = (Attribute)list.get(i);  

33.               

34.             String attrName = attr.getName();  

35.             String attrValue = attr.getValue();  

36.               

37.             System.out.println(attrName + "=" + attrValue);  

38.         }  

39.           

40.         hello.removeChild("world");  

41.           

42.         XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent("    "));  

43.           

44.           

45.         out.output(doc, new FileOutputStream("jdom2.xml"));       

46.           

47.     }  

48. }  

 

 

Dom4j

官網：DOM4Jhttp://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 是一個很是很是優秀的Java XML API，具備性能優異、功能強大和極端易用使用的特色，同時它也是一個開放源代碼的軟件。現在你能夠看到愈來愈多的 Java 軟件都在使用 DOM4J 來讀寫 XML，特別值得一提的是連 Sun 的 JAXM 也在用 DOM4J。 

Java代碼  

1.  import java.io.FileOutputStream;  

2.  import java.io.FileWriter;  

3.    

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. public class Test1  

11. {  

12.     public static void main(String[] args) throws Exception  

13.     {  

14.         // 建立文檔並設置文檔的根元素節點 ：第一種方式  

15.         // Document document = DocumentHelper.createDocument();  

16.         //  

17.         // Element root = DocumentHelper.createElement("student");  

18.         //  

19.         // document.setRootElement(root);  

20.   

21.         // 建立文檔並設置文檔的根元素節點 ：第二種方式  

22.         Element root = DocumentHelper.createElement("student");  

23.         Document document = DocumentHelper.createDocument(root);  

24.   

25.         root.addAttribute("name", "zhangsan");  

26.   

27.         Element helloElement = root.addElement("hello");  

28.         Element worldElement = root.addElement("world");  

29.   

30.         helloElement.setText("hello");  

31.         worldElement.setText("world");  

32.   

33.         helloElement.addAttribute("age", "20");  

34.   

35.         XMLWriter xmlWriter = new XMLWriter();  

36.         xmlWriter.write(document);  

37.           

38.         OutputFormat format = new OutputFormat("    ", true);  

39.           

40.         XMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream("student2.xml"), format);  

41.         xmlWriter2.write(document);  

42.           

43.         XMLWriter xmlWriter3 = new XMLWriter(new FileWriter("student3.xml"), format);  

44.           

45.         xmlWriter3.write(document);  

46.         xmlWriter3.close();  

47.   

48.     }  

49. }  

 

Java代碼  

1.  import java.io.File;  

2.  import java.util.Iterator;  

3.  import java.util.List;  

4.    

5.  import javax.xml.parsers.DocumentBuilder;  

6.  import javax.xml.parsers.DocumentBuilderFactory;  

7.    

8.  import org.dom4j.Document;  

9.  import org.dom4j.Element;  

10. import org.dom4j.io.DOMReader;  

11. import org.dom4j.io.SAXReader;  

12.   

13. public class Test2  

14. {  

15.     public static void main(String[] args) throws Exception  

16.     {  

17.         SAXReader saxReader = new SAXReader();  

18.           

19.         Document doc = saxReader.read(new File("student2.xml"));  

20.           

21.         Element root = doc.getRootElement();  

22.           

23.         System.out.println("root element: " + root.getName());  

24.           

25.         List childList = root.elements();  

26.           

27.         System.out.println(childList.size());  

28.           

29.         List childList2 = root.elements("hello");  

30.           

31.         System.out.println(childList2.size());  

32.           

33.         Element first = root.element("hello");  

34.           

35.         System.out.println(first.attributeValue("age"));  

36.           

37.         for(Iterator iter = root.elementIterator(); iter.hasNext();)  

38.         {  

39.             Element e = (Element)iter.next();  

40.               

41.             System.out.println(e.attributeValue("age"));  

42.         }  

43.           

44.         System.out.println("---------------------------");  

45.           

46.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  

47.         DocumentBuilder db = dbf.newDocumentBuilder();  

48.         org.w3c.dom.Document document = db.parse(new File("student2.xml"));  

49.           

50.         DOMReader domReader = new DOMReader();  

51.           

52.         //將JAXP的Document轉換爲dom4j的Document  

53.         Document d = domReader.read(document);  

54.           

55.         Element rootElement = d.getRootElement();  

56.           

57.         System.out.println(rootElement.getName());  

58.   

59.     }  

60. }  

 

Java代碼  

1.  import java.io.FileWriter;  

2.    

3.  import org.jdom.Attribute;  

4.  import org.jdom.Document;  

5.  import org.jdom.Element;  

6.  import org.jdom.output.Format;  

7.  import org.jdom.output.XMLOutputter;  

8.    

9.  public class Test3  

10. {  

11.     public static void main(String[] args) throws Exception  

12.     {  

13.         Document document = new Document();  

14.   

15.         Element root = new Element("聯繫人列表").setAttribute(new Attribute("公司",  

16.                 "A集團"));  

17.   

18.         document.addContent(root);  

19.           

20.         Element contactPerson = new Element("聯繫人");  

21.           

22.         root.addContent(contactPerson);  

23.   

24.         contactPerson  

25.                 .addContent(new Element("姓名").setText("張三"))  

26.                 .addContent(new Element("公司").setText("A公司"))  

27.                 .addContent(new Element("電話").setText("021-55556666"))  

28.                 .addContent(  

29.                         new Element("地址")  

30.                                 .addContent(new Element("街道").setText("5街"))  

31.                                 .addContent(new Element("城市").setText("上海"))  

32.                                 .addContent(new Element("省份").setText("上海市")));  

33.   

34.         XMLOutputter output = new XMLOutputter(Format.getPrettyFormat()  

35.                 .setIndent("    ").setEncoding("gbk"));  

36.   

37.         output.output(document, new FileWriter("contact.xml"));  

38.   

39.     }  

40. }  

 

參考文獻：http://inotgaoshou.iteye.com/blog/1012188