`
sysu_zeh
  • 浏览: 28152 次
  • 性别: Icon_minigender_1
  • 来自: 广州
最近访客 更多访客>>
ccitllz
社区版块
存档分类
最新评论

java解析xml之一:使用SAX与DOM

XMLJava编程XSLSUN
阅读更多

一.概要

　　用Java解析XML文档，最常用的有两种方法：使用基于事件的XML简单API（Simple API for XML）称为SAX和基于树和节点的文档对象模型（Document Object Module）称为DOM。Sun公司提供了Java API for XML Parsing（JAXP）接口来使用SAX和DOM，通过JAXP，我们可以使用任何与JAXP兼容的XML解析器。
　　
　　JAXP接口包含了三个包：
　　
　　（1）org.w3c.dom　W3C推荐的用于XML标准规划文档对象模型的接口。
　　
　　（2）org.xml.sax　 用于对XML进行语法分析的事件驱动的XML简单API（SAX）
　　
　　（3）javax.xml.parsers解析器工厂工具，程序员获得并配置特殊的特殊语法分析器。

二.实例

1.所需xml文件

Test.xml

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <books>  
  3.   <book email="zeh2007@126.com">  
  4.   <name>C++编程思想</name>  
  5.   <price>60.0</price>  
  6.   </book>  
  7. </books>  

students.xml

  1. <?xml version="1.0" encoding="gb2312"?>  
  2. <?xml-stylesheet type="text/xsl" href="students.xsl"?>  
  3. <students>  
  4.   <student sn="04378066">  
  5.      <name>ldz</name>  
  6.      <age>23</age>  
  7.   </student>  
  8.   <student sn="04378069">  
  9.      <name>zeh</name>  
  10.      <age>21</age>  
  11.   </student>  
  12. </students>  

 2.将xml文件转化为dom：

  1. package domParser;   
  2.   
  3. import java.io.File;   
  4. import java.io.IOException;   
  5. import javax.xml.parsers.DocumentBuilder;   
  6. import javax.xml.parsers.DocumentBuilderFactory;   
  7. import javax.xml.parsers.ParserConfigurationException;   
  8. import javax.xml.transform.Transformer;   
  9. import javax.xml.transform.TransformerConfigurationException;   
  10. import javax.xml.transform.TransformerException;   
  11. import javax.xml.transform.TransformerFactory;   
  12. import javax.xml.transform.dom.DOMSource;   
  13. import javax.xml.transform.stream.StreamResult;   
  14. //下面主要是org.xml.sax包的类   
  15. import org.w3c.dom.Document;   
  16. import org.w3c.dom.Element;   
  17. import org.w3c.dom.Node;   
  18. import org.w3c.dom.NodeList;   
  19. import org.w3c.dom.Text;   
  20. import org.xml.sax.SAXException;   
  21.   
  22.   
  23. public class DOMConvert {   
  24.   
  25.     public static void main(String[] args) {   
  26.         //DOM解析器的工厂实例   
  27.         DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();   
  28.         try {   
  29.             //从DOM工厂获得DOM解析器   
  30.             DocumentBuilder db=dbf.newDocumentBuilder();   
  31.             //解析XML文档的输入流，得到一个Document   
  32.             Document doc=db.parse(new File("xmlFil/students.xml"));   
  33.             //建立一个XML节点   
  34.             Element eltStu=doc.createElement("student");   
  35.             Element eltName=doc.createElement("name");   
  36.             Element eltAge=doc.createElement("age");   
  37.                
  38.             Text textName=doc.createTextNode("yyr");   
  39.             Text textAge=doc.createTextNode("22");   
  40.                
  41.             eltName.appendChild(textName);   
  42.             eltAge.appendChild(textAge);   
  43.                
  44.             eltStu.appendChild(eltName);   
  45.             eltStu.appendChild(eltAge);   
  46.             eltStu.setAttribute("sn","04378072");   
  47.             //将此节点插入根的孩子中   
  48.             Element root=doc.getDocumentElement();   
  49.             root.appendChild(eltStu);   
  50.             //获取stuent标签节点   
  51.             NodeList nl=root.getElementsByTagName("student");   
  52.             //删除第一个节点   
  53.             root.removeChild(nl.item(0));   
  54.             //获取第一个节点   
  55.             Element eltStuChg=(Element)nl.item(0);   
  56.             //获取age标签节点   
  57.             Node nodeAgeChg=eltStuChg.getElementsByTagName("age").item(0);   
  58.             nodeAgeChg.getFirstChild().setNodeValue("20");   
  59.            
  60.             int len=nl.getLength();   
  61.             for(int i=0;i
  62.                 Element elt=(Element)nl.item(i);   
  63.                 System.out.println("编号：" + elt.getAttribute("sn"));   
  64.                    
  65.                 Node nodeName=elt.getElementsByTagName("name").item(0);   
  66.                 Node nodeAge=elt.getElementsByTagName("age").item(0);   
  67.                    
  68.                 String name=nodeName.getFirstChild().getNodeValue();   
  69.                 String age=nodeAge.getFirstChild().getNodeValue();   
  70.                    
  71.                 System.out.println("姓名："+name);   
  72.                 System.out.println("年龄：" + age);   
  73.                    
  74.                 System.out.println("--------------------");   
  75.             }   
  76.             //实例化一个转换工厂   
  77.             TransformerFactory tff=TransformerFactory.newInstance();   
  78.             //获取一个转换实例   
  79.             Transformer tf=tff.newTransformer();   
  80.             //设置输出属性   
  81.             tf.setOutputProperty("encoding","gb2312");   
  82.             //根据Document对象新建一个DOM数据源   
  83.             DOMSource source=new DOMSource(doc);   
  84.             //定义输出流   
  85.             StreamResult result=new StreamResult(new File("convert.xml"));   
  86.             //从数据源转换至输出流   
  87.             tf.transform(source,result);   
  88.         }   
  89.         catch (ParserConfigurationException e) {   
  90.             e.printStackTrace();   
  91.         }    
  92.         catch (SAXException e) {   
  93.             e.printStackTrace();   
  94.         }    
  95.         catch (IOException e) {   
  96.             e.printStackTrace();   
  97.         }    
  98.         catch (TransformerConfigurationException e) {   
  99.             e.printStackTrace();   
  100.         }   
  101.         catch (TransformerException e) {   
  102.             e.printStackTrace();   
  103.         }   
  104.     }   
  105. }

3.解析DOM树

  1. package domParser;   
  2.   
  3. import java.io.FileInputStream;   
  4. import java.io.FileNotFoundException;   
  5. import java.io.IOException;   
  6. import java.io.InputStream;   
  7. import javax.xml.parsers.DocumentBuilder;   
  8. import javax.xml.parsers.DocumentBuilderFactory;   
  9. import javax.xml.parsers.ParserConfigurationException;   
  10. //下面主要是org.xml.sax包的类   
  11. import org.w3c.dom.Document;   
  12. import org.w3c.dom.Element;   
  13. import org.w3c.dom.Node;   
  14. import org.w3c.dom.NodeList;   
  15. import org.xml.sax.SAXException;   
  16.   
  17.   
  18. public class DomParser {   
  19.   
  20.     public DomParser() {   
  21.         //DOM解析器的工厂实例   
  22.         DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();   
  23.         try {   
  24.             //从DOM工厂获得DOM解析器   
  25.             DocumentBuilder dombuilder=domfac.newDocumentBuilder();   
  26.             //把要解析的XML文档转化为输入流   
  27.             InputStream is=new FileInputStream("Test.xml");   
  28.             //解析XML文档的输入流，得到一个Document   
  29.             Document doc=dombuilder.parse(is);   
  30.             //得到XML文档的根节点   
  31.             Element root=doc.getDocumentElement();   
  32.             //得到节点的子节点   
  33.             NodeList books=root.getChildNodes();   
  34.             if(books!=null) {   
  35.                 for(int i=0;i
  36.                     Node book=books.item(i);   
  37.                     if(book.getNodeType()==Node.ELEMENT_NODE) {   
  38.                         //取得节点的属性值   
  39.                         String email=book.getAttributes().getNamedItem("email").getNodeValue();   
  40.                         System.out.println(email);   
  41.                         //轮循子节点   
  42.                         for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()) {   
  43.                             if(node.getNodeType()==Node.ELEMENT_NODE) {   
  44.                                 if(node.getNodeName().equals("name")) {   
  45.                                     String name=node.getNodeValue();   
  46.                                     node.setNodeValue("Java编程思想");   
  47.                                     String name1=node.getFirstChild().getNodeValue();   
  48.                                     System.out.println(name);   
  49.                                     System.out.println(name1);   
  50.                                 }   
  51.                                 if(node.getNodeName().equals("price")) {   
  52.                                     String price=node.getFirstChild().getNodeValue();   
  53.                                     System.out.println(price);   
  54.                                 }   
  55.                             }   
  56.                         }   
  57.                     }   
  58.                 }   
  59.             }   
  60.         }    
  61.         catch (ParserConfigurationException e) {   
  62.             e.printStackTrace();   
  63.         }    
  64.         catch (FileNotFoundException e) {   
  65.             e.printStackTrace();   
  66.         }    
  67.         catch (SAXException e) {   
  68.             e.printStackTrace();   
  69.         }    
  70.         catch (IOException e) {   
  71.             e.printStackTrace();   
  72.         }   
  73.     }   
  74.     public static void main(String[] args)    
  75.     {   
  76.         new DomParser();   
  77.     }   
  78. }  

4.打印DOM树

  1. package domParser;   
  2.   
  3. import java.io.File;   
  4. import java.io.IOException;   
  5. import javax.xml.parsers.DocumentBuilder;   
  6. import javax.xml.parsers.DocumentBuilderFactory;   
  7. import javax.xml.parsers.ParserConfigurationException;   
  8. //下面主要是org.xml.sax包的类   
  9. import org.w3c.dom.*;   
  10. import org.xml.sax.SAXException;   
  11.   
  12. public class DOMPrinter{   
  13.     //打印指定节点(节点名:节点值)   
  14.     public static void printNodeInfo(Node node){   
  15.         System.out.println(node.getNodeName()+" : "+node.getNodeValue());   
  16.     }   
  17.     //递归打印全部节点   
  18.     public static void printNode(Node node){   
  19.         short nodeType=node.getNodeType();   
  20.         //判断节点类型   
  21.         switch(nodeType){   
  22.             //前缀节点   
  23.             case Node.PROCESSING_INSTRUCTION_NODE:   
  24.                 System.out.println("-----------PI start-----------");   
  25.                 printNodeInfo(node);   
  26.                 System.out.println("-----------PI end-----------");   
  27.                 break;   
  28.             //元素节点   
  29.             case Node.ELEMENT_NODE:   
  30.                 System.out.println("-----------Element start-----------");   
  31.                 printNodeInfo(node);   
  32.                 System.out.println("-----------Element end-----------");   
  33.                 //打印节点属性值   
  34.                 NamedNodeMap attrs=node.getAttributes();   
  35.                 int attrNum=attrs.getLength();   
  36.                 for(int i=0;i
  37.                     Node attr=attrs.item(i);   
  38.                     System.out.println("-----------Attribute start-----------");   
  39.                     printNodeInfo(attr);   
  40.                     System.out.println("-----------Attribute end-----------");   
  41.                 }   
  42.                 break;   
  43.             //文本节点   
  44.             case Node.TEXT_NODE:   
  45.                 System.out.println("-----------Text start-----------");   
  46.                 printNodeInfo(node);   
  47.                 System.out.println("-----------Text end-----------");   
  48.                 break;   
  49.             default:   
  50.                 break;   
  51.         }   
  52.         //递归打印节点信息   
  53.         Node child=node.getFirstChild();   
  54.         while(child!=null){   
  55.             printNode(child);   
  56.             child=child.getNextSibling();   
  57.         }   
  58.     }   
  59.        
  60.     public static void main(String[] args){   
  61.         //DOM解析器的工厂实例   
  62.         DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();   
  63.         try{   
  64.             //从DOM工厂获得DOM解析器   
  65.             DocumentBuilder db=dbf.newDocumentBuilder();   
  66.             //解析XML文档的输入流，得到一个Document   
  67.             Document doc=db.parse(new File("students.xml"));   
  68.             //打印节点   
  69.             printNode(doc);   
  70.         }   
  71.         catch (ParserConfigurationException e){   
  72.             e.printStackTrace();   
  73.         }   
  74.         catch (SAXException e){   
  75.             e.printStackTrace();   
  76.         }   
  77.         catch (IOException e){   
  78.             e.printStackTrace();   
  79.         }   
  80.     }   
  81. }  

 
分享到：
| acm例程
评论
1 楼 Java小菜哈 2011-07-04  
大哥，你有没有试过的，解析DOM数的时候还是个死循环。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics