JAVA DOM生成和解析XML实例

XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。java操作XML时候有4中经典方法，本文将介绍DOM操作XML。并给出一个用DOM生成和解析XML的实例。

初始步骤如下：

1.创建解析工厂：

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

2.指定DocumentBuilder
    DocumentBuilder db = factory.newDocumentBuilder();

3.从文件构造一个Document,因为XML文件中已经指定了编码，所以这里不必了

Document xmlDoc = db.parse(new File("book.xml"));

 

上面三步可以得到映射了指定的XML文件的Document,之后，通过这个Document可以来操作XML。

 

得到Document的根

Element root = xmlDoc.getDocumentElement();

 

得到根后通过getTagName可以得到根节点名及其他一系列操作。

 

一.解析

获得XML某个元素的值：

NodeList list = root.getElementsByTagName_r("page");

//NodeList对象存储的是指定元素的值的列表，

//我们可以通过遍历来得到指定元素的各个值：

for(int i=0;i

Element element = (Element)list.item(i); //得到"page"的第i+1组标签

String id = element.getAttribute("id");  //获得ID属性

//

//得到标签title的列表

NodeList titleList = element.getElementsByTagName_r("title");

//得到"title"的第1组标签，事实上也只有一组标签

Element titleElement = (Element)titleList.item(0);

//获得title元素的第一个值

String title = titleElement.getFirstChild().getNodeValue();

}

 

二.修改

Element theBook=null, theElem=null;

//   创建指定类型的元素
   theBook = xmlDoc.createElement_x_x("book");
   theElem = xmlDoc.createElement_x_x("name");
   //   元素theElem设置数值，并作为theBook的子节点   

theElem.setTextContent("新书");

 theBook.a(theElem);

//     作为root的子节点

   root.a(theBook);

 

三.输出

通过DOMSource和StreamResult完成

//首先创建转化工厂

TransformerFactory transFactory=TransformerFactory.newInstance();

//创建Transformer，它能够将源树转换为结果树

Transformer transformer = transFactory.newTransformer();

//接下来设置输出属性

transformer.setOutputProperty("indent", "yes");

DOMSource source =new DOMSource();
source.setNode(xmlDoc);
StreamResult result = new StreamResult();

接下来有三种输出用途：

//1.将XML字符串输出到String字符串中

ByteArrayOutputStream baos = new ByteArrayOutputStream();
result.setOutputStream(baos);

在执行完transformer.transform(source, result)后，

加入String s = baos.toString();

//2.直接输出到控制台上

result.setOutputStream(System.out);

//3.保存到指定的文件里面
result.setOutputStream(new FileOutputStream("book.xml"));

 

//开始执行将XML Source转换为 Result
transformer.transform(source, result);  

四、实例

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. import java.awt.List;  
  2. import java.io.*;  
  3. import java.util.*;  
  4. import javax.xml.parsers.DocumentBuilder;  
  5. import javax.xml.parsers.DocumentBuilderFactory;  
  6. import javax.xml.parsers.ParserConfigurationException;  
  7. import javax.xml.transform.Transformer;  
  8. import javax.xml.transform.TransformerException;  
  9. import javax.xml.transform.TransformerFactory;  
  10. import javax.xml.transform.dom.DOMSource;  
  11. import javax.xml.transform.stream.StreamResult;  
  12. import org.w3c.dom.Document;  
  13. import org.w3c.dom.Element;  
  14. import org.w3c.dom.NodeList;  
  15. import org.w3c.dom.Node;   
  16.   
  17. //将XML中的节点以对象的方式进行封装  
  18. class XMLObject{  
  19.     private String name,grade,age;  
  20.     public XMLObject(String name,String grade,String age) {  
  21.         this.name=name;  
  22.         this.grade=grade;  
  23.         this.age=age;  
  24.           
  25.     }  
  26.     //返回一个XML的节点类Element  
  27.     public Element getXMLObject(Document doc) throws ParserConfigurationException{  
  28.       
  29.         //通过Document类的createElement创建一个节点  
  30.         Element Name = doc.createElement("name");  
  31.         Element Grade= doc.createElement("grade");  
  32.         Element Age =doc.createElement("age");  
  33.         Element Student=doc.createElement("student");  
  34.         //Element类的setTextContent(String textContent)方法设置节点值  
  35.         Name.setTextContent(name);  
  36.         Grade.setTextContent(grade);  
  37.         Age.setTextContent(age);  
  38.         Student.appendChild(Name);  
  39.         Student.appendChild(Grade);  
  40.         Student.appendChild(Age);  
  41.         return Student;  
  42.     }  
  43. }  
  44.   
  45. public class XML{   
  46.       
  47.       
  48.     public static void createXML(String XMLname)throws ParserConfigurationException, TransformerException, IOException{  
  49.          //创建一个Document类  
  50.          DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
  51.          DocumentBuilder builder = factory.newDocumentBuilder();  
  52.          Document doc = builder.newDocument();  
  53.          //创建一个根节点，并且将根节点添加到Document对象中去  
  54.          Element root=doc.createElement("students");  
  55.          doc.appendChild(root);  
  56.          //使用ArryayList，便于添加自己所创建的对象  
  57.          ArrayList<XMLObject> stu=new ArrayList<XMLObject>();  
  58.          stu.add(new XMLObject("Jhon","B","12"));  
  59.          stu.add(new XMLObject("Mary","A","11"));  
  60.          stu.add(new XMLObject("Simon","A","18"));  
  61.          //将ArrayList里面的对象全部添加到根节点中去  
  62.          for(XMLObject t:stu){       
  63.            root.appendChild(t.getXMLObject(doc));  
  64.          }  
  65.          //开始把Document映射到文件  
  66.          TransformerFactory transFactory = TransformerFactory.newInstance();  
  67.          Transformer transFormer = transFactory.newTransformer();   
  68.          //设置输出结果并且生成XML文件  
  69.          DOMSource domSource = new DOMSource(doc);                             
  70.          File file = new File(XMLname);   
  71.          if (!file.exists())  file.createNewFile();  
  72.          //设置输入源并且输出XML文件  
  73.          FileOutputStream out = new FileOutputStream(file);         
  74.          StreamResult xmlResult = new StreamResult(out);//设置输入源      
  75.          transFormer.transform(domSource, xmlResult);//输出xml文件              
  76.          System.out.println(file.getAbsolutePath());//测试文件输出的路径  
  77.     }  
  78.     public static void parseXML(String fileName) {   
  79.         try {   
  80.             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();   
  81.             DocumentBuilder db = dbf.newDocumentBuilder();   
  82.             File file = new File(fileName);   
  83.             if (file.exists()) {   
  84.                 Document doc = db.parse(file);   
  85.                 Element docEle = doc.getDocumentElement();   
  86.      
  87.                 // Print root element of the document   
  88.                 System.out.println("Root element of the document: "  
  89.                         + docEle.getNodeName());   
  90.      
  91.                 NodeList studentList = docEle.getElementsByTagName("student");   
  92.      
  93.                 // Print total student elements in document   
  94.                 System.out.println("Total students: " + studentList.getLength());   
  95.   
  96.                 if (studentList != null && studentList.getLength() > 0) {   
  97.                     for (int i = 0; i < studentList.getLength(); i++) {   
  98.     
  99.                         Node node = studentList.item(i);   
  100.      
  101.                         if (node.getNodeType() == Node.ELEMENT_NODE) {   
  102.      
  103.                             System.out.println("=====================");   
  104.   
  105.                             Element e = (Element) node;   
  106.                             NodeList nodeList = e.getElementsByTagName("name");   
  107.                             System.out.println("Name: "  
  108.                                     + nodeList.item(0).getChildNodes().item(0)   
  109.                                             .getNodeValue());   
  110.     
  111.                             nodeList = e.getElementsByTagName("grade");   
  112.                             System.out.println("Grade: "  
  113.                                     + nodeList.item(0).getChildNodes().item(0)   
  114.                                             .getNodeValue());   
  115.      
  116.                             nodeList = e.getElementsByTagName("age");   
  117.                             System.out.println("Age: "  
  118.                                     + nodeList.item(0).getChildNodes().item(0)   
  119.                                             .getNodeValue());   
  120.                         }   
  121.                     }   
  122.                 } else {   
  123.                     System.exit(1);   
  124.                 }   
  125.             }   
  126.         } catch (Exception e) {   
  127.             System.out.println(e);   
  128.         }   
  129.     }   
  130.     //测试  
  131.     public static void main(String []args) throws ParserConfigurationException, TransformerException, IOException{  
  132.         XML.createXML("D:\\java\\zhengZe\\Student.xml");  
  133.         XML.parseXML("D:\\java\\zhengZe\\Student.xml");  
  134.     }  
  135. }  



 

    这样就可以在相应的路径下面创建和解析XML文档了，这段代码将要插入的XML节点以对象封装，插入其他节点时候，只需对XMLObject修改即可。

    可以看到，生成的XML文件如下：

   

posted @ 2014-04-20 18:04  wxfvm  阅读(871)  评论(0)  编辑  收藏  举报