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 Transformations),具体可参阅w3c官方网站文档http://www.w3.org获取更多信息。

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

<?xml version="1.0" encoding="UTF-8"?>

<employees>

  <employee>

    <name>ddviplinux</name>

    <sex>m</sex>

    <age>30</age>

  </employee>

   <employee>

    <name>david</name>

    <sex>f</sex>

    <age>30</age>

  </employee>

</employees>

定义一个操作四种XML文档的接口XmlDocument.java

 

1. package com.alisoft.facepay.framework.bean;
3. public interface XmlDocument {
4. public void createXml(String fileName);
5. public void parserXml(String fileName);
6. }

为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。

 

 

1. package com.alisoft.facepay.framework.bean;
3. import java.io.FileInputStream;
4. import java.io.FileNotFoundException;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. import java.io.InputStream;
8. import java.io.PrintWriter;
10. import javax.xml.parsers.DocumentBuilder;
11. import javax.xml.parsers.DocumentBuilderFactory;
12. import javax.xml.parsers.ParserConfigurationException;
13. import javax.xml.transform.OutputKeys;
14. import javax.xml.transform.Transformer;
15. import javax.xml.transform.TransformerConfigurationException;
16. import javax.xml.transform.TransformerException;
17. import javax.xml.transform.TransformerFactory;
18. import javax.xml.transform.dom.DOMSource;
19. import javax.xml.transform.stream.StreamResult;
21. import org.w3c.dom.Document;
22. import org.w3c.dom.Element;
23. import org.w3c.dom.Node;
24. import org.w3c.dom.NodeList;
25. import org.xml.sax.SAXException;
27. public class DomDemo implements XmlDocument {
28.     @SuppressWarnings("unused")
29.     private Document document;
31.     @SuppressWarnings("unused")
32.     private String fileName;
34.     public void init() {
35.         try {
36.             DocumentBuilderFactory factory = DocumentBuilderFactory
37.                     .newInstance();
38.             DocumentBuilder builder = factory.newDocumentBuilder();
39.             this.document = builder.newDocument();
40.         } catch (ParserConfigurationException e) {
41.             System.out.println(e.getMessage());
42.         }
43.     }
45.     public void createXml(String fileName) {
47.         Element root = this.document.createElement("employees");
48.         this.document.appendChild(root);
49.         Element employee = this.document.createElement("employee");
50.         Element name = this.document.createElement("name");
51.         name.appendChild(this.document.createTextNode("丁宏亮"));
52.         employee.appendChild(name);
53.         Element sex = this.document.createElement("sex");
54.         sex.appendChild(this.document.createTextNode("m"));
55.         employee.appendChild(sex);
56.         Element age = this.document.createElement("age");
57.         age.appendChild(this.document.createTextNode("30"));
58.         employee.appendChild(age);
59.         root.appendChild(employee);
61.         TransformerFactory tf = TransformerFactory.newInstance();
62.         try {
63.             Transformer transformer = tf.newTransformer();
64.             DOMSource source = new DOMSource(document);
65.             transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312");
66.             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
67.             PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
68.             StreamResult result = new StreamResult(pw);
69.             transformer.transform(source, result);
70.             System.out.println("生成XML文件成功!");
71.         } catch (TransformerConfigurationException e) {
73.             System.out.println(e.getMessage());
74.         } catch (IllegalArgumentException e) {
76.             System.out.println(e.getMessage());
77.         } catch (FileNotFoundException e) {
79.             System.out.println(e.getMessage());
80.         } catch (TransformerException e) {
82.             System.out.println(e.getMessage());
83.         }
85.     }
87.     public void parserXml(String fileName) {
88.         try {
89.             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
90.             DocumentBuilder db = dbf.newDocumentBuilder();
91.             Document document = db.parse(fileName);
92.             NodeList employees = document.getChildNodes();
93.             for (int i = 0; i < employees.getLength(); i++) {
94.                 Node employee = employees.item(i);
95.                 NodeList employeeInfo = employee.getChildNodes();
96.                 for (int j = 0; j < employeeInfo.getLength(); j++) {
97.                     Node node = employeeInfo.item(j);
98.                     NodeList employeeMeta = node.getChildNodes();
99.                     for (int k = 0; k < employeeMeta.getLength(); k++) {
100.                         System.out.println(employeeMeta.item(k).getNodeName()
101.                                 + ":" + employeeMeta.item(k).getTextContent());
102.                     }
103.                 }
104.             }
105.             System.out.println("解析完毕");
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.         }
116.     }
119. }

    为解决DOM的问题，出现了SAX。SAX ，事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；

 

 

 

 

1. package com.alisoft.facepay.framework.bean;
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.SAXException;
14. import org.xml.sax.helpers.DefaultHandler;
16. public class SaxDemo implements XmlDocument {
18.     public void createXml(String fileName) {
19.      
20.     }
22.     public void parserXml(String fileName) {
23.         SAXParserFactory saxfac = SAXParserFactory.newInstance();
25.         try {
27.             SAXParser saxparser = saxfac.newSAXParser();
29.             InputStream is = new FileInputStream(fileName);
31.             saxparser.parse(is, new MySAXHandler());
33.         } catch (ParserConfigurationException e) {
35.             e.printStackTrace();
37.         } catch (SAXException e) {
39.             e.printStackTrace();
41.         } catch (FileNotFoundException e) {
43.             e.printStackTrace();
45.         } catch (IOException e) {
47.             e.printStackTrace();
49.         }
51.     }
53. }
55. class MySAXHandler extends DefaultHandler {
57.     boolean hasAttribute = false;
59.     Attributes attributes = null;
61.     public void startDocument() throws SAXException {
63.         System.out.println("文档开始打印了");
65.     }
67.     public void endDocument() throws SAXException {
69.         System.out.println("文档打印结束了");
71.     }
73.     public void startElement(String uri, String localName, String qName,
75.     Attributes attributes) throws SAXException {
77.         if (qName.equals("employees")) {
79.             return;
81.         }
83.         if (qName.equals("employee")) {
85.             System.out.println(qName);
87.         }
89.         if (attributes.getLength() > 0) {
91.             this.attributes = attributes;
93.             this.hasAttribute = true;
95.         }
97.     }
99.     public void endElement(String uri, String localName, String qName)
101.     throws SAXException {
103.         if (hasAttribute && (attributes != null)) {
105.             for (int i = 0; i < attributes.getLength(); i++) {
107.                 System.out.println(attributes.getQName(0)
108.                         + attributes.getValue(0));
110.             }
112.         }
114.     }
116.     public void characters(char[] ch, int start, int length)
118.     throws SAXException {
120.         System.out.println(new String(ch, start, length));
122.     }
124. }

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

 

 

 

1. package com.alisoft.facepay.framework.bean;
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. public class Dom4jDemo implements XmlDocument {
18.     public void createXml(String fileName) {
19.         Document document = DocumentHelper.createDocument();
20.         Element employees=document.addElement("employees");
21.         Element employee=employees.addElement("employee");
22.         Element name= employee.addElement("name");
23.         name.setText("ddvip");
24.         Element sex=employee.addElement("sex");
25.         sex.setText("m");
26.         Element age=employee.addElement("age");
27.         age.setText("29");
28.         try {
29.             Writer fileWriter=new FileWriter(fileName);
30.             XMLWriter xmlWriter=new XMLWriter(fileWriter);
31.             xmlWriter.write(document);
32.             xmlWriter.close();
33.         } catch (IOException e) {
34.             
35.             System.out.println(e.getMessage());
36.         }
37.         
38.         
39.     }
42.     public void parserXml(String fileName) {
43.          File inputXml=new File(fileName);
44.          SAXReader saxReader = new SAXReader();
45.          try {
46.             Document document = saxReader.read(inputXml);
47.             Element employees=document.getRootElement();
48.             for(Iterator i = employees.elementIterator(); i.hasNext();){
49.                  Element employee = (Element) i.next();
50.                  for(Iterator j = employee.elementIterator(); j.hasNext();){
51.                      Element node=(Element) j.next();
52.                      System.out.println(node.getName()+":"+node.getText());
53.                  }
55.             }
56.         } catch (DocumentException e) {
57.             System.out.println(e.getMessage());
58.         }
59.      System.out.println("dom4j parserXml");
60.     }
63. }

 

4.       JDOM生成和解析XML

为减少DOM、SAX的编码量，出现了JDOM；优点：20-80原则，极大减少了代码量。使用场合：要实现的功能简单，如解析、创建等，但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。

 

 

 

 

 

1. package com.alisoft.facepay.framework.bean;
3. import java.io.FileNotFoundException;
4. import java.io.FileOutputStream;
5. import java.io.IOException;
6. import java.util.List;
8. import org.jdom.Document;
9. import org.jdom.Element;
10. import org.jdom.JDOMException;
11. import org.jdom.input.SAXBuilder;
12. import org.jdom.output.XMLOutputter;
14. public class JDomDemo implements XmlDocument {
16.     public void createXml(String fileName) {
17.       Document document;
18.       Element  root;
19.       root=new Element("employees");
20.       document=new Document(root);
21.       Element employee=new Element("employee");
22.       root.addContent(employee);
23.       Element name=new Element("name");
24.       name.setText("ddvip");
25.       employee.addContent(name);
26.       Element sex=new Element("sex");
27.       sex.setText("m");
28.       employee.addContent(sex);
29.       Element age=new Element("age");
30.       age.setText("23");
31.       employee.addContent(age);
32.       XMLOutputter XMLOut = new XMLOutputter();
33.       try {
34.         XMLOut.output(document, new FileOutputStream(fileName));
35.     } catch (FileNotFoundException e) {
36.         e.printStackTrace();
37.     } catch (IOException e) {
38.         e.printStackTrace();
39.     }
41.     }
43.     public void parserXml(String fileName) {
44.         SAXBuilder builder=new SAXBuilder(false); 
45.         try {
46.             Document document=builder.build(fileName);
47.             Element employees=document.getRootElement(); 
48.             List employeeList=employees.getChildren("employee");
49.             for(int i=0;i<employeeList.size();i++){
50.                 Element employee=(Element)employeeList.get(i);
51.                 List employeeInfo=employee.getChildren();
52.                 for(int j=0;j<employeeInfo.size();j++){
53.                     System.out.println(((Element)employeeInfo.get(j)).getName()+":"+((Element)employeeInfo.get(j)).getValue());
54.                     
55.                 }
56.             }
57.         } catch (JDOMException e) {
58.         
59.             e.printStackTrace();
60.         } catch (IOException e) {
61.         
62.             e.printStackTrace();
63.         } 
65.     }
66. }

 

3.       DOM4J生成和解析XML文档

2.       SAX生成和解析XML文档

1.       DOM生成和解析XML文档