XML解析详解

javaWeb 专栏收录该内容
7 篇文章 0 订阅

概述

  1. XML(eXtensive Markup Language)可扩展的标记语言,是万维网联盟(World Wide Web Consortium W3C)定义的一种标准。 可扩展性指允许用户按照XML规则自定义标记(tags 标签)。

  2. 作用:

    • 作为微型数据库,存储数据;
    • 作为通信数据;
    • 用于不同平台,不用系统交换数据;
    • 作为配置文件,为应用程序配置数据;
    • 结合样式表语言,展示数据。
  3. 强项:轻松表达多层结构的数据;可扩展。
    优点:平台无关,语言无关。设计目标是描述数据并集中于数据的内容,与显示分离。
    提醒:不能用XML来直接写网页。即便是包含了XML数据,依然要转换成HTML格式才能在浏览器上显示。

  4. xml特征 :纯文本 、严格的格式、可扩展(标记可扩展)。

语法

       XML文档主要由如下部分组成: XML声明–处理指令(Processing Instruction) 、元素、属性、实体、注释。

声明(指令)

       大多数XML文档以XML声明作为开始,它向解析器提供了关于文档的基本信息。建议使用XML声明,但它不是必需的。如果有的话,那么它一定是文档的第一行内容。例如:

<?xml version="1.0"  encoding="UTF-8" standalone="no"?>

       声明最多可以包含三个名称-值对(许多人称它们为属性,尽管在技术上它们并不是)。

  1. 问号与xml之间不能有空格;

  2. version 是使用的XML 版本:1.0, 1.1 ;

  3. encoding 是该文档所使用的字符集。该声明中引用的ISO-8859-1 字符集包括大多数西欧语言用到的所有字符。默认字符在UTF-8字符集中,这是一个几乎支持世界上所有语言的字符和象形文字的Unicode 标准;

  4. standalone(可以是yes 或no)定义了是否孤立处理该文档。如果XML文档没有引用任何其它文件,则可以指定 standalone=”yes”。如果XML文档引用其它描述该文档可以包含什么的文件(如DTD),则 standalone=”no”。默认值为”no”。

注释

  • 注释可以出现在文档的任何位置。(但不建议放在声明前面,部分浏览器会报错) ;
  • 注释以 结束;
  • 注释内不能包含双连字符(–);除此之外,注释可以包含任何内容;
  • 注释不能写在第一行,标签或注释内;
  • 注释内的任何标记都被忽略。

标记(标签)

       <标记名>内容<’/标记名>:左尖括号“<“和右尖括号“>“之间的文本:

  1. 在< >中的称为开始标记;在<’/ >中的称为结束标记;
  2. 空标记:不包含元素内容的标记。空标签必须以“/>”结束。格式: <空标记的名称/>,<空标记的名称 属性列表/>。

       注意:

  • 除空标记外,标签必须成对:有始有终。所有的开始标签和结束标签必须匹配;
  • 在标记符“<“和”标记的名称”之间不能含有空格。在标记符”/>”前面可以有空格或回行;
  • XML的标记是区分大小写的,开始标记与结束标记名称必须严格完全相同。

       XML标记必须遵循下面的命名规则:

  1. 名字中可以包含字母、数字以及其它字母或文字;还可包含下划线(_)、点(.)、连字符(-);
  2. 名字不能以数字开头;可以用字母、文字或者下划线开头;
  3. 名字不能以字母xml (或XML 或Xml ..) 开头;
  4. 名字中不能包含空格。

元素

  • 位于开始标记与结束标记间;
  • 一份文档有且只有一个根元素;
  • 根元素下的所有元素叫“子元素”;
  • 不包含子元素的元素叫“叶子”;包含子元素的元素叫“分支”。

属性

       属性是标记的属性,可以为标记添加附加信息。属性是一个名值对,必须由名称和值组成,属性必须在标记的开始标记或空标记中声明,用”=”为属性指定一个值。 语法如下:

<标记名称 属性列表/>  
<标记名称 属性列表>XXX</标记名称> 
<!-- 例如 -->
<桌子 width="40" height='100'/>

       所有的属性值必须位于单引号或双引号中。每个标记内可以出现多组属性,但是不能出现同名属性。开始标志内,类似赋值语句,例如:

<eric age="80" sex="man">……</eric> 

       使用属性的原则:

       属性不体现数据的结构,只是数据的附加信息; 一个信息是作为一个标记的属性或子标记,取决于具体问题,不要因为属性的频繁使用破坏XML的数据结构。下面是一个结构清晰的XML文件:

<楼房 height="23m" width="12m">  
    <结构>混凝土</结构>  
    <类别>商用</类别>  
</楼房> 

       下面是一个结构不清晰的XML文件:

<楼房 height="23m" width="12m" 结构="混凝土" 建筑商="华海集团" 类别="商用"></楼房>

处理指令

  • 大多数XML 文档都是以XML 声明开始,该声明本身就是特殊的处理指令;
  • 处理指令对应用程序特定的数据进行编码;
  • 一条处理指令包含一个目标,后跟数据。用<’?和?>定界符将处理指令包起来;
  • 目标确定应用程序,而对应用程序不能识别的目标,其会忽略这些处理指令。

实体

       XML 规范预定义了五个实体。

&lt;   ==== < 
&gt;   ==== > 
&quot; ==== ” 
&apos; ==== ‘ 
&amp;  ==== & 

       自定义实体:在DTD中定义 <’!ENTITY 实体标志 “实体内容”> ,在xml中引用自定义实体,用 &实体标志; 代表实体内容。另外,无法从键盘输入的字符可以使用字符引用,就是用字符的Unicode代码点来引用该字符。以”&#x”开始字符引用,以分号结尾,x必须为小写,使用十六进制。如: &#x003D’; 表示等于号。
也可以使用字符引用来引用 <,>,’,”,& ” 查看字符的代码点(附件-> 系统工具-> 字符映射表)。

CDATA

       当一段文本中出现很多实体引用和字符引用时,会导致文本数据的读写困难,CDATA段就是为了解决这一问题引入的。 DATA区段开始于 “<.![CDATA[” 结束于 “]]>” 。CDATA内部的所有东西都会被解析器忽略解析,不用检查它的格式。例如:

<superType 范围="200" 程度="100%">
    <![CDATA[<"溅射"伤害>]]>
</superType> 

       解析后内容:<”溅射”伤害> ,但是CDATA段中不能嵌套另一个CDATA段。

名称空间/包

       XML文件允许自定义标记,所以可能出现同名字的标记,为了区分这些标记,就需要使用名称空间。名称空间的目的是有效的区分相同的标记,其实并不真实存在。

       语法:使用属性 xmlns 来定义命名空间。
       声明有前缀的名称空间 xmlns:前缀名=名称空间的名字 ;
       声明无前缀的名称空间 xmlns=名称空间的名字 (缺省);

       注意:当且仅当它们的名字相同时称二个名称空间相同,也就是说,对于有前缀的名称空间,如果二个名称空间的名字相同,即使前缀不相同,也是相同的名称空间,返之同然。前缀只是方便引用而已。

格式

  • 序言Prolog:包括XML声明(XML Declaration)和文档类型声明(Document Type Declaration)。
  • 格式良好:符合基本格式,即良构(well-formed 规范的),符合W3C定义的XML文档。
  • 有效文档:符合可扩展,支持额外格式.能通过验证(如:DTD,Schema等)的文档。

       为什么需要验证?对XML文件施加额外的约束,以便交流。 规范的XML文件不一定是有效的;有效的一定是规范的。 构成格式良好的基本规则:

  1. 第一条指令(声明)必须顶头写,前面不能有任何空格等 ;
  2. 标记必须成对;
  3. 最外围的元素(根元素)只能有一个;
  4. 属性只能出现在开始标记内;
  5. 属性必须有值;
  6. 属性值必须加引号(单引号、双引号都可以) ;
  7. 元素可以嵌套,但是不能交叉;
  8. 空元素可以简写,例:<.A><./A> 简写后:<.A/>;
  9. 大小写敏感。

DTD验证

  • 文档类型定义(Document Type Definition) ;
  • DTD定义了XML文档内容的结构,保证XML以一致的格式存储数据;
  • 精确的定义词汇表,对XML的内容施加约束;
  • 符合DTD的规范XML文档称为有效的文档;由DTD定义的词汇表以及文档语法,XML解析器可以检查XML文档内容的有效性;
  • 不同的组织,可一致地使用相同标准的 DTD 来交换数据;
  • 应用程序也可使用定义的 DTD 来验证从外部接收到的数据;
  • 使用 DTD 来验证自身数据的有效性。

DTD声明

  1. DTD声明可以在单独的一个文件中;
  2. DTD声明可以内嵌在XML文件中;
  3. DTD声明可以一部分在单独的文件中,另一部分内嵌在XML文件中。

引入外部DTD文件

<!DOCTYPE root SYSTEM "DTDName.dtd">

       root:根节点名称;
       DTDName.dtd:dtd文件的路径与名字,相同文件夹下可以省略路径,只用名字。

DTD四种标记声明

       元素(ELEMENT)、属性(ATTLIST)、实体(ENTITY)、符号(NOTATION)。

       (1)元素(ELEMENT):XML元素类型声明

       声明元素:

<!ELEMENT 元素名 (内容模式)>

       元素的内容通过内容模式来描述。

       DTD 内容模式的种类有:

  • EMPTY:元素不能包含任何数据,但可以有属性(前提是必须声明其属性);不能有子元素,不能有文本数据(包括空白,换行符);DTD中定义:
<!ELEMENT elementName EMPTY> 

       XML中:

<elementName/>(推荐) 
或者:
<elementName></elementName>
  • (#PCDATA):规定元素只包含已析的字符数据,而不包含任何类型的子元素的内容类型;DTD中定义:
<!ELEMENT student (#PCDATA)>

       XML中合法内容:

<student>watching TV</student> 
  • (Elements):元素由内容模式部件指定。
<!ELEMENT  name  (child particles) >  

       内容模式部件可以是下表列出的内容:

<!ELEMENT name (a,b)>  子元素a、b必须出现,且按照列表的顺序 
<!ELEMENT name (a|b)>  选择;子元素a、b只能出现一个 
<!ELEMENT name (a)  >  子元素a只能且必须出现一次 
<!ELEMENT name (a)+ >  子元素a出现一次或多次 
<!ELEMENT name (a)* >  子元素a出现任意次(包括零次、一次及多次) 
<!ELEMENT name (a)? >  子元素a出现一次或不出现 
  • Mixed 混合模式:子元素中既可有文本数据又可有下级子元素。
<!ELEMENT rn (#PCDATA| an | en)*>

       “|”和“”必须写。上句表示在 rn 内,字符数据或en及an,可以出现任意多次,顺序不限。优先写(#PCDATA) 如:(#PCDATA|name) 正确 ,(name|#PCDATA)* 错误。

  • ANY:元素可以包含任何类型的数据。子元素(必须在DTD中有定义)和文本数据(包括空白)。DTD中定义:
<!ELEMENT a ANY> <!ELEMENT b ANY>

       XML中合法内容:

<a>somngthing</a> 
或者
<a/> 
或者 
<a><b>oo</b></a>

       (2)属性(ATTLIST):特定元素类型可设置的属性&属性的允许值声明

<!ATTLIST elementName 
attributeName1 attributeType attributeDefault 
....... 
attributeNameN attributeType attributeDefault> 

       属性类型 (Attribute Type):

  • CDATA :该属性只能包含字符数据(注意与CDATA段、PCDATA的区别) ;
  • NMTOKEN :是CDATA的子集,它的字符只能是字母,数字,句点,破折号,下划线或冒号;
  • NMTOKENS :类似NMTOKEN,但这个可以包含多个值,每个值之间用空格隔开;
  • ID : 该属性的取值在同一文档内是唯一的。一个元素只能有一个ID类型的属性;
  • IDREF :类似指针,指向文档中其他地方声明的ID值。如果该属性取值和指向的ID值不匹配,则返回错误。
  • IDREFS :类似IDREF,但它可以具有由空格分隔开的多个引用;
  • ENTITY: 该属性的值必须对应一个在文档内部声明的但还没有分析过的实体;
  • ENTITYS:类似ENTITY,但它可以包含由空格分隔开的多个实体;
  • NOTATION :该属性的值必须引用在文档中其他地方声明的某个注释的名称;
  • (enumerated) :类似枚举的变量,该属性必须匹配所列的值。各值用“|”分隔开。 如: (春|夏|秋|冬) 实际内容文档只能从中取一个。

       属性特性 (Attribute Default) :

  • #REQUIRED 必须有且只能有一个属性;
  • #IMPLIED 可有可无;
  • #FIXED 在DTD中定义默认值,XML中可以不指定,指定则必须等于该默认值;
  • attribute-value 如果不指定则用DTD定义的默认值,指定则用指定的值。

       属性(ATTLIST)的举例:

       例一(#REQUIRED)

       DTD中:

<!ELEMENT el (#PCDATA)> <!ATTLIST el at1 NMTOKENS #REQUIRED  at2 CDATA #REQUIRED>

       XML中:

正确: <el at1 = "10 20"   at2="10" >something</el> 
错误: <el at="10">something</el>  (没有写另一个#REQUIRED的属性 at2 ) 

       例二(#IMPLIED,#FIXED)

       DTD中:

<!ELEMENT el (#PCDATA)> <!ATTLIST el at CDATA #FIXED "10"  at2 CDATA #IMPLIED >

       XML中:

正确: <el   at2="20" >something</el> (at有默认值"10",at2 可写可不写) 
错误: <el at="11" >something</el>(at要么不写,要写只能写成跟默认值相同的) 

       例三(attribute-value)

       DTD中:

<!ELEMENT el (#PCDATA)> <!ATTLIST el at CDATA "10" at2 CDATA "20" > 

       XML中:

正确: <el at="11" >something</el> 

       例四(enumerated + attribute-value)

       DTD中:

<!ELEMENT el (#PCDATA)> <!ATTLIST el at (10|20|30) "10"> 

       XML中:

正确: <el at="20">something</el>  (at要么不写,默认值 10;要么在(10|20|30)中选一个写)

       (3)实体(ENTITY):可重用的内容声明。

       在DTD中定义

<!ENTITY 实体标志 "实体内容"> 

       在xml中引用自定义的实体,用 &实体标志; 代表实体内容。

       (4)符号(NOTATION) :不要解析的外部内容的格式声明。

内外部的实体举例

       内部实体:在xml文件里面写(少用);
       外部实体:另外在xml同一文件夹下建立一个dtd文件(提倡);

       外部的:

<?xml  version="1.0"  encoding="UTF-8" standalone="no"?> 
<!DOCTYPE root SYSTEM "goodsInfo.dtd"><!--用这句引用外部dtd--> 
<root>
    <goodsInfo> 
        <goodsName>goodsName</goodsName> 
        <goodsPrice>goodsPrice</goodsPrice> 
    </goodsInfo>
</root> 

       以下是名为”goodsInfo.dtd”文件

<!ELEMENT root   (goodsInfo)> 
<!ELEMENT goodsInfo  (goodsName,goodsPrice)> 
<!ELEMENT goodsName  (#PCDATA)> 
<!ELEMENT goodsPrice (#PCDATA)>

       内部的:

<?xml  version="1.0" encodint="utf-8"?> 
<!DOCTYPE root [ 
     <!ELEMENT root(student)> 
     <!ELEMENT student (#PCDATA)> 
     <!ENTITY CCTV  "中央电视台"> 
 ]>   
<!--把DTD文件写在体内--> 
<root>
    <student> 
      student watch &CCTV;<!--使用自定义实体 CCTV--> 
    </student>
</root>

XML Schema

XML Schema介绍

  1. XML Schema用来描述 XML 文档的结构 ,定义XML文档中合法的内容块 ;
  2. XML Schema优于DTD,是DTD的替代品;
  3. XML Schema文件以.xsd作为文件扩展名 ;
  4. XML Schema在2001年5月2日成为W3C标准;
  5. Schema本生也是特殊的XML;

       xsd文档的作用:

  • 定义可出现在文档中的元素;
  • 定义可出现在文档中的属性;
  • 定义哪个元素是子元素;
  • 定义子元素的次序;
  • 定义子元素的数目;
  • 定义元素是否为空,或者是否可包含文本 ;
  • 定义元素和属性的数据类型;
  • 定义元素和属性的默认值以及固定值;

       优点:

  1. XML Schema本身就是一个XML;
  2. XML Schema 支持数据类型;
  3. XML Schema 支持名称空间;
  4. XML Schema 约束能力更强大;

       缺点:XML Schema比DTD更复杂,不能定义实体。

XML Schema文档结构

       简单类型(元素,属性,Facet)、复杂类型元素、匿名类型、外置类型。

<xs:element name=“元素名” type=“元素类型"/>

       Schema内置了很多类型,常用的类型有:

  • xs:string 字符串;
  • xs:decimal 浮点型;
  • xs:integer 整型;
  • xs:boolean 布尔型;
  • xs:date 日期;
  • xs:time 时间;

       xs:是命名空间前缀,元素的默认值用属性default指定,例:

<xs:element name="color" type="xs:string" default="red"/> 

       元素的固定值用属性fixed指定,例:

<xs:element name="color" type="xs:string" fixed="red"/>

       元素出现的次数用属性minOccurs、maxOccurs来表示,默认值为1,unbounded表示不限制次数,例:

<xs:element name="comment" type=“xs:string” minOccurs="0"/> 
<xs:element name="item" type=“xs:string” minOccurs="99"  maxOccurs="unbounded"> 

       属性声明语法:

<xs:attribute name=“属性名” type=“属性类型"/>

       属性声明通常会出现在元素声明中,Schema的内置类型同样对属性类型有效,属性的默认值用属性default指定;

<xs:attribute name=“gender" type="xs:string" default=“male"/>

       属性的固定值用属性fixed指定:

<xs:attribute name=“gender" type="xs:string" fixed=“male"/>

       属性必须或可选性用属性use指定:

<xs:attribute name=“gender" type="xs:string" use=“required"/>

       use属性值的取值有: optional(默认值)(可有可没有), required(必须有), prohibited(禁止,很少用)。

       Facet(刻面):对xml元素或属性的简单数据类型进一步约束

  • 限制字符串的长度, 包括 (length、minLength、maxLength) ;
  • 限制整数的大小范围,包括 (minInclusive, maxInclusive, minExclusive, maxExclusive) ;
  • 限制元素内容的枚举取值(enumeration);
  • 限制浮点型数值的位数(totalDigits, fractionDigits) ;

       定义在下列元素中:

<xs:simpleType> 
  <xs:restriction> 
   (此处写Facet) 
  </xs:restriction>
</xs:simpleType>

       复杂类型元素:包含其他元素和文本或属性的 XML 元素,语法:

使用元素 <xs:complexType/> 来定义

       四种类型的复杂元素:只包含属性、只包含属性和子元素、只包含文本内容和属性、包含属性,子元素和文本内容。

       只包含属性 :

<xs:element name='blank'>  
   <xs:complexType>  
    <xs:attribute name='base' type='xs:integer' use='optional' default='10'/>  
   </xs:complexType>  
</xs:element>

       只包含属性和子元素:

<xs:element name=‘customer'>  
   <xs:complexType>  
    <xs:sequence>  
     <xs:element name=‘favor’ type=‘xs:string’/> 
    </xs:sequence> 
    <xs:attribute name=‘age' type='xs:integer'/>  
  </xs:complexType>  
</xs:element>

       复杂类型元素包含的子元素出现的顺序

<sequence> --- 子元素必须以它们被声明的次序出现 
<choice> --- 子元素是选择关系,只能出现其中一个 
<all> --- 子元素可按任意次序出现 

       只包含文本内容和属性:

<xs:element name='quantity'>  
   <xs:complexType>  
    <xs:simpleContent>  
     <xs:extension base='xs:nonNegativeInteger'>  
     <xs:attribute name='backorderable‘ type='xs:boolean'/>  
     </xs:extension>  
    </xs:simpleContent>  
   </xs:complexType>  
</xs:element>

       包含属性,子元素和文本内容:

<xs:element name="工作经历"> 
   <xs:complexType mixed="true"> 
    <xs:sequence> 
     <xs:element name="year“ type="xs:date"/> 
    </xs:sequence> 
    <xs:attribute name=“title” type=“xs:string”use=“optional”/> 
   </xs:complexType> 
</xs:element> 

       匿名类型定义:

<xs:element name="employee" > 
   <xs:complexType> 
        <xs:sequence> 
        <xs:element name="firstname" type="xs:string"/> 
             <xs:element name="lastname" type="xs:string"/> 
        </xs:sequence> 
   </xs:complexType> 
 </xs:element>

       外置类型定义:

<xs:element name="employee" type=“emptype”/> 
  <xs:complexType name=“emptype”>   //必须定义在根元素中 
   <xs:sequence> 
    <xs:element name="firstname" type="xs:string"/> 
    <xs:element name="lastname" type="xs:string"/> 
   </xs:sequence> 
 </xs:complexType>

XML Schema 验证

       Schema文件:

<?xml version="1.0"?> 
  <xs:schema  xmlns:xs="http://www.w3.org/2001/XMLSchema"    
   xmlns:xs="http://www.w3.org/2001/XMLSchema" //必须且固定(名字xs 可改变) 
   targetNamespace=" www.tarena.com.cn" 
   xmlns="http://www.tarena.com.cn"  
   elementFormDefault="qualified" />
  1. XML Schema 文件的根元素一定是<.schema>;

  2. xmlns:xs=”http://www.w3.org/2001/XMLSchema”:指明schema 中用到的元素和数据类型来自的命名空间为“http://www.w3.org/2001/XMLSchema” ,xs为自定义的前缀名。

  3. targetNamespace=”http://www.tarena.com.cn”:目标命名空间。用于指明此 xsd文档 约束的xml文件中元素 (note, to, from, heading, body) 的命名空间;

  4. xmlns=”http://www.tarena.com.cn”: XSD也是一个XML文档, schema文档中默认的命名空间是 “http:// www.tarena.com.cn ” ;

  5. elementFormDefault=”qualified“:Schema中定义的元素在xml中使用时,必须被命名空间限定。

       受约束的XML文件:

<?xml version="1.0"?> 
 <note xmlns="http://www.tarena.com.cn" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://www.tarena.com.cn  note.xsd" /> 
  1. xmlns=”http://www.tarena.com.cn”:缺省命名空间的声明。此声明会告知 schema 验证器,在此 XML 文档中使用的元素默认都被声明于 “http://www.tarena.com.cn” 这个命名空间。

  2. xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://www.tarena.com.cn note.xsd” /> :指定xsd的物理位置,前半部分是名称空间,后半部分参数是物理位置。使用的属性schemaLocation需要指定其所在的命名空间。

利用Java代码解析XML文档

解析方式

  1. DOM:Document Object Model,文档对象模型。这种方式是W3C推荐的处理XML的一种标准方式。

  2. SAX:Simple API for XML。这种方式不是官方标准,属于开源社区XML-DEV,几乎所有的XML解析器都支持它。

       DOM与SAX比较:

  • DOM解析:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的,这种结构占用的内存较多,而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问。优点:提供随机定义元素操作,来回移动指针、将整个XML文件一次性加载到内存,形成虚的内存树;缺点:如果XML文件较大,内存空间占用较大、强制将较大的XML文件加载到内存中,有可能损害文件。

  • SAX解析:不同于DOM,SAX是事件驱动型的XML解析方式。它顺序逐行读取XML文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个事件,用户通过在其回调事件中写入处理代码来处理XML文件,适合对XML的顺序访问。

解析工具

  1. JAXP:DOM或SAX方式进行解析XML。API在JDK之中;

  2. JDom::JDOM是一个开源项目,它基于树型结构,利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。(http://jdom.org),JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性(方法重载、集合概念等),把SAX和DOM的功能有效地结合起来。JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下,这些API函数被最大限度的优化。

  3. Dom4J(推荐):dom4j是目前在xml解析方面是最优秀的(Hibernate、Sun的JAXM也都使用dom4j来解析XML),它合并了许多超出基本 XML 文档表示的功能,包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。

JAXP-DOM解析

       Java代码

import java.io.File;  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.NodeList;  
public class DomTest1 {  
    public static void main(String[] args) throws Exception {  
        // step 1: 获得dom解析器工厂(工作的作用是用于创建具体的解析器)  
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
        //System.out.println("class name: " + dbf.getClass().getName());  
        // step 2:获得具体的dom解析器  
        DocumentBuilder db = dbf.newDocumentBuilder();  
        //System.out.println("class name: " + db.getClass().getName());  
        // step3: 解析一个xml文档,获得Document对象(根结点)  
        Document document = db.parse(new File("candidate.xml"));  
        NodeList list = document.getElementsByTagName("PERSON");  
        for(int i = 0; i < list.getLength(); i++) {  
           Element element = (Element)list.item(i);  
           String content = element.getElementsByTagName("NAME")
                                   .item(0).getFirstChild().getNodeValue(); 
           System.out.println("name:" + content);  
           content = element.getElementsByTagName("ADDRESS")
                            .item(0).getFirstChild().getNodeValue();  
           System.out.println("address:" + content);  
           content = element.getElementsByTagName("TEL")
                            .item(0).getFirstChild().getNodeValue();  
           System.out.println("tel:" + content);  
           content = element.getElementsByTagName("FAX")
                            .item(0).getFirstChild().getNodeValue();  
           System.out.println("fax:" + content);  
           content = element.getElementsByTagName("EMAIL")
                            .item(0).getFirstChild().getNodeValue(); 
           System.out.println("email:" + content);  
           System.out.println("--------------------------------------");  
         }  
     }  
}  
import java.io.File;  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import org.w3c.dom.Attr;  
import org.w3c.dom.Comment;  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.NamedNodeMap;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
/** 
 * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上 
 * @author 
 */  
public class DomTest3 {  
    public static void main(String[] args) throws Exception {  
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
        DocumentBuilder db = dbf.newDocumentBuilder();  
        Document doc = db.parse(new File("student.xml"));  
        //获得根元素结点  
        Element root = doc.getDocumentElement();  
        parseElement(root);  
    }  
    private static void parseElement(Element element){  
        String tagName = element.getNodeName();  
        NodeList children = element.getChildNodes();  
        System.out.print("<" + tagName);  
        //element元素的所有属性所构成的NamedNodeMap对象,需要对其进行判断  
        NamedNodeMap map = element.getAttributes();  
        //如果该元素存在属性  
        if(null != map){  
            for(int i = 0; i < map.getLength(); i++){  
                //获得该元素的每一个属性  
                Attr attr = (Attr)map.item(i);  
                String attrName = attr.getName();  
                String attrValue = attr.getValue();  
                System.out.print(" " + attrName + "=\"" + attrValue + "\"");  
            }  
        }  
        System.out.print(">");  
        for(int i = 0; i < children.getLength(); i++){  
            Node node = children.item(i);  
            //获得结点的类型  
            short nodeType = node.getNodeType();  
            if(nodeType == Node.ELEMENT_NODE){  
                //是元素,继续递归  
                parseElement((Element)node);  
            } else if(nodeType == Node.TEXT_NODE){  
                //递归出口  
                System.out.print(node.getNodeValue());  
            }  
            else if(nodeType == Node.COMMENT_NODE){  
                System.out.print("<!--");  
                Comment comment = (Comment)node;  
                //注释内容  
                String data = comment.getData();  
                System.out.print(data);  
                System.out.print("-->");  
            }  
        }  
        System.out.print("</" + tagName + ">");  
    }  
}  

JAXP-SAX解析

       Java代码

import java.io.File;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
import org.xml.sax.Attributes;  
import org.xml.sax.SAXException;  
import org.xml.sax.helpers.DefaultHandler;  
public class SaxTest1{  
    public static void main(String[] args) throws Exception {  
        //step1: 获得SAX解析器工厂实例  
        SAXParserFactory factory = SAXParserFactory.newInstance();  
        //step2: 获得SAX解析器实例  
        SAXParser parser = factory.newSAXParser();  
        //step3: 开始进行解析  
        parser.parse(new File("student.xml"), new MyHandler());  
    }  
}  
class MyHandler extends DefaultHandler {  
    @Override  
    public void startDocument() throws SAXException {  
        System.out.println("parse began");  
    }  
    @Override  
    public void endDocument() throws SAXException {  
        System.out.println("parse finished");  
    }  
    @Override  
    public void startElement(String uri, String localName, String qName,  
            Attributes attributes) throws SAXException {  
        System.out.println("start element");  
    }  
    @Override  
    public void endElement(String uri, String localName, String qName)  
            throws SAXException {  
        System.out.println("finish element");  
    }  
}  
import java.io.File;  
import java.util.Stack;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
import org.xml.sax.Attributes;  
import org.xml.sax.SAXException;  
import org.xml.sax.helpers.DefaultHandler;  
public class SaxTest2 {  
    public static void main(String[] args) throws Exception  {  
        SAXParserFactory factory = SAXParserFactory.newInstance();  
        SAXParser parser = factory.newSAXParser();  
        parser.parse(new File("student.xml"), new MyHandler2());  
    }  
}  
class MyHandler2 extends DefaultHandler {  
    private Stack<String> stack = new Stack<String>();  
    private String name;  
    private String gender;  
    private String age;  
    @Override  
    public void startElement(String uri, String localName, String qName,  
            Attributes attributes) throws SAXException {  
        stack.push(qName);  
        for(int i = 0; i < attributes.getLength(); i++)  
        {  
            String attrName = attributes.getQName(i);  
            String attrValue = attributes.getValue(i);  
            System.out.println(attrName + "=" + attrValue);  
        }  
    }  
    @Override  
    public void characters(char[] ch, int start, int length)  
            throws SAXException {  
        String tag = stack.peek();  
        if("姓名".equals(tag))  {  
            name = new String(ch, start,length);  
        } else if("性别".equals(tag)){  
            gender = new String(ch, start, length);  
        } else if("年龄".equals(tag)){  
            age = new String(ch, start, length);  
        }  
    }  
    @Override  
    public void endElement(String uri, String localName, String qName)  
            throws SAXException {  
        stack.pop(); //表示该元素已经解析完毕,需要从栈中弹出  
        if("学生".equals(qName)){  
            System.out.println("姓名:" + name);  
            System.out.println("性别:" + gender);  
            System.out.println("年龄:" + age);  
            System.out.println();  
        }    
    }  
}  

JDOM解析

       Java代码:JDOM创建xml

import java.io.FileWriter;  
import org.jdom.Attribute;  
import org.jdom.Comment;  
import org.jdom.Document;  
import org.jdom.Element;  
import org.jdom.output.Format;  
import org.jdom.output.XMLOutputter;  
public class JDomTest1{  
    public static void main(String[] args) throws Exception {  
        Document document = new Document();  
        Element root = new Element("root");  
        document.addContent(root);  
        Comment comment = new Comment("This is my comments");  
        root.addContent(comment); 
        Element e = new Element("hello");  
        e.setAttribute("sohu", "www.sohu.com");  
        root.addContent(e);  
        Element e2 = new Element("world");  
        Attribute attr = new Attribute("test", "hehe");  
        e2.setAttribute(attr);  
        e.addContent(e2); 
        e2.addContent(new Element("aaa").setAttribute("a", "b")  
            .setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));  
        Format format = Format.getPrettyFormat(); 
        format.setIndent("    ");  
//      format.setEncoding("gbk");  
        XMLOutputter out = new XMLOutputter(format);  
        out.output(document, new FileWriter("jdom.xml"));  
    }  
}  

       Java代码:JDOM解析xml

import java.io.File;  
import java.io.FileOutputStream;  
import java.util.List;  
import org.jdom.Attribute;  
import org.jdom.Document;  
import org.jdom.Element;  
import org.jdom.input.SAXBuilder;  
import org.jdom.output.Format;  
import org.jdom.output.XMLOutputter; 
public class JDomTest2 {  
    public static void main(String[] args) throws Exception  {  
        SAXBuilder builder = new SAXBuilder();  
        Document doc = builder.build(new File("jdom.xml"));  
        Element element = doc.getRootElement();  
        System.out.println(element.getName());  
        Element hello = element.getChild("hello");  
        System.out.println(hello.getText());  
        List list = hello.getAttributes();  
        for(int i = 0 ;i < list.size(); i++) {  
            Attribute attr = (Attribute)list.get(i); 
            String attrName = attr.getName();  
            String attrValue = attr.getValue();  
            System.out.println(attrName + "=" + attrValue);  
        }  
        hello.removeChild("world");  
        XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent("    "));  
        out.output(doc, new FileOutputStream("jdom2.xml"));       
    }  
}  

DOM4J解析(推荐,开发常用)

       Java代码:DOM4J解析XML单元测试

package com.study.xml.junit;

import java.io.FileOutputStream;
import java.io.OutputStream;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

/**
* @Name: DOM4JTest
* @Description: 使用DOM4J解析XML测试类
* @Author: XXX
* @CreateDate: XXX 
* @Version: V1.0
 */
public class DOM4JTest {

    /**
    * @Name: writeXML2Console
    * @Description: 将指定XML文件中的内容打印到控制台
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void writeXML2Console() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        XMLWriter writer = new XMLWriter(System.out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: findElementContent
    * @Description: 得到某个具体节点的内容
    * 例如:
    *   得到第二本书节点中的售价节点的内容
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void findElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element salePrice = secondBook.element("售价") ;
        System.out.println(salePrice.getUniquePath() + "[" + salePrice.getText() + "]");
    }

    /**
    * @Name: iteratorAllElement
    * @Description: 遍历所有元素节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void iteratorAllElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        treeWalk(rootElement) ;
    }

    private void treeWalk(Element element) {
        System.out.println(element.getName());
        for (int i = 0; i < element.nodeCount(); i++) {
            Node node = element.node(i) ;
            if(node instanceof Element) {
                treeWalk((Element) node) ;
            }
        }
    }

    /**
    * @Name: updateElementContent
    * @Description: 修改某个元素节点下的内容
    * 例如:
    *   修改第二本书节点下售价节点的内容为300
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void updateElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element salePrice = secondBook.element("售价") ;
        salePrice.setText("300") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: addChildElement
    * @Description: 向指定元素节点增加子节点
    * 例如:
    *   在第二本书节点下增加内部价:<批发价 id="p2" name="pfj">800</批发价>  
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addChildElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        secondBook.addElement("批发价")
            .addAttribute("id", "p2")
            .addAttribute("name", "pfj")
            .addText("800") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: addSameLevelElement
    * @Description: 向指定元素节点下增加同级元素节点
    * 例如:
    *   向第二本书节点的售价前增加内部价<内部价>200</内部价>
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addSameLevelElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element innerPrice = DocumentHelper.createElement("内部价") ;
        innerPrice.addText("200") ;
        secondBook.elements().add(2, innerPrice) ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: deleteElement
    * @Description: 删除指定元素节点:
    * 例如:
    *   删除第二本书节点下的批发价节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void deleteElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element pfj = secondBook.element("批发价") ;
        secondBook.remove(pfj) ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: opeElementAttribute
    * @Description: 操作节点属性
    * 例如:
    *   添加:向第二本书节点上添加属性:bookid="a2"
    *   删除:删除第二本书节点中批发价节点的name属性
    *   修改:将第三本书节点的id属性改为:bookid="a33"
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void opeElementAttribute() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        //向第二本书节点上添加属性:bookid="a2"
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        secondBook.addAttribute("bookid", "a2") ;
        //删除批发价中的name属性
        Element pfj = secondBook.element("批发价") ;
        Attribute name = pfj.attribute("name") ;
        pfj.remove(name) ;
        //将第三本书节点的id属性改为:bookid="a33"
        Element thridBook = (Element) rootElement.elements("书").get(2) ;
        thridBook.setAttributeValue("bookid", "a33") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }
}

补充:Xpath介绍

       百度百科解释:

XPath即为XML路径语言,它是一种用来确定XML(标准通用标记语言的子集)文档中某部分位置的语言。XPath基于XML的树状结构,提供在数据结构树中找寻节点的能力。起初 XPath 的提出的初衷是将其作为一个通用的、介于XPointer与XSLT间的语法模型。但是 XPath 很快的被开发者采用来当作小型查询语言。

       XPath是一个努力为XSL转换XSLT和XPointer之间共享一个共同的XPointer功能语法和语义的结果。它的主要目的是解决一个XML XML文档部分[ ]。为了支持这一功能,还提供用于处理字符串的基本设施、数字和布尔值。XPath使用一个紧凑的、非XML语法方便使用在uri和XML属性值的XPath。XPath操作基于XML文档的逻辑结构,而不是其表面的语法。Xpath的名字来自其使用的符号在URL路径通过一个XML文档的层次结构导航。 除了用于定位,XPath还设计有一个真子集,可用于匹配(测试一个节点是否符合一个模式);使用XPath进行XSLT。

       XPath模型的XML文档的节点树。有不同类型的节点,包括元素节点、属性节点和文本节点。XPath定义了一个方法来计算每个节点类型字符串值。某些类型的节点也有名字。XPath完全支持XML命名空间的XML名称。因此,一个节点的名称被建模为一个地方的部分和一个可能的空命名空间URI;这就是所谓的扩展名。

       Java代码:DOM4J+XPATH解析XML文件

package com.study.xml.junit;

import java.io.FileOutputStream;
import java.io.OutputStream;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.XPath;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

import com.study.xml.utils.DOM4JUtils;

/**
* @Name: DOM4JXpathTest
* @Description: 使用DOM4J解析XML测试类,使用Xpath语法定位元素位置
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class DOM4JXpathTest {

    /**
    * @Name: writeXML2Console
    * @Description: 将指定XML文件中的内容打印到控制台
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void writeXML2Console() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        XMLWriter writer = new XMLWriter(System.out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: findElementContent
    * @Description: 得到某个具体节点的内容
    * 例如:
    *   得到第二本书节点中的售价节点的内容
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void findElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Node salePrice = document.selectSingleNode("/书架/书[2]/售价") ;
        System.out.println(salePrice.getUniquePath() + "[" + salePrice.getText() + "]");
    }

    /**
    * @Name: iteratorAllElement
    * @Description: 遍历所有元素节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void iteratorAllElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        treeWalk(rootElement) ;
    }

    private void treeWalk(Element element) {
        System.out.println(element.getName());
        for (int i = 0; i < element.nodeCount(); i++) {
            Node node = element.node(i) ;
            if(node instanceof Element) {
                treeWalk((Element) node) ;
            }
        }
    }

    /**
    * @Name: updateElementContent
    * @Description: 修改某个元素节点下的内容
    * 例如:
    *   修改第二本书节点下售价节点的内容为300
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void updateElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element salePrice = (Element) document.selectSingleNode("/书架/书[2]/售价") ;
        salePrice.setText("300") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: addChildElement
    * @Description: 向指定元素节点增加子节点
    * 例如:
    *   向第二本书节点的售价前增加内部价:<批发价 id="p2" name="pfj">800</批发价>  
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addChildElement() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        Element secondBook = (Element) document.selectSingleNode("//书[2]") ;
        secondBook.addElement("批发价")
            .addAttribute("id", "p2")
            .addAttribute("name", "pfj")
            .addText("800") ;
        DOM4JUtils.writeBackXml(document, url) ;
    }

    /**
    * @Name: addSameLevelElement
    * @Description: 向指定元素节点下增加同级元素节点
    * 例如:
    *   向第二本书节点的售价前增加内部价<内部价>200</内部价>
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addSameLevelElement() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        Element secondBook = (Element) document.selectSingleNode("/书架/书[2]") ;
        Element innerPrice = DocumentHelper.createElement("内部价") ;
        innerPrice.addText("200") ;
        //向第二本书节点的售价前增加内部价<内部价>200</内部价>
        secondBook.elements().add(2, innerPrice) ;
        DOM4JUtils.writeBackXml(document, url) ;
    }

    /**
    * @Name: deleteElement
    * @Description: 删除指定元素节点:
    * 例如:
    *   删除第二本书节点下的批发价节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void deleteElement() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        Element secondBook = (Element) document.selectSingleNode("/书架/书[2]") ;
        Element pfj = secondBook.element("批发价") ;
        //删除第二本书节点下的批发价节点
        secondBook.remove(pfj) ;
        DOM4JUtils.writeBackXml(document, url) ;
    }

    /**
    * @Name: opeElementAttribute
    * @Description: 操作节点属性
    * 例如:
    *   添加:向第二本书节点上添加属性:bookid="a2"
    *   删除:删除第二本书节点中批发价节点的name属性
    *   修改:将第三本书节点的id属性改为:bookid="a33"
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void opeElementAttribute() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        //向第二本书节点上添加属性:bookid="a2"
        Element secondBook = (Element) document.selectSingleNode("//书[2]") ;
        secondBook.addAttribute("bookid", "a2") ;
        //删除批发价中的name属性
        Element pfj = secondBook.element("批发价") ;
        Attribute name = pfj.attribute("name") ;
        pfj.remove(name) ;
        //将第三本书节点的id属性改为:bookid="a33"
        Element thridBook = (Element) document.selectSingleNode("//书[3]") ;
        thridBook.setAttributeValue("bookid", "a33") ;
        DOM4JUtils.writeBackXml(document, url) ;
    }


}

项目练习

项目介绍

       使用DOM4J+XPATH解析XML实践:使用XML实现数据存储,将页面用户提交的数据存储到xml进行持久化,按照分层设计思想,使用Jsp+Servlet实现简单的用户注册系统。

前期准备

(1)导入依赖包:dom4j-1.6.1.jar、jaxen-1.1-beta-6.jar、commons-beanutils-1.8.3.jar、commons-logging-1.1.1.jar。

(2)编写xml文件:users.xml

<?xml version="1.0" encoding="UTF-8"?>
<users>
    <user username="admin" password="admin" birthday="2016-01-12" email="123@123.com"/>
    <user username="test01" password="test01" birthday="2016-01-12" email="123@123.com"/>
    <user username="test02" password="test02" birthday="2016-01-12" email="123@123.com"/>
</users>

(3)创建JavaBean:User.java

       说明:JavaBean中的属性与xml文件中user节点的属性名称保持一致,以便将JavaBean属性值传入xml文档进行存储。

package com.study.java.domain;

import java.io.Serializable;
import java.util.Date;

/**
* @Name: User
* @Description: PO类:用户信息类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class User implements Serializable {

    private static final long serialVersionUID = 5274992031371114394L;

    private String username ;
    private String password ;
    private Date birthday ;
    private String email ;

    public User() {}

    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 getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password
                + ", birthday=" + birthday + ", email=" + email + "]";
    }
}

编写工具类

       (1)编写DOM4JUtils工具类

package com.study.java.utils;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.URL;

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

/**
* @Name: DOM4JUtils
* @Description: XML-DOM4J解析工具包
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class DOM4JUtils {

    private static String XMLPATH = "users.xml" ;

    static {
        ClassLoader loader = DOM4JUtils.class.getClassLoader() ;
        URL url = loader.getResource(XMLPATH) ;
        XMLPATH = url.getPath() ;
    }

    /**
    * @Name: getDocument
    * @Description: 获取xml-Document对象
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Return: Document
     */
    public static Document getDocument() {
        Document document = null ;
        try {
            SAXReader reader = new SAXReader() ;
            document = reader.read(XMLPATH) ;
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return document ;
    }

    /**
    * @Name: writeXML
    * @Description: 将内存中的xml数据写入到xml文件中
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param document
    * @Return: void
     */
    public static void writeXML(Document document) {
        OutputStream out = null ;
        OutputFormat format = null ;
        XMLWriter writer = null ;
        try {
            out = new FileOutputStream(XMLPATH) ;
            format = OutputFormat.createPrettyPrint() ;
            format.setEncoding("UTF-8") ;
            writer = new XMLWriter(out, format) ;
            writer.write(document) ;
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        } finally {
            if(writer != null) {
                try {
                    writer.close() ;
                } catch (Exception e) {
                    e.printStackTrace() ;
                } finally {
                    writer = null ;
                }
            }
            if(out != null) {
                try {
                    out.close() ;
                } catch (Exception e) {
                    e.printStackTrace() ;
                } finally {
                    out = null ;
                }
            }
        }
    }
}

       (2)编写日期格式处理工具类:DateConverterUtils.java

package com.study.java.utils;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
* @Name: DateConverterUtils
* @Description: 日期-字符串转换工具类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class DateConverterUtils {

    private static final String FORMAT = "yyyy-MM-dd" ;
    private static SimpleDateFormat sdf = null ;

    static {
        sdf = new SimpleDateFormat(FORMAT) ;
    }

    /**
    * @Name: parse
    * @Description: 将给定的字符串转换成日期类型
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param str
    * @Return: Date
     */
    public static Date parse(String str) {
        Date date = null ;
        try {
            date = sdf.parse(str) ;
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }
        return date ;
    }

    /**
    * @Name: format
    * @Description: 格式化日期类型到字符串
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param date
    * @Return: String
     */
    public static String format(Date date) {
        String result = null ;
        try {
            result = sdf.format(date) ;
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }
        return result ;
    }
}

DAO层开发

       (1)开发UserDao接口

package com.study.java.dao;

import com.study.java.domain.User;

/**
* @Name: UserDao
* @Description: 用户信息操作DAO接口
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public interface UserDao {

    /**
    * @Name: getUserByUsername
    * @Description: 根据用户名获取用户信息
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param username
    * @Return: User
     */
    User getUserByUsername(String username) ;

    /**
    * @Name: getUserByUsernameAndPassword
    * @Description: 根据用户名和密码获取用户信息
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param username
    * @Parameters: @param password
    * @Return: User
     */
    User getUserByUsernameAndPassword(String username, String password) ;

    /**
    * @Name: addUser
    * @Description: 添加用户信息到xml
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param user
    * @Return: void
     */
    void addUser(User user) ;
}

       (2)开发UserDao接口实现类(练习重点:使用XML解析技术实现数据的存储和读取)

package com.study.java.dao.impl;

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

import com.study.java.dao.UserDao;
import com.study.java.domain.User;
import com.study.java.utils.DOM4JUtils;
import com.study.java.utils.DateConverterUtils;

/**
* @Name: UserDaoImpl
* @Description: 用户信息操作DAO接口实现类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class UserDaoImpl implements UserDao {

    public User getUserByUsername(String username) {
        User user = null ;
        //1、获取domcument对象
        Document document = DOM4JUtils.getDocument() ;
        //2、使用xpath获取指定的user节点元素
        Element userElement = (Element) document
            .selectSingleNode("//user[@username='"+ username +"']") ;
        if(userElement != null) {
            //3、将获取到的user节点元素中的属性值放入到user-bean中
            user = new User() ;
            user.setUsername(userElement.valueOf("@username")) ;
            user.setPassword(userElement.valueOf("@password")) ;
            //将字符串转换成日期类型
            user.setBirthday(DateConverterUtils
                .parse(userElement.valueOf("@birthday"))) ;
            user.setEmail(userElement.valueOf("@email")) ;
        }
        //4、返回查询结果
        return user;
    }

    public User getUserByUsernameAndPassword(String username, String password) {
        User user = null ;
        //1、获取domcument对象
        Document document = DOM4JUtils.getDocument() ;
        //2、使用xpath获取指定的user节点元素
        Element userElement = (Element) document
            .selectSingleNode("//user[@username='"+ username 
            + "' and @password='"+ password +"']") ;
        if(userElement != null) {
            //3、将获取到的user节点元素中的属性值放入到user-bean中
            user = new User() ;
            user.setUsername(userElement.valueOf("@username")) ;
            user.setPassword(userElement.valueOf("@password")) ;
            //将字符串转换成日期类型
            user.setBirthday(DateConverterUtils
                .parse(userElement.valueOf("@birthday"))) ;
            user.setEmail(userElement.valueOf("@email")) ;
        }
        //4、返回查询结果
        return user;
    }

    public void addUser(User user) {
        //1、获取document对象
        Document document = DOM4JUtils.getDocument() ;
        //2、获取根节点元素
        Element rootElement = document.getRootElement() ;
        //3、创建新user节点元素,将user-bean中的属性值设置到user节点的属性中
        Element newUserElement = DocumentHelper.createElement("user") ;
        newUserElement.addAttribute("username", user.getUsername()) ;
        newUserElement.addAttribute("password", user.getPassword()) ;
        newUserElement.addAttribute("birthday", DateConverterUtils.format(user.getBirthday())) ;
        newUserElement.addAttribute("email", user.getEmail()) ;
        //4、加入新节点
        rootElement.add(newUserElement) ;
        //5、写回到xml
        DOM4JUtils.writeXML(document) ;
    }
}

Service层开发

       (1)开发UserService接口

package com.study.java.service;

import com.study.java.domain.User;

/**
* @Name: UserService
* @Description: 用户信息操作Service接口
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public interface UserService {

    /**
    * @Name: login
    * @Description: 登录操作
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param username
    * @Parameters: @param password
    * @Return: User
     */
    User login(String username, String password) ;

    /**
    * @Name: register
    * @Description: 注册操作
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param user
    * @Return: boolean
     */
    boolean register(User user) ;
}

       (2)开发UserService接口实现类

package com.study.java.service.impl;

import com.study.java.dao.UserDao;
import com.study.java.dao.impl.UserDaoImpl;
import com.study.java.domain.User;
import com.study.java.service.UserService;

/**
* @Name: UserServiceImpl
* @Description: 用户信息操作Service接口实现类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao = new UserDaoImpl() ;

    public User login(String username, String password) {
        User user = null ;
        try {
            user = userDao.getUserByUsernameAndPassword(username, password) ;
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        return user;
    }

    public boolean register(User user) {
        //判断用户名是否已经存在
        User u = userDao.getUserByUsername(user.getUsername()) ;
        if(u == null) {
            userDao.addUser(user) ;
            return true ;
        }
        return false;
    }
}

控制层开发

       (1)编写WebFormBean:UserFormBean.java

package com.study.java.web.bean;

import java.util.HashMap;
import java.util.Map;

import com.study.java.utils.DateConverterUtils;

/**
* @Name: UserFormBean
* @Description: 表单VO类:用户表单信息类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class UserFormBean {

    private String username ;
    private String password ;
    private String repassword ;
    private String birthday ;
    private String email ;
    //校验错误信息集合
    private Map<String, String> errorMsg = new HashMap<String, String>() ;

    public UserFormBean() {}

    /**
    * @Name: validate
    * @Description: 校验注册字段格式
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    public boolean validate() {

        if(username == null || "".equals(username.toString().trim())) {
            errorMsg.put("username", "用户名不能为空!") ;
        } else {
            if(!username.matches("^[a-zA-Z]{3,8}$")) {
                errorMsg.put("username", "用户名必须为3-8位的字母!") ;
            }
        }

        if(password == null || "".equals(password)) {
            errorMsg.put("password", "密码不能为空!") ;
        } else {
            if(!password.matches("^[a-zA-Z]{3,8}$")) {
                errorMsg.put("password", "密码必须为3-8位的字母!") ;
            }
        }

        if(!repassword.equals(password)) {
            errorMsg.put("repassword", "与原密码输入不一致!") ;
        }

        if(birthday == null || "".equals(birthday)) {
            errorMsg.put("birthday", "出生年月不能为空!") ;
        } else {
            try {
                DateConverterUtils.parse(birthday) ;
            } catch (Exception e) {
                errorMsg.put("birthday", "输入格式(yyyy-MM-dd)不正确!") ;
            }
        }
        if(email == null || "".equals(email)) {
            errorMsg.put("email", "邮箱不能为空!") ;
        } else {
            if(!email.matches("\\b^['_a-z0-9-\\+]+(\\.['_a-z0-9-\\+]+)*@[a-z0-9-]+(\\.[a-z0-9-]+)*\\.([a-z]{2}|aero|arpa|asia|biz|com|coop|edu|gov|info|int|jobs|mil|mobi|museum|name|nato|net|org|pro|tel|travel|xxx)$\\b")) {
                errorMsg.put("email", "邮箱格式错误!") ;
            }
        }

        return errorMsg.isEmpty() ;
    }

    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 String getRepassword() {
        return repassword;
    }
    public void setRepassword(String repassword) {
        this.repassword = repassword;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }

    public Map<String, String> getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(Map<String, String> errorMsg) {
        this.errorMsg = errorMsg;
    }
}

       (2)开发前端控制器:ControllerServlet.java

package com.study.java.web.controller;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.study.java.domain.User;
import com.study.java.service.UserService;
import com.study.java.service.impl.UserServiceImpl;
import com.study.java.utils.WebUtils;
import com.study.java.web.bean.UserFormBean;

/**
* @Name: ControllerServlet
* @Description: 用户操作控制器
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class ControllerServlet extends HttpServlet {

    private UserService userService = new UserServiceImpl() ;

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String operate = request.getParameter("op") ;
        if("logout".equals(operate)) {
            logout(request, response) ;
        }
        if("login".equals(operate)) {
            login(request, response) ;      
        }
        if("register".equals(operate)) {
            register(request, response) ;
        }
    }

    /**
    * @Name: register
    * @Description: 注册
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param request
    * @Parameters: @param response
    * @Parameters: @throws ServletException
    * @Parameters: @throws IOException
    * @Return: void
     */
    private void register(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8") ;
        PrintWriter out = response.getWriter() ;
        //获取表单Bean实例对象
        UserFormBean userFormBean = WebUtils.fillBean(request, UserFormBean.class) ;
        //对页面表单中输入的字段格式进行校验
        if(!userFormBean.validate()) {
            request.setAttribute("userFormBean", userFormBean) ;
            request.getRequestDispatcher("/jsp/register.jsp").forward(request, response) ;
            return ;
        } 
        //对象拷贝:UserFormBean -> UserBean
        User user = WebUtils.copyProperties(User.class, userFormBean) ;
        //注册,保存到xml
        boolean result = userService.register(user) ;
        if(result) {
            //将用户信息保存到session
            HttpSession session = request.getSession() ;
            session.setAttribute("user", user) ;
            out.write("注册成功,2秒后跳转到系统首页!!!") ;
            response.setHeader("Refresh", "2;URL=" + request.getContextPath()) ;
        } else {
            userFormBean.getErrorMsg().put("username", "用户名已存在!") ;
            request.setAttribute("userFormBean", userFormBean) ;
            request.getRequestDispatcher("/jsp/register.jsp").forward(request, response) ;
        }
    }

    /**
    * @Name: login
    * @Description: 登录
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param request
    * @Parameters: @param response
    * @Parameters: @throws ServletException
    * @Parameters: @throws IOException
    * @Return: void
     */
    private void login(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8") ;
        PrintWriter out = response.getWriter() ;
        //获取页面请求参数
        request.setCharacterEncoding("UTF-8") ; //设置请求参数内容编码,适用于post提交
        String username = request.getParameter("username") ;
        String password = request.getParameter("password") ;
        User user = userService.login(username, password) ;
        if(user != null) {
            HttpSession session = request.getSession() ;
            session.setAttribute("user", user) ;
            out.write("登录成功,2秒后跳转到系统首页!!!") ;
            response.setHeader("Refresh", "2;URL=" + request.getContextPath()) ;
        } else {
            out.write("用户名或密码错误,登录失败,请重新登录!!!") ;
            response.setHeader("Refresh", "2;URL=" + request.getContextPath() + "/jsp/login.jsp") ;
        }
    }

    /**
    * @Name: logout
    * @Description: 注销
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param request
    * @Parameters: @param response
    * @Parameters: @throws ServletException
    * @Parameters: @throws IOException
    * @Return: void
     */
    private void logout(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8") ;
        PrintWriter out = response.getWriter() ;
        HttpSession session = request.getSession() ;
        session.removeAttribute("user") ;
        out.write("注销成功,2秒后跳转到系统首页!!!") ;
        response.setHeader("Refresh", "2;URL=" + request.getContextPath()) ;
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.doGet(request, response);
    }
}

       (3)配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <display-name></display-name>
  <servlet>
    <servlet-name>ControllerServlet</servlet-name>
    <servlet-class>com.study.java.web.controller.ControllerServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/servlet/ControllerServlet</url-pattern>
  </servlet-mapping>    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

视图层开发

       (1)系统首页:index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>首页</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
  </head>

  <body>
    <h1>练习项目</h1>
    <hr/>
    <c:choose>
        <c:when test="${sessionScope.user == null }">
            <a href="${pageContext.request.contextPath }/jsp/register.jsp">注册</a>
            &nbsp;&nbsp;&nbsp;&nbsp;
            <a href="${pageContext.request.contextPath }/jsp/login.jsp">登录</a>
        </c:when>
        <c:otherwise>
            欢迎您!!!${sessionScope.user.username }
            &nbsp;&nbsp;&nbsp;&nbsp;
            <a href="${pageContext.request.contextPath }/servlet/ControllerServlet?op=logout">注销</a>
        </c:otherwise>
    </c:choose>
  </body>
</html>

       (2)登录页面:login.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>登录</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
      </head>
  <body>
    <form action="${pageContext.request.contextPath }/servlet/ControllerServlet?op=login" method="post">
        用户名:<input type="text" name="username"/><br/>
        密&nbsp;&nbsp;&nbsp;码:<input type="password" name="password"/><br>
        <input type="submit" value="登录"/>
    </form>
  </body>
</html>

       (3)注册页面:register.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>注册</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">  
    <script type="text/javascript" 
        src="${pageContext.request.contextPath }/js/Birthday-Calendar.js" ></script>  
  </head>
  <body>
    <form action="${pageContext.request.contextPath }/servlet/ControllerServlet?
                                                        op=register" method="post">
        <table border="1" align="center">
            <tr>
                <td>用户名:</td>
                <td>
                    <input type="text" name="username" 
                           value="${userFormBean.username }">
                    ${userFormBean.errorMsg.username }
                </td>
            </tr>
            <tr>
                <td>密&nbsp;&nbsp;&nbsp;码:</td>
                <td>
                    <input type="password" name="password" 
                    value="${userFormBean.password }">
                    ${userFormBean.errorMsg.password }
                </td>
            </tr>
            <tr>
                <td>确认密码:</td>
                <td>
                    <input type="password" name="repassword" 
                    value="${userFormBean.repassword }">
                </td>
            </tr>
            <tr>
                <td>出生年月:</td>
                <td>
                    <input type="text" name="birthday" 
                    onclick="new Calendar().show(this);" readonly="readonly">
                    ${userFormBean.errorMsg.birthday }
                </td>
            </tr>
            <tr>
                <td>邮&nbsp;&nbsp;&nbsp;箱:</td>
                <td>
                    <input type="text" name="email" 
                    value="${userFormBean.email }">
                    ${userFormBean.errorMsg.email }
                </td>
            </tr>
            <tr>
                <td colspan="2" align="center">
                    <input type="submit" value="提交" />
                    &nbsp;&nbsp;&nbsp;
                    <input type="reset" value="重置" />
                </td>
            </tr>
        </table>
    </form>
  </body>
</html>

项目git地址

       Jsp+Servlet+Xml实现简单注册系统:http://git.oschina.net/li2chao/XMLRegisterSystem

  • 5
    点赞
  • 1
    评论
  • 31
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

评论 1 您还未登录,请先 登录 后发表或查看评论
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页

打赏作者

李超的博客

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值