zoukankan      html  css  js  c++  java

  • 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）

     
    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。 

        DOM4J  
    package xmlParse;  
      
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileNotFoundException;  
    import java.io.FileWriter;  
    import java.io.IOException;  
    import java.io.UnsupportedEncodingException;  
    import java.util.Iterator;  
    import java.util.List;  
      
    import org.dom4j.Document;  
    import org.dom4j.DocumentException;  
    import org.dom4j.DocumentHelper;  
    import org.dom4j.Element;  
    import org.dom4j.Node;  
    import org.dom4j.io.OutputFormat;  
    import org.dom4j.io.SAXReader;  
    import org.dom4j.io.XMLWriter;  
      
    public class TestDom4J {  
      
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
            buildXmlByDOM4J();  
            paserXmlByDOM4J();  
        }  
        public static void buildXmlByDOM4J(){  
            Document doc=DocumentHelper.createDocument();  
            doc.setXMLEncoding("UTF-8");  
            Element root=doc.addElement("students");  
            root.addAttribute("class", "一班").addAttribute("count", "3");  
            Element student=root.addElement("student");  
            student.addElement("name").setText("小明");  
            student.addElement("age").setText("10");  
              
            student=root.addElement("student").addAttribute("position", "班长");  
            student.addElement("name").setText("小汪");  
            student.addElement("age").setText("11");  
          
            student=root.addElement("student");  
            student.addElement("name").setText("小兵");  
            student.addElement("age").setText("12");  
              
            String xmlStr=doc.asXML();  
            try {  
                OutputFormat format=OutputFormat.createPrettyPrint();  
                XMLWriter writer=new XMLWriter(new FileWriter(new File("students.xml")),format);  
                writer.setEscapeText(false);  
                writer.write(xmlStr);  
                writer.close();  
            } catch (UnsupportedEncodingException e) {  
                e.printStackTrace();  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            }catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
        public static void paserXmlByDOM4J(){  
              long begintime=System.currentTimeMillis();  
              SAXReader reader=new SAXReader();  
              try {  
                Document doc=reader.read(new FileInputStream(new File("students.xml")));  
                Element root=doc.getRootElement();  
                System.out.println(root.attributeValue("class")+"--人数--"+root.attributeValue("count"));  
        /*      List<Node> list=root.selectNodes("student");//需要引入jaxen-1.1.1.jar 
                for(int i=0,len=list.size();i<len;i++){ 
                    Node node=(Node)list.get(i); 
                    System.out.println(node.selectSingleNode("name").getText()+"---"+node.selectSingleNode("age").getStringValue()); 
                }*/  
                Iterator it=root.elementIterator();  
                Element ele;  
                while(it.hasNext()){  
                    ele=(Element)it.next();  
                    //System.out.println(ele.selectSingleNode("name").getText()+"---"+ele.selectSingleNode("age").getText());  
                    System.out.println(ele.elementText("name")+"---"+ele.elementText("age"));  
                }  
              } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (DocumentException e) {  
                e.printStackTrace();  
            }  
                
              System.out.println("sax解析时间(毫秒)"+(System.currentTimeMillis()-begintime));  
        }  
    }

     dom4解析xml的另一个代码案例：

        package com.java.team;  
      
    import java.io.File;  
    import java.util.ArrayList;  
    import java.util.Iterator;  
    import java.util.List;  
      
    import org.dom4j.Document;  
    import org.dom4j.DocumentException;  
    import org.dom4j.Element;  
    import org.dom4j.io.SAXReader;  
      
    public class ParseXml {  
        public void read() throws Exception {  
            SAXReader reader = new SAXReader();  
            Document document = reader.read(new File("src/test.xml"));  
            Element root = document.getRootElement();  
            //将解析出来的allresource下的resourceitem放在list中  
            List list  = root.elements("resourceitem");  
            //创建source存放每一个resourceitem中资源  
            List<XmlBean> source = new ArrayList<XmlBean>();  
            //将resourceitem中的各项解析出来，通过XmlBean存放到source中  
            for(Iterator i = list.iterator();i.hasNext();) {  
                Element resourceitem = (Element) i.next();  
                String id = resourceitem.element("id").getText();  
                String title = resourceitem.element("title").getText();  
                String keywords = resourceitem.element("keywords").getText();  
                String kind = resourceitem.element("kind").getText();  
                String describe = resourceitem.element("describe").getText();  
                String date = resourceitem.element("date").getText();  
                String url = resourceitem.element("url").getText();  
                String author = resourceitem.element("author").getText();  
                String publisher = resourceitem.element("publisher").getText();  
                XmlBean bean = new XmlBean();  
                bean.setId(id);  
                bean.setTitle(title);  
                bean.setKeywords(keywords);  
                bean.setKind(kind);  
                bean.setDescribe(describe);  
                bean.setDate(date);  
                bean.setUrl(url);  
                bean.setAuthor(author);  
                bean.setPublisher(publisher);  
                source.add(bean);  
            }  
         
        }  
      
    }  


 
XmlBean类如下：
[java] view plain copy

    package com.java.team;  
      
    public class XmlBean {  
        private String id;  
        private String title;  
        private String keywords;  
        private String kind;  
        private String describe;  
        private String date;  
        private String url;  
        private String author;  
        public String getKeywords() {  
            return keywords;  
        }  
      
        public void setKeywords(String keywords) {  
            this.keywords = keywords;  
        }  
      
        public String getKind() {  
            return kind;  
        }  
      
        public void setKind(String kind) {  
            this.kind = kind;  
        }  
      
        public String getDescribe() {  
            return describe;  
        }  
      
        public void setDescribe(String describe) {  
            this.describe = describe;  
        }  
      
        public String getDate() {  
            return date;  
        }  
      
        public void setDate(String date) {  
            this.date = date;  
        }  
      
        public String getUrl() {  
            return url;  
        }  
      
        public void setUrl(String url) {  
            this.url = url;  
        }  
      
        public String getAuthor() {  
            return author;  
        }  
      
        public void setAuthor(String author) {  
            this.author = author;  
        }  
      
        public String getPublisher() {  
            return publisher;  
        }  
      
        public void setPublisher(String publisher) {  
            this.publisher = publisher;  
        }  
      
        private String publisher;  
      
        public String getId() {  
            return id;  
        }  
      
        public void setId(String id) {  
            this.id = id;  
        }  
      
        public String getTitle() {  
            return title;  
        }  
      
        public void setTitle(String title) {  
            this.title = title;  
        }  
      
    }  

xml文件部分如下：
[html] view plain copy

    <?xml version="1.0" encoding="UTF-8"?>  
      
    <allresource host="192.168.16.111" remote="192.168.16.111">   
      <resourcenum>499</resourcenum>    
      <resourceitem>   
        <id>2</id>    
        <title>《实数》复习d.doc</title>    
        <keywords>实数复习，期中复习</keywords>    
        <kind>doc</kind>    
        <describe>期中复习训练题</describe>    
        <date>2008-6-18 20:50:01</date>    
        <url>http://192.168.16.111:8080/resources/《实数》复习d.doc</url>    
        <author>胡克林</author>    
        <publisher>历城二中</publisher>   
      </resourceitem>    
      <resourceitem>   
        <id>3</id>    
        <title>《轴对称图形》教学设计</title>    
        <keywords>轴对称图形，平面几何图形</keywords>    
        <kind>doc</kind>    
        <describe>认识轴对称图形，知道轴对称图形的含义，能够找出轴对称图形的对称轴</describe>    
        <date>2008-6-18 20:55:10</date>    
        <url>http://192.168.16.111:8080/resources/《轴对称图形》教学设计.doc</url>    
        <author>胡克林</author>    
        <publisher>历城二中</publisher>   
      </resourceitem>
  • 相关阅读:
    C#、.NET Framework、CLR的关系
    C# out和ref区别
    声明式事务管理
    SSH项目搭建后的简化
    SSH项目的搭建
    SSH的框架整合
    Swift
    如何下载String jar包
    SSH(struts2，spring4，hibernate5)详解
    SSH框架的简化(struts2、spring4、hibernate5)
  • 原文地址：https://www.cnblogs.com/sxc1991/p/7419375.html
Copyright © 2011-2022 走看看