加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 百科 > 正文

XML的4种解析及对比

发布时间：2020-12-16 06:41:05 所属栏目：百科 来源：网络整理
导读：转载于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种解析X

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

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

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

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

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

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

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

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

三、【性能测试】

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

六、【补充】

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

输出的结果是：

  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信息，也包括nt等特殊字符。

4、DOM4j同JDOM

参考：

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

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

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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同