四種XML解析方法：

(1)Dom生成和解析XML文檔

*解析器讀入整個文檔，然後構建一個駐留內存的樹結構，然後代碼就可以使用 DOM 接口來操作這個樹結構。
* 優點：整個文檔樹在內存中，便於操作；支持刪除、修改、重新排列等多種功能；
* 缺點：將整個文檔調入內存（包括無用的節點），浪費時間和空間；
* 使用場合：一旦解析了文檔還需多次訪問這些數據；硬件資源充足（內存、CPU）。

(2)SAX生成和解析XML文檔

* SAX ，事件驅動。
* 當解析器發現元素開始、元素結束、文本、文檔的開始或結束等時，發送事件，程序員編寫響應這些事件的代碼，保存數據。
* 優點：不用事先調入整個文檔，占用資源少；SAX解析器代碼比DOM解析器代碼小，適於Applet，下載。
* 缺點：不是持久的；事件過後，若沒保存數據，那麽數據就丟了；
* 無狀態性；從事件中只能得到文本，但不知該文本屬於哪個元素；
* 使用場合：Applet;只需XML文檔的少量內容，很少回頭訪問；機器內存少；

(3)DOM4J生成和解析XML文檔

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

(4)JDOM生成和解析XML

*為減少DOM、SAX的編碼量，出現了JDOM；
*優點：20-80原則，極大減少了代碼量。
*使用場合：要實現的功能簡單，如解析、創建等，
*但在底層，JDOM還是使用SAX（最常用）、DOM、Xanan文檔。

首先編寫一個要解析的test.xml文件

1. <?xml version="1.0" encoding="UTF-8" standalone="no"?>
2. <employees>
3. <employee>
4. <name>wxyfree</name>
5. <age>30</age>
6. </employee>
7. <employee>
8. <name>freewxy</name>
9. <age>22</age>
10. </employee>
11. </employees>

然後，編寫一個XMLDocument接口

1. /**
2. * 定義XML文檔建立與解析的接口
3. * @author wxy
4. *
5. */
6. public interface XMLDocument {
7. /**
8. *建立XML文檔
9. * @param fileName 文件全路徑名
10. */
11. public void createXML(String fileName);
12. /**
13. * 解析XML文檔
14. * @param fileName 文件全路徑名
15. */
16. public void parseXML(String fileName);
17. }

一、

1. package review.testXML;
3. import java.io.FileNotFoundException;
4. import java.io.FileOutputStream;
5. import java.io.IOException;
6. import java.io.PrintWriter;
8. import javax.xml.parsers.DocumentBuilder;
9. import javax.xml.parsers.DocumentBuilderFactory;
10. import javax.xml.parsers.ParserConfigurationException;
11. import javax.xml.transform.OutputKeys;
12. import javax.xml.transform.Transformer;
13. import javax.xml.transform.TransformerConfigurationException;
14. import javax.xml.transform.TransformerException;
15. import javax.xml.transform.TransformerFactory;
16. import javax.xml.transform.dom.DOMSource;
17. import javax.xml.transform.stream.StreamResult;
20. import org.w3c.dom.Document;
21. import org.w3c.dom.Element;
22. import org.w3c.dom.Node;
23. import org.w3c.dom.NodeList;
24. import org.xml.sax.SAXException;
28. /**
29. * Dom生成和解析XML文檔
30. * 為 XML 文檔的已解析版本定義了一組接口。
31. * 解析器讀入整個文檔，然後構建一個駐留內存的樹結構，然後代碼就可以使用 DOM 接口來操作這個樹結構。
32. * 優點：整個文檔樹在內存中，便於操作；支持刪除、修改、重新排列等多種功能；
33. * 缺點：將整個文檔調入內存（包括無用的節點），浪費時間和空間；
34. * 使用場合：一旦解析了文檔還需多次訪問這些數據；硬件資源充足（內存、CPU）。
35. * @param args
36. */
37. public class DomDemo implements XMLDocument {
39. private Document document;
40. private String fileName;
42. public void init(){
43. try{
44. DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
45. DocumentBuilder builder=factory.newDocumentBuilder();
46. this.document=builder.newDocument();
47. }catch(ParserConfigurationException e){
48. System.out.println(e.getMessage());
49. }
50. }
51. @Override
52. public void createXML(String fileName) {
53. Element root=this.document.createElement("employees");//創建根元素
54. this.document.appendChild(root);
55. Element employee=this.document.createElement("employee");//創建子元素
56. Element name=this.document.createElement("name");//添加元素的屬性
57. name.appendChild(this.document.createTextNode("wxyfree"));
58. employee.appendChild(name);//將元素添加到子元素中
59. Element sex=this.document.createElement("sex");
60. sex.appendChild(this.document.createTextNode("m"));
61. Element age=this.document.createElement("age");
62. age.appendChild(this.document.createTextNode("30"));
63. employee.appendChild(age);
64. root.appendChild(employee);//將子元素添加到根元素中
65. TransformerFactory tf=TransformerFactory.newInstance();//此抽象類的實例能夠將源樹轉為結果樹
66. try{
67. Transformer transformer=tf.newTransformer();
68. DOMSource source=new DOMSource(document);//創建帶有DOM節點的新輸入源
69. transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");//設置轉換中世紀的輸出屬性
70. transformer.setOutputProperty(OutputKeys.INDENT, "yes");//
71. PrintWriter pw=new PrintWriter(new FileOutputStream(fileName));
72. StreamResult result=new StreamResult(pw);//充當轉換結果的持有者，可以為xml、純文本、HTML或某些其他格式的標記
73. transformer.transform(source, result);//將XML Source轉換為Result
74. System.out.println("生成XML文件成功");
75. }catch(TransformerConfigurationException e){
76. System.out.println(e.getMessage());
77. } catch (TransformerException e) {
78. System.out.println(e.getMessage());
79. } catch (FileNotFoundException e) {
80. System.out.println(e.getMessage());
81. }
82. }
84. @Override
85. public void parseXML(String fileName) {
86. DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
87. DocumentBuilder db;
88. try {
89. db = dbf.newDocumentBuilder();
90. Document document = db.parse(fileName);
91. NodeList employees=document.getChildNodes();
92. for(int i=0;i<employees.getLength();i++){
93. Node employee=employees.item(i);
94. NodeList employeeInfo=employee.getChildNodes();
95. for(int j=0;j<employeeInfo.getLength();j++){
96. Node node=employeeInfo.item(j);
97. NodeList employeeMeta=node.getChildNodes();
98. for(int k=0;k<employeeMeta.getLength();k++){
99. System.out.println(employeeMeta.item(k).getNodeName()+":"+employeeMeta.item(k).getTextContent());
100. }
101. }
102. }
103. } catch (ParserConfigurationException e) {
104. // TODO Auto-generated catch block
105. e.printStackTrace();
106. } catch (SAXException e) {
107. // TODO Auto-generated catch block
108. e.printStackTrace();
109. } catch (IOException e) {
110. // TODO Auto-generated catch block
111. e.printStackTrace();
112. }
113. System.out.println("解析完畢");
114. }
116. public static void main(String[] args){
117. DomDemo d=new DomDemo();
118. d.init();
119. d.createXML("conf/test2.xml");
120. d.parseXML("conf/test.xml");
122. }
124. }

二、

1. package review.testXML;
3. import java.io.FileInputStream;
4. import java.io.FileNotFoundException;
5. import java.io.IOException;
6. import java.io.InputStream;
8. import javax.xml.parsers.ParserConfigurationException;
9. import javax.xml.parsers.SAXParser;
10. import javax.xml.parsers.SAXParserFactory;
12. import org.xml.sax.Attributes;
13. import org.xml.sax.HandlerBase;
14. import org.xml.sax.SAXException;
15. import org.xml.sax.helpers.DefaultHandler;
17. /**
18. * SAX ，事件驅動。
19. * 當解析器發現元素開始、元素結束、文本、文檔的開始或結束等時，發送事件，程序員編寫響應這些事件的代碼，保存數據。
20. * 優點：不用事先調入整個文檔，占用資源少；SAX解析器代碼比DOM解析器代碼小，適於Applet，下載。
21. * 缺點：不是持久的；事件過後，若沒保存數據，那麽數據就丟了；
22. * 無狀態性；從事件中只能得到文本，但不知該文本屬於哪個元素；
23. * 使用場合：Applet;只需XML文檔的少量內容，很少回頭訪問；機器內存少；
24. * @author wxy
25. *
26. */
27. public class SaxDemo implements XMLDocument{
29. @Override
30. public void createXML(String fileName) {
31. System.out.println("<<"+fileName+">>");
33. }
35. @Override
36. public void parseXML(String fileName) {
37. SAXParserFactory saxfac=SAXParserFactory.newInstance();
38. try {
39. SAXParser saxParser=saxfac.newSAXParser();
40. InputStream ins=new FileInputStream(fileName);
41. saxParser.parse(ins,new MySAXHandler());
42. } catch (ParserConfigurationException e) {
43. System.out.println(e.getMessage());
44. } catch (SAXException e) {
45. System.out.println(e.getMessage());
46. } catch (FileNotFoundException e) {
47. System.out.println(e.getMessage());
48. } catch (IOException e) {
49. System.out.println(e.getMessage());
50. }
52. }
53. /**
54. * @param args
55. */
56. public static void main(String[] args) {
57. SaxDemo s=new SaxDemo();
58. s.parseXML("conf/test.xml");
59. }
60. }
61. class MySAXHandler extends DefaultHandler{
62. boolean hasAttribute=false;
63. Attributes attributes=null;
65. /**
66. * Receive notification of the beginning of the document.
67. */
68. public void startDocument()throws SAXException{
69. System.out.print("文檔開始打印了");
70. }
71. /**
72. * Receive notification of the end of the document.
73. */
74. public void endDocument()throws SAXException{
75. System.out.print("文檔開始結束了");
76. }
77. /**
78. * Receive notification of the start of an element.
79. * @param uri The Namespace URI, or the empty string if the
80. * element has no Namespace URI or if Namespace
81. * processing is not being performed.
82. * @param localName The local name (without prefix), or the
83. * empty string if Namespace processing is not being
84. * performed.
85. * @param qName The qualified name (with prefix), or the
86. * empty string if qualified names are not available.
87. * @param attributes The attributes attached to the element. If
88. * there are no attributes, it shall be an empty
89. * Attributes object.
90. * @exception org.xml.sax.SAXException Any SAX exception, possibly
91. * wrapping another exception.
92. */
93. public void startElement(String uri,String localName,String qName,Attributes attributes)throws SAXException{
94. if(qName.equals("employees")){return;}
95. if(qName.equals("employee")){
96. System.out.print(qName);
97. }
98. if(attributes.getLength()>0){
99. this.attributes=attributes;
100. this.hasAttribute=true;
101. }
102. }
103. /**
104. * Receive notification of the end of an element.
105. * @param uri The Namespace URI, or the empty string if the
106. * element has no Namespace URI or if Namespace
107. * processing is not being performed.
108. * @param localName The local name (without prefix), or the
109. * empty string if Namespace processing is not being
110. * performed.
111. * @param qName The qualified name (with prefix), or the
112. * empty string if qualified names are not available.
113. * @exception org.xml.sax.SAXException Any SAX exception, possibly
114. * wrapping another exception.
115. */
116. public void endElement(String uri,String localName,String qNaqme)throws SAXException{
117. if(hasAttribute&&(attributes!=null)){
118. for(int i=0;i<attributes.getLength();i++){
119. System.out.print(attributes.getQName(0)+attributes.getValue(0));
120. }
121. }
122. }
123. /**
124. * Receive notification of character data inside an element.
125. * @param ch The characters.
126. * @param start The start position in the character array.
127. * @param length The number of characters to use from the
128. * character array.
129. */
130. public void characters(char[] ch,int start,int length)throws SAXException{
131. System.out.print(new String(ch,start,length));
132. }
133. }

三、

1. package review.testXML;
3. import java.io.File;
4. import java.io.FileWriter;
5. import java.io.IOException;
6. import java.io.Writer;
7. import java.util.Iterator;
9. import org.dom4j.Document;
10. import org.dom4j.DocumentException;
11. import org.dom4j.DocumentHelper;
12. import org.dom4j.Element;
13. import org.dom4j.io.SAXReader;
14. import org.dom4j.io.XMLWriter;
16. /**
17. * Dom4j 生成XML文檔與解析XML文檔
18. * DOM4J 是一個非常非常優秀的Java XML API，
19. * 具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。
20. * 如今你可以看到越來越多的 Java 軟件都在使用 DOM4J 來讀寫 XML，特別值得一提的是連 Sun 的 JAXM 也在用 DOM4J。
21. * @author wxy
22. *
23. */
24. public class Dom4jDemo implements XMLDocument{
26. @Override
27. public void createXML(String fileName) {
28. Document document = DocumentHelper.createDocument();
29. Element employees=document.addElement("employees");
30. Element employee=document.addElement("employee");
31. Element name=employee.addElement("name");
32. name.setText("wxy");
33. Element sex=employee.addElement("sex");
34. name.setText("f");
35. Element age=employee.addElement("age");
36. name.setText("29");
37. try {
38. Writer fileWriter=new FileWriter(fileName);
39. XMLWriter xmlWriter=new XMLWriter(fileWriter);
40. xmlWriter.write(document);
41. xmlWriter.close();
42. } catch (IOException e) {
43. System.out.println(e.getMessage());
44. }
45. }
47. @Override
48. public void parseXML(String fileName) {
49. File inputXML=new File(fileName);
50. SAXReader saxReader=new SAXReader();
51. try {
52. Document document=saxReader.read(inputXML);
53. Element employees=document.getRootElement();
54. for(Iterator i=employees.elementIterator();i.hasNext();){
55. Element employee=(Element)i.next();
56. for(Iterator j=employee.elementIterator();j.hasNext();){
57. Element node=(Element)j.next();
58. System.out.println(node.getName()+":"+node.getText());
59. }
60. }
61. } catch (DocumentException e) {
62. System.out.println(e.getMessage());
63. }
64. System.out.println("dom4j parserXML");
65. }
68. public static void main(String[] args) {
69. Dom4jDemo d=new Dom4jDemo();
70. d.parseXML("conf/test.xml");
71. }
73. }

四、

1. package review.testXML;
4. import java.io.FileNotFoundException;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. import java.util.List;
9. import org.jdom.Document;
10. import org.jdom.Element;
11. import org.jdom.JDOMException;
12. import org.jdom.input.SAXBuilder;
13. import org.jdom.output.XMLOutputter;
16. /**
17. * JDOM生成和解析XML
18. *為減少DOM、SAX的編碼量，出現了JDOM；
19. *優點：20-80原則，極大減少了代碼量。
20. *使用場合：要實現的功能簡單，如解析、創建等，
21. *但在底層，JDOM還是使用SAX（最常用）、DOM、Xanan文檔。
22. * @author wxy
23. *
24. */
25. public class JDomDemo implements XMLDocument{
28. @Override
29. public void createXML(String fileName) {
30. Document document;
31. Element root;
32. root=new Element("employees");
33. document=new Document(root);
34. Element employee=new Element("employee");
35. root.addContent(employee);
36. Element name=new Element("name");
37. name.setText("wxywxy");
38. employee.addContent(name);
39. Element sex=new Element("sex");
40. sex.setText("m");
41. employee.addContent(sex);
42. Element age=new Element("age");
43. age.setText("25");
44. employee.addContent(age);
45. XMLOutputter XMLOut=new XMLOutputter();
46. try {
47. XMLOut.output(document, new FileOutputStream(fileName));
48. } catch (FileNotFoundException e) {
49. System.out.println(e.getMessage());
50. } catch (IOException e) {
51. System.out.println(e.getMessage());
52. }
53. }
55. @Override
56. public void parseXML(String fileName) {
57. SAXBuilder builder=new SAXBuilder(false);
58. try {
59. Document document=builder.build(fileName);
60. Element employees=document.getRootElement();
61. List employeeList=employees.getChildren("employee");
62. for(int i=0;i<employeeList.size();i++){
63. Element employee=(Element)employeeList.get(i);
64. List employeeInfo=employee.getChildren();
65. for(int j=0;j<employeeInfo.size();j++){
66. System.out.println(((Element)employeeInfo.get(j)).getName()+":"+((Element)employeeInfo.get(j)).getText());
67. }
68. }
69. } catch (JDOMException e) {
70. System.out.println(e.getMessage());
71. } catch (IOException e) {
72. System.out.println(e.getMessage());
73. }
74. }
77. public static void main(String[] args){
78. JDomDemo jd=new JDomDemo();
79. jd.parseXML("conf/test.xml");
80. }
81. }

XML 的解析方法