Java中Xml解析详解 DOM、SAX、JDOM、DOM4J

1.1 什么是XML

一种表示结构化信息的标准方法，以使计算机能够方便地使用此类信息，并且人们可以非常方便地编写和理解这些信息。XML 是 eXtensible Markup Language（可扩展标记语言）的缩写。www.w3.org/XML/ 上提供了 XML 标准。XML 提供了一种简便的标准方法对数据进行分类，以使其更易于读取、访问以及处理。XML 使用类似于 HTML 的树结构和标签结构.

例如：

<?xml version="1.0"?>
<myfile>
<title>XML Quick Start</title>
<author>zhangsan</author>
<email>[email protected]</email>
<date>2013-1-1</date>
</myfile>

大部分标签都是我们自己定义的

XML产生的目标：

 处理XML文档的程序应该容易编写

 在XML中，要求可供选择的特性数量保持绝对的少，更理想一点一个也没有

 XML文档应当是可读性强和条理清晰的

 XML的设计应当是正规并且简洁的

 XML文档应该容易创建

 在XML的结构中应该简洁、精练

 在Internet上XML应该是直接可以使用的

 XML应该支持各种各样的应用

Java与xml是一种完美的组合，Java平台是一种跨平台的编程环境，XML是一种跨平台的数据格式与其他语言相比，Java平台提供了更好的XML支持

1.2 Xml的作用和优点：

主要作用：

 存储数据：最基本的办法是采用io流读取

 配置文件（用得最多）

XML与Access,Oracle和SQL Server等数据库不同，数据库提供了更强有力的数据存储和分析能力，例如：数据索引、排序、查找、相关一致性等，XML仅仅是展示数据。事实上XML与其他数据表现形式最大的不同是：他极其简单。

主要特点：

 支持设计与特定领域相关的标记

 自描述数据

不需要借助于其它的工具就可以理解XML中数据的含义，是因为XML中对数据进行了自描述，这保证了只要XML文件本身不被破坏就可以理解所包含数据的含义。同时，XML有很好的规格文档，保证了XML的语义不被误解。

 应用间自由交换数据

webservice

 结构化和集成的数据

1.3 XML 文档类型：

 无效文档：

没有遵守 XML 规范定义的语法规则。

如果开发人员已经在 DTD 或模式中定义了文档能够包含什么，而某个文档没有遵守在其 DTD 或模式中定义的规则

 有效文档：既遵守 XML 语法规则也遵守在其 DTD 或模式中定义的规则。

格式良好（well-formed）的文档：遵守 XML 语法，但没有 DTD 或模式。

1.4 XML 声明

<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>

建议使用 XML 声明，但它不是必需的。如有应该在文档开始位置。

声明最多可以包含三个名称-值对。

version 是使用的 XML 版本；目前该值必须是 1.0。

encoding 是该文档所使用的字符集。该声明中引用的 ISO-8859-1。如没有指定 encoding，XML 解析器会假定字符在 UTF-8 字符集中，这个字符集是一个几乎支持世界上所有语言的字符和象形文字的 Unicode 标准。

standalone（可以是 yes 或 no），本是独立的意思，定义了是否可以在不读取任何其它文件的情况下处理该文档。例如，如果 XML 文档没有引用任何其它文件，可指定 standalone="yes"。如果 XML 文档引用其它描述该文档可以包含什么的文件可指定 standalone="no"，standalone="no" 是缺省的。

1.5 XML 文档中的转义字符

为解决xml文档中各种标记符号的歧义问题，xml提供了如下转义字符：

< 代表小于符号

> 代表大于符号

" 代表一个双引号

' 代表一个单引号（或撇号）

& 代表一个“与”符号&。

为了避免 XML 解析错误，我们应该使用 < 来替代 <，使用 & 替代 &。但是假设你需要在 XML 文档里写一段内容，里面包含了很多 < 或者 &，要将所有 < 或者 & 转换成实体引用是很讨厌的事情。

这时候，你可以使用 CDATA 区 (CDATA section)。在 CDATA 区里，你可以不必使用实体引用，因为 XML 解析器不会解析 CDATA 区内的内容。

CDATA 区 (CDATA section) 以 <![CDATA[ 开始，以 ]]> 结束。示例如下：

<mycode> This is a html page
<![CDATA[
<html>
	<head>
		<title>呵呵</title>
	</head>
	<body>
		I like 
	</body>
</html>
]]></mycode>

注意：在 CDATA 区内，不能出现 ]]>

1.6 XML语法规则

1、是否有DTD文件

如果文档是一个"有效的XML文档"，那么文档一定要有相应DTD文件，并且严格遵守DTD文件制定的规范。DTD为英文Document Type Definition，中文意思为“文档类型定义”，用于定义这个文档的具体类型，不通场合的xml类型不一样，具体用那一种，要通过DTD定义，所以使用时要指明相应的DTD文件。

DTD的作用:

一方面它帮助你编写合法的代码，另一方面它让浏览器正确地显示器代码。

DTD文件的声明语句紧跟在XML声明语句后面，格式如下：

<!DOCTYPE type-of-doc SYSTEM/PUBLIC "dtd-name">

其中：

"!DOCTYPE"是指你要定义一个DOCTYPE;

 "type-of-doc"是文档类型的名称，由你自己定义；

 "SYSTEM/PUBLIC"这两个参数只用其一。SYSTEM是指文档使用的私有DTD文件的网址，而PUBLIC则指文档调用一个公用的DTD文件的网址。

 "dtd-name" 就是DTD文件的网址和名称。所有DTD文件的后缀名为".dtd"。

例如用上面的例子，可写成这样：

<?xml version="1.0" standalone="no" encoding="UTF-8"?>
<!DOCTYPE filelist SYSTEM "filelist.dtd">

上面的声明表示:

该xml文件版本是1.0，引用了其他文件，文档字符编码是UTF-8

DTD文档类型名称是filelist，使用的是私有DTD文件的网址，DTD文件为filelist.dtd

2、区分大小写(case-sensitive)

在XML文档中，大小写是有区别的。<P>和<p>是不同的标识。注意在写元素时，前后标识大小写要保持一样。例如:<Author>ajie</Author>，写成<Author>ajie</author>是错误的。

3、属性值

在XML中则规定，所有属性值必须加引号(可以是单引号，也可以是双引号)，否则将被视为错误。

 属性名的第一个字母必须以字母或下划线开头

 在同一个开始标记里，一个特殊的属性名只能出现一次

4、所有的标识必须有相应的结束标识

在XML中规定，所有标识必须成对出现，有一个开始标识，就必须有一个结束标识。

5、所有的空标识也必须被关闭

空标识就是标识对之间没有内容的标识。在XML中，规定所有的标识必须有结束标识，针对这样的空标识，XML中处理的方法是在原标识最后加“/”。例如：<br>应写为<br/>；

1.7 XML解析技术(XML常用作作为数据存储格式)

1、DOM（Document object model）

解析器采用了基于树状的模型，侧重结果

优点：

层次清晰，便于存取其中的节点。

缺点：

DOM 构建整个文档驻留内存的树。如果文档很大，就会要求有极大的内存。

 DOM 创建表示原始文档中每个东西的对象，包括元素、文本、属性和空格。如果您只需关注原始文档的一小部分，那么创建那些永远不被使用的对象是极其浪费的。

 DOM 解析器必须在您的代码取得控制权之前读取整个文档。对于非常大的文档，这会引起显著的延迟。

DOM 解析器把 XML 文档转化为一个包含其内容的树，并可以对树进行遍历。然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用 DOM 解析器的时候需要处理整个 XML 文档，所以对性能和内存的要求比较高，尤其是遇到很大的 XML 文件的时候。由于它的遍历能力，DOM 解析器常用于 XML 文档需要频繁的改变的服务中。

2、SAX

解析器采用了基于事件的模型，侧重过程

优点：

快速、适合大文件。

缺点:

编程较难，仅用于串行存取，由于应用程序不以任何方式存储数据，所以，使用 SAX 时，不可能对数据进行更改。

SAX(Simple API for XML) 不是某个官方标准,但它是 XML 社区事实上的标准，几乎所有的 XML 解析器都支持它。SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag（标签）的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。

由于应用程序简单地检查经过其的数据，所以不需要将数据存储在内存里。当遇到大文档时，这是一个突出的优势。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

选择 DOM 还是 SAX，这取决于几个因素：

应用程序的目的：如果必须对数据进行更改，并且作为 XML 将它输出，则在大多数情况下，使用 DOM。

 数据的数量：对于大文件，SAX 是更好的选择。

 将如何使用数据：如果实际上只使用一小部分数据，则使用 SAX 将数据抽取到应用程序中，这种方法更好些。

 需要速度：通常，SAX 实现比 DOM 实现快。

3、JDOM

注意JDOM的J是Java的意思，决不是DOM扩展，虽然名字差不多，但两者平行的关系。与DOM主要有两方面不同：

首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。

第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快 JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。

4、DOM4J

具有性能优异、功能强大和使用便捷的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如Hibernate也用DOM4J来读取XML配置文件。

1.8 用DOM4J技术解析XML

1、简介

dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。Dom4j是一个易用的、开源的库，用于XML，XPath和XSLT。它应用于Java平台，采用了Java集合框架并完全支持DOM，SAX和JAXP。

2、 DOM4J的API文档

从网上可以下载DOM4J的API帮助文档、jar包（如dom4j-1.6.1.jar）、开源代码。其帮助文档首页如下：

Home是首页，FAQ是常见问题，Quick start是快速入门，主要说明dom4j的基本使用方法，并列举了一写简单的例子。包括如何得到一个xml文档对应的Document对象，（在Java编程环境中模拟的一个文档），通过迭代器(Iterator)遍历xml树，快速循环，创建XML文档，把一个document写到文件中等。Javadoc(1.6.1)就是对应的dom4j对应的类似Java JDK帮助文档一样文档。里面特别常用的接口以斜体方式显示。如Node、Document、Elemet等。

3、 dom4j中常用的接口概述

它的主要接口都在org.dom4j这个包里定义：

Attribute 接口定义了XML的属性

 Branch接口为能够包含子节点的节点如XML元素(Element)和文档(Docuemnts)定义了一个公共的行为，

 CDATA接口定义了XML CDATA 区域，次区域的大于小于等符号不会被当做标签的符号来读取。

 CharacterData接口是一个标识借口，标识基于字符的节点。如CDATA，Comment, Text.

 Comment接口定义了XML注释的行为

 Document 定义了XML文档

 DocumentType接口定义XML DOCTYPE声明

 Element Element定义XML 元素

 ElementHandler接口定义了 Element 对象的处理器

 ElementPath 被 ElementHandler 使用，用于取得当前正在处理的路径层次信息

 Entity接口定义xml实体：XML entity

 Node接口为所有的dom4j中XML节点定义了多态行为

 NodeFilter接口定义了在dom4j节点中产生的一个滤镜或谓词的行为（predicate）

 ProcessingInstruction接口定义 XML 处理指令.

 Text接口定义XML 文本节点.

 Visitor接口用于实现Visitor模式.

 XPath接口在分析一个字符串后会提供一个XPath 表达式

常用接口的继承关系：

java.lang.Cloneable

Node

DocumentType

Attribute

ProcessingInstruction

Entity

Branch

Document

Element

CharacterData

CDATA

Text

Comment

可见，上面关系中，大多都是Node的子节点，这些节点都来自java.org.dom4包中。

4、 Dom4j常用接口、类说明

1) Node接口

asXML():隶属于Node类，用于将XML转换为String

 public Node selectSingleNode(String xpathExpression)可以通过xpath路径返回一个节点。若xpathExpression为"/users/user[id='108']"，则得到的是user节点，它有一个子元素id，标签id的值为108.若xpathExpression为"/users/user[@firstname='liu']"，则会得到一个user节点，它有个属性是firstname，属性值为liu。

public List selectNodes(String xpathExpression)可以返回所有xpath路径指定的节点

2) SAXReader接口

此接口通过SAX解析事件创建一个DOM4J的SAXReader对象树。常用其无参构造方法SAXReader()。

 public Document read(InputStream in)此方法可以读取一个输入流in，返回一个Java环境下文档Document类型的对象。SAXReader的read方法是重载的，可以从InputStream, File, Url等多种不同的源来读取。得到的Document对象就带表了整个XML。读取的字符编码是按照XML文件头定义的编码来转换。如果遇到乱码问题，注意要把各处的编码名称保持一致即可。

3) Document接口

此接口是Node的子接口，用于定义一个XML文档，没有自己的构造方法，有两种方法得到Document对象：一是从SAXReader的read方法读流得到，二是由DocumentHelper类的静态方法createDocument得到。

 public Element getRootElement() 此方法可以得到这个Document的根元素，也就是树的根。

 public Element addElement(String name)此方法是从Document的父类Node那里继承而来的，可以给Document添加一个名为name元素，并返回这个元素。

 public void add(Element element)此方法也是从Node那里继承而来，可以添加一个元素到该document的分支上。如果传进来的元素已经有了父节点，就会抛出非法异常。

4) Element接口

此接口是Node、Branch的子接口，用于定义一个XML元素，也就是树的节点，一个元素可以设置命名空间，属性，子节点和文本内容。

 public Element element(String name) 此方法可以得到该元素下面名字为name的子元素

 public List elements() 此方法可以得到一个存储该元素下面所有元素的List表。

 public String getText() 此方法可以返回该元素的文本内容，如果内容为空则返回一个空字符串而不是null。

 public String getTextTrim() 返回该元素所含有的text内容，其中连续的空格被转化为单个空格，该方法不会返回null

 public String attributeValue(String name) 此方法可以得到该元素名为name的属性的值，如果xml文档中没有指明该属性，就返回其默认值。

 public String attributeValue(String name,String defaultValue)该方法返回该元素名为name属性的值，如果xml文档中没有指明，就返回传给此方法的dafaultValue，这可能并不是该属性的默认值。

 public Element addAttribute(String name,String value)此方法可以给该元素名为name的属性设置值，并覆盖该属性先前的值。返回该元素。

 部分其他方法简介

MethodComment

getQName()元素的QName对象

getNamespace()元素所属的Namespace对象

getNamespacePrefix()元素所属的Namespace对象的prefix

getNamespaceURI()元素所属的Namespace对象的URI

getName()获取该元素的local name

getQualifiedName()元素的qualified name

attributeIterator()元素属性的iterator，其中每个元素都是Attribute对象

attributeValue()元素的某个指定属性所含的值

elementIterator()元素的子元素的迭代器Iterator，其中每个元素都是Element对象

element()元素的某个指定（qualified name或者local name）的子元素

elementText()元素的某个指定（qualified name或者local name）的子元素中的text信息

getParent元素的父元素

getPath()元素的XPath表达式，其中父元素的qualified name和子元素的qualified name之间使用"/"分隔

isTextOnly()是否该元素只含有text或是空元素

detach() 移除自己

isRootElement()是否该元素是XML树的根节点

selectNodes(String xpathExpression)通过XPATH获取节点。

selectSingleNode(String xpathExpression)通过XPATH获取一个节点。

getDocument()作为一个Document返回

5) OutputFormat类

问题：把做好的xml文档直接用流输出，输出的方式默认为紧凑的，才用UTF-8编码，遇到中文字符就会显示为乱码。如何用很清晰的缩进的格式显示呢。

 说明：此类位于java.org.dom4j.io包中，用于格式化XML文档的输出。

此类的使用方式是将此类的对象作为参数传递给XMLWriter类的构造方法，从而构建一个XML输出流类，调用其write方法进行输出。

 public static OutputFormat createPrettyPrint()此静态方法不是OutputFormat的构造方法，但该方法可以创建一个设定好XML输出格式的OutputFormat对象。此默认格式就是，元素标签之间换行，并且子元素与父元素间产生2个空格的缩进，且换行、缩进中空的部分都是空白。

 public void setIndent(String indent) 该方法可以设置该类对象的XML文档输出时，子元素与父元素间缩进填充的字符串indent。字符串indent将会显示在XML文档子元素与父元素间缩进的位置。

 public void setEncoding(String encoding)此方法可以设定输出的XML文档的编码方式，如果是GBK就可正确显示文档的中文信息。

6) XMLWriter类

此类是dom4j.io中的类，可以得到一个dom4j树，把他按xml文件格式的流。其有参构造方法可以接受一个设定好xml文档格式的OutputFormat，并按照这个OutputFormat给定格式输出xml文档。写入文件后，要调用此类的flush方法刷新缓冲区，在关闭流。

 public XMLWriter(OutputStream out, OutputFormat format)

给构造方法，就收一个输出流对象和一个OutputForemat对象。out可以指定XMLWriter输出XML文档的地方，format指定输出格式。

 write方法

此方法进行了多次重载，可以写Document、Element、String等等。

7) DocumentHelper

createDocument():创建一个Document对象

 parseText(String text):解析给定Xml的文本，生成Document对象

5、用DOM4解析技术操作xml文档

1) 几种存储方式：

普通txt文件------存取不便

 数据库 -----------没必要

 技术 -------------结构清晰，层次明了

Xml与数据库中表的关系：

根元素-----表名

 子元素-----记录

 子元素中的子元素---------字段

2) 生成xml文档：

得到文件输出流：新建File对象，创建FileWriter输出流

 设置生成文档格式：创建OutputFromat对象设置

 创建输出流：创建XMLWriter，构造方法得到输出流、设定的格式

 写文件到磁盘：把已有的Document对象通过XMLWriter的write方法写入磁盘

 刷新、关闭流

3) 获取xml文档：
找到文件：通过磁盘xml文件，new一个File对象

 打开文件：通过得到的文件对象创建一个InputStream

 把InputStream变成树：创建一个SAXReader对象，通过其read方法读文件对象或输入流对象得到一个Document对象

4) 查询xml文档的叶子节点
找树根：Document的getRootElement方法可以得到SAXReader创建的树的类型为Element的根节点。

 找树枝：Element接口中的elements()可以找到该元素下的所有节点

 找树叶：用element方法可以找到指定名称的子节点

 关闭流

Xml path简称xpath

问题：查找过程浪费时间在一些中间节点，如果中间节点过多则性能下降。

定义：由xml中的节点或者属性构成的序列。

XPath是用来搜索和查询XML文档，以得到与给定标准相匹配的节点列表的语言。它已经被W3C标准化了。一个XPath语言的表达式可详细说明要匹配的位置和模式。将布尔运算符、字符串运算符和算术运算符应用到XPath语言的表达式中，能够建立极其复杂的查询.

作用：根据条件（某个节点或者属性）快速定位某个节点。

关系：

Users----user-----id

/users/user[id='108']

借助子节点的值来定位父节点

条件是id的值

定位的节点是user

/users/user[@firstname='liu']

借助节点属性值来定位所在的节点。

XPath语言的特性

能找到当前节点的所有子节点

 能找到具有特定标志的当前上下文节点的所有祖先节点

 能找到具有特定标志的当前节点的最后一个子元素

 根据一个给定属性的元素的当前上下文节点找到第n个元素

 能找到具有<tag1>或<tag2>标志的第一个子元素

 能找到不具有某个属性的元素的所有子节点

 能找到所有数字元素子节点的总和

 能找到所有子节点的数量

待解析的xml：

<?xml version="1.0" encoding="UTF-8"?>
<students count="1"> 
   <student aa="abc"> 
        <sid>119</sid>  
        <sname>刘晓东</sname>  
        <major>computer</major>
        <password>34567</password>  
        <birth>1997-08-01</birth>  
        <address>USA</address>  
        <gender>m</gender> 
    </student>
    <student firstname="liu"> 
        <sid>121</sid>  
        <sname>晓东</sname>  
        <major>computer</major>
        <password>34567</password>  
        <birth>1997-08-01</birth>  
        <address>USA</address>  
        <gender>m</gender> 
    </student>
     <student> 
        <sid>120</sid>  
        <sname>刘晓东</sname>
        <major>computer</major>  
        <password>34567</password>  
        <birth>1997-08-01</birth>  
        <address>USA</address>  
        <gender>m</gender> 
    </student> 
</students>

示例部分代码如下：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**对Document的一些操作都放在此类管理
 * 1.通过xml文件得到Document对象
 * 2.对已有的Document对象，把他按照我们的格式写到磁盘中
 */
public class DocumentManager {

	private static String fileName = "src/Users.xml";
	public static Document getDocument(){
		return getDocument(fileName);
	}
	public static Document getDocument(String fileName){
		try {		
			File file = new File(fileName);
			InputStream is = new FileInputStream(file);
			SAXReader reader = new SAXReader();
			Document document = reader.read(is);
			return document;
		} catch (Exception e) {
			e.printStackTrace();
		} 
		return null;
	}
	
	public static void writeDocument(Document document){
		writeDocument(document,fileName);
	}
	public static void writeDocument(Document document,String filename){
		//1.set the format
		OutputFormat format = OutputFormat.createPrettyPrint();
		//2.set the indent to 4 white spaces.
		format.setIndent("    ");		
		try {			
			XMLWriter writer = new XMLWriter(new FileOutputStream(filename),format);			
			writer.write(document);	
			writer.flush();
			writer.close();			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}
	
	public static void main(String[] args) {
		 getDocument();

	}

}

import java.sql.Date;

/**创建一个程序中实体对应xml中的信息，更加人性化，用户也更容易
 * 理解 当然这就需要xml中的东西与实体间进行转换，包含对象、操作等 
 * 1.创建一个用户类User，对应xml中的Student，用户的属性对应xml中Student所有子元素
 * 2.实体的各属性都要有set、get方法，以便设置、获取属性值
 * 3.尤其是对xml的文档的元素进行排序，如果用xml里面的元素排，在排的时候要把元素从他们的父节点上移除
 *   添加的时候还要设置被被添加的子元素的父节点为null，很是麻烦，用把Element转换成为User对象，排好了序
 *   再写到原来的xml文档，这样就简单很多。
 * 4.重写toString方法便于查看属性
 */
public class User {
	private Integer id = null;
	private String username =  null;
	private String password = null;
	private Date   birth = null;
	private String address = null;
	private String gender = null;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	
	@Override
	public String toString(){
		return "id=" + id + "\tusername=" + username + "\tpassword=" + password
				+ "\tgender="+gender+"\taddress"+address+"\tbirth="+birth;
	}
}


import java.util.List;

/**创建一个接口，让人一步了然的看清有什么方法，做了写什么事，
 * 还可以实现接口
 */
public interface IUserDAO {
	public List<User> getAllUser();
	public User getUserByUsername(String username);
	public List<User> getUserListByUsername(String username);
	public List<User> getUserListByKeyword1(String keyword);
	public List<User> getUserListByKeyword2(String keyword);
	public boolean addUser(User user);
	public boolean addUserWithUniquePK(User user)throws UserExistsException;
	public boolean addUserWithAutoPK(User user);
	public boolean deleteUserByPK(int id);
	public boolean update(User user);
	public void sortUserList(List<User> userList);
	public void sortUserList(List<User> userList,boolean ascendable);
	public void testXPath1();
	public User getUserById(int id);
	public void sortById1();
	public void sortById2();
	public void sortById3();
	public void sortById4();
}

import java.sql.Date;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

public class UserDAO implements IUserDAO {
	/**
	 * 把一个Element对象转换成一个User对象 
	 * 1.得到Element各子元素存储的信息
	 * 2.把这些String类型的信息转换成相应的类型后赋值给User对象的属性
	 * 3.返回User对象
	 */
	private User getObjectFromElement(Element userElement) {
		String idStr = userElement.elementTextTrim("id");
		String username = userElement.elementTextTrim("username");
		String birthStr = userElement.elementTextTrim("birth");
		String gender = userElement.elementTextTrim("gender");
		String password = userElement.elementTextTrim("password");
		String address = userElement.elementTextTrim("address");

		Integer id = Integer.parseInt(idStr);
		// convert a string in the format "yyyy-mm-dd" into a Date type.
		Date birth = Date.valueOf(birthStr);
		User user = new User();
		user.setId(id);
		user.setUsername(username);
		user.setPassword(password);
		user.setBirth(birth);
		user.setAddress(address);
		user.setGender(gender);

		return user;
	}

	// 通过指定的用户名得到xml中第一个与指定用户名相同的用户对应的User对象
	public User getUserByUsername(String username) {
		try {
			Document document = DocumentManager.getDocument();
			Element usersElement = document.getRootElement();
			List<Element> userElementList = usersElement.elements();
			for (Element userElement : userElementList) {
				Element usernameElement = userElement.element("username");
				String _username = usernameElement.getText();
				if (username.equals(_username) == false) {
					continue;
				}
				return this.getObjectFromElement(userElement);
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public List<User> getAllUser() {
		return null;
	}

	/**
	 * 通过指定的字符串查找到xml文件中用户名中包含此字符串的所有User对象
	 * 1.得到xml对应的Docuement对象，寻找到xml中所有的Student元素 
	 * 2.创建一个存储User对象的List列表
	 * 3.让Student的子元素也就是叶子节点存储的信息与我们想找的username比较
	 * 4.把匹配的转换成为User对象后添加到List中
	 * 5.返回这个List
	 */
	@Override
	public List<User> getUserListByUsername(String username) {
		Document document = DocumentManager.getDocument();
		Element usersElement = document.getRootElement();
		List<Element> userElementList = usersElement.elements();
		List<User> userList = new ArrayList<User>();
		// 创建一个ArrayList，这样的数组列表有序、可以重复、长度可变，
		// 用于存储我们找到的User对象
		for (Element userElement : userElementList) {
			String _username = userElement.elementTextTrim("username");
			if (_username.contains(username)) {
				User user = this.getObjectFromElement(userElement);
				userList.add(user);
			}
		}
		return userList;
	}

	/**
	 * 查询所有包含我们指定字符串内容信息的用户，并转换成User对象返回 
	 * 1.创建一个存储User对象的ArrayList
	 * 2.找到存有所有用户元素列表，循环找到各个user节点 
	 * 2.找到其字节点叶子节点，看他们的内容是否包含我们要查询的信息keywword
	 * 3.如果遇到任何一个叶子结点包含，就不再找这个user的后面元素了
	 * 4.满足条件的user节点转换成user对象，添加到List中
	 * 5.返回List
	 */
	public List<User> getUserListByKeyword1(String keyword) {
		Document document = DocumentManager.getDocument();
		Element usersElement = document.getRootElement();
		List<Element> userElementList = usersElement.elements();

		List<User> userList = new ArrayList<User>();
		for (Element userElement : userElementList) {
			String _username = userElement.elementTextTrim("username");
			if (_username.contains(keyword)) {
				User user = this.getObjectFromElement(userElement);
				userList.add(user);
				continue;
				// 如果这叶子节点包含我们想找的信息，就添加到List中，并终止本次循环
				// 不用在查这个user元素后面的子元素是否包含keyword
			}
			String password = userElement.elementTextTrim("password");
			if (password.contains(keyword)) {
				User user = this.getObjectFromElement(userElement);
				userList.add(user);
				continue;
			}
			String birth = userElement.elementTextTrim("birth");
			if (birth.contains(keyword)) {
				User user = this.getObjectFromElement(userElement);
				userList.add(user);
				continue;
			}
			String address = userElement.elementTextTrim("address");
			if (address.contains(keyword)) {
				User user = this.getObjectFromElement(userElement);
				userList.add(user);
				continue;
			}
			String gender = userElement.elementTextTrim("gender");
			if (gender.contains(keyword)) {
				User user = this.getObjectFromElement(userElement);
				userList.add(user);
				continue;
			}
		}
		return userList;
	}

	/**
	 * 与上面的getUserListByKeyword2功能一样
	 */
	public List<User> getUserListByKeyword2(String keyword) {
		Document document = DocumentManager.getDocument();
		Element usersElement = document.getRootElement();
		List<Element> userElementList = usersElement.elements();
		List<User> userList = new ArrayList<User>();
		for (Element userElement : userElementList) {
			List<Element> userSubelementList = userElement.elements();

			// traverse every sub-element of the user element.
			for (Element userSubelement : userSubelementList) {
				String elementValue = userSubelement.getTextTrim();
				if (elementValue.contains(keyword)) {
					// if the sub-element is located successfully,other
					// sub-element is not read any longer.
					User user = this.getObjectFromElement(userElement);
					userList.add(user);
					break;
					// 如果找到了user的某个子元素包含keyword，就跳出访问其
					// 子元素的这个循环，接着外层查找下个user的子节点是否包含
				}
			}
		}
		return userList;
	}

	/**
	 * 把一个User对象user，把它转换成为Element类型的user节点
	 * 1.创建名为user的Element对象
	 * 2.通过Element的addElement方法给user添加子元素 
	 * 3.设置子元素中的内容为User对象对应属性的内容
	 * 4.返回一个Element元素
	 */
	private Element getElementFromObject(User user) {
		Element userElement = DocumentHelper.createElement("user");
		// dom4j中的大多对象都不是构造方法生成的，而是用DcumentHelper来creat的
		// 包括文档、元素、属性、文本等都可以依次来生成
		userElement.addElement("id").setText(user.getId() + "");
		userElement.addElement("username").setText(user.getUsername());
		userElement.addElement("password").setText(user.getPassword());
		userElement.addElement("birth").setText(user.getBirth() + "");
		userElement.addElement("address").setText(user.getAddress());
		userElement.addElement("gender").setText(user.getGender());
		return userElement;
	}

	/**
	 * 添加User对象的用户user到XML文档中 
	 * 1.把User对象user转换成为Element类型的元素
	 * 2.得到指定xml文档的Document对象，找到要添加元素的节点 
	 * 3.通过addElement方法把要添加的元素填进去
	 * 4.更改计算user节点元素个数的count属性，每添加一个就加1 
	 * 5.把我们修改后的Document对象写到磁盘
	 */
	@Override
	public boolean addUser(User user) {
		Element userElement = this.getElementFromObject(user);
		Document document = DocumentManager.getDocument();
		Element usersElement = document.getRootElement();
		usersElement.add(userElement);
		this.setCountAttribute(usersElement, true);
		DocumentManager.writeDocument(document);
		return false;
	}

	/**
	 * 设置usersElement的计user数的属性count 
	 * 1.通过attributeValue方法得到该元素的指定属性的值 
	 * 2.转换成为整数类型
	 * 3.increment为false表示是增加元素，count就增加，反之减少
	 * 4.把count转换成字符串后通过addAtributte方法把设定好的属性添加到原节点中
	 */
	private void setCountAttribute(Element usersElement, boolean increment) {String countStr = usersElement.attributeValue("count");int count = 0;try {count = Integer.parseInt(countStr);} catch (NumberFormatException e) {
	// TODO Auto-generated 
	catch blocke.printStackTrace();}if (increment) {count++;} else {count--;}
	//addAttribute方法可以向元素中添加属性
	usersElement.addAttribute("count", count + "");
	}

	/**
	 * 添加id唯一的用户，一旦id相同就抛出异常。 
	 * 1.得到元素id 
	 * 2.坚持要插入元素的id是否已经存在 
	 * 3.如果不存在就添加元素，如果存在就抛出异常
	 * 这写操作是在转换成Element前做的，只是对User对象，这样更简便 *
	 */
	@Overridepublic
	boolean addUserWithUniquePK(User user) throws UserExistsException {
		Document document = DocumentManager.getDocument();
		if (this.findUserElementById(document, user.getId()) != null) {
			throw new UserExistsException("The user DOES EXIST!");
		}
		this.addUser(user);
		return false;
	}

	@Overridepublic
	boolean addUserWithAutoPK(User user) {
		// PK是primary key的缩写，主键的意思，这里就是id号
		// 自动设置用户id，找出现有id号最大的，让新加入的用户id号比最大的大一就可以了
		Document document = DocumentManager.getDocument();
		Element usersElement = document.getRootElement();
		List<Element> userElementList = usersElement.elements();
		int maxId = 0;
		for (Element userElement : userElementList) {
			String idStr = userElement.elementTextTrim("id");
			int id = 0;
			try {
				id = Integer.parseInt(idStr);
			} catch (NumberFormatException e) {
				e.printStackTrace();
			}
			if (maxId < id) {
				maxId = id;
			}
		}
		maxId++;
		user.setId(maxId);
		this.addUser(user);
		return false;
	}

	/** 通过id找到一个Document对象中的元素 */
	private Element findUserElementById(Document document, int id) {
		Element usersElement = document.getRootElement();
		List<Element> userElementList = usersElement.elements();
		for (Element userElement : userElementList) {
			// Step 2:
			String idStr = userElement.elementTextTrim("id");
			if (idStr.equals(id + "")) {
				return userElement;
			}
		}
		return null;
	}

	/**
	 * 删除指定id的节点  
	 * 1.通过id找到要删除的节点
	 *  2.找到要删除节点的父节点，可以用父接口中的getParent找到，在这里就是根节点
	 * 3.判断要删除的节点是否为空 
	 * 4.通过父节点，调用remove方法删除要删除的节点 
	 * 5.如果删除成功，就让计算user节点个数的减少
	 * 6.把修改过的Document对象写到原xml文件中 *
	 */
	public boolean deleteUserByPK(int id) {
		Document document = DocumentManager.getDocument();
		Element userElement = this.findUserElementById(document, id);
		if (userElement != null) {
			Element usersElement = document.getRootElement();
			if (usersElement.remove(userElement)) {
				// 执行remove方法的同时也做了判断条件，移除后才能设置计数的属性
				// alter the count attribute if succeeded in removing the
				element.this.setCountAttribute(usersElement, false);
			}
			// Step 4:re-write the document into the
			disc.DocumentManager.writeDocument(document);
		}
		return false;
	}

	/**
	 * 用户传入一个User对象，更新xml文档中对应元素的信息 
	 * 1.得到要更新的xml文档的document
	 * 2.由于id是唯一的，通过User对象中的id属性值，找到xml文档中对应id的元素
	 * 3.得到这个元素的父节点，可以用getParent方法，这里是根节点 
	 * 4.通过父节点调用remove方法移除原来的节点
	 * 5.把User对象转换成Element对象，添加到document中 
	 * 6.写更新后的document到xml文档
	 */
	@Overridepublic
	boolean update(User user) {
		Document document = DocumentManager.getDocument();
		Element userElement = this.findUserElementById(document, user.getId());
		Element usersElement = document.getRootElement();
		if (usersElement.remove(userElement)) {
			userElement = this.getElementFromObject(user);
			usersElement.add(userElement);
		}
		DocumentManager.writeDocument(document);
		return false;
	}

	/**
	 * 对一个存储User对象的UserList中的元素排序 
	 * 1.构建比较器对象，指定排序标准 
	 * 2.用Conections的sort方法排序
	 */
	@Overridepublic
	void sortUserList(List<User> userList, boolean ascendable) {
		// Step 1:make a sort
		standard.Comparator<User> userComparator = new UserComparator(
				ascendable);
		// Step 2:relate the sort standard to the sorted objects
		// 调用Collections的静态方法sort根据排序标准排序
		Collections.sort(userList, userComparator);
	}

	@Overridepublic
	void sortUserList(List<User> userList) {
		this.sortUserList(userList, true);
		// 默认排序顺序是升序
	}

	/**
	 * 通过xpath来快速查找 
	 * 1.设置xpath路径，是字符串的形式，XPath技术可以通过子元素名、自己属性名来获得节点， 
	 *    并可以进而找到其父节点、子节点、元素等
	 * 2.可以把xpath字符串路径传递给selectSingleNode、selectNodes方法，这两个方法来自Node，
	 * 来得到Node实例调用这两个方法的对象是说指XPath路径的父节点
	 */
	@Overridepublic
	void testXPath1() {
		// xpath可以根据条件（某个节点或者属性）快速定位某个节点。
		// locate user node whose sub-element id value is 121
		String xpath = "/users/user[id='121']";
		
		// 通过id值查找节点
		userDocument document = DocumentManager.getDocument();
		Node userElement = document.selectSingleNode(xpath);
		
		// selectSingleNode方法来自Node,可以通过xpath字符串路径得到一个Node实例
		// 此方法在此处返回的实例是Element对象，拥有子节点id为121的user节点
		System.out.println(this.getObjectFromElement((Element) userElement));
		System.out.println("username="
				+ ((Element) userElement).elementText("username"));
		String xpath = "/users/user[id='121']/username";
		Document document = DocumentManager.getDocument();
		Node userElement = document.selectSingleNode(xpath);
		
		// 此时selectSingleNode得到的是一个user节点的子元素username，
		// 该user节点有一个元素id，他的值为121
		System.out.println("username=" + ((Element) userElement).getTextTrim());
		String xpath = "/users/user[@firstname='liu']/birth";
		
		// 通过属性访问,这里的selectSingleNode方法得到的是user的一个子元素birth，
		// 这个user有个属性叫firstname，属性值为liu
		Element birthElement = (Element) DocumentManager.getDocument()
				.getRootElement().selectSingleNode(xpath);	
	}

	/**
	 * 通过id得到用户User对象
	 *  1.通过指定指定id建立可变的XPath字符串路径 
	 *  2.通过XPath路径得到xml文档中对应的元素
	 *  3.把找到的元素转换成为User对象类型返回
	 */
	@Overridepublic
	User getUserById(int id) {
		String xpath = "/users/user[id='" + id + "']";
		System.out.println("xpath=" + xpath);
		Element userElement = (Element) DocumentManager.getDocument()
				.selectSingleNode(xpath);
		return this.getObjectFromElement(userElement);
	}

	/**
	 * 让xml文档按照id进行排序 * 保留document，建新的根节点users 
	 * 1.得到原xml文档的document 
	 * 2.创建一个List
	 * 3.取原来xml文档的所有等待排序的user元素存在List中
	 * 4.把所有要排序的user元素从原根节点中移除来，这样他们才“自由”了，才可以进行排序，否则会抛出异常 
	 * 5.对List中所有元素排序 *
	 * 6.设置List中所有元素的父节点为null 
	 * 7.新建一个Element对象users
	 * 8.把排好序的List中的元素依次添加到users下面,添加一个节点为子元素时，必须确认其父元素为空
	 * 9.在document下面移除原来的根节点，设置users为根节点 
	 * 10.写document到xml文档
	 */
	public void sortById3() {
		List<Element> userElementList = rootElement.elements("user");
		// 把原来的所有用户存入List中
		Element newRootElement = DocumentHelper.createElement("users");
		
		// System.out.println("newRootElement父节点为"+newRootElement.getParent());
		// 重新创建一个users的节点
		for (Element userElement : userElementList) {
			rootElement.remove(userElement);
		}
		
		// 把原来根节点的所有内容从原来的根节点移除出去，这样这些节点才是自由的，才可以排序？
		List l = rootElement.elements();
		System.out
				.println("rootElement.elements() 有 " + rootElement.elements());
		Comparator userElementComparator = new UserElementComparator();
		Collections.sort(userElementList, userElementComparator);
		
		// sort方法根据Comparator中的compare方法的结果进行排序,Comparator是个比较器。
		// 此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置每个元素的列表上进行迭代。
		for (Element userElement : userElementList) {
			System.out.println(userElement.elementTextTrim("id"));
		}
		for (Element userElement : userElementList) {
			// System.out.println("userElement父节点是："+userElement.getParent());
			userElement.setParent(null);
			// System.out.println("userElement父节点变成了："+userElement.getParent());
			// System.out.println();
			// 设置userElement的父节点为空newRootElement.add(userElement);
			// 在新的根节点上添加元素}newRootElement.setAttributeValue("count",
			// userElementList.size() + "");
			// 为新的根节点添加属性document.setRootElement(newRootElement);
			// setRootElement可以设置document的根节点DocumentManager.writeDocument(document);}}
		}
	}
}

Java中Xml解析详解 DOM、SAX、JDOM、DOM4J

1.1 什么是XML

1.2 Xml的作用和优点：

1.3 XML 文档类型：

1.4 XML 声明

1.5 XML 文档中的转义字符

1.6 XML语法规则

1.7 XML解析技术(XML常用作作为数据存储格式)

1.8 用DOM4J技术解析XML

继续阅读

Flex的MXML文件结构

Flex中如何通过创建新的XML命名空间（namespace），在MXML中使用flash.filters类

关于Flex及AS3的百多条小小知识

Socket套接字类 AS3

Flash AS3 连续加载外部若干图片

tomcat conf目录下web.xml tomcat-users.xml server.xml context.xml这四个文件的作用

Silverlight调用WCF服务，在添加WCF服务引用时，报错如下：

sqli-labs第一关--报错注入练习

小程序自定义button组件获取用户信息（用户授权登录）

写一个Junit类...在Spring中

jqGrid的使用笔记：5. 事件

invalid byte 1 of 1-byte UTF-8 sequence

出现invalid byte 1 of 1-byte UTF-8 sequence问题

为什么要选择UniDAC

SIP Presence SUBSCRIBE-NOTIFY

QName是什么