四种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文件

Java代码  

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接口

Java代码  

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. }  

一、

Java代码  

1. package review.testXML;  
2.   
3. import java.io.FileNotFoundException;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.PrintWriter;  
7.   
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;  
18.   
19.   
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;  
25.   
26.   
27.   
28. /** 
29.  * Dom生成和解析XML文档 
30.  * 为 XML 文档的已解析版本定义了一组接口。 
31.  * 解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。 
32.  * 优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能； 
33.  * 缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间； 
34.  * 使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。  
35.  * @param args 
36.  */  
37. public class DomDemo implements XMLDocument  {  
38.   
39.     private Document document;  
40.     private String fileName;  
41.       
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.     }  
83.   
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.     }  
115.   
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");  
121.   
122.     }  
123.   
124. }  

二、

Java代码  

1. package review.testXML;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7.   
8. import javax.xml.parsers.ParserConfigurationException;  
9. import javax.xml.parsers.SAXParser;  
10. import javax.xml.parsers.SAXParserFactory;  
11.   
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;  
16.   
17. /** 
18.  * SAX ，事件驱动。 
19.  * 当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。 
20.  * 优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。 
21.  * 缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了； 
22.  *      无状态性；从事件中只能得到文本，但不知该文本属于哪个元素； 
23.  * 使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；  
24.  * @author wxy 
25.  * 
26.  */  
27. public class SaxDemo implements XMLDocument{  
28.   
29.     @Override  
30.     public void createXML(String fileName) {  
31.         System.out.println("<<"+fileName+">>");  
32.           
33.     }  
34.   
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.         }  
51.           
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;  
64.       
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. }  

三、

Java代码  

1. package review.testXML;  
2.   
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;  
8.   
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;  
15.   
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{  
25.   
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.     }  
46.   
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.     }  
66.   
67.       
68.     public static void main(String[] args) {  
69.         Dom4jDemo d=new Dom4jDemo();  
70.         d.parseXML("conf/test.xml");  
71.     }  
72.   
73. }  

四、

Java代码  

1. package review.testXML;  
2.   
3.   
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.util.List;  
8.   
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;  
14.   
15.   
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{  
26.       
27.   
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.     }  
54.   
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.     }  
75.   
76.       
77.     public static void main(String[] args){  
78.         JDomDemo jd=new JDomDemo();  
79.         jd.parseXML("conf/test.xml");  
80.     }  
81. }  

XML 的解析方法