XML的4种解析及对比

前端之家收集整理的这篇文章主要介绍了XML的4种解析及对比前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

转载于http://www.cnblogs.com/jiugehuanying/archive/2012/01/12/2320058.html

关键字:Java解析xml、解析xml四种方法、DOM、SAX、JDOM、DOM4j、XPath

【引言】

目前在Java中用于解析XML的技术很多,主流的有DOM、SAX、JDOM、DOM4j,下文主要介绍这4种解析XML文档技术的使用、优缺点及性能测试。

一、【基础知识——扫盲】

sax、dom是两种对xml文档进行解析的方法(没有具体实现,只是接口),所以只有它们是无法解析xml文档的;jaxp只是api,它进一步封装了sax、dom两种接口,并且提供了DomcumentBuilderFactory/DomcumentBuilder和SAXParserFactory/SAXParser(默认使用xerces解释器)。

二、【DOM、SAX、JDOM、DOM4j简单使用介绍】

1、【DOM(Document Object Model) 】
由W3C提供的接口,它将整个XML文档读入内存,构建一个DOM树来对各个节点(Node)进行操作。
示例代码

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <universityname="pku">
  3. <collegename="c1">
  4. <classname="class1">
  5. <studentname="stu1"sex='male'age="21"/>
  6. <studentname="stu2"sex='female'age="20"/>
  7. <studentname="stu3"sex='female'age="20"/>
  8. </class>
  9. <classname="class2">
  10. <studentname="stu4"sex='male'age="19"/>
  11. <studentname="stu5"sex='female'age="20"/>
  12. <studentname="stu6"sex='female'age="21"/>
  13. </class>
  14. </college>
  15. <collegename="c2">
  16. <classname="class3">
  17. <studentname="stu7"sex='male'age="20"/>
  18. </class>
  19. </college>
  20. <collegename="c3">
  21. </college>
  22. </university>

后文代码中有使用到text.xml(该文档放在src路径下,既编译后在classes路径下),都是指该xml文档。

  1. packagetest.xml;
  2. importjava.io.File;
  3. importjava.io.FileNotFoundException;
  4. importjava.io.FileOutputStream;
  5. importjava.io.IOException;
  6. importjava.io.InputStream;
  7. importjavax.xml.parsers.DocumentBuilder;
  8. importjavax.xml.parsers.DocumentBuilderFactory;
  9. importjavax.xml.parsers.ParserConfigurationException;
  10. importjavax.xml.transform.Transformer;
  11. importjavax.xml.transform.TransformerConfigurationException;
  12. importjavax.xml.transform.TransformerException;
  13. importjavax.xml.transform.TransformerFactory;
  14. importjavax.xml.transform.dom.DOMSource;
  15. importjavax.xml.transform.stream.StreamResult;
  16. importorg.w3c.dom.Document;
  17. importorg.w3c.dom.Element;
  18. importorg.w3c.dom.Node;
  19. importorg.w3c.dom.NodeList;
  20. importorg.w3c.dom.Text;
  21. importorg.xml.sax.SAXException;
  22. /**
  23. *dom读写xml
  24. *@authorwhwang
  25. */
  26. publicclassTestDom{
  27. publicstaticvoidmain(String[]args){
  28. read();
  29. //write();
  30. }
  31. publicstaticvoidread(){
  32. DocumentBuilderFactorydbf=DocumentBuilderFactory.newInstance();
  33. try{
  34. DocumentBuilderbuilder=dbf.newDocumentBuilder();
  35. InputStreamin=TestDom.class.getClassLoader().getResourceAsStream("test.xml");
  36. Documentdoc=builder.parse(in);
  37. //root<university>
  38. Elementroot=doc.getDocumentElement();
  39. if(root==null)return;
  40. System.err.println(root.getAttribute("name"));
  41. //allcollegenode
  42. NodeListcollegeNodes=root.getChildNodes();
  43. if(collegeNodes==null)return;
  44. for(inti=0;i<collegeNodes.getLength();i++){
  45. Nodecollege=collegeNodes.item(i);
  46. if(college!=null&&college.getNodeType()==Node.ELEMENT_NODE){
  47. System.err.println("\t"+college.getAttributes().getNamedItem("name").getNodeValue());
  48. //allclassnode
  49. NodeListclassNodes=college.getChildNodes();
  50. if(classNodes==null)continue;
  51. for(intj=0;j<classNodes.getLength();j++){
  52. Nodeclazz=classNodes.item(j);
  53. if(clazz!=null&&clazz.getNodeType()==Node.ELEMENT_NODE){
  54. System.err.println("\t\t"+clazz.getAttributes().getNamedItem("name").getNodeValue());
  55. //allstudentnode
  56. NodeListstudentNodes=clazz.getChildNodes();
  57. if(studentNodes==null)continue;
  58. for(intk=0;k<studentNodes.getLength();k++){
  59. Nodestudent=studentNodes.item(k);
  60. if(student!=null&&student.getNodeType()==Node.ELEMENT_NODE){
  61. System.err.print("\t\t\t"+student.getAttributes().getNamedItem("name").getNodeValue());
  62. System.err.print(""+student.getAttributes().getNamedItem("sex").getNodeValue());
  63. System.err.println(""+student.getAttributes().getNamedItem("age").getNodeValue());
  64. }
  65. }
  66. }
  67. }
  68. }
  69. }
  70. }catch(ParserConfigurationExceptione){
  71. e.printStackTrace();
  72. }catch(FileNotFoundExceptione){
  73. e.printStackTrace();
  74. }catch(SAXExceptione){
  75. e.printStackTrace();
  76. }catch(IOExceptione){
  77. e.printStackTrace();
  78. }
  79. }
  80. publicstaticvoidwrite(){
  81. DocumentBuilderFactorydbf=DocumentBuilderFactory.newInstance();
  82. try{
  83. DocumentBuilderbuilder=dbf.newDocumentBuilder();
  84. InputStreamin=TestDom.class.getClassLoader().getResourceAsStream("test.xml");
  85. Documentdoc=builder.parse(in);
  86. //root<university>
  87. Elementroot=doc.getDocumentElement();
  88. if(root==null)return;
  89. //修改属性
  90. root.setAttribute("name","tsu");
  91. NodeListcollegeNodes=root.getChildNodes();
  92. if(collegeNodes!=null){
  93. for(inti=0;i<collegeNodes.getLength()-1;i++){
  94. //删除节点
  95. Nodecollege=collegeNodes.item(i);
  96. if(college.getNodeType()==Node.ELEMENT_NODE){
  97. StringcollegeName=college.getAttributes().getNamedItem("name").getNodeValue();
  98. if("c1".equals(collegeName)||"c2".equals(collegeName)){
  99. root.removeChild(college);
  100. }elseif("c3".equals(collegeName)){
  101. ElementnewChild=doc.createElement("class");
  102. newChild.setAttribute("name","c4");
  103. college.appendChild(newChild);
  104. }
  105. }
  106. }
  107. }
  108. //新增节点
  109. ElementaddCollege=doc.createElement("college");
  110. addCollege.setAttribute("name","c5");
  111. root.appendChild(addCollege);
  112. Texttext=doc.createTextNode("text");
  113. addCollege.appendChild(text);
  114. //将修改后的文档保存到文件
  115. TransformerFactorytransFactory=TransformerFactory.newInstance();
  116. TransformertransFormer=transFactory.newTransformer();
  117. DOMSourcedomSource=newDOMSource(doc);
  118. Filefile=newFile("src/dom-modify.xml");
  119. if(file.exists()){
  120. file.delete();
  121. }
  122. file.createNewFile();
  123. FileOutputStreamout=newFileOutputStream(file);
  124. StreamResultxmlResult=newStreamResult(out);
  125. transFormer.transform(domSource,xmlResult);
  126. System.out.println(file.getAbsolutePath());
  127. }catch(ParserConfigurationExceptione){
  128. e.printStackTrace();
  129. }catch(SAXExceptione){
  130. e.printStackTrace();
  131. }catch(IOExceptione){
  132. e.printStackTrace();
  133. }catch(TransformerConfigurationExceptione){
  134. e.printStackTrace();
  135. }catch(TransformerExceptione){
  136. e.printStackTrace();
  137. }
  138. }
  139. }

代码只要稍做修改,即可变得更加简洁,无需一直写if来判断是否有子节点。

2、【SAX (Simple API for XML) 】
SAX不用将整个文档加载到内存,基于事件驱动的API(Observer模式),用户只需要注册自己感兴趣的事件即可。SAX提供EntityResolver,DTDHandler,ContentHandler,ErrorHandler接口,分别用于监听解析实体事件、DTD处理事件、正文处理事件和处理出错事件,与AWT类似,SAX还提供了一个对这4个接口默认的类DefaultHandler(这里的默认实现,其实就是一个空方法),一般只要继承DefaultHandler,重写自己感兴趣的事件即可。
示例代码

  1. packagetest.xml;
  2. importjava.io.IOException;
  3. importjava.io.InputStream;
  4. importjavax.xml.parsers.ParserConfigurationException;
  5. importjavax.xml.parsers.SAXParser;
  6. importjavax.xml.parsers.SAXParserFactory;
  7. importorg.xml.sax.Attributes;
  8. importorg.xml.sax.InputSource;
  9. importorg.xml.sax.Locator;
  10. importorg.xml.sax.SAXException;
  11. importorg.xml.sax.SAXParseException;
  12. importorg.xml.sax.helpers.DefaultHandler;
  13. /**
  14. *
  15. *@authorwhwang
  16. */
  17. publicclassTestSAX{
  18. publicstaticvoidmain(String[]args){
  19. read();
  20. write();
  21. }
  22. publicstaticvoidread(){
  23. try{
  24. SAXParserFactoryfactory=SAXParserFactory.newInstance();
  25. SAXParserparser=factory.newSAXParser();
  26. InputStreamin=TestSAX.class.getClassLoader().getResourceAsStream("test.xml");
  27. parser.parse(in,newMyHandler());
  28. }catch(ParserConfigurationExceptione){
  29. e.printStackTrace();
  30. }catch(SAXExceptione){
  31. e.printStackTrace();
  32. }catch(IOExceptione){
  33. e.printStackTrace();
  34. }
  35. }
  36. publicstaticvoidwrite(){
  37. System.err.println("纯SAX对于写操作无能为力");
  38. }
  39. }
  40. //重写对自己感兴趣的事件处理方法
  41. classMyHandlerextendsDefaultHandler{
  42. @Override
  43. publicInputSourceresolveEntity(StringpublicId,StringsystemId)
  44. throwsIOException,SAXException{
  45. returnsuper.resolveEntity(publicId,systemId);
  46. }
  47. @Override
  48. publicvoidnotationDecl(Stringname,StringpublicId,StringsystemId)
  49. throwsSAXException{
  50. super.notationDecl(name,publicId,systemId);
  51. }
  52. @Override
  53. publicvoidunparsedEntityDecl(Stringname,
  54. StringsystemId,StringnotationName)throwsSAXException{
  55. super.unparsedEntityDecl(name,systemId,notationName);
  56. }
  57. @Override
  58. publicvoidsetDocumentLocator(Locatorlocator){
  59. super.setDocumentLocator(locator);
  60. }
  61. @Override
  62. publicvoidstartDocument()throwsSAXException{
  63. System.err.println("开始解析文档");
  64. }
  65. @Override
  66. publicvoidendDocument()throwsSAXException{
  67. System.err.println("解析结束");
  68. }
  69. @Override
  70. publicvoidstartPrefixMapping(Stringprefix,Stringuri)
  71. throwsSAXException{
  72. super.startPrefixMapping(prefix,uri);
  73. }
  74. @Override
  75. publicvoidendPrefixMapping(Stringprefix)throwsSAXException{
  76. super.endPrefixMapping(prefix);
  77. }
  78. @Override
  79. publicvoidstartElement(Stringuri,StringlocalName,StringqName,
  80. Attributesattributes)throwsSAXException{
  81. System.err.print("Element:"+qName+",attr:");
  82. print(attributes);
  83. }
  84. @Override
  85. publicvoidendElement(Stringuri,StringqName)
  86. throwsSAXException{
  87. super.endElement(uri,localName,qName);
  88. }
  89. @Override
  90. publicvoidcharacters(char[]ch,intstart,intlength)
  91. throwsSAXException{
  92. super.characters(ch,start,length);
  93. }
  94. @Override
  95. publicvoidignorableWhitespace(char[]ch,intlength)
  96. throwsSAXException{
  97. super.ignorableWhitespace(ch,length);
  98. }
  99. @Override
  100. publicvoidprocessingInstruction(Stringtarget,Stringdata)
  101. throwsSAXException{
  102. super.processingInstruction(target,data);
  103. }
  104. @Override
  105. publicvoidskippedEntity(Stringname)throwsSAXException{
  106. super.skippedEntity(name);
  107. }
  108. @Override
  109. publicvoidwarning(SAXParseExceptione)throwsSAXException{
  110. super.warning(e);
  111. }
  112. @Override
  113. publicvoiderror(SAXParseExceptione)throwsSAXException{
  114. super.error(e);
  115. }
  116. @Override
  117. publicvoidfatalError(SAXParseExceptione)throwsSAXException{
  118. super.fatalError(e);
  119. }
  120. privatevoidprint(Attributesattrs){
  121. if(attrs==null)return;
  122. System.err.print("[");
  123. for(inti=0;i<attrs.getLength();i++){
  124. System.err.print(attrs.getQName(i)+"="+attrs.getValue(i));
  125. if(i!=attrs.getLength()-1){
  126. System.err.print(",");
  127. }
  128. }
  129. System.err.println("]");
  130. }
  131. }

3、【JDOM】
JDOM与DOM非常类似,它是处理XML的纯JAVA API,API大量使用了Collections类,且JDOM仅使用具体类而不使用接口。 JDOM 它自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档(尽管它还可以将以前构造的 DOM 表示作为输入)。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档
示例代码

  1. packagetest.xml;
  2. importjava.io.File;
  3. importjava.io.FileOutputStream;
  4. importjava.io.IOException;
  5. importjava.io.InputStream;
  6. importjava.util.List;
  7. importorg.jdom.Attribute;
  8. importorg.jdom.Document;
  9. importorg.jdom.Element;
  10. importorg.jdom.JDOMException;
  11. importorg.jdom.input.SAXBuilder;
  12. importorg.jdom.output.XMLOutputter;
  13. /**
  14. *JDom读写xml
  15. *@authorwhwang
  16. */
  17. publicclassTestJDom{
  18. publicstaticvoidmain(String[]args){
  19. //read();
  20. write();
  21. }
  22. publicstaticvoidread(){
  23. try{
  24. booleanvalidate=false;
  25. SAXBuilderbuilder=newSAXBuilder(validate);
  26. InputStreamin=TestJDom.class.getClassLoader().getResourceAsStream("test.xml");
  27. Documentdoc=builder.build(in);
  28. //获取根节点<university>
  29. Elementroot=doc.getRootElement();
  30. readNode(root,"");
  31. }catch(JDOMExceptione){
  32. e.printStackTrace();
  33. }catch(IOExceptione){
  34. e.printStackTrace();
  35. }
  36. }
  37. @SuppressWarnings("unchecked")
  38. publicstaticvoidreadNode(Elementroot,Stringprefix){
  39. if(root==null)return;
  40. //获取属性
  41. List<Attribute>attrs=root.getAttributes();
  42. if(attrs!=null&&attrs.size()>0){
  43. System.err.print(prefix);
  44. for(Attributeattr:attrs){
  45. System.err.print(attr.getValue()+"");
  46. }
  47. System.err.println();
  48. }
  49. //获取他的子节点
  50. List<Element>childNodes=root.getChildren();
  51. prefix+="\t";
  52. for(Elemente:childNodes){
  53. readNode(e,prefix);
  54. }
  55. }
  56. publicstaticvoidwrite(){
  57. booleanvalidate=false;
  58. try{
  59. SAXBuilderbuilder=newSAXBuilder(validate);
  60. InputStreamin=TestJDom.class.getClassLoader().getResourceAsStream("test.xml");
  61. Documentdoc=builder.build(in);
  62. //获取根节点<university>
  63. Elementroot=doc.getRootElement();
  64. //修改属性
  65. root.setAttribute("name","tsu");
  66. //删除
  67. booleanisRemoved=root.removeChildren("college");
  68. System.err.println(isRemoved);
  69. //新增
  70. ElementnewCollege=newElement("college");
  71. newCollege.setAttribute("name","new_college");
  72. ElementnewClass=newElement("class");
  73. newClass.setAttribute("name","ccccc");
  74. newCollege.addContent(newClass);
  75. root.addContent(newCollege);
  76. XMLOutputterout=newXMLOutputter();
  77. Filefile=newFile("src/jdom-modify.xml");
  78. if(file.exists()){
  79. file.delete();
  80. }
  81. file.createNewFile();
  82. FileOutputStreamfos=newFileOutputStream(file);
  83. out.output(doc,fos);
  84. }catch(JDOMExceptione){
  85. e.printStackTrace();
  86. }catch(IOExceptione){
  87. e.printStackTrace();
  88. }
  89. }
  90. }

4、【DOM4j】
dom4j是目前在xml解析方面是最优秀的(Hibernate、Sun的JAXM也都使用dom4j来解析XML),它合并了许多超出基本 XML 文档表示的功能包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理
示例代码

  1. packagetest.xml;
  2. importjava.io.File;
  3. importjava.io.FileWriter;
  4. importjava.io.IOException;
  5. importjava.io.InputStream;
  6. importjava.util.List;
  7. importorg.dom4j.Attribute;
  8. importorg.dom4j.Document;
  9. importorg.dom4j.DocumentException;
  10. importorg.dom4j.DocumentHelper;
  11. importorg.dom4j.Element;
  12. importorg.dom4j.ProcessingInstruction;
  13. importorg.dom4j.VisitorSupport;
  14. importorg.dom4j.io.SAXReader;
  15. importorg.dom4j.io.XMLWriter;
  16. /**
  17. *Dom4j读写xml
  18. *@authorwhwang
  19. */
  20. publicclassTestDom4j{
  21. publicstaticvoidmain(String[]args){
  22. read1();
  23. //read2();
  24. //write();
  25. }
  26. publicstaticvoidread1(){
  27. try{
  28. SAXReaderreader=newSAXReader();
  29. InputStreamin=TestDom4j.class.getClassLoader().getResourceAsStream("test.xml");
  30. Documentdoc=reader.read(in);
  31. Elementroot=doc.getRootElement();
  32. readNode(root,"");
  33. }catch(DocumentExceptione){
  34. e.printStackTrace();
  35. }
  36. }
  37. @SuppressWarnings("unchecked")
  38. publicstaticvoidreadNode(Elementroot,Stringprefix){
  39. if(root==null)return;
  40. //获取属性
  41. List<Attribute>attrs=root.attributes();
  42. if(attrs!=null&&attrs.size()>0){
  43. System.err.print(prefix);
  44. for(Attributeattr:attrs){
  45. System.err.print(attr.getValue()+"");
  46. }
  47. System.err.println();
  48. }
  49. //获取他的子节点
  50. List<Element>childNodes=root.elements();
  51. prefix+="\t";
  52. for(Elemente:childNodes){
  53. readNode(e,prefix);
  54. }
  55. }
  56. publicstaticvoidread2(){
  57. try{
  58. SAXReaderreader=newSAXReader();
  59. InputStreamin=TestDom4j.class.getClassLoader().getResourceAsStream("test.xml");
  60. Documentdoc=reader.read(in);
  61. doc.accept(newMyVistor());
  62. }catch(DocumentExceptione){
  63. e.printStackTrace();
  64. }
  65. }
  66. publicstaticvoidwrite(){
  67. try{
  68. //创建一个xml文档
  69. Documentdoc=DocumentHelper.createDocument();
  70. Elementuniversity=doc.addElement("university");
  71. university.addAttribute("name","tsu");
  72. //注释
  73. university.addComment("这个是根节点");
  74. Elementcollege=university.addElement("college");
  75. college.addAttribute("name","cccccc");
  76. college.setText("text");
  77. Filefile=newFile("src/dom4j-modify.xml");
  78. if(file.exists()){
  79. file.delete();
  80. }
  81. file.createNewFile();
  82. XMLWriterout=newXMLWriter(newFileWriter(file));
  83. out.write(doc);
  84. out.flush();
  85. out.close();
  86. }catch(IOExceptione){
  87. e.printStackTrace();
  88. }
  89. }
  90. }
  91. classMyVistorextendsVisitorSupport{
  92. publicvoidvisit(Attributenode){
  93. System.out.println("Attibute:"+node.getName()+"="
  94. +node.getValue());
  95. }
  96. publicvoidvisit(Elementnode){
  97. if(node.isTextOnly()){
  98. System.out.println("Element:"+node.getName()+"="
  99. +node.getText());
  100. }else{
  101. System.out.println(node.getName());
  102. }
  103. }
  104. @Override
  105. publicvoidvisit(ProcessingInstructionnode){
  106. System.out.println("PI:"+node.getTarget()+""+node.getText());
  107. }
  108. }

三、【性能测试】

环境:AMD4400+ 2.0+GHz主频 JDK6.0
运行参数:-Xms400m -Xmx400m
xml文件大小:10.7M
结果:
DOM: >581297ms
SAX: 8829ms
JDOM: 581297ms
DOM4j: 5309ms
时间包括IO的,只是进行了简单的测试,仅供参考!!!!

四、【对比】

1、【DOM】
DOM是基于树的结构,通常需要加载整文档和构造DOM树,然后才能开始工作。
优点:
a、由于整棵树在内存中,因此可以对xml文档随机访问
b、可以对xml文档进行修改操作
c、较sax,dom使用也更简单。
缺点:
a、整个文档必须一次性解析完
a、由于整个文档都需要载入内存,对于大文档成本高
2、【SAX】
SAX类似流媒体,它基于事件驱动的,因此无需将整个文档载入内存,使用者只需要监听自己感兴趣的事件即可。
优点:
a、无需将整个xml文档载入内存,因此消耗内存少
b、可以注册多个ContentHandler
缺点:
a、不能随机的访问xml中的节点
b、不能修改文档
3、【JDOM】
JDOM是纯Java的处理XML的API,其API中大量使用Collections类,
优点:
a、DOM方式的优点
b、具有SAX的Java规则
缺点
a、DOM方式的缺点
4、【DOM4J】
这4中xml解析方式中,最优秀的一个,集易用和性能于一身。

五、【小插曲XPath】

XPath 是一门在 XML 文档中查找信息的语言, 可用来在 XML 文档中对元素和属性进行遍历。XPath 是 W3C XSLT 标准的主要元素,并且 XQuery 和 XPointer 同时被构建于 XPath 表达之上。因此,对 XPath 的理解是很多高级 XML 应用的基础。
XPath非常类似对数据库操作的sql语言,或者说JQuery,它可以方便开发者抓起文档中需要的东西。(dom4j也支持xpath)
示例代码

  1. packagetest.xml;
  2. importjava.io.IOException;
  3. importjava.io.InputStream;
  4. importjavax.xml.parsers.DocumentBuilder;
  5. importjavax.xml.parsers.DocumentBuilderFactory;
  6. importjavax.xml.parsers.ParserConfigurationException;
  7. importjavax.xml.xpath.XPath;
  8. importjavax.xml.xpath.XPathConstants;
  9. importjavax.xml.xpath.XPathExpression;
  10. importjavax.xml.xpath.XPathExpressionException;
  11. importjavax.xml.xpath.XPathFactory;
  12. importorg.w3c.dom.Document;
  13. importorg.w3c.dom.NodeList;
  14. importorg.xml.sax.SAXException;
  15. publicclassTestXPath{
  16. publicstaticvoidmain(String[]args){
  17. read();
  18. }
  19. publicstaticvoidread(){
  20. try{
  21. DocumentBuilderFactorydbf=DocumentBuilderFactory.newInstance();
  22. DocumentBuilderbuilder=dbf.newDocumentBuilder();
  23. InputStreamin=TestXPath.class.getClassLoader().getResourceAsStream("test.xml");
  24. Documentdoc=builder.parse(in);
  25. XPathFactoryfactory=XPathFactory.newInstance();
  26. XPathxpath=factory.newXPath();
  27. //选取所有class元素的name属性
  28. //XPath语法介绍:http://w3school.com.cn/xpath/
  29. XPathExpressionexpr=xpath.compile("//class/@name");
  30. NodeListnodes=(NodeList)expr.evaluate(doc,XPathConstants.NODESET);
  31. for(inti=0;i<nodes.getLength();i++){
  32. System.out.println("name="+nodes.item(i).getNodeValue());
  33. }
  34. }catch(XPathExpressionExceptione){
  35. e.printStackTrace();
  36. }catch(ParserConfigurationExceptione){
  37. e.printStackTrace();
  38. }catch(SAXExceptione){
  39. e.printStackTrace();
  40. }catch(IOExceptione){
  41. e.printStackTrace();
  42. }
  43. }
  44. }

六、【补充】

注意4种解析方法对TextNode(文本节点)的处理:

1、在使用DOM时,调用node.getChildNodes()获取该节点的子节点,文本节点也会被当作一个Node来返回,如:

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <universityname="pku">
  3. <collegename="c1">
  4. <classname="class1">
  5. <studentname="stu1"sex='male'age="21"/>
  6. <studentname="stu2"sex='female'age="20"/>
  7. <studentname="stu3"sex='female'age="20"/>
  8. </class>
  9. </college>
  10. </university>

  1. packagetest.xml;
  2. importjava.io.FileNotFoundException;
  3. importjava.io.IOException;
  4. importjava.io.InputStream;
  5. importjava.util.Arrays;
  6. importjavax.xml.parsers.DocumentBuilder;
  7. importjavax.xml.parsers.DocumentBuilderFactory;
  8. importjavax.xml.parsers.ParserConfigurationException;
  9. importorg.w3c.dom.Document;
  10. importorg.w3c.dom.Element;
  11. importorg.w3c.dom.Node;
  12. importorg.w3c.dom.NodeList;
  13. importorg.xml.sax.SAXException;
  14. /**
  15. *dom读写xml
  16. *@authorwhwang
  17. */
  18. publicclassTestDom2{
  19. publicstaticvoidmain(String[]args){
  20. read();
  21. }
  22. publicstaticvoidread(){
  23. DocumentBuilderFactorydbf=DocumentBuilderFactory.newInstance();
  24. try{
  25. DocumentBuilderbuilder=dbf.newDocumentBuilder();
  26. InputStreamin=TestDom2.class.getClassLoader().getResourceAsStream("test.xml");
  27. Documentdoc=builder.parse(in);
  28. //root<university>
  29. Elementroot=doc.getDocumentElement();
  30. if(root==null)return;
  31. //System.err.println(root.getAttribute("name"));
  32. //allcollegenode
  33. NodeListcollegeNodes=root.getChildNodes();
  34. if(collegeNodes==null)return;
  35. System.err.println("university子节点数:"+collegeNodes.getLength());
  36. System.err.println("子节点如下:");
  37. for(inti=0;i<collegeNodes.getLength();i++){
  38. Nodecollege=collegeNodes.item(i);
  39. if(college==null)continue;
  40. if(college.getNodeType()==Node.ELEMENT_NODE){
  41. System.err.println("\t元素节点:"+college.getNodeName());
  42. }elseif(college.getNodeType()==Node.TEXT_NODE){
  43. System.err.println("\t文本节点:"+Arrays.toString(college.getTextContent().getBytes()));
  44. }
  45. }
  46. }catch(ParserConfigurationExceptione){
  47. e.printStackTrace();
  48. }catch(FileNotFoundExceptione){
  49. e.printStackTrace();
  50. }catch(SAXExceptione){
  51. e.printStackTrace();
  52. }catch(IOExceptione){
  53. e.printStackTrace();
  54. }
  55. }
  56. }

输出的结果是:

  1. university子节点数:3
  2. 子节点如下:
  3. 文本节点:[10,9]
  4. 元素节点:college
  5. 文本节点:[10]

其中\n的ASCII码为10,\t的ASCII码为9。结果让人大吃一惊,university的子节点数不是1,也不是2,而是3,这3个子节点都是谁呢?为了看得更清楚点,把xml文档改为:

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <universityname="pku">11
  3. <collegename="c1">
  4. <classname="class1">
  5. <studentname="stu1"sex='male'age="21"/>
  6. <studentname="stu2"sex='female'age="20"/>
  7. <studentname="stu3"sex='female'age="20"/>
  8. </class>
  9. </college>22
  10. </university>

还是上面的程序,输出结果为:

  1. university子节点数:3
  2. 子节点如下:
  3. 文本节点:[49,49,10,9]
  4. 元素节点:college
  5. 文本节点:[50,50,10]

其中数字1的ASCII码为49,数字2的ASCII码为50。

2、使用SAX来解析同DOM,当你重写它的public void characters(char[] ch,int start,int length)方法时,你就能看到。

3、JDOM,调用node.getChildren()只返回子节点,不包括TextNode节点(不管该节点是否有Text信息)。如果要获取该节点的Text信息,可以调用node.getText()方法,该方法返回节点的Text信息,也包括\n\t等特殊字符。

4、DOM4j同JDOM

参考:

http://www.docin.com/p-78963650.html

http://wenku.baidu.com/view/b091f9360b4c2e3f5727638b.html

http://kree.iteye.com/blog/668280

猜你在找的XML相关文章