Java解析xml

Java的xml解析器库有很多，总的来说，万变不离其宗的就是SAX和DOM解析器。

SAX的包是org.xml.sax

DOM的包是org.w3c.dom

 

1) DOM

     DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。 

     另一方面，对于特别大的文档，解析和加载整个文档可能很慢且很耗资源，因此使用其他手段来处理这样的数据会更好。这些基于事件的模型，比如 SAX。 

 

2) SAX 

     这种处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX 还比它的替代者 DOM 快许多。 

 

3) 选择 DOM 还是选择 SAX ？ 

     对于需要自己编写代码来处理 XML 文档的开发人员来说，选择 DOM 还是 SAX 解析模型是一个非常重要的设计决策。

     DOM 采用建立树形结构的方式访问 XML 文档，而 SAX 采用的事件模型。 

     DOM 解析器把 XML 文档转化为一个包含其内容的树，并可以对树进行遍历。用 DOM 解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigationAPIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用 DOM 解析器的时候需要处理整个 XML 文档，所以对性能和内存的要求比较高，尤其是遇到很大的 XML 文件的时候。由于它的遍历能力，DOM 解析器常用于 XML 文档需要频繁的改变的服务中。 

　　SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

 

个人总结

*******************

DOM：

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

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

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

       使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）

 

SAX：

       事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。

       优点：不用事先调入整个文档，占用资源少

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

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

       注意:SAX 解析器不创建任何对象。

 

***********************

DOM和SAX的使用例子 (http://sinye.javaeye.com/blog/763926 / http://www.javaeye.com/topic/763895)

Xml文件内容

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

2. <books> 

3.     <book id="12"> 

4.         <name>thinking in java</name> 

5.         <price>85.5</price> 

6.     </book> 

7.     <book id="15"> 

8.         <name>Spring in Action</name> 

9.         <price>39.0</price> 

10.     </book> 

11. </books> 

Book.java如下：主要是用来组装数据

1. public class Book { 

2.     private int id; 

3.     private String name; 

4.     private float price; 

5.  

6.     public int getId() { 

7.         return id; 

8.     } 

9.  

10.     public void setId(int id) { 

11.         this.id = id; 

12.     } 

13.  

14.     public String getName() { 

15.         return name; 

16.     } 

17.  

18.     public void setName(String name) { 

19.         this.name = name; 

20.     } 

21.  

22.     public float getPrice() { 

23.         return price; 

24.     } 

25.  

26.     public void setPrice(float price) { 

27.         this.price = price; 

28.     } 

29.      

30.     @Override 

31.     public String toString(){ 

32.         return this.id+":"+this.name+":"+this.price; 

33.     } 

34. } 

1. Dom解析是将xml文件全部载入，组装成一颗dom树，然后通过节点以及节点之间的关系来解析xml文件，结合一张图来发现dom解析时需要注意的地方

在这里当我们得到节点book时，也就是图中1所画的地方，如果我们调用它的getChildNodes()方法，大家猜猜它的子节点有几个？不包括它的孙子节点，thinkingin java这种的除外，因为它是孙子节点。它总共有5个子节点，分别是图中2、3、4、5、6所示的那样。所以在解析时，一定要小心，不要忽略空白的地方。

然后看代码来解析book.xml文件 DomParseService.java

1. import java.io.InputStream; 

2. import java.util.ArrayList; 

3. import java.util.List; 

4.  

5. import javax.xml.parsers.DocumentBuilder; 

6. import javax.xml.parsers.DocumentBuilderFactory; 

7.  

8. import org.w3c.dom.Document; 

9. import org.w3c.dom.Element; 

10. import org.w3c.dom.NodeList; 

11. import org.w3c.dom.Node; 

12.  

13. import com.xtlh.cn.entity.Book; 

14.  

15. public class DomParseService { 

16.     public List<Book> getBooks(InputStream inputStream) throws Exception{ 

17.         List<Book> list = new ArrayList<Book>(); 

18.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 

19.         DocumentBuilder builder = factory.newDocumentBuilder(); 

20.         Document document = builder.parse(inputStream); 

21.         Element element = document.getDocumentElement(); 

22.  

23.         NodeList bookNodes = element.getElementsByTagName("book"); 

24.         for(int i=0;i<bookNodes.getLength();i++){ 

25.             Element bookElement = (Element) bookNodes.item(i); 

26.             Book book = new Book(); 

27.             book.setId(Integer.parseInt(bookElement.getAttribute("id"))); 

28.             NodeList childNodes = bookElement.getChildNodes(); 

29. //          System.out.println("*****"+childNodes.getLength()); 

30.             for(int j=0;j<childNodes.getLength();j++){ 

31.                 if(childNodes.item(j).getNodeType()==Node.ELEMENT_NODE){ 

32.                     if("name".equals(childNodes.item(j).getNodeName())){ 

33.                         book.setName(childNodes.item(j).getFirstChild().getNodeValue()); 

34.                     }else if("price".equals(childNodes.item(j).getNodeName())){ 

35.                         book.setPrice(Float.parseFloat(childNodes.item(j).getFirstChild().getNodeValue())); 

36.                     } 

37.                 } 

38.             }//end for j 

39.             list.add(book); 

40.         }//end for i 

41.         return list; 

42.     } 

43. } 

测试使用单元测试如下ParseTest.java

1. public class ParseTest extends TestCase{ 

2.  

3.     public void testDom() throws Exception{ 

4.         InputStream input = this.getClass().getClassLoader().getResourceAsStream("book.xml"); 

5.         DomParseService dom = new DomParseService(); 

6.         List<Book> books = dom.getBooks(input); 

7.         for(Book book : books){ 

8.             System.out.println(book.toString()); 

9.         } 

10.     } 

11. } 

 

2. Sax解析是按照xml文件的顺序一步一步的来解析，在解析xml文件之前，我们要先了解xml文件的节点的种类，一种是ElementNode，一种是TextNode。

    其中，像<books>、<book>这种节点就属于ElementNode,而thinking in java、85.5这种就属于TextNode。

下面结合一张图来详细讲解Sax解析。

    xml文件被Sax解析器载入，由于Sax解析是按照xml文件的顺序来解析，当读入<?xml.....>时，会调用startDocument()方法，当读入<books>的时候，由于它是个ElementNode，所以会调用startElement(String uri, String localName, String qName, Attributesattributes) 方法，其中第二个参数就是节点的名称，注意：由于有些环境不一样，有时候第二个参数有可能为空，所以可以使用第三个参数，因此在解析前，先调用一下看哪个参数能用，第4个参数是这个节点的属性。这里我们不需要这个节点，所以从<book>这个节点开始，也就是图中1的位置，当读入时，调用startElement(....)方法，由于只有一个属性id，可以通过attributes.getValue(0)来得到，然后在图中标明2的地方会调用characters(char[] ch, int start, intlength)方法，不要以为那里是空白，Sax解析器可不那么认为，Sax解析器会把它认为是一个TextNode。但是这个空白不是我们想要的数据，我们是想要<name>节点下的文本信息。这就要定义一个记录当上一节点的名称的TAG，在characters(.....)方法中，判断当前节点是不是name，是再取值，才能取到thinking in java。具体见代码：SaxParseService.java

1. import java.io.InputStream; 

2. import java.util.ArrayList; 

3. import java.util.List; 

4.  

5. import javax.xml.parsers.SAXParser; 

6. import javax.xml.parsers.SAXParserFactory; 

7.  

8. import org.xml.sax.Attributes; 

9. import org.xml.sax.SAXException; 

10. import org.xml.sax.helpers.DefaultHandler; 

11.  

12. import com.xtlh.cn.entity.Book; 

13.  

14. public class SaxParseService extends DefaultHandler{ 

15.     private List<Book> books = null; 

16.     private Book book = null; 

17.     private String preTag = null;//作用是记录解析时的上一个节点名称 

18.  

19.     public List<Book> getBooks(InputStream xmlStream) throws Exception{ 

20.         SAXParserFactory factory = SAXParserFactory.newInstance(); 

21.         SAXParser parser = factory.newSAXParser(); 

22.         SaxParseService handler = new SaxParseService(); 

23.         parser.parse(xmlStream, handler); 

24.         return handler.getBooks(); 

25.     } 

26.  

27.     public List<Book> getBooks(){ 

28.         return books; 

29.     } 

30.  

31.     @Override 

32.     public void startDocument() throws SAXException { 

33.         books = new ArrayList<Book>(); 

34.     } 

35.  

36.     @Override 

37.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { 

38.         if("book".equals(qName)){ 

39.             book = new Book(); 

40.             book.setId(Integer.parseInt(attributes.getValue(0))); 

41.         } 

42.         preTag = qName;//将正在解析的节点名称赋给preTag 

43.     } 

44.  

45.     @Override 

46.     public void endElement(String uri, String localName, String qName) 

47.             throws SAXException { 

48.         if("book".equals(qName)){ 

49.             books.add(book); 

50.             book = null; 

51.         } 

52.         preTag = null;/**当解析结束时置为空。这里很重要，例如，当图中画3的位置结束后，会调用这个方法 

53.         ，如果这里不把preTag置为null，根据startElement(....)方法，preTag的值还是book，当文档顺序读到图 

54.         中标记4的位置时，会执行characters(char[] ch, int start, int length)这个方法，而characters(....)方 

55.         法判断preTag!=null，会执行if判断的代码，这样就会把空值赋值给book，这不是我们想要的。*/ 

56.     } 

57.  

58.     @Override 

59.     public void characters(char[] ch, int start, int length) throws SAXException { 

60.         if(preTag!=null){ 

61.             String content = new String(ch,start,length); 

62.             if("name".equals(preTag)){ 

63.                 book.setName(content); 

64.             }else if("price".equals(preTag)){ 

65.                 book.setPrice(Float.parseFloat(content)); 

66.             } 

67.         } 

68.     } 

69.  

70. } 

测试是用的单元测试，测试代码如下：ParseTest

1. import java.io.InputStream; 

2. import java.util.List; 

3.  

4. import junit.framework.TestCase; 

5.  

6. import com.xtlh.cn.demo.DomParseService; 

7. import com.xtlh.cn.demo.SaxParseService; 

8. import com.xtlh.cn.entity.Book; 

9.  

10. public class ParseTest extends TestCase{ 

11.  

12.     public void testSAX() throws Throwable{ 

13.         SaxParseService sax = new SaxParseService(); 

14.         InputStream input = this.getClass().getClassLoader().getResourceAsStream("book.xml"); 

15.         List<Book> books = sax.getBooks(input); 

16.         for(Book book : books){ 

17.             System.out.println(book.toString()); 

18.         } 

19.     } 

20. } 

在用Sax解析的时候最需要重视的一点就是不要把那些<节点>之间的空白忽略就好！