dom4j介绍
dom4j的项目地址:http://sourceforge.net/projects/dom4j/?source=directory
dom4j是一个简单的开源库,用于处理XML、 XPath和XSLT,它基于Java平台,使用Java的集合框架,全面集成了DOM,SAX和JAXP。
dom4j的使用
下载了dom4j项目之后,解压缩,将其jar包(我的当前版本叫做dom4j-1.6.1.jar)加入class path下面。
(Properties->Java Build Path -> Add External JARs...)。
之后就可以使用其提供的API进行编程。
程序实例1
第一个程序,用Java代码生成xml文档,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
package com.example.xml.dom4j; import java.io.FileOutputStream; import java.io.FileWriter; import org.dom4j.Document; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.io.OutputFormat; import org.dom4j.io.XMLWriter; /** * dom4j框架学习 使用dom4j框架创建xml文档并输出保存 * */ public class Dom4JTest1 { public static void main(String[] args) throws Exception { // 第一种方式:创建文档,并创建根元素 // 创建文档:使用了一个Helper类 Document document = DocumentHelper.createDocument(); // 创建根节点并添加进文档 Element root = DocumentHelper.createElement( "student" ); document.setRootElement(root); // 第二种方式:创建文档并设置文档的根元素节点 Element root2 = DocumentHelper.createElement( "student" ); Document document2 = DocumentHelper.createDocument(root2); // 添加属性 root2.addAttribute( "name" , "zhangsan" ); // 添加子节点:add之后就返回这个元素 Element helloElement = root2.addElement( "hello" ); Element worldElement = root2.addElement( "world" ); helloElement.setText( "hello Text" ); worldElement.setText( "world text" ); // 输出 // 输出到控制台 XMLWriter xmlWriter = new XMLWriter(); xmlWriter.write(document); // 输出到文件 // 格式 OutputFormat format = new OutputFormat( " " , true ); // 设置缩进为4个空格,并且另起一行为true XMLWriter xmlWriter2 = new XMLWriter( new FileOutputStream( "student.xml" ), format); xmlWriter2.write(document2); // 另一种输出方式,记得要调用flush()方法,否则输出的文件中显示空白 XMLWriter xmlWriter3 = new XMLWriter( new FileWriter( "student2.xml" ), format); xmlWriter3.write(document2); xmlWriter3.flush(); // close()方法也可以 } } |
程序Console输出:
1
2
|
<? xml version = "1.0" encoding = "UTF-8" ?> < student /> |
生成的一个xml文档:
1
2
3
4
5
6
|
<? xml version = "1.0" encoding = "UTF-8" ?> < student name = "zhangsan" > < hello >hello Text</ hello > < world >world text</ world > </ student > |
程序实例2
程序实例2,读入xml文档并分析,将其内容输出。
首先,待分析的文档如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
<?xml version= "1.0" encoding= "UTF-8" ?> <students name= "zhangsan" > <hello name= "lisi" >hello Text1</hello> <hello name= "lisi2" >hello Text2</hello> <hello name= "lisi3" >hello Text3</hello> <world name= "wangwu" >world text1</world> <world name= "wangwu2" >world text2</world> <world >world text3</world> </students> package com.example.xml.dom4j; import java.io.File; import java.util.Iterator; import java.util.List; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.io.DOMReader; import org.dom4j.io.SAXReader; /** * dom4j框架学习: 读取并解析xml * * */ public class Dom4JTest2 { public static void main(String[] args) throws Exception { SAXReader saxReader = new SAXReader(); Document document = saxReader.read( new File( "students.xml" )); // 获取根元素 Element root = document.getRootElement(); System.out.println( "Root: " + root.getName()); // 获取所有子元素 List<Element> childList = root.elements(); System.out.println( "total child count: " + childList.size()); // 获取特定名称的子元素 List<Element> childList2 = root.elements( "hello" ); System.out.println( "hello child: " + childList2.size()); // 获取名字为指定名称的第一个子元素 Element firstWorldElement = root.element( "world" ); // 输出其属性 System.out.println( "first World Attr: " + firstWorldElement.attribute( 0 ).getName() + "=" + firstWorldElement.attributeValue( "name" )); System.out.println( "迭代输出-----------------------" ); // 迭代输出 for (Iterator iter = root.elementIterator(); iter.hasNext();) { Element e = (Element) iter.next(); System.out.println(e.attributeValue( "name" )); } System.out.println( "用DOMReader-----------------------" ); DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); // 注意要用完整类名 org.w3c.dom.Document document2 = db.parse( new File( "students.xml " )); DOMReader domReader = new DOMReader(); // 将JAXP的Document转换为dom4j的Document Document document3 = domReader.read(document2); Element rootElement = document3.getRootElement(); System.out.println( "Root: " + rootElement.getName()); } } |
代码运行后输出:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
Root: students total child count: 6 hello child: 3 first World Attr: name=wangwu 迭代输出----------------------- lisi lisi2 lisi3 wangwu wangwu2 null 用DOMReader----------------------- Root: students |
SAX解析XML
下面是SAX实现实体解析的步骤
//下面使用XMLReader 来解析
(一)第一步:新建一个工厂类SAXParserFactory,代码如下:
SAXParserFactory factory = SAXParserFactory.newInstance();
(二)第二步:让工厂类产生一个SAX的解析类SAXParser,代码如下:
SAXParser parser = factory.newSAXParser();
(三)第三步:从SAXPsrser中得到一个XMLReader实例,代码如下:
XMLReader reader = parser.getXMLReader();
(四)第四步:把自己写的handler注册到XMLReader中,一般最重要的就是ContentHandler,代码如下:
reader.setContentHandler(this);
(五)第五步:将一个xml文档或者资源变成一个java可以处理的InputStream流后,解析正式开始,代码如下:
reader.parse(new InputSource(is));
//下面使用SAXParser来解析
(一)第一步:新建一个工厂类SAXParserFactory,代码如下:
SAXParserFactory factory = SAXParserFactory.newInstance();
(二)第二步:让工厂类产生一个SAX的解析类SAXParser,代码如下:
SAXParser parser = factory.newSAXParser();
(三)第三步:将一个xml文档或者资源变成一个java可以处理的InputStream流后,解析正式开始,代码如下:
parser.parse(is,this);
估计大家都看到了ContentHandler ,下面具体的讲下
解析开始之前,需要向XMLReader/SAXParser 注册一个ContentHandler,也就是相当于一个事件监听器,在ContentHandler中定义了很多方法
//设置一个可以定位文档内容事件发生位置的定位器对象
public void setDocumentLocator(Locator locator)
//用于处理文档解析开始事件
public void startDocument()throws SAXException
//处理元素开始事件,从参数中可以获得元素所在名称空间的uri,元素名称,属性类表等信息
public void startElement(String namespacesURI , String localName , String qName , Attributes atts) throws SAXException
//处理元素结束事件,从参数中可以获得元素所在名称空间的uri,元素名称等信息
public void endElement(String namespacesURI , String localName , String qName) throws SAXException
//处理元素的字符内容,从参数中可以获得内容
public void characters(char[] ch , int start , int length) throws SAXException
顺便介绍下XMLReader中的方法。
//注册处理XML文档解析事件ContentHandler
public void setContentHandler(ContentHandler handler)
//开始解析一个XML文档
public void parse(InputSorce input) throws SAXException
大概的讲的差不多了 接下来开始讲解解析的步骤
我们还是用上一章的代码
首先 我们创建一个Person类 用来存储用户的信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
package com.example.demo; import java.io.Serializable; public class Person implements Serializable { /** * */ private static final long serialVersionUID = 1L; private String _id; private String _name; private String _age; public String get_id() { return _id; } public void set_id(String _id) { this ._id = _id; } public String get_name() { return _name; } public void set_name(String _name) { this ._name = _name; } public String get_age() { return _age; } public void set_age(String _age) { this ._age = _age; } } |
接下来 我们要实现一个ContentHandler 用来解析XML
实现一个ContentHandler 一般需要下面几个步骤
1、声明一个类,继承DefaultHandler。DefaultHandler是一个基类,这个类里面简单实现了一个ContentHandler。我们只需要重写里面的方法即可。
2、重写 startDocument() 和 endDocument(),一般将正式解析之前的初始化放到startDocument()里面,收尾的工作放到endDocument()里面。
3、重写startElement(),XML解析器遇到XML里面的tag时就会调用这个函数。经常在这个函数内是通过对localName的值进行判断而操作一些数据。
4、重写characters()方法,这是一个回调方法。解析器执行完startElement()后,解析节点的内容后就会执行这个方法,并且参数ch[]就是节点的内容。
5、重写endElement()方法,这个方法与startElement()相对应,解析完一个tag节点后,执行这个方法,解析一个tag后,调用这个处理还原和清除相关信息
首先 新建一个类 继承DefaultHandler 并重写以下几个方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
public class SAX_parserXML extends DefaultHandler { /** * 当开始解析xml文件的声明的时候就会触发这个事件, 可以做一些初始化的工作 * */ @Override public void startDocument() throws SAXException { // TODO Auto-generated method stub super .startDocument(); } /** * 当开始解析元素的开始标签的时候,就会触发这个事件 * */ @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { // TODO Auto-generated method stub super .startElement(uri, localName, qName, attributes); } /** * 当读到文本元素的时候要触发这个事件. * */ @Override public void characters( char [] ch, int start, int length) throws SAXException { // TODO Auto-generated method stub super .characters(ch, start, length); } /** * 当读到结束标签的时候 就会触发这个事件 * */ @Override public void endElement(String uri, String localName, String qName) throws SAXException { // TODO Auto-generated method stub super .endElement(uri, localName, qName); } } |
首先 我们创建一个list 用来保存解析出来的person数据
1
|
List<Person> persons; |
但是?在哪里初始化呢?我们可以在startDocument()里面初始化,因为当开始解析xml文件的声明的时候就会触发这个事件所以放在这里比较合适
1
2
3
4
5
6
7
8
9
10
|
/** * 当开始解析xml文件的声明的时候就会触发这个事件, 可以做一些初始化的工作 * */ @Override public void startDocument() throws SAXException { // TODO Auto-generated method stub super .startDocument(); // 初始化list persons = new ArrayList<Person>(); } |
接下来 就要开始解析了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 当开始解析元素的开始标签的时候,就会触发这个事件 * */ @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { // TODO Auto-generated method stub super .startElement(uri, localName, qName, attributes); // 如果读到是person标签 开始存储 if (localName.equals( "person" )) { person = new Person(); person.set_id(attributes.getValue( "id" )); } curNode = localName; } |
上面的代码中 localName表示当前解析到的元素名
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
//步骤 //1.判断是否是person元素 //2.创建新的Person对象 //3.获取id 添加到Person对象中 curNode 用来保存当前的元素名 在characters中会使用到 /** * 当读到文本元素的时候要触发这个事件. * */ @Override public void characters( char [] ch, int start, int length) throws SAXException { // TODO Auto-generated method stub super .characters(ch, start, length); if (person != null ) { //取出目前元素对应的值 String txt = new String(ch, start, length); //判断元素是否是name if (curNode.equals( "name" )) { //将取出的值添加到person对象 person.set_name(txt); } else if (curNode.equals( "age" )) { person.set_age(txt); } } } |
接下来是介绍标签结束的时候需要做的事情
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * 当读到结束标签的时候 就会触发这个事件 * */ @Override public void endElement(String uri, String localName, String qName) throws SAXException { // TODO Auto-generated method stub super .endElement(uri, localName, qName); // 如果是 并且person不为空,添加到list if (localName.equals( "person" ) && person != null ) { persons.add(person); person = null ; } curNode = "" ; } |
解析的事情结束了 大概流程就是
1.一个元素开始时 会调用startElement方法
2.接下来会调用到characters方法,可以用来获取元素的值
3.一个元素结束时 会调用到endElement方法
解析结束之后 我们需要写一个方法 用来获取解析后保存的list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public List<Person> ReadXML(InputStream is) { SAXParserFactory factory = SAXParserFactory.newInstance(); try { SAXParser parser = factory.newSAXParser(); // 第一种方法 // parser.parse(is, this); // 第二种方法 XMLReader reader = parser.getXMLReader(); reader.setContentHandler( this ); reader.parse( new InputSource(is)); } catch (Exception e) { // TODO: handle exception e.printStackTrace(); } return persons; } |
上面的代码就不解释了 只要将inputStream对象传入 就可以解析出内容
看完了代码,我来给出完整的代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
package com.example.demo.Utils; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.xml.sax.Attributes; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.XMLReader; import org.xml.sax.helpers.DefaultHandler; import com.example.demo.Person; public class SAX_parserXML extends DefaultHandler { List<Person> persons; Person person; // 当前节点 String curNode; public List<Person> ReadXML(InputStream is) { SAXParserFactory factory = SAXParserFactory.newInstance(); try { SAXParser parser = factory.newSAXParser(); // 第一种方法 // parser.parse(is, this); // 第二种方法 XMLReader reader = parser.getXMLReader(); reader.setContentHandler( this ); reader.parse( new InputSource(is)); } catch (Exception e) { // TODO: handle exception e.printStackTrace(); } return persons; } /** * 当开始解析xml文件的声明的时候就会触发这个事件, 可以做一些初始化的工作 * */ @Override public void startDocument() throws SAXException { // TODO Auto-generated method stub super .startDocument(); // 初始化list persons = new ArrayList<Person>(); } /** * 当开始解析元素的开始标签的时候,就会触发这个事件 * */ @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { // TODO Auto-generated method stub super .startElement(uri, localName, qName, attributes); // 如果读到是person标签 开始存储 if (localName.equals( "person" )) { person = new Person(); person.set_id(attributes.getValue( "id" )); } curNode = localName; } /** * 当读到文本元素的时候要触发这个事件. * */ @Override public void characters( char [] ch, int start, int length) throws SAXException { // TODO Auto-generated method stub super .characters(ch, start, length); if (person != null ) { // 取出目前元素对应的值 String txt = new String(ch, start, length); // 判断元素是否是name if (curNode.equals( "name" )) { // 将取出的值添加到person对象 person.set_name(txt); } else if (curNode.equals( "age" )) { person.set_age(txt); } } } /** * 当读到结束标签的时候 就会触发这个事件 * */ @Override public void endElement(String uri, String localName, String qName) throws SAXException { // TODO Auto-generated method stub super .endElement(uri, localName, qName); // 如果是person结尾 并且person不为空,添加到list if (localName.equals( "person" ) && person != null ) { persons.add(person); person = null ; } curNode = "" ; } } |
写个方法调用下这个类
1
2
3
4
5
6
7
8
9
|
List<Person> persons = new SAX_parserXML().ReadXML(is); StringBuffer buffer = new StringBuffer(); for ( int i = 0 ; i < persons.size(); i++) { Person person =persons.get(i); buffer.append( "id:" + person.get_id() + " " ); buffer.append( "name:" + person.get_name() + " " ); buffer.append( "age:" + person.get_age() + "\n" ); } Toast.makeText(activity, buffer, Toast.LENGTH_LONG).show(); |
如果你看到下面的界面 说明解析成功了~
小结:
DOM(文件对象模型)解析:解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以根据DOM接口来操作这个树结构了。
优点:整个文档读入内存,方便操作:支持修改、删除和重现排列等多种功能。
缺点:将整个文档读入内存中,保留了过多的不需要的节点,浪费内存和空间。
使用场合:一旦读入文档,还需要多次对文档进行操作,并且在硬件资源充足的情况下(内存,CPU)。
为了解决DOM解析存在的问题,就出现了SAX解析。其特点为:
优点:不用实现调入整个文档,占用资源少。尤其在嵌入式环境中,如android,极力推荐使用SAX解析。
缺点:不像DOM解析一样将文档长期驻留在内存中,数据不是持久的。如果事件过后没有保存数据,数据就会丢失。
使用场合:机器有性能限制