xml的四种解析方式实例

xml的四种解析方式实例

一、DOM（Document Object Model）解析方式

在应用程序中,基于DOM的xml分析器将xml文档解析成一个对象模型的集合(通常称DOM树),应用程序正是通过对这个对象模型的操作,来实现对xml数据的操作.通过DOM接口应用程序可以在任何时候访问xml文档的任何一部分数据.

DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式,这些分层对象模型依据XML的文档结构形成了一棵节点树。无论XML文档中所描述的是什么类型的信息,即便是制表数据、项目列表或一个文档,利用DOM所生成的模型都是节点树的形式。也就是说,DOM强制使用树模型来访问XML文档中的信息。由于XML本质上就是一种分层结构，所以这种描述方法是相当有效的。

DOM树所提供的随机访问方式给应用程序带来了很大的灵活性,它可以任意控制xml文档中的内容。然而,由于DOM分析器把整个xml文档转换成DOM树放在了内存中,因此,当文档比较大或者数据比较复杂的时候,对内存的需求就比较高。而且对于结构复杂的树的遍历也是一项耗时的工作。所以DOM分析器对于机器性能要求比较高,实现效率不十分理想。不过,由于DOM分析器所采用的树结构的思想与xml文档的结构相吻合,同时鉴于随机访问所带来的方便,因此DOM分析器还是有着比较广泛的应用。

实例一：

[java] view plaincopy

1. package dom;  
2.   
3. import java.io.File;  
4.   
5. import javax.xml.parsers.DocumentBuilder;  
6. import javax.xml.parsers.DocumentBuilderFactory;  
7.   
8. import org.w3c.dom.Document;  
9. import org.w3c.dom.Element;  
10. import org.w3c.dom.NodeList;  
11.   
12. public class DomTest1  
13. {  
14.     public static void main(String[] args) throws Exception  
15.     {  
16.         // step 1: 获得dom解析器工厂（工作的作用是用于创建具体的解析器）  
17.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
18.           
19.         System.out.println("class name: " + dbf.getClass().getName());  
20.           
21.         // step 2:获得具体的dom解析器  
22.         DocumentBuilder db = dbf.newDocumentBuilder();  
23.           
24.         System.out.println("class name: " + db.getClass().getName());  
25.           
26.         // step3: 解析一个xml文档，获得Document对象（根结点）  
27.         Document document = db.parse(new File("candidate.xml"));//文件路径可以是绝对路径也可以是相对路径  
28.           
29.         NodeList list = document.getElementsByTagName("PERSON");  
30.           
31.         for(int i = 0; i < list.getLength(); i++)  
32.         {  
33.             Element element = (Element)list.item(i);  
34.               
35.             String content = element.getElementsByTagName("NAME").item(0).getFirstChild().getNodeValue();  
36.               
37.             System.out.println("name:" + content);  
38.               
39.             content = element.getElementsByTagName("ADDRESS").item(0).getFirstChild().getNodeValue();  
40.               
41.             System.out.println("address:" + content);  
42.               
43.             content = element.getElementsByTagName("TEL").item(0).getFirstChild().getNodeValue();  
44.               
45.             System.out.println("tel:" + content);  
46.               
47.             content = element.getElementsByTagName("FAX").item(0).getFirstChild().getNodeValue();  
48.               
49.             System.out.println("fax:" + content);  
50.               
51.             content = element.getElementsByTagName("EMAIL").item(0).getFirstChild().getNodeValue();  
52.               
53.             System.out.println("email:" + content);  
54.               
55.             System.out.println("--------------------------------------");  
56.         }  
57.     }  
58. }  

xml文件：

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <a>  
3.     <PERSON>  
4.         <NAME  id="cheng">海成</NAME>  
5.         <ADDRESS>立水桥</ADDRESS>  
6.         <TEL>15210221200</TEL>  
7.         <FAX>无</FAX>  
8.         <EMAIL>[e-mail]</EMAIL>  
9.     </PERSON>  
10.     <PERSON>  
11.         <NAME  id="yang">海洋</NAME>  
12.         <ADDRESS>庆安县</ADDRESS>  
13.         <TEL>15210221200</TEL>  
14.         <FAX>无</FAX>  
15.         <EMAIL>[e-mail]</EMAIL>  
16.     </PERSON>  
17.     <PERSON>  
18.         <NAME id="long">海龙</NAME>  
19.         <ADDRESS>庆安县</ADDRESS>  
20.         <TEL>15210221200</TEL>  
21.         <FAX>无</FAX>  
22.         <EMAIL>[e-mail]</EMAIL>  
23.     </PERSON>       
24. </a>  

实例二：运用递归遍历xml文档中的所有元素

[java] view plaincopy

1. package dom;  
2.   
3. import java.io.File;  
4.   
5. import javax.xml.parsers.DocumentBuilder;  
6. import javax.xml.parsers.DocumentBuilderFactory;  
7.   
8. import org.w3c.dom.Attr;  
9. import org.w3c.dom.Comment;  
10. import org.w3c.dom.Document;  
11. import org.w3c.dom.Element;  
12. import org.w3c.dom.NamedNodeMap;  
13. import org.w3c.dom.Node;  
14. import org.w3c.dom.NodeList;  
15.   
16. /** 
17.  * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上 
18.  * @author zhanglong 
19.  * 
20.  */  
21. public class DomTest3  
22. {  
23.     public static void main(String[] args) throws Exception  
24.     {  
25.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
26.         DocumentBuilder db = dbf.newDocumentBuilder();  
27.           
28.         Document doc = db.parse(new File("candidate.xml"));  
29.         //获得根元素结点  
30.         Element root = doc.getDocumentElement();  
31.           
32.         parseElement(root);  
33.     }  
34.       
35.     private static void parseElement(Element element)  
36.     {  
37.         String tagName = element.getNodeName();//节点名称  
38.           
39.         NodeList children = element.getChildNodes();  
40.           
41.         System.out.print("<" + tagName);  
42.           
43.         //element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断  
44.         NamedNodeMap map = element.getAttributes();  
45.           
46.         //如果该元素存在属性  
47.         if(null != map)  
48.         {  
49.             for(int i = 0; i < map.getLength(); i++)  
50.             {  
51.                 //获得该元素的每一个属性  
52.                 Attr attr = (Attr)map.item(i);  
53.                   
54.                 String attrName = attr.getName();  
55.                 String attrValue = attr.getValue();  
56.                   
57.                 System.out.print(" " + attrName + "=\"" + attrValue + "\"");  
58.             }  
59.         }  
60.           
61.         System.out.print(">");  
62.           
63.         for(int i = 0; i < children.getLength(); i++)  
64.         {  
65.             Node node = children.item(i);  
66.             //获得结点的类型  
67.             short nodeType = node.getNodeType();  
68.               
69.             if(nodeType == Node.ELEMENT_NODE)  
70.             {  
71.                 //是元素，继续递归  
72.                 parseElement((Element)node);  
73.             }  
74.             else if(nodeType == Node.TEXT_NODE)  
75.             {  
76.                 //递归出口  
77.                 System.out.print(node.getNodeValue());  
78.             }  
79.             else if(nodeType == Node.COMMENT_NODE)  
80.             {  
81.                 System.out.print("<!--");  
82.                   
83.                 Comment comment = (Comment)node;  
84.                   
85.                 //注释内容  
86.                 String data = comment.getData();  
87.                   
88.                 System.out.print(data);  
89.                   
90.                 System.out.print("-->");  
91.             }  
92.         }  
93.           
94.         System.out.print("</" + tagName + ">");  
95.     }  
96. }  

二、SAX(Simple APIs for XML)解析xml文件   XML简单应用程序接口。

与DOM不同,SAX提供的访问模式是一种顺序模式,而不是基于DOM的随机模式,这是一种快速读写XML文件的方式,当使用SAX分析器对xml文档进行解析的时候会触发一系列的事件,并激活相应的事件处理函数,应用程序通过这些事件处理函数对xml文档进行访问,因而SAX接口也被称为事件驱动接口。

实例三：

xml文件：

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <root>  
3.     <student id="1" group="1">  
4.         <name>张三</name>  
5.         <sex>男</sex>  
6.         <age>18</age>  
7.         <email>[e-mail]</email>  
8.         <birthday>1987-06-08</birthday>  
9.         <memo>好学生</memo>  
10.     </student>  
11.     <student id="2" group="2">  
12.         <name>李四</name>  
13.         <sex>女</sex>  
14.         <age>18</age>  
15.         <email>[e-mail]</email>  
16.         <birthday>1987-06-08</birthday>  
17.         <memo>好学生</memo>  
18.     </student>  
19.     <student id="3" group="3">  
20.         <name>小王</name>  
21.         <sex>男</sex>  
22.         <age>18</age>  
23.         <email>[e-mail]</email>  
24.         <birthday>1987-06-08</birthday>  
25.         <memo>好学生</memo>  
26.     </student>  
27.     <student id="4" group="4">  
28.         <name>小张</name>  
29.         <sex>男</sex>  
30.         <age>18</age>  
31.         <email>[e-mail]</email>  
32.         <birthday>1987-06-08</birthday>  
33.         <memo>好学生</memo>  
34.     </student>  
35.     <student id="5" group="5">  
36.         <name>小明</name>  
37.         <sex>男</sex>  
38.         <age>18</age>  
39.         <email>[e-mail]</email>  
40.         <birthday>1987-06-08</birthday>  
41.         <memo>好学生</memo>  
42.     </student>  
43. </root>  

xml对应的JavaBean：

[java] view plaincopy

1. package sax;  
2.   
3. public class Student {  
4.       
5.     private int id;  
6.     private int group;  
7.     private String name;  
8.     private String sex;  
9.     private int age;  
10.     private String email;  
11.     private String memo;  
12.     private String birthday;  
13.     public int getId() {  
14.         return id;  
15.     }  
16.     public void setId(int id) {  
17.         this.id = id;  
18.     }  
19.     public int getGroup() {  
20.         return group;  
21.     }  
22.     public void setGroup(int group) {  
23.         this.group = group;  
24.     }  
25.     public String getName() {  
26.         return name;  
27.     }  
28.     public void setName(String name) {  
29.         this.name = name;  
30.     }  
31.     public String getSex() {  
32.         return sex;  
33.     }  
34.     public void setSex(String sex) {  
35.         this.sex = sex;  
36.     }  
37.     public int getAge() {  
38.         return age;  
39.     }  
40.     public void setAge(int age) {  
41.         this.age = age;  
42.     }  
43.     public String getEmail() {  
44.         return email;  
45.     }  
46.     public void setEmail(String email) {  
47.         this.email = email;  
48.     }  
49.     public String getMemo() {  
50.         return memo;  
51.     }  
52.     public void setMemo(String memo) {  
53.         this.memo = memo;  
54.     }  
55.     public String getBirthday() {  
56.         return birthday;  
57.     }  
58.     public void setBirthday(String birthday) {  
59.         this.birthday = birthday;  
60.     }  
61.       
62. }  

解析类：

[java] view plaincopy

1. package sax;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.util.ArrayList;  
7. import java.util.List;  
8.   
9. import javax.xml.parsers.ParserConfigurationException;  
10. import javax.xml.parsers.SAXParser;  
11. import javax.xml.parsers.SAXParserFactory;  
12.   
13. import org.xml.sax.Attributes;  
14. import org.xml.sax.SAXException;  
15. import org.xml.sax.helpers.DefaultHandler;  
16.   
17.   
18. /** 
19.  * 功能描述:采用sax方式解析XML<br> 
20.  *  
21.  * @author HaiCheng 
22.  * 
23.  */  
24. public class SaxParseXml extends DefaultHandler{  
25.   
26.     //存放遍历集合  
27.     private List<Student> list;  
28.     //构建Student对象  
29.     private Student student;  
30.     //用来存放每次遍历后的元素名称(节点名称)  
31.     private String tagName;  
32.       
33.       
34.     public List<Student> getList() {  
35.         return list;  
36.     }  
37.   
38.   
39.     public void setList(List<Student> list) {  
40.         this.list = list;  
41.     }  
42.   
43.   
44.     public Student getStudent() {  
45.         return student;  
46.     }  
47.   
48.   
49.     public void setStudent(Student student) {  
50.         this.student = student;  
51.     }  
52.   
53.   
54.     public String getTagName() {  
55.         return tagName;  
56.     }  
57.   
58.   
59.     public void setTagName(String tagName) {  
60.         this.tagName = tagName;  
61.     }  
62.   
63.   
64.     //只调用一次  初始化list集合    
65.     @Override  
66.     public void startDocument() throws SAXException {  
67.         list=new ArrayList<Student>();  
68.     }  
69.       
70.       
71.     //调用多次    开始解析  
72.     @Override  
73.     public void startElement(String uri, String localName, String qName,  
74.             Attributes attributes) throws SAXException {  
75.         if(qName.equals("student")){  
76.             student=new Student();  
77.             //获取student节点上的id属性值  
78.             student.setId(Integer.parseInt(attributes.getValue(0)));  
79.             //获取student节点上的group属性值  
80.             student.setGroup(Integer.parseInt(attributes.getValue(1)));  
81.         }  
82.         this.tagName=qName;  
83.     }  
84.       
85.       
86.     //调用多次    
87.     @Override  
88.     public void endElement(String uri, String localName, String qName)  
89.             throws SAXException {  
90.         if(qName.equals("student")){  
91.             this.list.add(this.student);  
92.         }  
93.         this.tagName=null;  
94.     }  
95.       
96.       
97.     //只调用一次  
98.     @Override  
99.     public void endDocument() throws SAXException {  
100.     }  
101.       
102.     //调用多次  
103.     @Override  
104.     public void characters(char[] ch, int start, int length)  
105.             throws SAXException {  
106.         if(this.tagName!=null){  
107.             String date=new String(ch,start,length);  
108.             if(this.tagName.equals("name")){  
109.                 this.student.setName(date);  
110.             }  
111.             else if(this.tagName.equals("sex")){  
112.                 this.student.setSex(date);  
113.             }  
114.             else if(this.tagName.equals("age")){  
115.                 this.student.setAge(Integer.parseInt(date));  
116.             }  
117.             else if(this.tagName.equals("email")){  
118.                 this.student.setEmail(date);  
119.             }  
120.             else if(this.tagName.equals("birthday")){  
121.                 this.student.setBirthday(date);  
122.             }  
123.             else if(this.tagName.equals("memo")){  
124.                 this.student.setMemo(date);  
125.             }  
126.         }  
127.     }  
128.       
129.       
130.       
131.     public static void main(String[] args) {  
132.         SAXParser parser = null;  
133.         try {  
134.             //构建SAXParser  
135.             parser = SAXParserFactory.newInstance().newSAXParser();  
136.             //实例化  DefaultHandler对象  
137.             SaxParseXml parseXml=new SaxParseXml();  
138. <strong><span style="color:#33ff33">            /* 
139.              * 加载资源文件 转化为一个输入流,搞不懂为什么下面注释掉的那行代码获取不到文件流, 
140.              * 上网查了一些说大多数是路径的原因,可是怎么试验都获取到的都是null,所以只能用 
141.              * InputStream stream=new FileInputStream("Student.xml") ;来获取文件流 
142.              */</span></strong>  
143.            //InputStream stream=SaxParseXml.class.getClassLoader().getResourceAsStream("Student.xml");  
144.               
145.             InputStream stream=new FileInputStream("Student.xml") ;  
146.             System.out.println(stream);   
147.             //调用parse()方法  
148.             parser.parse(stream, parseXml);  
149.             //遍历结果  
150.             List<Student> list=parseXml.getList();  
151.             for(Student student:list){  
152.                 System.out.println("id:"+student.getId()+"\tgroup:"+student.getGroup()+"\tname:"+student.getName()+"\tsex:"+student.getSex()+"\tage:"+student.getAge()+"\temail:"+student.getEmail()+"\tbirthday:"+student.getBirthday()+"\tmemo:"+student.getMemo());  
153.             }  
154.         } catch (ParserConfigurationException e) {  
155.             e.printStackTrace();  
156.         } catch (SAXException e) {  
157.             e.printStackTrace();  
158.         } catch (IOException e) {  
159.             e.printStackTrace();  
160.         }  
161.     }   
162.       
163. }  

关于实例三的粗体注释部分相关的一些东西贴出来：

this.getClass().getClassLoader().getResource("template"); 
   首先，调用对象的getClass()方法是获得对象当前的类类型，这部分数据存在方法区中，而后在类类型上调用getClassLoader()方法是得到当前类型的类加载器，我们知道在Java中所有的类都是通过加载器加载到虚拟机中的，而且类加载器之间存在父子关系，就是子知道父，父不知道子，这样不同的子加载的类型之间是无法访问的（虽然它们都被放在方法区中），所以在这里通过当前类的加载器来加载资源也就是保证是和类类型同一个加载器加载的。 
最后调用了类加载器的getResourceAsStream()方法来加载资源。

===

JAVA运行时，首先会在指定的类路径下（classpath路径下）搜索JAVA编译后的字节码文件（class文件），然后通过类加载器加载到虚拟机中。 DBConn.class.getClassLoader().getResourceAsStream("database.properties") 1、DBConn.class得到表示DBConn类的Class对象，请参照JDK中对Class的说明http://wenku.baidu.com/view/1fa5e8ebe009581b6bd9ebe1.html。 2、通过Class的getClassLoader方法取得加载DBConn类的类加载器对象ClassLoader。 3、调用ClassLoader的getResourceAsStream方法从类加载路径取得文件的输入流（会通过当前的ClassLoader的findResource方法查找指定文件），请参照：http://download.oracle.com/javase/1.5.0/docs/api/java/lang/ClassLoader.html#getResourceAsStream%28java.lang.String%29。

终于找到了答案：

[html] view plaincopy

1. <span style="color:#330099">老兄和我犯的错误是一样的：  
2. 要区分Class的getResourceAsStream和ClassLoader的getResourceAsStream方法。  
3. ClassLoader的该方法如果name以/开头那么就什么也找不到了。  
4.   
5. 而Class的getResourceAsStream方法如果name以/开头那么就把/以后的name传递给ClassLoader的  
6. getResourceAsStream方法。如果不已/开头那么将该class的包名加上name作为参数（用/代替.)之后  
7. 传给ClassLoader的对应方法。  
8.   
9. 看一下程序：  
10. package com.test;  
11. import java.io.*;  
12.   
13. public class UseResourceTest {  
14. public static void main(String[] args) throws Exception {  
15. UseResourceTest test = new UseResourceTest();  
16. InputStream in = test.getClass().getResourceAsStream("a.txt");  
17. System.out.println(in);  
18. }  
19. }  
20. 效果相当于：  
21. package com.test;  
22. import java.io.*;  
23.   
24. public class UseResourceTest {  
25. public static void main(String[] args) throws Exception {  
26. InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream("com/test/a.txt");  
27. System.out.println(in);  
28. }  
29. }</span>  

所以说我上面的那个例子可以有三种方式获取到io流：

InputStream stream=SaxParseXml.class.getClassLoader().getResourceAsStream("sax/Student.xml");

InputStream stream=SaxParseXml.class.getResourceAsStream("Student.xml");

InputStream stream=new FileInputStream("Student.xml") ;

/*标记一下以后继续补充这部分相关的知识*/

三、JDOM解析XML

JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。（http://jdom.org）

•JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念等），把SAX和DOM的功能有效地结合起来。

•JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下，这些API函数被最大限度的优化。

实例四：

JDOM创建XML文件：

[java] view plaincopy

1. package jdom;  
2. import java.io.FileWriter;  
3.   
4. import org.jdom.Attribute;  
5. import org.jdom.Comment;  
6. import org.jdom.Document;  
7. import org.jdom.Element;  
8. import org.jdom.output.Format;  
9. import org.jdom.output.XMLOutputter;  
10.   
11. public class JDomTest1  
12. {  
13.     public static void main(String[] args) throws Exception  
14.     {  
15.         Document document = new Document();  
16.   
17.         Element root = new Element("root");  
18.   
19.         document.addContent(root);  
20.   
21.         Comment comment = new Comment("This is my comments");  
22.   
23.         root.addContent(comment);  
24.   
25.         Element e = new Element("hello");  
26.   
27.         e.setAttribute("sohu", "www.sohu.com");  
28.   
29.         root.addContent(e);  
30.   
31.         Element e2 = new Element("world");  
32.   
33.         Attribute attr = new Attribute("test", "hehe");  
34.   
35.         e2.setAttribute(attr);  
36.   
37.         e.addContent(e2);  
38.   
39.         e2.addContent(new Element("aaa").setAttribute("a", "b").setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));  
40.   
41.         Format format = Format.getPrettyFormat();  
42.           
43.         format.setIndent("    ");  
44. //      format.setEncoding("gbk");  
45.           
46.         XMLOutputter out = new XMLOutputter(format);  
47.   
48.         out.output(document, new FileWriter("jdom.xml"));  
49.           
50.     }  
51. }  

实例五：

JDOM解析XML文件

[java] view plaincopy

1. package jdom;  
2.   
3. import java.io.File;  
4. import java.io.FileOutputStream;  
5. import java.util.List;  
6.   
7. import org.jdom.Attribute;  
8. import org.jdom.Document;  
9. import org.jdom.Element;  
10. import org.jdom.input.SAXBuilder;  
11. import org.jdom.output.Format;  
12. import org.jdom.output.XMLOutputter;  
13.   
14. public class JDomTest2  
15. {  
16.     public static void main(String[] args) throws Exception  
17.     {  
18.         SAXBuilder builder = new SAXBuilder();  
19.           
20.         Document doc = builder.build(new File("jdom.xml"));  
21.           
22.         Element element = doc.getRootElement();  
23.           
24.         System.out.println(element.getName());  
25.           
26.         Element hello = element.getChild("hello");  
27.           
28.         System.out.println(hello.getText());  
29.           
30.         List list = hello.getAttributes();  
31.           
32.         for(int i = 0 ;i < list.size(); i++)  
33.         {  
34.             Attribute attr = (Attribute)list.get(i);  
35.               
36.             String attrName = attr.getName();  
37.             String attrValue = attr.getValue();  
38.               
39.             System.out.println(attrName + "=" + attrValue);  
40.         }  
41.           
42.         hello.removeChild("world");  
43.           
44.         XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent("    "));  
45.           
46.           
47.         out.output(doc, new FileOutputStream("jdom2.xml"));       
48.           
49.     }  
50. }  

四、Dom4j方式：

实例六：

[java] view plaincopy

1. package dom4j;  
2.   
3. import java.io.FileOutputStream;  
4. import java.io.FileWriter;  
5.   
6. import org.dom4j.Document;  
7. import org.dom4j.DocumentHelper;  
8. import org.dom4j.Element;  
9. import org.dom4j.io.OutputFormat;  
10. import org.dom4j.io.XMLWriter;  
11.   
12. public class Dom4jTest1  
13. {  
14.     public static void main(String[] args) throws Exception  
15.     {  
16.         // 创建文档并设置文档的根元素节点 ：第一种方式  
17.         // Document document = DocumentHelper.createDocument();  
18.         //  
19.         // Element root = DocumentHelper.createElement("student");  
20.         //  
21.         // document.setRootElement(root);  
22.   
23.         // 创建文档并设置文档的根元素节点 ：第二种方式  
24.         Element root = DocumentHelper.createElement("student");  
25.         Document document = DocumentHelper.createDocument(root);  
26.   
27.         root.addAttribute("name", "zhangsan");  
28.   
29.         Element helloElement = root.addElement("hello");  
30.         Element worldElement = root.addElement("world");  
31.   
32.         helloElement.setText("hello");  
33.         worldElement.setText("world");  
34.   
35.         helloElement.addAttribute("age", "20");  
36.   
37.         XMLWriter xmlWriter = new XMLWriter();  
38.         xmlWriter.write(document);  
39.           
40.         OutputFormat format = new OutputFormat("    ", true);  
41.           
42.         XMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream("student2.xml"), format);  
43.         xmlWriter2.write(document);  
44.           
45.         XMLWriter xmlWriter3 = new XMLWriter(new FileWriter("student3.xml"), format);  
46.           
47.         xmlWriter3.write(document);  
48.         xmlWriter3.close();  
49.   
50.     }  
51. }  

实例七：

[java] view plaincopy

1. package dom4j;  
2.   
3. import java.io.File;  
4. import java.util.Iterator;  
5. import java.util.List;  
6.   
7. import javax.xml.parsers.DocumentBuilder;  
8. import javax.xml.parsers.DocumentBuilderFactory;  
9.   
10. import org.dom4j.Document;  
11. import org.dom4j.Element;  
12. import org.dom4j.io.DOMReader;  
13. import org.dom4j.io.SAXReader;  
14.   
15. public class Dom4jTest2  
16. {  
17.     public static void main(String[] args) throws Exception  
18.     {  
19.         SAXReader saxReader = new SAXReader();  
20.           
21.         Document doc = saxReader.read(new File("student2.xml"));  
22.           
23.         Element root = doc.getRootElement();  
24.           
25.         System.out.println("root element: " + root.getName());  
26.           
27.         List childList = root.elements();  
28.           
29.         System.out.println(childList.size());  
30.           
31.         List childList2 = root.elements("hello");  
32.           
33.         System.out.println(childList2.size());  
34.           
35.         Element first = root.element("hello");  
36.           
37.         System.out.println(first.attributeValue("age"));  
38.           
39.         for(Iterator iter = root.elementIterator(); iter.hasNext();)  
40.         {  
41.             Element e = (Element)iter.next();  
42.               
43.             System.out.println(e.attributeValue("age"));  
44.         }  
45.           
46.         System.out.println("---------------------------");  
47.           
48.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
49.         DocumentBuilder db = dbf.newDocumentBuilder();  
50.         org.w3c.dom.Document document = db.parse(new File("student2.xml"));  
51.           
52.         DOMReader domReader = new DOMReader();  
53.           
54.         //将JAXP的Document转换为dom4j的Document  
55.         Document d = domReader.read(document);  
56.           
57.         Element rootElement = d.getRootElement();  
58.           
59.         System.out.println(rootElement.getName());  
60.   
61.     }  
62. }