java读取Xml几种方式

话说前两天刚看过读取xml的方式 ，结果当被人问起java 通常是如何读取xml的时候，还是不知从何说起》》》巨汗啊！！！

先来点废话吧：xml现在已经成为一种通用的数据交换格式，它的平台无关性，语言无关性，系统无关性，给数据集成于交互带来了极大的方便。对xml本省语法知识与技术细节，需要阅读相关的技术文献，这里面包括的内容有DOM（Document Object Model），DTD（Document Type Definition），SAX(Simple API for XML)，XSD（Xml Schema Definition），XSLT（Extensible  Stylesheet    Language   Transfomations ）,具体可参见W3C。

XML在不同的余元里解析方式都是一样的，只不过在现实语法不同而已。基本的解析方式有两种，一种叫SAX，另一种叫DOM。SAX是基于事件流的解析，DOM是基于XML文档树结构的解析。假设我们XML的内容和结构如下：

[html]   view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <employees>   
3. <employee>   
4. <name>ddviplinux</name>   
5. <sex>m</sex>   
6. <age>30</age>   
7. </employee>   
8. </employees>  

本文使用JAVA语言来实现DOM与SAX的XML文档生成和解析。

首先定义一个操作XML文档的接口XMLDocument 它定义了XML文档的简历与解析的接口。

[html]   view plain copy print ?

1. package com.alisoft.facepay.framework.bean;   
2. /**   
3. *   
4. * @author hongliang.dinghl   
5. * 定义XML文档建立与解析的接口   
6. */   
7. public interface XmlDocument {   
8. /**   
9. * 建立XML文档   
10. * @param fileName 文件全路径名称   
11. */   
12. public void createXml(String fileName);   
13. /**   
14. * 解析XML文档   
15. * @param fileName 文件全路径名称   
16. */   
17. public void parserXml(String fileName);   
18. }   

1. DOM生成和解析XML文档

   为XML文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的数据够，然后代码就可以使用DOM接口来操作这个数结构。

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

   缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；

   使用场合：一旦解析了文档还要多次访问这些数据；硬件资源充足

   [java]   view plain copy print ?

   1. package com.mwh.test.readXml;  
   2.   
   3. import java.io.FileNotFoundException;  
   4. import java.io.FileOutputStream;  
   5. import java.io.IOException;  
   6. import java.io.PrintWriter;  
   7. import javax.xml.parsers.DocumentBuilder;  
   8. import javax.xml.parsers.DocumentBuilderFactory;  
   9. import javax.xml.parsers.ParserConfigurationException;  
   10. import javax.xml.transform.OutputKeys;  
   11. import javax.xml.transform.Transformer;  
   12. import javax.xml.transform.TransformerConfigurationException;  
   13. import javax.xml.transform.TransformerException;  
   14. import javax.xml.transform.TransformerFactory;  
   15. import javax.xml.transform.dom.DOMSource;  
   16. import javax.xml.transform.stream.StreamResult;  
   17. import org.w3c.dom.Document;  
   18. import org.w3c.dom.Element;  
   19. import org.w3c.dom.Node;  
   20. import org.w3c.dom.NodeList;  
   21. import org.xml.sax.SAXException;  
   22.   
   23. /** 
   24.  *  
   25.  * @author mwh DOM生成与解析XML文档 
   26.  */  
   27. public class DomDemo implements XmlDocument {  
   28.     private Document document;  
   29.     private String fileName;  
   30.   
   31.     public void init() {  
   32.         try {  
   33.             DocumentBuilderFactory factory = DocumentBuilderFactory  
   34.                     .newInstance();  
   35.             DocumentBuilder builder = factory.newDocumentBuilder();  
   36.             this.document = builder.newDocument();  
   37.         } catch (ParserConfigurationException e) {  
   38.             System.out.println(e.getMessage());  
   39.         }  
   40.     }  
   41.   
   42.     public static void main(String args[]) {  
   43.         DomDemo dd = new DomDemo();  
   44.         String str = "D:/grade.xml";  
   45.         dd.init();  
   46.         dd.createXml(str); // 创建xml  
   47.         dd.parserXml(str); // 读取xml  
   48.     }  
   49.   
   50.     public void createXml(String fileName) {  
   51.         Element root = this.document.createElement("employees");  
   52.         this.document.appendChild(root);  
   53.         Element employee = this.document.createElement("employee");  
   54.         Element name = this.document.createElement("name");  
   55.         name.appendChild(this.document.createTextNode("@年华已逝不爱财"));  
   56.         employee.appendChild(name);  
   57.         Element sex = this.document.createElement("sex");  
   58.         sex.appendChild(this.document.createTextNode("男"));  
   59.         employee.appendChild(sex);  
   60.         Element age = this.document.createElement("age");  
   61.         age.appendChild(this.document.createTextNode("24"));  
   62.         employee.appendChild(age);  
   63.         root.appendChild(employee);  
   64.         TransformerFactory tf = TransformerFactory.newInstance();  
   65.         try {  
   66.             Transformer transformer = tf.newTransformer();  
   67.             DOMSource source = new DOMSource(document);  
   68.             transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");  
   69.             transformer.setOutputProperty(OutputKeys.INDENT, "yes");  
   70.             PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));  
   71.             StreamResult result = new StreamResult(pw);  
   72.             transformer.transform(source, result);  
   73.             System.out.println("生成XML文件成功!");  
   74.         } catch (TransformerConfigurationException e) {  
   75.             System.out.println(e.getMessage());  
   76.         } catch (IllegalArgumentException e) {  
   77.             System.out.println(e.getMessage());  
   78.         } catch (FileNotFoundException e) {  
   79.             System.out.println(e.getMessage());  
   80.         } catch (TransformerException e) {  
   81.             System.out.println(e.getMessage());  
   82.         }  
   83.     }  
   84.   
   85.     public void parserXml(String fileName) {  
   86.         try {  
   87.             Long s = System.currentTimeMillis();  
   88.             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
   89.             DocumentBuilder 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()  
   100.                                 + ":" + employeeMeta.item(k).getTextContent());  
   101.                     }  
   102.                 }  
   103.             }  
   104.             long e = System.currentTimeMillis();  
   105.             System.out.println("解析完毕,耗时" + (e - s));  
   106.         } catch (FileNotFoundException e) {  
   107.             System.out.println(e.getMessage());  
   108.         } catch (ParserConfigurationException e) {  
   109.             System.out.println(e.getMessage());  
   110.         } catch (SAXException e) {  
   111.             System.out.println(e.getMessage());  
   112.         } catch (IOException e) {  
   113.             System.out.println(e.getMessage());  
   114.         }  
   115.     }  
   116. }  
   
   

2. SAX生成和解析XML文档

     为解决DOM的问题，出现了SAX。 SAX，事件驱动。当解析器放生元素开始、元素结束、文本、文档的开始或结束等式，发送事件，程序员编写相应这些事件的代码，保存数据。

   优点：不事先调入整个文档，占有资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。

   缺点：不是持久的；事件过后，没有保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知道文本属于哪个元素；

   使用场合：Applet；只需XML文档的少量内容，很少回头访问；机器内存少；

   [java]   view plain copy print ?

   1. package com.mwh.test.readXml;  
   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.SAXException;  
   14. import org.xml.sax.helpers.DefaultHandler;  
   15.   
   16. /** 
   17.  *  
   18.  * @author mwh SAX文档解析 
   19.  */  
   20. public class SaxDemo implements XmlDocument {  
   21.     public void createXml(String fileName) {  
   22.         System.out.println("<<" + fileName + ">>");  
   23.     }  
   24.   
   25.     public static void main(String args[]) {  
   26.         SaxDemo dd = new SaxDemo();  
   27.         String str = "D:/grade.xml";  
   28.         dd.createXml(str); // 创建xml  
   29.         dd.parserXml(str); // 读取xml  
   30.     }  
   31.   
   32.     public void parserXml(String fileName) {  
   33.         SAXParserFactory saxfac = SAXParserFactory.newInstance();  
   34.         try {  
   35.             SAXParser saxparser = saxfac.newSAXParser();  
   36.             InputStream is = new FileInputStream(fileName);  
   37.             saxparser.parse(is, new MySAXHandler());  
   38.         } catch (ParserConfigurationException e) {  
   39.             e.printStackTrace();  
   40.         } catch (SAXException e) {  
   41.             e.printStackTrace();  
   42.         } catch (FileNotFoundException e) {  
   43.             e.printStackTrace();  
   44.         } catch (IOException e) {  
   45.             e.printStackTrace();  
   46.         }  
   47.     }  
   48. }  
   49.   
   50. class MySAXHandler extends DefaultHandler {  
   51.     boolean hasAttribute = false;  
   52.     Attributes attributes = null;  
   53.   
   54.     public void startDocument() throws SAXException {  
   55.         System.out.println("文档开始打印了");  
   56.     }  
   57.   
   58.     public void endDocument() throws SAXException {  
   59.         System.out.println("文档打印结束了");  
   60.     }  
   61.   
   62.     public void startElement(String uri, String localName, String qName,  
   63.             Attributes attributes) throws SAXException {  
   64.         if (qName.equals("employees")) {  
   65.             return;  
   66.         }  
   67.         if (qName.equals("employee")) {  
   68.             System.out.println(qName);  
   69.         }  
   70.   
   71.         if (attributes.getLength() > 0) {  
   72.             this.attributes = attributes;  
   73.             this.hasAttribute = true;  
   74.         }  
   75.   
   76.     }  
   77.   
   78.     public void endElement(String uri, String localName, String qName)  
   79.             throws SAXException {  
   80.         if (hasAttribute && (attributes != null)) {  
   81.             for (int i = 0; i < attributes.getLength(); i++) {  
   82.                 System.out.println(attributes.getQName(0)  
   83.                         + attributes.getValue(0));  
   84.             }  
   85.         }  
   86.     }  
   87.   
   88.     public void characters(char[] ch, int start, int length)  
   89.             throws SAXException {  
   90.         System.out.println(new String(ch, start, length));  
   91.     }  
   92.   
   93. }  
   
   
   

3. DOM4J生成和解析文档  DOM4J 是一个非常优秀的Java XML API ，具有性能优异、功能强大和极端易用的特点，同时它也是一个开源的软件。如今你可以看到越来越多的Jaca软件都在使用DOM4J来独秀XML，特别值得一提的是连SUN 的JAXM也在用DOM4J。
   [java]   view plain copy print ?

   1. package com.mwh.test.readXml;  
   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.  *  
   18.  * @author mwh Dom4j 生成XML文档与解析XML文档 
   19.  */  
   20. public class Dom4jDemo implements XmlDocument {  
   21.     public static void main(String args[]) {  
   22.         Dom4jDemo dd = new Dom4jDemo();  
   23.         String str = "D:/grade.xml";  
   24.         dd.createXml(str); // 创建xml  
   25.         dd.parserXml(str); // 读取xml  
   26.     }  
   27.   
   28.     public void createXml(String fileName) {  
   29.         Document document = DocumentHelper.createDocument();  
   30.         Element employees = document.addElement("employees");  
   31.         Element employee = employees.addElement("employee");  
   32.         Element name = employee.addElement("name");  
   33.         name.setText("年华已逝不爱财");  
   34.         Element sex = employee.addElement("sex");  
   35.         sex.setText("男");  
   36.         Element age = employee.addElement("age");  
   37.         age.setText("24");  
   38.         try {  
   39.             Writer fileWriter = new FileWriter(fileName);  
   40.             XMLWriter xmlWriter = new XMLWriter(fileWriter);  
   41.             xmlWriter.write(document);  
   42.             xmlWriter.close();  
   43.         } catch (IOException e) {  
   44.             System.out.println(e.getMessage());  
   45.         }  
   46.     }  
   47.   
   48.     public void parserXml(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. }  
   关于DOM4J这里推荐一篇好文章http://www.blogjava.net/i369/articles/154264.html
4. JDOM生成和解析XML   为减少DOM、SAX的编码量，出现了JDOM；优点：20-80原则，极大减少了代码量。使用场合：要实现的功能简单，如创建、解析等，但在底层，JDOM还是用用SAX（最常用）、DOM、Xanan文档。
   [java]   view plain copy print ?

   1. package com.mwh.test.readXml;  
   2.   
   3. import java.io.FileNotFoundException;  
   4. import java.io.FileOutputStream;  
   5. import java.io.IOException;  
   6. import java.util.Iterator;  
   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.  * @author mwh JDOM 生成与解析XML文档 
   18.  *  
   19.  */  
   20. public class JDomDemo implements XmlDocument {  
   21.     public static void main(String args[]) {  
   22.         JDomDemo dd = new JDomDemo();  
   23.         String str = "D:/grade.xml";  
   24.         dd.createXml(str); // 创建xml  
   25.         dd.parserXml(str); // 读取xml  
   26.     }  
   27.     public void createXml(String fileName) {  
   28.         Document document;  
   29.         Element root;  
   30.         root = new Element("employees");  
   31.         document = new Document(root);  
   32.         Element employee = new Element("employee");  
   33.         root.addContent(employee);  
   34.         Element name = new Element("name");  
   35.         name.setText("年华已逝不爱财");  
   36.         employee.addContent(name);  
   37.         Element sex = new Element("sex");  
   38.         sex.setText("m");  
   39.         employee.addContent(sex);  
   40.         Element age = new Element("age");  
   41.         age.setText("23");  
   42.         employee.addContent(age);  
   43.         XMLOutputter XMLOut = new XMLOutputter();  
   44.         try {  
   45.             XMLOut.output(document, new FileOutputStream(fileName));  
   46.         } catch (FileNotFoundException e) {  
   47.             e.printStackTrace();  
   48.         } catch (IOException e) {  
   49.             e.printStackTrace();  
   50.         }  
   51.   
   52.     }  
   53.   
   54.     public void parserXml(String fileName) {  
   55.         SAXBuilder builder = new SAXBuilder(false);  
   56.         try {  
   57.             Document document;  
   58.             document = builder.build(fileName);  
   59.             Element root = document.getRootElement();// 获得根节点  
   60.             List<Element> list = root.getChildren();  
   61.             for (Element e : list) {  
   62.                 System.out.println("name="+ e.getChildText("name"));  
   63.                 System.out.println("age=" + e.getChildText("age"));  
   64.                 System.out.println("sex=" + e.getChildText("sex"));  
   65.             }  
   66.         } catch (JDOMException e1) {  
   67.             // TODO Auto-generated catch block  
   68.             e1.printStackTrace();  
   69.         } catch (IOException e1) {  
   70.             // TODO Auto-generated catch block  
   71.             e1.printStackTrace();  
   72.         }  
   73.     }  
   74. }  

结果内容：

[java]   view plain copy print ?

1. name=年华已逝不爱财  
2. age=23  
3. sex=m