Dom4j全部实例
|
Attribute
|
Attribute定义了XML的属性
|
|
Branch
|
Branch为能够包含子节点的节点如XML元素(Element)和文档(Docuemnts)定义了一个公共的行为，
|
|
CDATA
|
CDATA 定义了XML CDATA 区域
|
|
CharacterData
|
CharacterData是一个标识接口，标识基于字符的节点。如CDATA，Comment, Text.
|
|
Comment
|
Comment 定义了XML注释的行为
|
|
Document
|
定义了XML文档
|
|
DocumentType
|
|
DocumentType 定义XML DOCTYPE声明
|
|
|
Element
|
Element定义XML 元素
|
|
ElementHandler
|
ElementHandler定义了 Element 对象的处理器
|
|
ElementPath
|
被 ElementHandler 使用，用于取得当前正在处理的路径层次信息
|
|
Entity
|
Entity定义 XML entity
|
|
Node
|
Node为所有的dom4j中XML节点定义了多态行为
|
|
NodeFilter
|
NodeFilter 定义了在dom4j节点中产生的一个滤镜或谓词的行为（predicate）
|
|
ProcessingInstruction
|
ProcessingInstruction 定义 XML 处理指令.
|
|
Text
|
Text 定义XML 文本节点.
|
|
Visitor
|
Visitor 用于实现Visitor模式.
|
|
XPath
|
XPath
|
要想弄懂这套接口，关键的是要明白接口的继承关系：
- interface java.lang.Cloneable
- interface org.dom4j.Node
- interface org.dom4j.Attribute
- interface org.dom4j.Branch
- interface org.dom4j.Document
- interface org.dom4j.Element
- interface org.dom4j.CharacterData
- interface org.dom4j.CDATA
- interface org.dom4j.Comment
- interface org.dom4j.Text
- interface org.dom4j.DocumentType
- interface org.dom4j.Entity
- interface org.dom4j.ProcessingInstruction
１． 读取并解析XML文档：
读写XML文档主要依赖于org.dom4j.io包，其中提供DOMReader和SAXReader两类不同方式，而调用方式是一样的。这就是依靠接口的好处。
|
// 从文件读取XML，输入文件名，返回XML文档
public Document read(String fileName)
throws MalformedURLException, DocumentException {
SAXReader reader =
new SAXReader();
Document document = reader.read(
new File(fileName));
return document;
}
|
其中，reader的read方法是重载的，可以从InputStream, File, Url等多种不同的源来读取。得到的Document对象就带表了整个XML。根据本人自己的经验，读取的字符编码是按照XML文件头定义的编码来转换。如果遇到乱码问题，注意要把各处的编码名称保持一致即可。
２． 取得Root节点
读取后的第二步，就是得到Root节点。熟悉XML的人都知道，一切XML分析都是从Root元素开始的。
|
public Element getRootElement(Document doc){
return doc.getRootElement();
}
|
３． 遍历XML树
DOM4J提供至少3种遍历节点的方法：
1) 枚举(Iterator)
|
// 枚举所有子节点
for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
Element element = (Element) i.next();
// do something
}
// 枚举名称为foo的节点
for ( Iterator i = root.elementIterator(foo); i.hasNext();) {
Element foo = (Element) i.next();
// do something
}
// 枚举属性
for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
Attribute attribute = (Attribute) i.next();
// do something
}
|
2)递归
递归也可以采用Iterator作为枚举手段，但文档中提供了另外的做法
|
public
void treeWalk() {
treeWalk(getRootElement());
}
public
void treeWalk(Element element) {
for (
int i = 0, size = element.nodeCount(); i < size; i++) {
Node node = element.node(i);
if (node
instanceof Element) {
treeWalk((Element) node);
}
else { // do something....
}
}
}
|
3) Visitor模式
最令人兴奋的是DOM4J对Visitor的支持，这样可以大大缩减代码量，并且清楚易懂。了解设计模式的人都知道，Visitor是GOF设计模式之一。其主要原理就是两种类互相保有对方的引用，并且一种作为Visitor去访问许多Visitable。我们来看DOM4J中的Visitor模式(快速文档中没有提供)
只需要自定一个类实现Visitor接口即可。
|
public
class MyVisitor
extends VisitorSupport {
public
void visit(Element element){
System.out.println(element.getName());
}
public
void visit(Attribute attr){
System.out.println(attr.getName());
}
}
调用： root.accept(new MyVisitor())
|
Visitor接口提供多种Visit()的重载，根据XML不同的对象，将采用不同的方式来访问。上面是给出的Element和Attribute的简单实现，一般比较常用的就是这两个。VisitorSupport是DOM4J提供的默认适配器，Visitor接口的Default Adapter模式，这个模式给出了各种visit(*)的空实现，以便简化代码。
注意，这个Visitor是自动遍历所有子节点的。如果是root.accept(MyVisitor)，将遍历子节点。我第一次用的时候，认为是需要自己遍历，便在递归中调用Visitor，结果可想而知。
4. XPath支持
DOM4J对XPath有良好的支持，如访问一个节点，可直接用XPath选择。
|
public
void bar(Document document) {
List list = document.selectNodes( //foo/bar );
Node node = document.selectSingleNode(//foo/bar/author);
String name = node.valueOf( @name );
}
|
例如，如果你想查找XHTML文档中所有的超链接，下面的代码可以实现：
|
public
void findLinks(Document document)
throws DocumentException {
List list = document.selectNodes( //a/@href );
for (Iterator iter = list.iterator(); iter.hasNext(); ) {
Attribute attribute = (Attribute) iter.next();
String url = attribute.getValue();
}
}
|
5. 字符串与XML的转换
有时候经常要用到字符串转换为XML或反之，
|
// XML转字符串
Document document = ...;
String text = document.asXML();
// 字符串转XML
String text = <person> <name>James</name> </person>;
Document document = DocumentHelper.parseText(text);
|
6 用XSLT转换XML
|
public Document styleDocument(
Document document,
String stylesheet
)
throws Exception {
// load the transformer using JAXP
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(
new StreamSource( stylesheet )
);
// now lets style the given document
DocumentSource source =
new DocumentSource( document );
DocumentResult result =
new DocumentResult();
transformer.transform( source, result );
// return the transformed document
Document transformedDoc = result.getDocument();
return transformedDoc;
}
|
7. 创建XML
一般创建XML是写文件前的工作，这就像StringBuffer一样容易。
|
public Document createDocument() {
Document document = DocumentHelper.createDocument();
Element root = document.addElement(root);
Element author1 =
root
.addElement(author)
.addAttribute(name, James)
.addAttribute(location, UK)
.addText(James Strachan);
Element author2 =
root
.addElement(author)
.addAttribute(name, Bob)
.addAttribute(location, US)
.addText(Bob McWhirter);
return document;
}
|
8. 文件输出
一个简单的输出方法是将一个Document或任何的Node通过write方法输出
|
FileWriter out =
new FileWriter( foo.xml );
document.write(out);
|
如果你想改变输出的格式，比如美化输出或缩减格式，可以用XMLWriter类
|
public
void write(Document document)
throws IOException {
// 指定文件
XMLWriter writer =
new XMLWriter(
new FileWriter( output.xml )
);
writer.write( document );
writer.close();
// 美化格式
OutputFormat format = OutputFormat.createPrettyPrint();
writer =
new XMLWriter( System.out, format );
writer.write( document );
// 缩减格式
format = OutputFormat.createCompactFormat();
writer =
new XMLWriter( System.out, format );
writer.write( document );
}
|
5.
使用
ElementHandler
XmlHandler.java
import
java.io.File;
import
org.dom4j.DocumentException;
import
org.dom4j.Element;
import
org.dom4j.ElementHandler;
import
org.dom4j.ElementPath;
import
org.dom4j.io.SAXReader;
public
class
XmlHandler {
public
static
void
main(String[] args) {
SAXReader saxReader =
new
SAXReader();
File file =
new
File(
"students.xml"
);
try
{
//
添加一个
ElementHandler
实例。
saxReader.addHandler(
"/students/student"
,
new
StudentHandler());
saxReader.read(file);
}
catch
(DocumentException e) {
System.
out
.println(e.getMessage());
}
}
/**
*
定义
StudentHandler
处理器类，对
<student>
元素进行处理。
*/
private
static
class
StudentHandler
implements
ElementHandler {
public
void
.Start(ElementPath path) {
Element elt = path.getCurrent();
System.
out
.println(
"Found student: "
+ elt.attribut.ue(
"sn"
));
//
添加对子元素
<name>
的处理器。
path.addHandler(
"name"
,
new
NameHandler());
}
public
void
.End(ElementPath path) {
//
移除对子元素
<name>
的处理器。
path.removeHandler(
"name"
);
}
}
/**
*
定义
NameHandler
处理器类，对
<student>
的
<name>
子元素进行处理。
*/
private
static
class
NameHandler
implements
ElementHandler {
public
void
.Start(ElementPath path) {
System.
out
.println(
"path : "
+ path.getPath());
}
public
void
.End(ElementPath path) {
Element elt = path.getCurrent();
//
输出
<name>
元素的名字和它的文本内容。
System.
out
.println(elt.getName() +
" : "
+ elt.getText());
}
}
}