DOM,SAX,JDOM,DOM4J优缺点比较及生产xml和解析xml

下载必要的jar包：

activation.jar
commons-logging-1.0.4.jar
dom4j-1.6.1.jar
jaxen-1.1.1.jar
jdom-1.0.jar

一、DOM

解析器读入整个文档，然后构建一个驻留内存的树结构，使用 DOM 接口来操作这个树结构。

优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；访问效率高。

缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）

[java] view plain copy

1. package xmlParse;  
2.   
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.util.Calendar;  
8. import java.util.Locale;  
9. import java.util.TimeZone;  
10.   
11. import javax.xml.parsers.DocumentBuilder;  
12. import javax.xml.parsers.DocumentBuilderFactory;  
13. import javax.xml.parsers.ParserConfigurationException;  
14. import javax.xml.parsers.SAXParser;  
15. import javax.xml.parsers.SAXParserFactory;  
16. import javax.xml.transform.Result;  
17. import javax.xml.transform.Transformer;  
18. import javax.xml.transform.TransformerConfigurationException;  
19. import javax.xml.transform.TransformerException;  
20. import javax.xml.transform.TransformerFactory;  
21. import javax.xml.transform.dom.DOMSource;  
22. import javax.xml.transform.stream.StreamResult;  
23.   
24. import org.w3c.dom.DOMException;  
25. import org.w3c.dom.Document;  
26. import org.w3c.dom.Element;  
27. import org.w3c.dom.Node;  
28. import org.w3c.dom.NodeList;  
29. import org.xml.sax.SAXException;  
30.   
31. /** 
32.  * java自带的dom解析xml文件 
33.  *  
34.  * @author abc 
35.  *  
36.  */  
37. public class TestDom {  
38.     public static void main(String[] args) {  
39.         builXmlByDom();  
40.         parseXmlByDom();  
41.     }  
42.     /** 
43.      * 生成xml信息 
44.      */  
45.     public static void builXmlByDom() {  
46.         long begintime = System.currentTimeMillis();  
47.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
48.         try {  
49.             //构建Document  
50.             DocumentBuilder db = dbf.newDocumentBuilder();  
51.             Document doc=db.newDocument();  
52.             Element root=doc.createElement("students");  
53.             root.setAttribute("class", "一班");  
54.             root.setAttribute("count", "3");  
55.               
56.             Element stu=doc.createElement("student");  
57.             Element name=doc.createElement("name");  
58.             name.appendChild(doc.createTextNode("小明"));  
59.             Element age=doc.createElement("age");  
60.             age.appendChild(doc.createTextNode("10"));  
61.             stu.appendChild(name);  
62.             stu.appendChild(age);  
63.             root.appendChild(stu);  
64.               
65.               
66.              stu=doc.createElement("student");  
67.              stu.setAttribute("position","班长");  
68.              name=doc.createElement("name");  
69.              name.appendChild(doc.createTextNode("小王"));  
70.              age=doc.createElement("age");  
71.              age.appendChild(doc.createTextNode("11"));  
72.              stu.appendChild(name);  
73.              stu.appendChild(age);  
74.              root.appendChild(stu);  
75.   
76.              stu=doc.createElement("student");  
77.              name=doc.createElement("name");  
78.              name.appendChild(doc.createTextNode("小兵"));  
79.              age=doc.createElement("age");  
80.              age.appendChild(doc.createTextNode("12"));  
81.              stu.appendChild(name);  
82.              stu.appendChild(age);  
83.              root.appendChild(stu);  
84.                
85.              doc.appendChild(root);  
86.              //将被变换的Document对象封装到一个DOMSource对象中  
87.              DOMSource xmlSource=new DOMSource(doc);  
88.              //使用 Transformer对象将一个Document节点变换为一个XML文件  
89.              TransformerFactory transFactory=TransformerFactory. newInstance();  
90.              Transformer transformer=transFactory.newTransformer();  
91.                
92.              //创建Result  
93.              File file=new File("students.xml");  
94.              FileOutputStream fos;  
95.              fos = new FileOutputStream(file);  
96.              StreamResult result=new StreamResult(fos);  
97.              transformer.transform(xmlSource, result);  
98.              if(fos!=null){  
99.                  fos.close();  
100.              }  
101.         }catch (ParserConfigurationException e) {  
102.             e.printStackTrace();  
103.         }catch (TransformerConfigurationException e) {  
104.             e.printStackTrace();  
105.         }catch (FileNotFoundException e) {  
106.             e.printStackTrace();  
107.         }catch (TransformerException e) {  
108.             e.printStackTrace();  
109.         }catch (IOException e) {  
110.             e.printStackTrace();  
111.         }    
112.         System.out.println("dom生成时间(毫秒)"  
113.                 + (System.currentTimeMillis() - begintime));  
114.     }  
115.     /** 
116.      * 解析xml信息 
117.      */  
118.     public static void parseXmlByDom() {  
119.         long begintime = System.currentTimeMillis();;  
120.         try {  
121.             DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();  
122.             DocumentBuilder builder=dbf.newDocumentBuilder();  
123.             File file=new File("students.xml");  
124.             Document doc=builder.parse(file);  
125.             NodeList students=doc.getFirstChild().getChildNodes();  
126.             Node student=null;  
127.             Node node=null;  
128.             for(int i=0,len=students.getLength();i<len;i++){  
129.                 student=students.item(i);  
130.                 NodeList childs=student.getChildNodes();  
131.                 System.out.println("第"+(i+1)+"个学生");  
132.                 for(int j=0,size=childs.getLength();j<size;j++){  
133.                     node=childs.item(j);  
134.                     if("name".equals(node.getNodeName())){  
135.                         System.out.println(node.getNodeName()+"---"+node.getTextContent());  
136.                     }  
137.                     if("age".equals(node.getNodeName())){  
138.                         System.out.println(node.getNodeName()+"---"+node.getTextContent());  
139.                     }  
140.                 }  
141.             }  
142.         } catch (DOMException e) {  
143.             e.printStackTrace();  
144.         } catch (ParserConfigurationException e) {  
145.             e.printStackTrace();  
146.         } catch (SAXException e) {  
147.             e.printStackTrace();  
148.         } catch (IOException e) {  
149.             e.printStackTrace();  
150.         }  
151.         System.out.println("dom解析时间(毫秒)"  
152.                 + (System.currentTimeMillis() - begintime));  
153.     }  
154. }  

二、SAX

特点：  1、边读边解析，应用于大型XML文档

              2、只支持读

              3、访问效率低

              4、顺序访问

[java] view plain copy

1. package xmlParse;  
2.   
3. import java.io.File;  
4.   
5. import javax.xml.parsers.SAXParser;  
6. import javax.xml.parsers.SAXParserFactory;  
7.   
8. public class TestSAXParse {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         sax();  
15.     }  
16.   
17.     public static void sax() {  
18.         long begintime = System.currentTimeMillis();  
19.         File f = new File("students.xml");  
20.         SAXParserFactory sf = SAXParserFactory.newInstance();  
21.         try {  
22.             SAXParser sp = sf.newSAXParser();  
23.             SAXHandler handler = new SAXHandler();  
24.             sp.parse(f, handler);  
25.         } catch (Exception e) {  
26.             e.printStackTrace();  
27.         }  
28.         System.out.println("sax解析时间(毫秒)"  
29.                 + (System.currentTimeMillis() - begintime));  
30.   
31.     }  
32. }  
33.   
34.   
35.   
36. SAXHandler.java  
37. package xmlParse;  
38.   
39. import org.xml.sax.Attributes;  
40. import org.xml.sax.SAXException;  
41. import org.xml.sax.helpers.DefaultHandler;  
42. import java.util.Stack;  
43. public class SAXHandler extends DefaultHandler {  
44.     Stack tags = null;  
45.     @Override  
46.     public void startDocument() throws SAXException {  
47.         tags=new Stack();  
48.     }  
49.   
50.     @Override  
51.     public void endDocument() throws SAXException {  
52.         while(!tags.isEmpty()){  
53.             System.out.println(tags.peek());  
54.             tags.pop();  
55.         }  
56.         tags=null;  
57.     }  
58.   
59.     @Override  
60.     public void startElement(String uri, String localName, String qName,  
61.             Attributes attributes) throws SAXException {  
62.         if("students".equals(qName)){  
63.             System.out.println(attributes.getValue("class")+"--人数-"+attributes.getValue("count"));  
64.         }  
65.         tags.push(qName);//压入栈  
66.     }  
67.   
68.     @Override  
69.     public void endElement(String uri, String localName, String qName)  
70.             throws SAXException {  
71.         tags.pop();//取出栈顶元素  
72.     }  
73.   
74.     @Override  
75.     public void characters(char[] ch, int start, int length)  
76.             throws SAXException {  
77.         String tag=(String) tags.peek();//查看栈顶元素，但不移除  
78.         if("name".equals(tag)){  
79.             System.out.println("name==="+new String(ch,start,length));  
80.         }  
81.         if("age".equals(tag)){  
82.             System.out.println("age==="+new String(ch,start,length));  
83.         }  
84.     }  
85.   
86. }  

三、JDOM

JDOM
优点:①是基于树的处理XML的Java API，把树加载在内存中
     ②没有向下兼容的限制，因此比DOM简单
     ③速度快，缺陷少
     ④具有SAX的Java规则
缺点:①不能处理大于内存的文档
     ②JDOM表示XML文档逻辑模型。不能保证每个字节真正变换。
     ③针对实例文档不提供DTD与模式的任何实际模型。
     ④不支持与DOM中相应遍历包
最适合于:JDOM具有树的便利，也有SAX的JAVA规则。在需要平衡时使用

[java] view plain copy

1. JDOM  
2.   
3.   
4. package xmlParse;  
5.   
6. import java.io.ByteArrayOutputStream;  
7. import java.io.File;  
8. import java.io.FileInputStream;  
9. import java.io.FileNotFoundException;  
10. import java.io.FileOutputStream;  
11. import java.io.IOException;  
12. import java.util.List;  
13.   
14. import org.jdom.Document;  
15. import org.jdom.Element;  
16. import org.jdom.JDOMException;  
17. import org.jdom.input.SAXBuilder;  
18. import org.jdom.output.XMLOutputter;  
19.   
20. public class TestJDOM {  
21.   
22.     /** 
23.      * @param args 
24.      */  
25.     public static void main(String[] args) {  
26.         buildXmlByJDOM();  
27.         parseXmlByJDOM();  
28.     }  
29.       
30.     public static String buildXmlByJDOM(){  
31.         Document doc=new Document();  
32.         Element root=new Element("students");  
33.         root.setAttribute("count", "3");  
34.         root.setAttribute("class", "一班");  
35.         doc.setRootElement(root);  
36.         root.addContent(new Element("student").addContent(new Element("name").setText("小明"))  
37.                 .addContent(new Element("age").setText("10")));  
38.         root.addContent(new Element("student").addContent(new Element("name").setText("小汪"))  
39.                 .addContent(new Element("age").setText("11")));  
40.         root.addContent(new Element("student").addContent(new Element("name").setText("小兵"))  
41.                 .addContent(new Element("age").setText("12")));  
42.         ByteArrayOutputStream out=new ByteArrayOutputStream();  
43.         XMLOutputter putter=new XMLOutputter();  
44.         try {  
45.             putter.output(doc, out);  
46.             putter.output(doc, new FileOutputStream("students.xml"));  
47.         } catch (FileNotFoundException e) {  
48.             e.printStackTrace();  
49.         } catch (IOException e) {  
50.             e.printStackTrace();  
51.         }  
52.         return out.toString();  
53.     }  
54.    public static void parseXmlByJDOM(){  
55.        long begintime=System.currentTimeMillis();  
56.        File f=new File("students.xml");    
57.        SAXBuilder builder=new SAXBuilder();  
58.        try {  
59.         Document doc=builder.build(new FileInputStream(f));  
60.         Element root=doc.getRootElement();  
61.         System.out.println(root.getAttributeValue("class")+"-人数：--"+root.getAttributeValue("count"));  
62.           
63.         List list=root.getChildren("student");  
64.         for(int i=0;i<list.size();i++){  
65.             Element ele=(Element)list.get(i);  
66.             System.out.println("第"+(i+1)+"个学生");  
67.             System.out.println(ele.getChildText("name")+"---"+ele.getChildText("age"));  
68.         }  
69.         } catch (FileNotFoundException e) {  
70.             e.printStackTrace();  
71.         } catch (JDOMException e) {  
72.             e.printStackTrace();  
73.         } catch (IOException e) {  
74.             e.printStackTrace();  
75.         }  
76.         System.out.println("sax解析时间(毫秒)"+(System.currentTimeMillis()-begintime));  
77.    }  
78. }  

四、DOM4J

DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。 

[java] view plain copy

1. DOM4J  
2. package xmlParse;  
3.   
4. import java.io.File;  
5. import java.io.FileInputStream;  
6. import java.io.FileNotFoundException;  
7. import java.io.FileWriter;  
8. import java.io.IOException;  
9. import java.io.UnsupportedEncodingException;  
10. import java.util.Iterator;  
11. import java.util.List;  
12.   
13. import org.dom4j.Document;  
14. import org.dom4j.DocumentException;  
15. import org.dom4j.DocumentHelper;  
16. import org.dom4j.Element;  
17. import org.dom4j.Node;  
18. import org.dom4j.io.OutputFormat;  
19. import org.dom4j.io.SAXReader;  
20. import org.dom4j.io.XMLWriter;  
21.   
22. public class TestDom4J {  
23.   
24.     /** 
25.      * @param args 
26.      */  
27.     public static void main(String[] args) {  
28.         buildXmlByDOM4J();  
29.         paserXmlByDOM4J();  
30.     }  
31.     public static void buildXmlByDOM4J(){  
32.         Document doc=DocumentHelper.createDocument();  
33.         doc.setXMLEncoding("UTF-8");  
34.         Element root=doc.addElement("students");  
35.         root.addAttribute("class", "一班").addAttribute("count", "3");  
36.         Element student=root.addElement("student");  
37.         student.addElement("name").setText("小明");  
38.         student.addElement("age").setText("10");  
39.           
40.         student=root.addElement("student").addAttribute("position", "班长");  
41.         student.addElement("name").setText("小汪");  
42.         student.addElement("age").setText("11");  
43.       
44.         student=root.addElement("student");  
45.         student.addElement("name").setText("小兵");  
46.         student.addElement("age").setText("12");  
47.           
48.         String xmlStr=doc.asXML();  
49.         try {  
50.             OutputFormat format=OutputFormat.createPrettyPrint();  
51.             XMLWriter writer=new XMLWriter(new FileWriter(new File("students.xml")),format);  
52.             writer.setEscapeText(false);  
53.             writer.write(xmlStr);  
54.             writer.close();  
55.         } catch (UnsupportedEncodingException e) {  
56.             e.printStackTrace();  
57.         } catch (FileNotFoundException e) {  
58.             e.printStackTrace();  
59.         }catch (IOException e) {  
60.             e.printStackTrace();  
61.         }  
62.     }  
63.     public static void paserXmlByDOM4J(){  
64.           long begintime=System.currentTimeMillis();  
65.           SAXReader reader=new SAXReader();  
66.           try {  
67.             Document doc=reader.read(new FileInputStream(new File("students.xml")));  
68.             Element root=doc.getRootElement();  
69.             System.out.println(root.attributeValue("class")+"--人数--"+root.attributeValue("count"));  
70.     /*      List<Node> list=root.selectNodes("student");//需要引入jaxen-1.1.1.jar 
71.             for(int i=0,len=list.size();i<len;i++){ 
72.                 Node node=(Node)list.get(i); 
73.                 System.out.println(node.selectSingleNode("name").getText()+"---"+node.selectSingleNode("age").getStringValue()); 
74.             }*/  
75.             Iterator it=root.elementIterator();  
76.             Element ele;  
77.             while(it.hasNext()){  
78.                 ele=(Element)it.next();  
79.                 //System.out.println(ele.selectSingleNode("name").getText()+"---"+ele.selectSingleNode("age").getText());  
80.                 System.out.println(ele.elementText("name")+"---"+ele.elementText("age"));  
81.             }  
82.           } catch (FileNotFoundException e) {  
83.             e.printStackTrace();  
84.         } catch (DocumentException e) {  
85.             e.printStackTrace();  
86.         }  
87.             
88.           System.out.println("sax解析时间(毫秒)"+(System.currentTimeMillis()-begintime));  
89.     }  
90. }