XML解析方式之DOM、SAX、JDOM、DOM4J

XML 前端之家
前端之家收集整理的这篇文章主要介绍了XML解析方式之DOM、SAX、JDOM、DOM4J，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

一、DOM4J

1、特点：最优秀的一个，集易用和性能于一身。开放源代码（需要导入外部jar包：dom4j-1.6.1.jar）
2、场合：使用DOM4J

Attribute定义了XML的属性
Branch为能够包含子节点的节点如XML元素(Element)和文档(Docuemnts)定义了一个公共的行为，
CDATA 定义了XML CDATA 区域
CharacterData是一个标识借口，标识基于字符的节点。如CDATA，Comment,Text.
Comment 定义了XML注释的行为
定义了XML文档
DocumentType 定义XML DOCTYPE声明
Element定义XML 元素
ElementHandler定义了 Element 对象的处理器
被 ElementHandler 使用，用于取得当前正在处理的路径层次信息
Entity定义 XML entity
Node为所有的dom4j中XML节点定义了多态行为
NodeFilter 定义了在dom4j节点中产生的一个滤镜或谓词的行为（predicate）
ProcessingInstruction 定义 XML 处理指令.
Text 定义XML 文本节点.
Visitor 用于实现Visitor模式.
XPath 在分析一个字符串后会提供一个XPath 表达式


[java] view plain copy print ?
  1. SAXReaderreader=newSAXReader();Documentdoc=reader.read(Filexmlfile);
  2. ListchildNodes=doc.selectNodes("//Config/Child/ChildNode");
  3. for(Objectobj:childNodes){
  4. NodechildNode=(Node)obj;
  5. Stringname=childNode.valueOf("@name");
  6. Stringtext=childNode.getText();
  7. }
  8. 一.Document对象相关
  9. 1.读取XML文件,获得document对象.
  10. SAXReaderreader=newSAXReader();
  11. Documentdocument=reader.read(newFile("input.xml"));
  12. 2.解析XML形式的文本,得到document对象.
  13. Stringtext="<members></members>";
  14. Documentdocument=DocumentHelper.parseText(text);
  15. 3.主动创建document对象.
  16. Documentdocument=DocumentHelper.createDocument();
  17. Elementroot=document.addElement("members");//创建根节点
  18. 二.节点相关
  19. 1.获取文档的根节点.
  20. ElementrootElm=document.getRootElement();
  21. 2.取得某节点的单个子节点.
  22. ElementmemberElm=root.element("member");//"member"是节点名
  23. 3.取得节点的文字
  24. Stringtext=memberElm.getText();也可以用:
  25. Stringtext=root.elementText("name");这个是取得根节点下的name字节点的文字.
  26. 4.取得某节点下名为"member"的所有字节点并进行遍历.
  27. Listnodes=rootElm.elements("member");
  28. for(Iteratorit=nodes.iterator();it.hasNext();){
  29. Elementelm=(Element)it.next();
  30. //dosomething
  31. 5.对某节点下的所有子节点进行遍历.
  32. for(Iteratorit=root.elementIterator();it.hasNext();){
  33. Elementelement=(Element)it.next();
  34. //dosomething
  35. }
  36. 6.在某节点下添加子节点.
  37. ElementageElm=newMemberElm.addElement("age");
  38. 7.设置节点文字.
  39. ageElm.setText("29");
  40. 8.删除某节点.
  41. parentElm.remove(childElm);//childElm是待删除的节点,parentElm是其父节点
  42. 9.添加一个CDATA节点.
  43. ElementcontentElm=infoElm.addElement("content");
  44. contentElm.addCDATA(diary.getContent());
  46. 三.属性相关.
  47. 1.取得某节点下的某属性
  48. Elementroot=document.getRootElement();
  49. Attributeattribute=root.attribute("size");//属性名name
  50. 2.取得属性的文字
  51. Stringtext=attribute.getText();也可以用:
  52. Stringtext2=root.element("name").attributeValue("firstname");这个是取得根节点下name字节点的属性firstname的值.
  53. 3.遍历某节点的所有属性
  54. for(Iteratorit=root.attributeIterator();it.hasNext();){
  55. Attributeattribute=(Attribute)it.next();
  56. Stringtext=attribute.getText();
  57. System.out.println(text);
  58. 4.设置某节点的属性和文字.
  59. newMemberElm.addAttribute("name","sitinspring");
  60. 5.设置属性的文字
  61. Attributeattribute=root.attribute("name");
  62. attribute.setText("sitinspring");
  63. 6.删除某属性
  64. Attributeattribute=root.attribute("size");//属性名name
  65. root.remove(attribute);
  66. 四.将文档写入XML文件.
  67. 1.文档中全为英文,不设置编码,直接写入的形式.
  68. XMLWriterwriter=newXMLWriter(newFileWriter("output.xml"));
  69. writer.write(document);
  70. writer.close();
  71. 2.文档中含有中文,设置编码格式写入的形式.(或以美化的格式输出到文件)
  72. OutputFormatformat=OutputFormat.createPrettyPrint();
  73. format.setEncoding("GBK");//指定XML编码
  74. XMLWriterwriter=newXMLWriter(newFileWriter("output.xml"),format);
  75. 五.字符串与XML的转换
  76. 1.将字符串转化为XML
  77. Stringtext="<members><member>sitinspring</member></members>";
  78. Documentdocument=DocumentHelper.parseText(text);
  79. 2.将文档或节点的XML转化为字符串.
  80. SAXReaderreader=newSAXReader();
  81. Documentdocument=reader.read(newFile("input.xml"));
  82. StringdocXmlText=document.asXML();
  83. StringrootXmlText=root.asXML();
  84. ElementmemberElm=root.element("member");
  85. StringmemberXmlText=memberElm.asXML();
  86. dom4jAPI包含一个解析XML文档的工具。本文中将使用这个解析器创建一个示例XML文档。清单1显示了这个示例XML文档，catalog.xml。
  87. 与W3CDOMAPI相比，使用dom4j所包含的解析器的好处是dom4j拥有本地的XPath支持。DOM解析器不支持使用XPath选择节点。

?

    /*DOM4J提供至少3种遍历节点的方法*/
  1. //1)枚举(Iterator)
  2. //枚举所有子节点
  3. for(Iteratori=root.elementIterator();i.hasNext();){
  4. Elementelement=(Element)i.next();
  5. //枚举名称为foo的节点
  6. for(Iteratori=root.elementIterator(foo);i.hasNext();){
  7. Elementfoo=(Element)i.next();
  8. //枚举属性
  9. for(Iteratori=root.attributeIterator();i.hasNext();){
  10. Attributeattribute=(Attribute)i.next();
  11. //2)递归
  12. //递归也可以采用Iterator作为枚举手段，但文档中提供了另外的做法
  13. publicvoidtreeWalk(){
  14. treeWalk(getRootElement());
  15. publicvoidtreeWalk(Elementelement){
  16. for(inti=0,size=element.nodeCount();i<size;i++){
  17. Nodenode=element.node(i);
  18. if(nodeinstanceofElement){
  19. treeWalk((Element)node);
  20. }else{//dosomething....
  21. //3)Visitor模式
  22. //主要原理就是两种类互相保有对方的引用，并且一种作为Visitor去访问许多Visitable。只需要自定一个类实现Visitor接口即可。
  23. publicclassMyVisitorextendsVisitorSupport{
  24. publicvoidvisit(Elementelement){
  25. System.out.println(element.getName());
  26. publicvoidvisit(Attributeattr){
  27. System.out.println(attr.getName());
  28. //调用：root.accept(newMyVisitor())
?
    importjava.io.File;
  1. importjava.io.FileWriter;
  2. importjava.io.IOException;
  3. importjava.util.Iterator;
  4. importorg.dom4j.Attribute;
  5. importorg.dom4j.Document;
  6. importorg.dom4j.DocumentException;
  7. importorg.dom4j.DocumentHelper;
  8. importorg.dom4j.Element;
  9. importorg.dom4j.io.SAXReader;
  10. importorg.dom4j.io.XMLWriter;
  11. /**
  12. *dom4j生成与解析XML文档
  13. */
  14. publicclassDom4jDemo{
  16. /**
  17. *利用dom4j进行xml文档的写入操作
  18. */
  19. publicvoidcreateXml(Filefile){
  20. //XML声明<?xmlversion="1.0"encoding="UTF-8"?>自动添加到XML文档中
  21. //使用DocumentHelper类创建文档实例(生成XML文档节点的dom4jAPI工厂类)
  22. //使用addElement()方法创建根元素employees(用于向XML文档中增加元素)
  23. Elementroot=document.addElement("employees");
  24. //在根元素中使用addComment()方法添加注释"AnXMLNote"
  25. root.addComment("AnXMLNote");
  26. //在根元素中使用addProcessingInstruction()方法增加一个处理指令
  27. root.addProcessingInstruction("target","text");
  28. //在根元素中使用addElement()方法增加employee元素。
  29. ElementempElem=root.addElement("employee");
  30. //使用addAttribute()方法向employee元素添加id和name属性
  31. empElem.addAttribute("id","0001");
  32. empElem.addAttribute("name","wanglp");
  33. //向employee元素中添加sex元素
  34. ElementsexElem=empElem.addElement("sex");
  35. //使用setText()方法设置sex元素的文本
  36. sexElem.setText("m");
  37. //在employee元素中增加age元素并设置该元素的文本。
  38. ElementageElem=empElem.addElement("age");
  39. ageElem.setText("25");
  40. Elementemp2Elem=root.addElement("employee");
  41. emp2Elem.addAttribute("id","0002");
  42. emp2Elem.addAttribute("name","fox");
  43. Elementsex2Elem=emp2Elem.addElement("sex");
  44. sex2Elem.setText("f");
  45. Elementage2Elem=emp2Elem.addElement("age");
  46. age2Elem.setText("24");
  47. //可以使用addDoctype()方法添加文档类型说明。
  48. //document.addDocType("employees",null,"file://E:/Dtds/dom4j.dtd");
  49. //这样就向XML文档中增加文档类型说明：
  50. //<!DOCTYPEemployeesSYSTEM"file://E:/Dtds/dom4j.dtd">
  51. //如果文档要使用文档类型定义（DTD）文档验证则必须有Doctype。
  52. try{
  53. XMLWriteroutput=newXMLWriter(newFileWriter(file));
  54. output.write(document);
  55. output.close();
  56. }catch(IOExceptione){
  57. System.out.println(e.getMessage());
  58. *利用dom4j进行xml文档的读取操作
  59. publicvoidparserXml(Filefile){
  60. Documentdocument=null;
  61. //使用SAXReader解析XML文档catalog.xml：
  62. SAXReadersaxReader=newSAXReader();
  63. try{
  64. document=saxReader.read(file);
  65. }catch(DocumentExceptione){
  66. e.printStackTrace();
  67. //将字符串转为XML
  68. //document=DocumentHelper.parseText(fileString);
  69. //获取根节点
  70. //打印节点名称
  71. System.out.println("<"+root.getName()+">");
  72. //获取根节点下的子节点遍历
  73. Iterator<?>iter=root.elementIterator("employee");
  74. //遍历employee节点
  75. while(iter.hasNext()){
  76. //获取当前子节点
  77. ElementempEle=(Element)iter.next();
  78. System.out.println("<"+empEle.getName()+">");
  79. //获取当前子节点的属性遍历
  80. Iterator<?>attrList=empEle.attributeIterator();
  81. while(attrList.hasNext()){
  82. Attributeattr=(Attribute)attrList.next();
  83. System.out.println(attr.getName()+"="+attr.getValue());
  84. //遍历employee节点下所有子节点
  85. Iterator<?>eleIte=empEle.elementIterator();
  86. while(eleIte.hasNext()){
  87. Elementele=(Element)eleIte.next();
  88. System.out.println("<"+ele.getName()+">"+ele.getTextTrim());
  89. //获取employee节点下的子节点sex值
  90. //Stringsex=empEle.elementTextTrim("sex");
  91. //System.out.println("sex:"+sex);
  92. System.out.println("</"+root.getName()+">");
  93. publicstaticvoidmain(String[]args){
  94. Dom4jDemodom4j=newDom4jDemo();
  95. Filefile=newFile("e:/dom4j.xml");
  96. //dom4j.createXml(file);
  97. dom4j.parserXml(file);
  98. }

/*修改xml文档*/

[html] view plain copy print ?
  1. publicstaticvoidmodifyxml(){
  2. //使用SAXReader去解析xml文件
  3. SAXReaderreader=newSAXReader();
  4. Documentdocument;
  5. try{
  6. Filefile=newFile("C:\\workspace\\Test\\myxml.xml");
  7. //获取document对象
  8. document=reader.read(file);
  9. //通过selectNodes寻找节点或者属性
  10. Listlist=document.selectNodes("/student/call/@show");
  11. Iteratorit=list.iterator();
  12. while(it.hasNext()){
  13. //Attribute属性的操作方法
  14. Attributeattribute=(Attribute)it.next();
  15. if(attribute.getValue().equals("yes"))
  16. {
  18. attribute.setValue("no");
  19. }
  20. }
  21. list=document.selectNodes("/student/call/name");
  22. it=list.iterator();
  23. while(it.hasNext()){
  24. //标签内容的操作方法
  25. ElementnameElment=(Element)it.next();
  26. nameElment.setText("studentname");
  27. //删除某个节点是要用两层循环，因为删除当前节点必须用父节点去删除。
  28. list=document.selectNodes("/student/call");
  29. //获取父节点
  30. ElementscoreElement=(Element)it.next();
  31. System.out.println(scoreElement);
  32. @SuppressWarnings("unused")
  33. //获取该父节点下面的需要查找的子节点
  34. Iteratoritera=scoreElement.elementIterator("English");
  35. while(itera.hasNext()){
  36. ElementscoreEnglish=(Element)itera.next();
  37. if(scoreEnglish.getText().equals("77")){
  38. //利用父节点去删除
  39. scoreElement.remove(scoreEnglish);
  40. @SuppressWarnings("unused")
  41. /*Iteratoritera=document.getRootElement().elementIterator("call");
  42. Elementele=(Element)itera.next();
  43. System.out.println(ele);
  44. }*/
  46. OutputFormatformat=OutputFormat.createPrettyPrint();
  47. format.setEncoding("UTF-8");
  48. XMLWriterwriter;
  49. try{
  50. writer=newXMLWriter(newFileWriter("myxml.xml"),format);
  51. writer.write(document);
  52. writer.close();
  53. }catch(IOExceptione){
  54. e.printStackTrace();
  55. }catch(DocumentExceptione){
  56. }

二、JDOM

1、原理：纯Java的处理XML的API，要实现的功能简单，如解析、创建等，但在底层，JDOM还是使
用SAX、DOM、Xanan文档。（需要导入外部jar包：jdom.jar）
2、优点：a、是基于树的处理XML的Java API，把树加载在内存中，具有DOM方式的优点。
b、没有向下兼容的限制，因此比DOM简单
c、可速度快，缺陷少
d、具有SAX的JAVA规则
3、 缺点：a、不能处理大于内存的文档。Dom方式的缺点
b、JDOM表示XML文档逻辑模型。不能保证每个字节真正变换。
c、针对实例文档不提供DTD与模式的任何实际模型。
d、不支持与DOM中相应遍历包
4、场合：在需要平衡时使用。JDOM具有树的便利，也有SAX的JAVA规则。
?
    //导入jar包：jdom.jarimportjava.io.File;
  1. importjava.io.FileNotFoundException;
  2. importjava.io.FileOutputStream;
  3. importjava.io.IOException;
  4. importjava.util.List;
  5. importorg.jdom.Attribute;
  6. importorg.jdom.Comment;
  7. importorg.jdom.Document;
  8. importorg.jdom.Element;
  9. importorg.jdom.JDOMException;
  10. importorg.jdom.input.SAXBuilder;
  11. importorg.jdom.output.Format;
  12. importorg.jdom.output.XMLOutputter;
  13. *jdom生成与解析XML文档
  14. publicclassJdomDemo{
  15. Documentdocument=newDocument();
  16. *利用JDom进行xml文档的写入操作
  17. //1.创建元素及设置为根元素
  18. Elementemployees=newElement("employees");
  19. document.setContent(employees);
  20. //2.创建注释及设置到根元素上
  21. Commentcommet=newComment("thisismycomment");
  22. employees.addContent(commet);
  23. //3.创建元素
  24. Elementelement1=newElement("employee");
  25. //3.1设置元素的属性名及属性值
  26. element1.setAttribute(newAttribute("id","0001"));
  27. //3.2创建元素的属性名及属性值
  28. AttributenameAttr=newAttribute("name",0); background-color:inherit">//3.3设置元素名及文本
  29. ElementsexEle=newElement("sex");
  30. sexEle.setText("m");
  31. //设置到上层元素上
  32. element1.addContent(sexEle);
  33. //设置元素
  34. ElementageEle=newElement("age");
  35. ageEle.setText("22");
  36. element1.addContent(ageEle);
  37. //设置为根元素的子元素
  38. employees.addContent(element1);
  39. //将元素属性设置到元素上
  40. element1.setAttribute(nameAttr);
  41. //3.创建元素
  42. Elementelement2=newElement("employee");
  43. //3.1设置元素的属性名及属性值
  44. element2.setAttribute(newAttribute("id","0002"));
  45. //3.2创建元素的属性名及属性值
  46. Attributename2Attr=newAttribute("name","fox");
  47. //3.3设置元素名及文本
  48. Elementsex2Ele=newElement("sex");
  49. sex2Ele.setText("f");
  50. //设置到上层元素上
  51. element2.addContent(sex2Ele);
  52. //设置元素
  53. Elementage2Ele=newElement("age");
  54. age2Ele.setText("21");
  55. element2.addContent(age2Ele);
  56. //设置为根元素的子元素
  57. employees.addContent(element2);
  58. //将元素属性设置到元素上
  59. element2.setAttribute(name2Attr);
  60. Elementelement3=newElement("employee");
  61. element3.setText("title");
  62. element3.addContent(newElement("name").addContent(newElement("hello")));
  63. employees.addContent(element3);
  64. //设置xml文档输出的格式
  65. Formatformat=Format.getPrettyFormat();
  66. XMLOutputterout=newXMLOutputter(format);
  67. //将得到的xml文档输出到文件流中
  68. out.output(document,newFileOutputStream(file));
  69. }catch(FileNotFoundExceptione){
  70. }catch(IOExceptione){
  71. *利用JDom进行xml文档的读取操作
  72. publicvoidparserXml(Filefile){
  73. //建立解析器
  74. SAXBuilderbuilder=newSAXBuilder();
  75. //将解析器与文档关联
  76. document=builder.build(file);
  77. }catch(JDOMExceptione1){
  78. e1.printStackTrace();
  79. }catch(IOExceptione1){
  80. //读取根元素
  81. Elementroot=document.getRootElement();
  82. //输出根元素的名字
  83. System.out.println("<"+root.getName()+">");
  84. //读取元素集合
  85. List<?>employeeList=root.getChildren("employee");
  86. 0;i<employeeList.size();i++){
  87. Elementele=(Element)employeeList.get(i);
  88. //得到元素的名字
  89. System.out.println("<"+ele.getName()+">");
  90. //读取元素的属性集合
  91. List<?>empAttrList=ele.getAttributes();
  92. for(intj=0;j<empAttrList.size();j++){
  93. Attributeattrs=(Attribute)empAttrList.get(j);
  94. //将属性的名字和值并输出
  95. Stringname=attrs.getName();
  96. Stringvalue=(String)attrs.getValue();
  97. System.out.println(name+"="+value);
  98. Elementsex=ele.getChild("sex");
  99. System.out.println("<sex>"+sex.getText());
  100. Elementage=ele.getChild("age");
  101. System.out.println("<age>"+age.getText());
  102. }catch(NullPointerExceptione){
  103. System.out.println(ele.getTextTrim());
  104. Elementname=ele.getChild("name");
  105. System.out.println("<name>"+name.getName());
  106. System.out.println("</employee>");
  107. System.out.println("</employees>");
  108. *测试
  109. publicstaticvoidmain(String[]args){
  110. JdomDemojdom=newJdomDemo();
  111. Filefile=newFile("E://jdom.xml");
  112. jdom.createXml(file);
  113. jdom.parserXml(file);
  114. 三、DOM 1、原理：DOM是基于树的结构，解析器读入-整个-文档，然后构建一个驻留内存的树结构，使用 DOM 接 口来操作这个树结构。
    2、优点：a、由于整棵树在内存中，便于操作,可以对xml文档随机访问
    b、可以对xml文档进行删除、修改、重新排列等多种功能；访问效率高
    c、较sax，dom使用也更简单。
    3、缺点：a、整个文档必须一次性解析完（无用的节点也会解析）,浪费时间和空间.
    b、由于整个文档都需要载入内存，对于大文档成本高
    4、 场合：小型xml文档；一旦解析了文档还需多次访问这些数据；
    ?
    importjava.io.PrintWriter;
  1. importjavax.xml.parsers.DocumentBuilder;
  2. importjavax.xml.parsers.DocumentBuilderFactory;
  3. importjavax.xml.parsers.ParserConfigurationException;
  4. importjavax.xml.transform.OutputKeys;
  5. importjavax.xml.transform.Transformer;
  6. importjavax.xml.transform.TransformerConfigurationException;
  7. importjavax.xml.transform.TransformerException;
  8. importjavax.xml.transform.TransformerFactory;
  9. importjavax.xml.transform.dom.DOMSource;
  10. importjavax.xml.transform.stream.StreamResult;
  11. importorg.w3c.dom.Attr;
  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;
  17. *DOM生成与解析XML文档
  18. *
  19. *@author莫小哆_ly2012-2-20
  20. publicclassDomDemo{
  21. /*
  22. *解析器读入整个文档，然后构建一个驻留内存的树结构，
  23. *
  24. *然后代码就可以使用DOM接口来操作这个树结构。
  25. *优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；
  26. *缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；
  27. *使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、cpu）
  28. //表示整个HTML或XML文档。从概念上讲，它是文档树的根，并提供对文档数据的基本访问
  29. privateDocumentdocument;
  30. *创建DOM树
  31. *要读入一个XML文档，首先要一个DocumentBuilder对象
  32. publicvoidinit(){
  33. //获取DocumentBuilderFactory的新实例
  34. DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();
  35. //使用当前配置的参数创建一个新的DocumentBuilder实例
  36. DocumentBuilderbuilder=null;
  37. builder=factory.newDocumentBuilder();
  38. }catch(ParserConfigurationExceptione){
  39. e.printStackTrace();
  40. //获取DOMDocument对象的一个新实例来生成一个DOM树
  41. this.document=builder.newDocument();
  42. *xml文档的写入操作
  43. *@paramfile
  44. //创建DOM树
  45. this.init();
  46. //创建XML根节点employees
  47. Elementroot=this.document.createElement("employees");
  48. //AddsthenodenewChildtotheendofthelistofchildrenofthis
  49. //node.
  50. //IfthenewChildisalreadyinthetree,itisfirstremoved.
  51. this.document.appendChild(root);
  52. //1.创建根节点的子节点employee
  53. Elementemployee=this.document.createElement("employee");
  54. //向根节点添加属性节点
  55. Attrid=this.document.createAttribute("id");
  56. id.setNodeValue("0001");
  57. //把属性节点对象，追加到达employee节点；
  58. employee.setAttributeNode(id);
  59. //声明employee的子节点name
  60. Elementname=this.document.createElement("name");
  61. //向XML文件name节点追加数据
  62. name.appendChild(this.document.createTextNode("wanglp"));
  63. //把子节点的属性追加到employee子节点中元素中
  64. employee.appendChild(name);
  65. //声明employee的子节点sex
  66. Elementsex=this.document.createElement("sex");
  67. //向XML文件sex节点追加数据
  68. sex.appendChild(this.document.createTextNode("m"));
  69. //把子节点的属性追加到employee子节点中元素中
  70. employee.appendChild(sex);
  71. //声明employee的子节点age
  72. Elementage=this.document.createElement("age");
  73. //向XML文件age节点追加数据
  74. age.appendChild(this.document.createTextNode("25"));
  75. employee.appendChild(age);
  76. //employee节点定义完成，追加到root
  77. root.appendChild(employee);
  78. //2.创建根节点的子节点employee
  79. employee=this.document.createElement("employee");
  80. //向根节点添加属性节点
  81. id=this.document.createAttribute("id");
  82. id.setNodeValue("0002");
  83. //把属性节点对象，追加到达employee节点；
  84. employee.setAttributeNode(id);
  85. //声明employee的子节点name
  86. name=this.document.createElement("name");
  87. //向XML文件name节点追加数据
  88. name.appendChild(this.document.createTextNode("huli"));
  89. employee.appendChild(name);
  90. //声明employee的子节点sex
  91. sex=this.document.createElement("sex");
  92. //向XML文件sex节点追加数据
  93. sex.appendChild(this.document.createTextNode("f"));
  94. employee.appendChild(sex);
  95. //声明employee的子节点age
  96. age=this.document.createElement("age");
  97. //向XML文件age节点追加数据
  98. age.appendChild(this.document.createTextNode("12"));
  99. employee.appendChild(age);
  100. //employee节点定义完成，追加到root
  101. root.appendChild(employee);
  102. //获取TransformerFactory的新实例。
  103. TransformerFactorytf=TransformerFactory.newInstance();
  104. //创建执行从Source到Result的复制的新Transformer。能够将源树转换为结果树
  105. Transformertransformer=null;
  106. transformer=tf.newTransformer();
  107. }catch(TransformerConfigurationExceptione){
  108. //设置转换中实际的输出属性
  109. //指定首选的字符编码
  110. transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
  111. //indent="yes"|"no".指定了当输出结果树时，Transformer是否可以添加额外的空白
  112. transformer.setOutputProperty(OutputKeys.INDENT,"yes");
  113. //声明文件流
  114. PrintWriterpw=null;
  115. pw=newPrintWriter(newFileOutputStream(file));
  116. System.out.println("文件没有找到!");
  117. //充当转换结果的持有者，可以为XML、纯文本、HTML或某些其他格式的标记
  118. StreamResultresult=newStreamResult(pw);
  119. //DOMSourceimplementsSource
  120. DOMSourcesource=newDOMSource(document);
  121. //将XMLSource转换为Result
  122. transformer.transform(source,result);
  123. }catch(TransformerExceptione){
  124. System.out.println("生成XML文件失败!");
  125. System.out.println("生成XML文件成功!");
  126. *xml文档的读取操作
  127. DocumentBuilderbuilder;
  128. //将给定URI的内容解析为一个XML文档，并且返回一个新的DOMDocument对象
  129. document=builder.parse(file);
  130. }catch(SAXExceptione){
  131. //获得文档根元素对对象;
  132. Elementroot=document.getDocumentElement();
  133. //获得文档根元素下一级子元素所有元素;
  134. NodeListnodeList=root.getChildNodes();
  135. System.out.print("<employees>");
  136. System.out.println(root.getNodeName());
  137. if(null!=root){
  138. for(inti=0;i<nodeList.getLength();i++){
  139. Nodechild=nodeList.item(i);
  140. //输出child的属性;
  141. System.out.print("<test>");
  142. System.out.println(child);
  143. if(child.getNodeType()==Node.ELEMENT_NODE){
  144. System.out.print("<id>");
  145. System.out.println(child.getAttributes().getNamedItem("id").getNodeValue());
  146. for(Nodenode=child.getFirstChild();node!=null;node=node.getNextSibling()){
  147. if(node.getNodeType()==Node.ELEMENT_NODE){
  148. if("name".equals(node.getNodeName())){
  149. System.out.print("<name>");
  150. System.out.println(node.getFirstChild().getNodeValue());
  151. if("sex".equals(node.getNodeName())){
  152. System.out.print("<sex>");
  153. if("age".equals(node.getNodeName())){
  154. System.out.print("<age>");
  155. if("email".equals(node.getNodeName())){
  156. System.out.print("<email>");
  157. System.out.println("解析完毕");
  158. *测试
  159. //为什么有类似于这样东西[#text:]
  160. //原因是XML文件元素之间的空白字符也是一个元素，<employees></employees>包含的空白
  161. DomDemodom=newDomDemo();
  162. Filefile=newFile("E://dom.xml");
  163. dom.createXml(file);
  164. dom.parserXml(file);
  165. 四、SAX 1、原理：SAX类似流媒体，它基于事件驱动，当解析器发现元素开始、元素结束、文本、文档的开始或结束 等时，发送事件，程序员编写响应这些事件的代码，保存数据。无需将整个文档载入内存，使用者 只需要监听自己感兴趣的事件即可。
    2、优点：a、无需将整个xml文档载入内存，因此消耗内存少
    b、SAX解析器代码比DOM解析器代码小，适于Applet，下载。
    c、可以注册多个ContentHandler
    3、缺点：a、不能随机的访问xml中的节点
    b、只支持读，不能修改文档。非持久，事件过后，若没保存数据，那么数据就丢了
    c、无状态性；从事件中只能得到文本，但不知该文本属于哪个元素
    4、场合：大型xml文档；Applet；只需XML文档的少量内容，很少回头访问；
    ?
      importjavax.xml.parsers.SAXParser;
    1. importjavax.xml.parsers.SAXParserFactory;
    2. importorg.xml.sax.Attributes;
    3. importorg.xml.sax.helpers.DefaultHandler;
    4. *startDocument()，endDocument(),startElement(),endElement(),characters()
    5. publicclassSAXParseDemoextendsDefaultHandler{
    6. privateStringtagValue;//标签值
    7. //开始解析XML文件
    8. publicvoidstartDocument()throwsSAXException{
    9. System.out.println("开始解析");
    10. //结束解析XML文件
    11. publicvoidendDocument()throwsSAXException{
    12. System.out.println("结束解析");
    13. //解析元素
    14. *开始解析一个元素
    15. *@paramqName标签名
    16. *@paramattributes属性
    17. @Override
    18. publicvoidstartElement(Stringuri,StringlocalName,StringqName,Attributesattributes)
    19. throwsSAXException{
    20. System.out.println(qName+"开始");
    21. //属性
    22. if(attributes!=null&&attributes.getLength()!=0){
    23. System.out.println("属性：");
    24. 0;i<attributes.getLength();i++){
    25. System.out.print(attributes.getQName(i)+"=");//属性名
    26. System.out.print(attributes.getValue(i)+"");//属性值
    27. System.out.println();
    28. *结束一个元素的解析遇到结束标签时调用此方法通常在此方法对标签取值并处理
    29. publicvoidendElement(Stringuri,StringqName)throwsSAXException{
    30. System.out.println(qName+"标签值："+tagValue);
    31. System.out.println(qName+"结束");
    32. //所有xml文件中的字符都会放到ch[]中
    33. publicvoidcharacters(charch[],intstart,intlength)throwsSAXException{
    34. tagValue=newString(ch,start,length).trim();
    35. Filefile=newFile("src/cn/main/example/demo.xml");
    36. SAXParserFactorysaxParFac=SAXParserFactory.newInstance();
    37. SAXParsersaxParser=saxParFac.newSAXParser();
    38. saxParser.parse(file,newSAXParseDemo());
    39. }catch(Exceptione){
    40. }

    五、资料(关于Xpath)

    1、选取节点

    XPath 使用路径表达式在 XML 文档中选取节点，节点是沿着路径或者 step 来选取的。

    常见的路径表达式：

    表达式

    描述

    nodename

    选取当前节点的所有子节点

    /

    从根节点选取

    //

    从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置

    .

    选取当前节点

    ..

    选取当前节点的父节点

    @

    选取属性

    实例

    路径表达式

    结果

    bookstore

    选取 bookstore 元素的所有子节点

    /bookstore

    选取根元素 bookstore

    bookstore/book

    选取bookstore 下名字为 book的所有子元素。

    //book

    选取所有 book 子元素，而不管它们在文档中的位置。

    bookstore//book

    选取bookstore 下名字为 book的所有后代元素，而不管它们位于 bookstore 之下的什么位置。

    //@lang

    选取所有名为 lang 的属性。

    2、谓语（Predicates）

    谓语用来查找某个特定的节点或者包含某个指定的值的节点。

    谓语被嵌在方括号中。

    实例

    常见的谓语的一些路径表达式：

    /bookstore/book[1]

    选取属于 bookstore 子元素的第一个 book 元素。

    /bookstore/book[last()]

    选取属于 bookstore 子元素的最后一个 book 元素。

    /bookstore/book[last()-1]

    选取属于 bookstore 子元素的倒数第二个 book 元素。

    /bookstore/book[position()<3]

    选取最前面的两个属于 bookstore 元素的子元素的 book 元素。

    //title[@lang]

    选取所有拥有名为 lang 的属性的 title 元素。

    //title[@lang='eng']

    选取所有 title 元素，要求这些元素拥有值为 eng 的 lang 属性。

    /bookstore/book[price>35.00]

    选取所有 bookstore 元素的 book 元素，要求book元素的子元素 price 元素的值须大于 35.00。

    /bookstore/book[price>35.00]/title

    选取所有 bookstore 元素中的 book 元素的 title 元素，要求book元素的子元素 price 元素的值须大于 35.00

    3、选取未知节点

    XPath 通配符可用来选取未知的 XML 元素。

    通配符

    *

    匹配任何元素节点

    @*

    匹配任何属性节点

    node()

    匹配任何类型的节点

    /bookstore/*

    //*

    选取文档中的所有元素

    //title[@*]

    选取所有带有属性的 title 元素。

    4、选取若干路径

    通过在路径表达式中使用“|”运算符，您可以选取若干个路径。

    路径表达式

    @H_189_5027@

    结果

    //book/title|//book/price

    @H_189_5027@

    选取所有 book 元素的 title 和 price 元素。

    //title|//price

    @H_189_5027@

    选取所有文档中的 title 和 price 元素。

    /bookstore/book/title|//price

    @H_189_5027@

    选取所有属于 bookstore 元素的 book 元素的 title 元素，以及文档中所有的 price 元素。

    5、XPath 轴

    轴可定义某个相对于当前节点的节点集。

    轴名称

    ancestor

    选取当前节点的所有先辈（父、祖父等）

    ancestor-or-self

    选取当前节点的所有先辈（父、祖父等）以及当前节点本身

    attribute

    选取当前节点的所有属性

    child

    选取当前节点的所有子元素。

    descendant

    选取当前节点的所有后代元素（子、孙等）。

    descendant-or-self

    选取当前节点的所有后代元素（子、孙等）以及当前节点本身。

    following

    选取文档中当前节点的结束标签之后的所有节点。

    namespace

    选取当前节点的所有命名空间节点

    parent

    选取当前节点的父节点。

    preceding

    选取文档中当前节点的开始标签之前的所有节点。

    preceding-sibling

    选取当前节点之前的所有同级节点。

    self

    选取当前节点。

    6、路径

    位置路径可以是绝对的，也可以是相对的。

    绝对路径起始于正斜杠( / )，而相对路径不会这样。在两种情况中，位置路径均包括一个或多个步，每个步均被斜杠分割：

    /step/step/...
    step/step/...

    每个步均根据当前节点集之中的节点来进行计算。

    轴（axis）：定义所选节点与当前节点之间的树关系

    节点测试（node-test）：识别某个轴内部的节点

    零个或者更多谓语（predicate）：更深入地提炼所选的节点集

    步的语法：轴名称::节点测试[谓语]

    例子

    child::book

    选取所有属于当前节点的子元素的 book 节点

    attribute::lang

    选取当前节点的 lang 属性

    child::*

    选取当前节点的所有子元素

    attribute::*

    child::text()

    选取当前节点的所有文本子节点

    child::node()

    descendant::book

    选取当前节点的所有 book 后代

    ancestor::book

    选择当前节点的所有 book 先辈

    ancestor-or-self::book

    选取当前节点的所有book先辈以及当前节点（假如此节点是book节点的话）

    child::*/child::price

    选取当前节点的所有 price 孙。

    7、XPath 运算符

    运算符

    描述

    实例

    返回值

    |

    计算两个节点集

    //book | //cd

    返回所有带有 book 和 ck 元素的节点集

    +

    加法

    6 + 4

    10

    -

    减法

    6 - 4

    2

    *

    乘法

    6 * 4

    24

    div

    除法

    8 div 4

    =

    等于

    price=9.80

    如果 price 是 9.80，则返回 true。

    如果 price 是 9.90，则返回 fasle。

    !=

    不等于

    price!=9.80

    如果 price 是 9.90，则返回 true。

    如果 price 是 9.80，则返回 fasle。

    <

    小于

    price<9.80

    如果 price 是 9.00，则返回 true。

    如果 price 是 9.90，则返回 fasle。

    <=

    小于或等于

    price<=9.80

    >

    大于

    price>9.80

    >=

    大于或等于

    price>=9.80

    如果 price 是 9.90，则返回 true。

    如果 price 是 9.70，则返回 fasle。

    or

    或

    price=9.80 or price=9.70

    如果 price 是 9.80，则返回 true。

    如果 price 是 9.50，则返回 fasle。

    and

    与

    price>9.00 and price<9.90

    如果 price 是 9.80，则返回 true。

    如果 price 是 8.50，则返回 fasle。

    mod

    计算除法的余数

    5 mod 2

    1

    大部分源代码来源于:http://www.jb51.cc/article/p-poqlaaev-bdz.html

    部分资料来源于:http://www.jb51.cc/article/p-gkrkxlnq-ck.html

    Dom4j大部分资料来源于:http://www.jb51.cc/article/p-atlhkbmf-bhz.html

    Xpath部分内容来源于:http://nemogu.iteye.com/blog/1305503

    猜你在找的XML相关文章

    10分钟掌握XML、JSON及其解析
    引言 NOKIA 有句著名的广告语：“科技以人为本”。任何技术都是为了满足人的生产生活需要而...
    [CXF REST标准实战系列] 一、JAXB xml与javaBean的转换
    Writer：BYSocket（泥沙砖瓦浆木匠） 微博：BYSocket 豆瓣：BYSocket Reprint it anywhere...
    [CXF REST标准实战系列] 一、JAXB xml与javaBean的转换
    Writer：BYSocket（泥沙砖瓦浆木匠） 微博：BYSocket 豆瓣：BYSocket Reprint it anywhere...
    10分钟掌握XML、JSON及其解析
    http://blog.jobbole.com/79252/ 引言 NOKIA 有句著名的广告语：“科技以人为本”。任何技...
    自定义圆形控件RoundImageView并认识一下attr.xml
    (点击上方公众号，可快速关注) 公众号：smart_android 作者：耿广龙｜loonggg 点击“阅读原...
    10分钟掌握XML、JSON及其解析
    引言 NOKIA 有句著名的广告语：“科技以人为本”。任何技术都是为了满足人的生产生活需要而...
    10分钟掌握XML、JSON及其解析(上)
     (点击上方公众号，可快速关注) 来源： Long Luo 的博客 链接：http://longluo.github.i...
    10分钟掌握XML、JSON及其解析(中)
    接上文 二、JSON XML很好很强大，但是最近有另外一个时代弄潮儿，这就是JSON。现在JSON的光...
    10分钟掌握XML、JSON及其解析(下)
    接上文 2.4 如何解析JSON？ Android JSON所有相关类，都在org.json包下。 包括JSONObject、...
    10分钟掌握XML、JSON及其解析
    原文出处：  Long Luo 的博客（@Long_Luo）   引言 NOKIA 有句著名的广告语：“科技以人...
    HTMLHTML5JavaScriptCSSjQueryBootstrapAngularjsTypeScriptVueDojoJsonElectronNode.jsextjsExpress XMLES6AjaxFlashUnityReactFlexAnt DesignWeb前端微信小程序微信公众号
    关闭广告单独headers封装代码提示错误整数正则非0开头跳页出页码antd table提示URL未注册公众号支付vue hash模式iSlider车牌键盘循环图片echarts 双折左右布局DllPlugin对象创建打字游戏圈选两栏云函数蒙版ES2020橱窗无缝滚动轮播色块碰撞组件销毁文档操作