xml视频笔记

1、xml发展历史

xml全称为Extensible Markup Language，可扩展标记语言；是由W3C组织发布的，目前遵循的是W3C组织于2000年发布的xml.0规范。

1969年gml（通用标记语言）主要目的是在不同的机器上进行通信的数据规范

1985年sgml（标准通用标记语言）

1993年html(www网)

Html语言本身是是由一些缺陷的，比如

<html>

       <body>

              <table>

                     <td>123</td>

              </table>

       </body>

</html>

（2）html本身缺少一些含义

<html>

<body>

<table>

<tr>

</tr>

</table>

</body>

</html>

（3）html本身没有真正的国际化

2、为什么需要学习xml

（1）xml的出现解决了程序间数据传输的问题；

比如QQ之间的数据用xml格式来传递，具有良好的可读性和可维护性；

（2）可以用做配置文件；

（3）可以充当小型的数据库；

因为直接读取文件显然要比读取数据库更快。

3、xml语法

入门案例：使用xml来记录一个班级的信息

<?xml version="1.0" encoding="gb2312"?>

<class>

</stu>

</stu>

</class>

一个xml文件分为如下几个部分内容：

3.1、文档声明

<?xml version="1.0" encoding="gb2312"?>

a、xml声明放在xml文档的第一行；

b、xml声明由以下几个部分组成：

version——文档符合xml1.0规范

encoding——文档字符编码，比如“utf-8”，“gb2312”；

standalone——文档定义是否独立使用，默认是“no”；

3.2、元素

a、每个xml文档必须有且仅有一个根元素；

b、根元素是一个完全包括文档中其他所有元素的元素；

c、根元素的起始标记要放在所有其他元素的起始标记之前；

d、根元素的结束标记要放在所有其他元素的结束标记之后；

e、xml元素指xml文件中出现的标签，一个标签分为开始标签和结束标签，主要有以下两种标签格式：

包含标签体：<a>www</a>

不包含标签体：<a></a>，简写为</a>

f、一个标签中可以嵌套若干个子标签，但所有标签必须是合理的嵌套，决不允许交、叉嵌套；

g、对于xml标签中出现的所有空格和换行，xml解析程序都会当做标签内容进行处理，因此在编写xml文件时要特别注意空格和换行；

h、一个xml元素可以包含字母、数字以及其它一些可见字符，但必须遵守下面的一些规范：

l区分大小写，例如，<P>和<p>是两个不同的标记；

l不能艺术字或“_”（下划线）开头；

l不能包含空格；

l名称中间不能包含冒号（：）。

3.3、属性

a、属性值用双引号或单引号分隔；

b、一个元素可以有多个属性，它的基本格式为：<元素名属性名=”属性值”>；

c、特定的属性名称在同一个元素标记中只能出现一次；

d、属性值不能包括<,>,&.

3.4、注释

a、注释内容中不要出现--；

b、不要把注释放在标记中间；

c、注释不能嵌套；

d、可以在除标记以外的任何地方放注释；

e、注释采用：“<!—注释-->”格式；

注意：xml声明之前不能有注释。

3.5、CDATA区、特殊字符

a、有些内容可能不想让解析引擎解析执行，而是当做原始内容来处理，用于把整段文本解释为纯字符数据而不是标记的情况。CDATA节中的所有字符都会被当做元素字符数据的常量部分，而不是xml标记。

b、语法形式：

<![CDATA[。。。。。]]>

c、可以输入任意字符，当然是除]]>之外了；

d、不可以嵌套使用。

e、转义字符

对于一些单个字符，若执行显示其原始样式，也可以使用转义的形式予以处理

转义符	符号
<	<
>	>
&	&
"	“
'	‘

3.6、处理指令（processing instruction）

a、处理指令，简称PI，处理指令用来指挥解析引擎如何解析xml文档内容；

b、在xml文档中使用xml-stylesheet指令，通知xml解析引擎，应用css文件显示xml文档内容，格式如下：

<?xml-stylesheet type="text/css" href="。。.css"?>

在myClass.xml文件中引入my.css样式：

name{

font-size:100px;

font-weight:bold;

color:red;

}

age{

font-size:50px;

font-weight:bold;

color:blue;

}

sex{

font-size:20px;

font-weight:bold;

color:yellow;

}

修改后的myClass.xml代码如下：

<?xml version="1.0" encoding="utf-8"?>

<?xml-stylesheet type="text/css" href="my.css"?>

<class>

</stu>

</stu>

</class>

注意：编码问题

ansi编码：美国国家标准协会制定的编码格式标准，在不同的国家是不一样的，比如在中国是gb2312。

总结：

遵循如下规则的xml文档称为正规的xml文档：

l语法规范

a、包含xml声明语句；

b、必须有且仅有一个根元素；

c、标记大小写敏感；

d、属性值用引号；

e、标记成对且空标记关闭；

f、元素正确嵌套。

l元素语法

a、名称中可以包含字母、数字或者其它字符；

b、名称中不能包含空格；

c、名称中不能含有冒号（注：冒号留给命名空间使用）。

4、xml文件约束

4.1、xml约束概述

xml约束是指通过编写一个文档来约束一个xml文档的书写规范，常用的约束技术是XML DTD和XML Schema。

4.2、DTD约束

DTD(Document Type Defintion)，全称为文档类型定义。

a、xml与DTD之间的关系如下图所示：

b、基本语法：

<!ELEMENT元素名类型>

c、快速入门案例：

编写myClass2.xml文件和myClass2.dtd文件，代码如下所示：

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE班级SYSTEM "myClass2.dtd">

<班级>

<学生>

<姓名>周星驰</姓名>

<年龄>23</年龄>

<介绍>学习刻苦</介绍>

</学生>

<学生>

<姓名>林青霞</姓名>

<年龄>45</年龄>

<介绍>认真</介绍>

</学生>

</班级>

<!ELEMENT班级(学生+)>

<!ELEMENT学生(姓名,年龄,介绍)>

<!ELEMENT姓名(#PCDATA)>

<!ELEMENT年龄(#PCDATA)>

<!ELEMENT介绍(#PCDATA)>

编写校验xml文档正确项的解析工具，在IE5以上浏览器内置了xml解析工具，也可通过xmlspy工具进行验证；

主要步骤如下：

1、创建xml文档解析器对象

2、开启xml校验

3、装载xml文档

4、获取错误信息

实现代码如下所示：

<html>

<head>

<title>my xml verfiy tool</title>

<!--

var xmldoc = new ActiveXObject("Microsoft XMLDOM");

xmldoc.validateOnParse ="true";//开启校验

xmldoc.load("myClass2.xml");//指定校验哪个xml文件

document.writeln("错误信息是："+xmldoc.parseError.Error);

document.writeln("错误信息所在行："+xmldoc.parseError.line);

-->

</script>

</head>

</html>

d、DTD文档的声明以及引用

内部DTD文档

<!DOCTYPE根元素[定义内容]>

示例：

<?xml version="1.0" encoding="gb2312"?>

<!DOCTYPE poem[

<!DOCTYPE poem (author,title,content)>

<!ELEMENT author (#PCDATA)>

<!ELEMENT title (#PCDATA)>

<!ELEMENT content (#PCDATA)>

<poem>

<content>空山不见人，但闻人语声。

返景入深林，复照青苔上。

</content>

</poem>

注意：例中的定义关键字一定要大写，比如DOCTYPE,ELEMENT,#PCDATA，且元素名称与数据类型之间也要有空格。

外部DTD文档

<!DOCTYPE根元素SYSTEM “DTD文件路径”>

示例见入门案例。

内外部DTD文档结合

<!DOCTYPE根元素SYSTEM “DTD文件路径”[定义内容]>

xml文件使用DOCTYPE声明语句来指明它所遵循的DTD文件，DOCTYPE声明语句有两种形式：

l当引用的文件在本地时，采用如下方式：

<!DOCTYPE文档根结点SYSTEM “DTD文件的URL”>

l当引用的文件时一个公共的文件时，采用如下形式：

<!DOCTYPE文档根结点PUBLIC “DTD名称” “DTD文件的URL”>

示例：

<!DOCTYPE web-app PUBLIC

"-//Sun Microsystems,Inc.//DTD Web Application 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd">

e、DTD元素

l语法

<!ELEMENT NAME CONTENT>

以上三个单词分别对应关键字、元素名称、元素类型（大写）；

CONTENT包括以下三种：

1）EMPTY：该元素不能包含子元素和文本，但是可以有属性（即空元素）；

示例：

<!ELEMENT人EMPTY>

<家庭>

<人名字="皮诺曹"性别="男"年龄="6"/>

</家庭>

2）ANY：该元素可以包含任何在DTD中定义的元素内容；

示例：

<!ELEMENT人ANY>

<家庭>

<人>皮诺曹</人>

<人><大人>皮诺曹爸爸</大人></人>

</家庭>

3）#PCDATA：可以包含任何字符数据，但是不能再其中包含任何子元素其它类型（组合）。

<!ELEMENT人(#PCDATA)>

<家庭>

<人性别="男"年龄="6">皮诺曹</人>

</家庭>

组合类型如下所示：

<!ELEMENT家庭(人+,家电*)>

<家庭>

<人名字="郭大路"性别="男"年龄="25"/>

<人名字="李寻欢"性别="男"年龄="38"爱好="作个教育家和伟人"/>

<家电名称="彩电"数量="3"/>

</家庭>

修饰符如下所示：

编号	符号	用途	示例	示例说明
1	( )	用来给元素分组	(古龙\|金庸),(王朔\|余杰),三毛	分成三组
2	\|	在列中的对象中选择一个	(男人\|女人)	表示男人或者女人必须出现，两者至少选一
3	+	该对象最少出现一次，可以出现多次	(成员+)	表示成员必须出现，而且可以出现多个成员
4	*	该对象允许出现零次到人一多次	(爱好*)	爱好可以出现零次到多次
5	?	该对象可以出现，但是只能出现一次（0到1次）	(菜鸟?)	菜鸟可以出现，也可以不出现，但是如果出现的话，最多只能出现一次
6	,	对象必须按指定的顺序出现	(西瓜,苹果,香蕉)	表示西瓜，苹果，香蕉必须出现，并且按这个顺序出现

4.3、属性

a、语法：

<!ATTLIST元素名称

属性名称类型属性特点

属性名称类型属性特点...

其中类型包括四种：CDATA、ID、IDREF/IDREFS、Enumerated、ENTITY/ENTITIES；

属性特点包括四种：#required、#IMPLIED、#FIXED value、#Default value。

b、属性类型：

lCDATA：属性值可以使任何字符（包括数字和中文）

<!ATTLIST木偶

姓名CDATA #required

<木偶姓名="dirk">

<木偶姓名="德克">

<木偶姓名="dirk41">

lID：表明该属性的取值必须是唯一的。

<!ELEMENT公司职员ANY>

<!ATTLIST公司职员

编号ID #required

姓名CDATA #required

<公司职员编号="1001"姓名="张三">

<公司职员编号="1002"姓名="李四">

lIDREF/IDREFS：IDREF属性的值指向文档中其它地方声明的ID类型的值；

IDREFS同IDREF，但是可以具有由空格分开的多个引用。

<!ELEMENT家庭(人+)>

<!ELEMENT人EMPTY>

<!ATTLIST人

relID ID #required

parentID IDREFS #IMPLIED

name CDATA #REUIRED

<家庭>

<人relID="p01" name="爸爸">

<人relID="p02" name="妈妈">

<人relID="p03" parentID="p01 02" name="儿子">

</家庭>

lEnumerated：事先定义好一些值，属性的值必须在所列出的值的范围内。

<!ATTLIST person婚姻状态(single|married|divorced|widowed) #IMPLIED>

<!ATTLIST person性别(男|女) #required>

c、属性的特点：

l#required：元素的所有实例都必须有该属性的值（NOT NULL）。

语法：

<!ATTLIST元素名属性名属性类型#required>

示例：

<!ATTLIST person number CDATA #required>

l#IMPLIED：元素的实例中可以忽略该属性（NULL）。

语法：

<!ATTLIST元素名属性名属性类型#IMPLIED>

示例：

<!ATTLIST contact fax CDATA #IMPLIED>

l#FIXED value：元素实例中该属性的值必须为指定的固定值。

语法：

<!ATTLIST元素名属性名属性类型#FIXED "value">

示例：

<!ATTLIST sender company CDATA #FIXED "Microsoft">

lDefault value：为属性听过一个默认的值。

语法：

<!ATTLIST元素名属性名类型"value">

示例：

<!ATTLIST payment type CDATA "check">

d、实体：

l定义：是用于为一段内容创建一个别名，以后再xml文档中就可以使用别名引用这段内容了，在DTD定义中，一条<!ENTITY ...>语句用于定义一个实体；实体可以分为两种类型：引用类型和参数实体。

l引用实体：主要在xml文档中被应用；

语法：

<!ENTITY实体名称"实体内容">：直接转变成实体内容

引用方式：

&实体名称;

示例：

<!ENTITY copyright "I am a coder">

&copyright;

l参数实体：被DTD文档自身使用；

语法：

<!ENTITY %实体名称"实体内容">

引用方式：

%实体名称;

示例：

<!ENTITY % TAG_NAMES "姓名|EMAIL|电话|地址">

<!ENTITY个人信息(%TAG_NAME;|生日)>

<!ENTITY客户信息(%TAG_NAME;|公司名)>

<!ENTITY %common.attributes

id ID #IMPLIED

account CDATA #required

...

<!ATTLIST purchaSEOrder %common.attributes;>

<!ATTLIST item %commo.attributes;>

e、练习：

根据以下的dtd文件写出相对应的xml文件：

1）报纸文章DTD

!DOCTYPE NEWSPAPER [

<!ELEMENT NEWSPAPER (ARTICLE+)>

<!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)>

<!ELEMENT HEADLINE (#PCDATA)>

<!ELEMENT BYLINE (#PCDATA)>

<!ELEMENT LEAD (#PCDATA)>

<!ELEMENT BODY (#PCDATA)>

<!ELEMENT NOTES (#PCDATA)>

<!ATTLIST ARTICLE AUTHOR CDATA #required>

<!ATTLIST ARTICLE EDITOR CDATA #IMPLIED>

<!ATTLIST ARTICLE DATE CDATA #IMPLIED>

<!ATTLIST ARTICLE EDITION CDATA #IMPLIED>

<!ENTITY NEWSPAPER "Vervet Logic Times">

<!ENTITY PUBLISHER "Vervet Logic Press">

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE NEWSPAPER SYSTEM "newspaper.dtd">

<BODY>huangwenbo</BODY>

<NOTES>sanjiangunivesity</NOTES>

</ARTICLE>

</NEWSPAPER>

2）产品目录DTD

<!DOCTYPE CATALOG [

<!ENTITY AUTHOR "John Doe">

<!ENTITY COMPANY "JD Power Tools,Inc.">

<!ENTITY EMAIL "jd@jd-tools.com">

<!ELEMENT CATALOG (PRODUCT+)>

<!ELEMENT PRODUCT

(SPECIFICATIONS+,OPTIONS?,PRICE+,NOTES?)>

<!ATTLIST PRODUCT

NAME CDATA #IMPLIED

CATEGORY (HandTool|Table|Shop-Professional) "HandTool"

PARTNUM CDATA #IMPLIED

PLANT (Pittsburgh|Milwaukee|Chicago) "Chicago"

INVENTORY (InStock|Backordered|Discontinued) "InStock">

<!ELEMENT SPECIFICATIONS (#PCDATA)>

<!ATTLIST SPECIFICATIONS

WEIGHT CDATA #IMPLIED

POWER CDATA #IMPLIED>

<!ELEMENT OPTIONS (#PCDATA)>

<!ATTLIST OPTIONS

FINISH (Metal|Polished|Matte) "Matte"

ADAPTER (Included|Optional|NotApplicable) "Included"

CASE (HardShell|Soft|NotApplicable) "HardShell">

<!ELEMENT PRICE (#PCDATA)>

<!ATTLIST PRICE

MSRP CDATA #IMPLIED

WHOLESALE CDATA #IMPLIED

STREET CDATA #IMPLIED

SHIPPING CDATA #IMPLIED>

<!ELEMENT NOTES (#PCDATA)>

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE CATALOG SYSTEM "product.dtd">

<SPECIFICATIONS WEIGHT="800" POWER="600">lenove y460p</SPECIFICATIONS>

</PRODUCT>

</CATALOG>

4.4、xml Schema

lxml Schema也是一种用于定义和描述XML文档结构与内容的模式语言，其出现是为了克服DTD的局限性。

lxml Schema的特点：

a、xml Schema比dtd更加符合XML语法结构，因为xml Schema自身就是xml文件，为了有所区别，扩展名通常为.xsd；

b、xml解析器很容易解析出xml Schema文档中的内容；

c、xml Schema比XML DTD支持更多的数据类型，并支持用户自定义新的数据类型；

d、xml Schema对名称空间支持的非常好；

e、xml Schema定义约束的能力非常强大，可以对XML实例文档作出细致的语义限制。

l一个XML Schema文档通常称之为模式文档（约束文档），遵循这个文档书写的xml文件称之为实例文档。

l和xml文件一样，一个xml Schema文档也必须有一个根结点，但这个根结点的名称为Schema。

l编写一个xml Schema岳苏文档后，通常需要把这个文件中的声明的元素绑定到一个uri地址上，在xml Schema技术中有一个专业术语来描述这个过程，即把XML Schema文档声明的元素绑定到一个名称空间上，以后xml文件就可以通过这个URI（即名称空间）来告诉解析引擎，xml文档正编写的元素来自哪里，被谁约束。

关于名称空间的注意点：

l为什么要声明名称空间：由于xml文档可以被任何组织或个人定义，这就完全有可能在一个xml文件中出现重复的元素，此时使用名称空间可以加以区分。

l在xml Schema中，每个模式文档都可以被赋以一个唯一的名称空间，名称空间用一个唯一的URI（Uniform Resource Identifier，统一资源标示符）表示。

比如：xml文件中的内容：

<itcast:书架xmlns:itcast="http://www.itcast.cn">

<itcast:书>....</itcast:书>

</itcast>

此处使用itcast来指向声明的名称，以便于后面对名称空间的引用。

l名称空间中的uri虽然是以http：//开头，但是它可以不指向任何一个真实的地址，而仅仅是作为一个名称空间来声明。

快速入门案例：

编写book.xsd文件来约束book.xml文件，代码如下所示：

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

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://wwwtcast.cn"

elementFormDefault="qualified">

<xs:element name='书架' >

<xs:complexType>

<xs:sequence maxOccurs='unbounded' >

<xs:element name='书' >

<xs:complexType>

<xs:sequence>

<xs:element name='书名' type='xs:string' />

<xs:element name='作者' type='xs:string' />

<xs:element name='售价' type='xs:string' />

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:schema>

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

<itcast:书架xmlns:itcast="http://www.itcast.cn"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.itcast.cn book.xsd">

<itcast:书>

<itcast:书名>

Javascript网页开发

</itcast:书名>

<itcast:作者>

张孝祥

</itcast:作者>

<itcast:售价>

28.00元

</itcast:售价>

</itcast:书>

</itcast:书架>

使用默认名称空间

l基本格式：

xmlns=”URI”

l举例：

<?xml version="1.0" encoding="utf-8"?>

<书架xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:noNamespaceSchemaLocation="xmlbook.xsd">

<书>

<书名>

Javascript网页开发

</书名>

<作者>

张孝祥

</作者>

<售价>

28.00元

</售价>

</书>

</书架>

5、xml编程

5.1、xml解析技术的介绍

5.1.1、xml解析分为：dom解析和sax解析

dom:Document Object Model，即文档对象模型，是W3C组织推荐的处理xml的一种方式；

sax:Simple API for xml，不是官方标准，但它是xml社区事实上的标准，几乎所有的xml解析器都支持它。

5.1.2、JAXP介绍

lJAXP开发包是J2SE的一部分，它由javax.xml、org.w3c.dom、org.xml.sax包及其子包组成；

l在javax.xml.parsers包中，定义了几个工厂类，程序员调用这些工厂类就可以得到对xml文档进行接卸的DOM和SAX的解析器对象。

5.1.3、获得JAXP中的DOM解析器的步骤

l1、调用DocumentBuilderFactory.newInstance()方法得到创建DOM解析器的工厂。

l2、调用工厂对象的new DocumentBuilder方法得到DOM解析器对象。

l3、调用DOM解析器对象的parse()方法解析xml文档，得到代表整个文档的Document对象，进行可以利用DOM特性对整个xml文档进行操作了。

5.2、DOM编程

lDOM模型就是Document Object Model；

lDOM解析器在解析XML文档给时，会把文档的所有元素，按照其出现的层次关系，解析成一个个Node对象（节点）；

l在DOM中，节点之间关系如下所示：

（1）位于一个节点之上的节点是该节点的父节点（parent）；

（2）一个节点之下的节点是该节点的子节点（children）；

（3）同一层次，具有相同父节点的节点是兄弟节点（sibling）；

（4）一个节点的下一个层次的节点是兄弟节点（descendant）；

（5）父、祖父节点及所有位于节点上面的，都是节点的祖先（ancestor）。

xml DOM的解析图如下所示：

5.2.1、Node对象

lNode对象提供了一系列常量来代表节点的类型，当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点对象（Node的子类对象），以便调用其特有的方法，

lNode对象提供了相应的方法去获得它的父节点或自己点。

5.2.2、更新XML文档

ljavax.xml.transform包中的Transformer类用于把代表xml文件的Document对象转换成某个格式后进行输出，例如把xml文件应用样式表后转换成一个html文档。利用这个对象，也可以把Document对象用重新写入到一个xml文件中；

lTransformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地；

lTransformer对象通过TransformerFactory获得。

5.2.3、JAXP实例：

对class.xml文件进行CRUD操作，class.xml中代码如下所示：

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

<班级>

<学生>

<姓名>周星驰</姓名>

<年龄>23</年龄>

<介绍>学习刻苦</介绍>

</学生>

<学生>

<姓名>林青霞</姓名>

<年龄>45</年龄>

<介绍>认真</介绍>

</学生>

</班级>

DomXml1.java代码如下所示：

package com.hwb;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

public class DomXml1 {

public static void main(String[] args) throws Exception {

//利用dom技术对xml文件进行CRUD操作

//创建一个DocumentBuilderFactory

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

//通过DocumentBuilderFactory得到一个DocumentBuilder对象

DocumentBuilder dBuilder = dbf.newDocumentBuilder();

//指定解析xml文件的地址

Document document = dBuilder.parse("src/class.xml");

//遍历xml文件

list(document);

//查询某个学生的信息（假设取出第一个学生的信息）

read(document);

//添加一个学生到xml文件中

add(document);

//从xml文件中删除一个学生信息

delete(document);

//更改xml文件中某个学生的信息

update(document);

}

public static void update(Document document) throws Exception {

//首先找到需要更改的节点并作出修改

Element node = (Element) document.getElementsByTagName("学生").item(0);

Element node_name = (Element) document.getElementsByTagName("姓名").item(

0);

node_name.setTextContent("宋江");

//更新xml文件

//得到TransformerFactory

TransformerFactory tff = TransformerFactory.newInstance();

//通过TransformerFactory得到一个转换器

Transformer tf = tff.newTransformer();

.transform(new DOMSource(document),new StreamResult(

"src/class.xml"));

}

public static void delete(Document document) throws Exception {

//删除属性sex

Element node = (Element) document.getElementsByTagName("学生").item(0);

node.removeAttribute("sex");

//更新xml文件

//得到TransformerFactory

TransformerFactory tff = TransformerFactory.newInstance();

//通过TransformerFactory得到一个转换器

Transformer tf = tff.newTransformer();

.transform(new DOMSource(document),new StreamResult(

"src/class.xml"));

}

public static void add(Document document) throws Exception {

//创建一个新的学生的节点

Element newStu = document.createElement("学生");

//为学生添加属性

newStu.setAttribute("sex","男");

//继续向下创建三个节点，包括姓名、年龄、介绍

Element newStu_name = document.createElement("姓名");

//为该节点赋值

newStu_name.setTextContent("小明");

Element newStu_age = document.createElement("年龄");

//为该节点赋值

newStu_age.setTextContent("23");

Element newStu_introduce = document.createElement("介绍");

//为该节点赋值

newStu_introduce.setTextContent("学习认真");

//将学生节点与姓名、年龄、介绍三个节点相关联

newStu.appendChild(newStu_name);

newStu.appendChild(newStu_age);

newStu.appendChild(newStu_introduce);

//把新的学生节点添加到根元素

document.getDocumentElement().appendChild(newStu);

//得到TransformerFactory

TransformerFactory tff = TransformerFactory.newInstance();

//通过TransformerFactory得到一个转换器

Transformer tf = tff.newTransformer();

.transform(new DOMSource(document),new StreamResult(

"src/class.xml"));

}

public static void read(Document document) {

//通过getElementsByTagName()方法得出节点的名称

NodeList nl = document.getElementsByTagName("学生");

//取出第一个学生的信息

Element stu = (Element) nl.item(0);

String stu_sex = stu.getAttribute("sex");

System.out.println("学生的性别是" + stu_sex);

Element name = (Element) stu.getElementsByTagName("姓名").item(0);

System.out.println(name.getTextContent());

}

public static void list(Node node) {

if (node.getNodeType() == node.ELEMENT_NODE) {

System.out.println("名字是" + node.getNodeName());

}

//取出node的子节点

NodeList nodelist = node.getChildNodes();

//通过递归调用来遍历xml文件

for (int i = 0; i < nodelist.getLength(); i++) {

Node n = nodelist.item(i);

list(n);

}

5.2.4、JAXP练习：

通过dom解析学生成绩，实现学生成绩管理系统。代码如下所示：

student.xml

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

</course>

</student>

</course>

</student>

</course>

</student>

</course>

</student>

</course>

</student>

</students>

StudentGrade.java

package com.dom.exercise;

import java.util.Scanner;

public class StudentGrade {

public static void main(String[] args) throws Exception {

while (true) {

show();

}

public static void show() throws Exception {

//显示操作界面

System.out.println("查询所有学生的成绩----view");

System.out.println("退出系统----exit");

//获取用户的操作类型

Scanner scanner = new Scanner(System.in);

StudentService studentService = new StudentService();

String operType = scanner.next();

if (operType.equals("view")) {

// view操作

System.out.println("所有学生的成绩如下所示：");

studentService.viewStudent();

} else if (operType.equals("exit")) {

// exit操作

System.exit(1);

}

Student.java

package com.dom.exercise;

class Student {

private String sid; //学生编号

private String name; //学生姓名

private int myjava; //Java成绩

private int myoracle;//Oracle成绩

private int myvb;//VB成绩

/*getter and setter*/

public String getSid() {

return sid;

}

public void setSid(String sid) {

this.sid = sid;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getMyjava() {

return myjava;

}

public void setMyjava(int myjava) {

this.myjava = myjava;

}

public int getMyoracle() {

return myoracle;

}

public void setMyoracle(int myoracle) {

this.myoracle = myoracle;

}

public int getMyvb() {

return myvb;

}

public void setMyvb(int myvb) {

this.myvb = myvb;

}

StudentService.java

package com.dom.exercise;

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;

class StudentService {

//从指定的xml文件中得到信息

public Document getDocument(String FullFilePath) throws Exception {

// 1、得到DocumentBuilderFactory

DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory

.newInstance();

// 2、得到DocumentBuilder

DocumentBuilder documentBuilder = documentBuilderFactory

.newDocumentBuilder();

// 3、指定得到的文件

return documentBuilder.parse(FullFilePath);

}

//得到第一个元素的值

public String getFirstElementTextVal(Element element,String name) {

return ((Element) element.getElementsByTagName(name).item(0))

.getTextContent()

+ "\t\t";

}

//显示所有学生的成绩

public void viewStudent() throws Exception {

// 1、通过调用getDocument()方法显示学生信息

NodeList nodeList = getDocument("src/com/dom/exercise/student.xml")

.getElementsByTagName("student");

// 2、通过遍历nodeList格式化显示学生成绩

for (int i = 0; i < nodeList.getLength(); i++) {

Element element = (Element) nodeList.item(i);

System.out.println("编号：" + element.getAttribute("sid") + "\t"

+ "名字：" + getFirstElementTextVal(element,"name") + "\t"

+ "Java成绩：" + getFirstElementTextVal(element,"java")

+ "\t" + "Oracle成绩："

+ getFirstElementTextVal(element,"oracle") + "\t"

+ "VB成绩：" + getFirstElementTextVal(element,"vb") + "\t");

}

5.3、SAX编程

5.3.1、概述：

l在使用DOM解析xml文档时，需要读取整个xml文档，在内存中构建代表整个DOM树的Document对象，从而在对xml文档进行操作。此种情况下，如果xml文档特别大，就会消耗计算机的大量内存，严重的情况下可能会导致内存溢出。

lsax解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才对文档进行操作。

l面试题：

阅读以下代码，请问该段代码是否正确？

package com.hwb;

public class Test {

public static void main(String[] args) {

byte bytes[]=new byte[1024*1024*200];

bytes[0]=0;

System.out.println(bytes[0]);

}

运行结果会出现如下错误：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

at com.hwb.Test.main(Test.java:4)

默认情况下JVM的虚拟内存是64M，可以在“Properties for Xxx.java”中选择“Edit”按钮后选择“Argument”中“VM arguments”下添加“-Xmx200M”（200可以替换），即可指定jvm机启动的内存大小。

5.3.2、原理图：

5.3.3、sax解析机制

sax是一种推式机制，当创建一个sax解析器时解析器在发现xml文档中的内容是会把事件退给你，如何处理这些内容，由程序员自己决定。

在基于sax的程序中，有五个最常用的sax事件：

（1）startDocument()---->告诉我们解析器发现了文档的开始，并且解析器开始扫描文档；

（2）endDocument()--->告诉我们解析器发现了文档尾；

（3）startElement()--->告诉我们解析器发现了一个起始标签，该事件告诉我们元素的名称以及该元素所有的属性名和值；

（4）character()--->告诉我们解析器发现了一些文本，将得到一个字符数组，该数组的偏移量和一个长度变量，有这三个变量便可以得到解析器所发现的文本；

（5）endElement()--->告诉我们解析器发现了一个结束标签，该事件告诉元素的名称。

5.3.4、sax解析

sax采用事件处理的方式解析xml文件，利用sax解析xml文档，涉及两个部分：解析器和事件处理器：

l解析器可以使用jaxp的API创建，创建出sax解析器后就可以指定解析器去解析某个xml文档了；

l解析器采用sax方式在解析某个xml文档时，它只要解析到xml文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器；

l事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松的得到sax解析器解析到的数据，从而可以决定如何对数据进行处理。

5.3.5、sax方式解析xml文档

l使用SAXParseFactory创建sax解析工厂

SAXParseFactory spf = SAXParseFactory.newInstance();

l通过sax解析工厂得到解析器对象

SAXParse sp = spf.newSAXParse();

l将解析对象和事件处理器对象关联

sp.parse(“src/myClass.xml”,new MyHander());

5.3.6、sax实例

myClass.xml文件代码如下所示：

<?xml version="1.0" encoding ="utf-8"?>

<班级>

<学生>

<名字>周星驰</名字>

<年龄>23</年龄>

<介绍>学习刻苦</介绍>

</学生>

<学生>

<名字>林青霞</名字>

<年龄>32</年龄>

<介绍>是一个好学生</介绍>

</学生>

</班级>

SaxXml类代码如下所示：

package com.hwb;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

public class SaxXml {

public static void main(String[] args) throws Exception {

//利用sax技术来解析xml文档，此例中解析myClass.xml文件

//使用SAXParseFactory创建sax解析工厂

SAXParserFactory spf = SAXParserFactory.newInstance();

//通过sax解析工厂得到解析器对象

SAXParser sp = spf.newSAXParser();

//将解析对象和事件处理器对象关联

sp.parse("src/class.xml",new MyHander());

System.out.println("*****************");

sp.parse("src/class.xml",new Hander());

}

MyHander类代码如下所示：

package com.hwb;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

//定义事件处理类

class MyHander extends DefaultHandler {

@Override

//发现文档开始

public void startDocument() throws SAXException {

System.out.println("startDocument");

}

@Override

//发现xml文件中的一个元素

public void startElement(String uri,String localName,String qName,

Attributes attributes) throws SAXException {

System.out.println("元素名称:" + qName);

}

@Override

//发现xml文件中的一个文本

public void characters(char[] ch,int start,int length)

throws SAXException {

String con = new String(ch,start,length);

if(!con.trim().equals("")){

System.out.println(con);

}

@Override

public void endElement(String uri,String qName)

throws SAXException {

// TODO Auto-generated method stub

super.endElement(uri,localName,qName);

}

@Override

//发现文档结束

public void endDocument() throws SAXException {

System.out.println("endDocument");

}

Hander类代码如下所示：

package com.hwb;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

//只显示学生的姓名和年龄

class Hander extends DefaultHandler {

private boolean isName = false;

private boolean isAge = false;

@Override

//发现文档开始

public void startDocument() throws SAXException {

System.out.println("startDocument");

}

@Override

//发现xml文件中的一个元素

public void startElement(String uri,length);

if(!con.trim().equals("")&&(isAge||isName)){

System.out.println(con);

}

isName =false;

isAge = false;

}

@Override

public void endElement(String uri,String qName)

throws SAXException {

if(qName.equals("名字")){

this.isName = true;

}else if(qName.equals("年龄")){

this.isAge = true;

}

@Override

//发现文档结束

public void endDocument() throws SAXException {

System.out.println("endDocument");

}

5.4、DOM4J编程

5.4.1、DOM4J解析XML文档

lDom4j是一个简单、灵活的开放源代码的库；与JDOM不同的是，dom4j使用接口和抽象基类，虽然dom4j的API相对复杂一些，但它提供了比JDOM更好的灵活性；

lDom4j是一个非常优秀的Java xml API，具有性能优异、功能强大和极易使用的特点；现在很多软件采用的是Dom4j，比如说Hibernate。

l使用Dom4j开发，需要先下载dom4j相应的jar文件。

5.4.2、Document对象

lDom4j中，获得Document对象的方式有三种：

（1）读取xml文件，获得document对象

SAXReader saxReader = new SAXReader();

Docuement document = saxReader.read(new File(“文件地址以及文件名”));

（2）解析xml形式的文本，得到document对象

String text =”<members></menbers>”;

Document document = DocumentHelper.parseText(text);

（3）主动创建document对象

Document document = DocumentHelper.createDocument();

//创建根节点

Element root = document.addElement(“members”);

5.4.3、节点对象

l1、获取文档的根节点

Element root = document.getRootElement();

l2、取得某个节点的子节点

Element element = node.element(“书名”);

l3、取得节点的文字

String text = node.getText();

l4、取得某节点下所有名为“member”的子节点，并进行遍历

List nodes = rootEle.elements(“member”);

for(Iterator it = nodes.iterator();it.hasNext();){

Element ele = (Element) it.next();

//do something

}

l5、对某个节点的所有字典进行遍历

for(Iterator it = nodes.iterator();it.hasNext();){

Element ele = (Element) it.next();

//do something

}

l6、在某节点下添加子节点

Element ageElm = newMemberElm.addElement("age");

l7、设置节点文字

element.setText(“2345”);

l8、删除某节点

parentEle.remove(childEle);

l9、添加一个CDATA节点

Element contentElm = infoElm.addElement(“content”);

contentElm.addCDATA(diary.getContent());

5.4.4、节点对象属性

l1、取得某节点下的某属性

Element root = document.getRootElement();

Attribute attribute = root.attribute(“size”);

l2、取得属性的文字

String text = attribute.getText();

l3、删除某属性

Attribute attribute = root.attribute(“size”);

root.remove();

l4、遍历某节点的所有属性

Element root = document.getRootElement();

for(Iterator it=root.attributeIterator;it.hasNext()){

Attribute attribute = attribute.getText();

String text = attribute.getText();

System.out.println(text);

}

l5、设置某节点的属性和文字

newMemberEle.addAttribute(“name”,”sanjiang”);

l6、设置属性的文字

Attribute attribute = root.attribute(“name”);

attribute.setText(“sanjiang”);

5.4.5、Dom4j在指定位置插入节点

l1、得到插入位置的节点列表（list）；

l2、调用list.add(index element)，由index决定element的插入位置；

Element元素可以通过DocumentHelper对象得到；示例代码如下：

Element element = DocumentHelper.createElement(“element”);

element.setText(“aaaa”);

List list = root.element(“书”).elements();

list.add(1,aaa);

//更新document

l3、将文档希尔xml文件

（1）文档中全为英文，不设置编码，直接写入的形式

XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));

writer.write(document);

writer.close();

（2）文档中含有中问，设置编码格式写入的形式

OutputFormat format = OutputFormat.createPrettyPrint();

//指定xml编码

format.setEncoding("GBK");

XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),format);

writer.write(document);

writer.close();

出现乱码时使用以下代码：

new OutputStreamWriter(new FileOutputStream("src/.."),"utf-8");

5.4.6、Dom4j入门案例

以下代码是allhero.xml文件，对其进行CRUD操作:

<?xml version="1.0" encoding="utf-8"?>

<水浒>

<英雄>

<名字别名="及时雨">宋江</名字>

<年龄>35</年龄>

<介绍>首领</介绍>

</英雄>

<英雄>

<名字别名="玉麒麟" >卢俊义</名字>

<年龄>25</年龄>

<介绍>二号首领</介绍>

</英雄>

<英雄>

<名字别名="行者">武松</名字>

<年龄>30</年龄>

<介绍>行者武松</介绍>

</英雄>

</水浒>

使用Dom4j解析代码如下所示：

package com.dom4j.test;

import java.io.File;

import java.io.FileOutputStream;

import java.util.Iterator;

import java.util.List;

import org.dom4j.Document;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.SAXReader;

import org.dom4j.io.XMLWriter;

public class Dom4jTest {

public static void main(String[] args) throws Exception {

// 1、得到解析器

SAXReader saxReader = new SAXReader();

// 2、指定需要解析的xml文件

Document document = saxReader.read(new File(

"src/com/dom4j/test/allhero.xml"));

//遍历文件

list(document.getRootElement());

//读取第一个英雄的信息

read(document);

//向xml文件中添加一个新的英雄

add(document);

//从xml文件中删除某个英雄

delete(document);

//在xml文件中的某个英雄后面添加新的英雄

addByIndex(document);

}

@SuppressWarnings("unchecked")

public static void addByIndex(Document document) throws Exception {

//首先创建一个新的英雄对象

Element newHero = DocumentHelper.createElement("英雄");

//为对象添加属性

newHero.setText("李逵");

List<Element> allHeroes = document.getRootElement().elements("英雄");

for (int i = 0; i < allHeroes.size(); i++) {

Element name = allHeroes.get(i).element("名字");

if (name.getText().equals("卢俊义")) {

System.out.println("i=" + i);

allHeroes.add(i + 1,newHero);

break;

}

//设置输出的xml文件的格式，若不设置则会产生乱码

OutputFormat outputFormat = OutputFormat.createPrettyPrint();

outputFormat.setEncoding("UTF-8");

//更新xml文件

XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(new File(

"src/com/dom4j/test/allhero.xml")),outputFormat);

xmlWriter.write(document);

xmlWriter.close();

}

public static void delete(Document document) throws Exception {

//找到该元素

Element ele_hero = document.getRootElement().element("英雄")

.element("名字");

//删除该元素，通过得到该元素的父元素来删除

ele_hero.getParent().remove(ele_hero);

//设置输出的xml文件的格式，若不设置则会产生乱码

OutputFormat outputFormat = OutputFormat.createPrettyPrint();

outputFormat.setEncoding("UTF-8");

//更新xml文件

XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(new File(

"src/com/dom4j/test/allhero.xml")),outputFormat);

xmlWriter.write(document);

xmlWriter.close();

}

public static void add(Document document) throws Exception {

//首先创建一个新的英雄对象

Element newHero = DocumentHelper.createElement("英雄");

Element newHero_name = DocumentHelper.createElement("名字");

Element newHero_age = DocumentHelper.createElement("年龄");

Element newHero_intro = DocumentHelper.createElement("介绍");

//为对象添加属性

newHero_name.setText("林冲");

newHero_name.addAttribute("别名","豹子头");

//关联子节点与父节点

newHero.add(newHero_name);

newHero.add(newHero_age);

newHero.add(newHero_intro);

//把父节点添加到根节点下

document.getRootElement().add(newHero);

//设置输出的xml文件的格式，若不设置则会产生乱码

OutputFormat outputFormat = OutputFormat.createPrettyPrint();

outputFormat.setEncoding("UTF-8");

//更新xml文件

XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(new File(

"src/com/dom4j/test/allhero.xml")),outputFormat);

xmlWriter.write(document);

xmlWriter.close();

}

public static void read(Document document) {

//得到根元素

Element element = document.getRootElement();

// element.elements("英雄") :表示取出root元素下的所有英雄元素

// element.element("英雄") :表示取出root元素下的第一个英雄元素

// element.elements("英雄").get(0) :表示取出root元素下的第一个学生元素

Element hero = (Element) element.elements("英雄").get(0);

Element hero_name = hero.element("名字");

System.out.println(hero_name.getText() + "别名"

+ hero_name.attributeValue("别名"));

}

//遍历根元素

@SuppressWarnings("unchecked")

public static void list(Element element) {

System.out.println(element.getName() + ":" + element.getTextTrim());

Iterator iterator = element.elementIterator();

while (iterator.hasNext()) {

Element ele = (Element) iterator.next();

list(ele);

}

5.4.7、XPATH技术

XPATH技术解决了按层取得元素的问题。

具体案例详见其官方文档中案例。

6、疯狂XML书中重要案例

6.1、DOM编程

6.1.1、使用dom解析xml文件

book.xml代码如下所示：

<?xml version="1.0" encoding="GBK"?>

<书籍列表>

<计算机书籍ISBN="34553">

<书名>疯狂Java讲义</书名>

<价格>99.00元</价格>

<简要介绍>Java SE</简要介绍>

</计算机书籍>

<计算机书籍ISBN="12345">

<书名>疯狂Java WEB讲义</书名>

<价格>89.00元</价格>

<简要介绍>Java WEB</简要介绍>

</计算机书籍>

<计算机书籍>

<书名>疯狂XML讲义</书名>

<价格>69.00元</价格>

<简要介绍>XML</简要介绍>

</计算机书籍>

<文学书籍>不能承受的生命之轻</文学书籍>

<哲学书籍>

<书名>乌合之众</书名>

能提高人类对世界认识的书籍

</哲学书籍>

</书籍列表>

DomParse.java代码如下所示：

/**

*使用DOM模型解析xml文档内容

package com.xml.dom;

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.Node;

import org.w3c.dom.NodeList;

public class DomParse {

public static void main(String[] args) throws Exception {

// DOM解析器工厂

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

factory.setIgnoringElementContentWhitespace(true);

//获取DOM解析器

DocumentBuilder builder = factory.newDocumentBuilder();

//解析XML文档，并获取该XML文档对应的Document

Document doc = builder.parse(new File("src/com/xml/dom/book.xml"));

//获取根节点的方法：getDocumentElement

Element bookList = doc.getDocumentElement();

//获取根元素所包含的所有“计算机书籍”子元素，如果传入*做参数，可获取所有子元素

NodeList nodeList = bookList.getElementsByTagName("计算机书籍");

//遍历每个子元素

for (int i = 0; i < nodeList.getLength(); i++) {

System.out.println("第" + i + "本计算机书籍");

Node comBook = nodeList.item(i);

//获取ISBN属性节点

Node isbnAttr = comBook.getAttributes().getNamedItem("ISBN");

if (isbnAttr != null) {

System.out.println("该图书的ISBN为" + isbnAttr.getTextContent());

}

//获取comBook下的所有子元素

NodeList attList = comBook.getChildNodes();

//遍历每个子元素

for (int j = 0; j < attList.getLength(); j++) {

System.out.println(attList.item(j).getTextContent().trim());

}

//获取根元素所包含的所有“文学书籍”子元素

nodeList = bookList.getElementsByTagName("文学书籍");

//遍历每个子元素

for (int i = 0; i < nodeList.getLength(); i++) {

System.out.println("第" + i + "本文学书籍");

Node cultureBook = nodeList.item(i);

System.out.println(cultureBook.getTextContent());

}

//获取根元素所包含的所有“哲学书籍”子元素

nodeList = bookList.getElementsByTagName("哲学书籍");

//遍历每个子元素

for (int i = 0; i < nodeList.getLength(); i++) {

System.out.println("第" + i + "本哲学书籍");

Node philosophyBook = nodeList.item(i);

System.out.println(philosophyBook.getTextContent().trim());

System.out.println(philosophyBook.getFirstChild().getTextContent()

.trim());

}

6.1.2、使用dom创建xml文件

DomCreate.java代码如下所示：

/**

*使用DOM模型创建xml文档

package com.xml.dom;

import java.io.FileWriter;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Comment;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.ProcessingInstruction;

import org.w3c.dom.bootstrap.DOMImplementationRegistry;

import org.w3c.dom.ls.DOMImplementationLS;

import org.w3c.dom.ls.LSOutput;

import org.w3c.dom.ls.LSSerializer;

public class DomCreate {

public static void main(String[] args) throws Exception {

// DOM解析器工厂

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

factory.setIgnoringElementContentWhitespace(true);

//获取DOM解析器

DocumentBuilder builder = factory.newDocumentBuilder();

//创建一个新的Document对象

Document doc = builder.newDocument();

//设置XML版本

doc.setXmlVersion("1.0");

//创建处理指令

ProcessingInstruction pi = doc.createProcessingInstruction("sju",

"href='www.sju.edu.cn'");

//添加处理指令

doc.appendChild(pi);

Comment comment = doc.createComment("根元素之前的注释");

//创建根元素

Element root = doc.createElement("student");

//为根元素添加学号属性

root.setAttribute("学号","12010054052");

//创建name元素

Element item = doc.createElement("name");

//为name元素增加文本子节点

item.appendChild(doc.createTextNode("黄文伯"));

//将name元素添加到根元素之下

root.appendChild(item);

//创建age元素

item = doc.createElement("age");

//为age元素增加文本子节点

item.appendChild(doc.createTextNode("24"));

//将age元素添加到根元素之下

root.appendChild(item);

//创建high元素

item = doc.createElement("high");

//为high元素增加文本子节点

item.appendChild(doc.createTextNode("1.83"));

//将age元素添加到根元素之下

root.appendChild(item);

//创建score元素

item = doc.createElement("score");

//创建Java元素

Element lesson = doc.createElement("Java");

//为Java元素添加文本子元素

lesson.appendChild(doc.createTextNode("95"));

//将Java元素添加到score元素之下

item.appendChild(lesson);

//创建Struts元素

lesson = doc.createElement("Struts");

//为Struts元素添加文本子元素

lesson.appendChild(doc.createTextNode("95"));

//将Struts元素添加到score元素之下

item.appendChild(lesson);

//创建Hibernate元素

lesson = doc.createElement("Hibernate");

//为Hibernate元素添加文本子元素

lesson.appendChild(doc.createTextNode("85"));

//将Hibernate元素添加到score元素之下

item.appendChild(lesson);

//将score元素添加到根元素下

root.appendChild(item);

//为文档指定根元素

doc.appendChild(root);

//获取DOMImplementationRegistry对象，它是获取DOMImplementation的工厂

DOMImplementationRegistry registry = DOMImplementationRegistry

.newInstance();

//获取DOMImplementationLS对象

DOMImplementationLS domImplLS = (DOMImplementationLS) registry

.getDOMImplementation("LS");

//获取LSSerializer对象，他是专门用于序列化DOM树的工具

LSSerializer serializer = domImplLS.createLSSerializer();

//设置使用合理缩进使得xml文档更加美观

serializer.getDomConfig().setParameter("format-pretty-print",true);

LSOutput out = domImplLS.createLSOutput();

//指定输出文档编码所用的字符集

out.setEncoding("GB2312");

FileWriter stringOut = new FileWriter("src/com/xml/dom/test.xml");

out.setCharacterStream(stringOut);

//执行序列化（将DOM树转换成XML文档）

serializer.write(doc,out);

}

结果生成create.xml文件，代码如下所示：

<?xml version="1.0" encoding="GB2312"?>

<student学号="12010054052">

<score>

</score>

</student>

<?sju href='www.sju.edu.cn'?>

6.1.3、使用dom更新xml文件

DomUpdate.java代码如下所示：

/**

*使用DOM修改XML文档

package com.xml.dom;

import java.io.FileWriter;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.bootstrap.DOMImplementationRegistry;

import org.w3c.dom.ls.DOMImplementationLS;

import org.w3c.dom.ls.LSOutput;

import org.w3c.dom.ls.LSSerializer;

public class DomUpdate {

public static void main(String[] args) throws Exception {

// DOM解析器工厂

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

factory.setIgnoringElementContentWhitespace(true);

//获取DOM解析器

DocumentBuilder builder = factory.newDocumentBuilder();

//创建一个新的Document对象

Document doc = builder.parse("src/com/xml/dom/create.xml");

//获取文档中所有标签名为“name”的元素

NodeList names = doc.getElementsByTagName("name");

//如果names节点列表不为null，且至少包含1个节点

if (names != null && names.getLength() > 0) {

//获取第一个节点

Node name = names.item(0);

//修改节点数据

name.setTextContent("dirk");

}

//获取DOMImplementationRegistry对象，它是获取DOMImplementation的工厂

DOMImplementationRegistry registry = DOMImplementationRegistry

.newInstance();

//获取DOMImplementationLS对象

DOMImplementationLS domImplLS = (DOMImplementationLS) registry

.getDOMImplementation("LS");

//获取LSSerializer对象，他是专门用于序列化DOM树的工具

LSSerializer serializer = domImplLS.createLSSerializer();

//设置使用合理缩进使得xml文档更加美观

serializer.getDomConfig().setParameter("format-pretty-print",true);

LSOutput out = domImplLS.createLSOutput();

//指定输出文档编码所用的字符集

out.setEncoding("GB2312");

FileWriter stringOut = new FileWriter("src/com/xml/dom/update.xml");

out.setCharacterStream(stringOut);

//执行序列化（将DOM树转换成XML文档）

serializer.write(doc,out);

}

结果生成update.xml文件代码如下所示：

<?xml version="1.0" encoding="GB2312"?>

<student学号="12010054052">

<score>

</score>

</student>

<?sju href='www.sju.edu.cn'?>

6.2、SAX编程

6.2.1、使用sax解析xml文件

book.xml文件以及其约束文档book.dtd代码如下所示：

<?xml version="1.0" encoding="GB2312"?>

<!DOCTYPE book SYSTEM "book.dtd"[

<!ELEMENT book (computer_book)*>

<!ELEMENT book_name (#PCDATA)>

<!ATTLIST computer_book intro_movie ENTITIES #IMPLIED>

]

<computer_book intro-movie="movie">

<book_name>疯狂Java</book_name>

<book_price>99.00元</book_price>

</computer_book>

</booklist>

<?xml version="1.0" encoding="GB2312"?>

<!ELEMENT computer_book ((book_name,book_price))>

<!ELEMENT book_price (#PCDATA)>

<!NOTATION wmv SYSTEM "video/x-ms-wmv">

<!ENTITY movie SYSTEM "http://www.sju.edu.cn/test.wmv" NDATA wmv>

SAXParse类和MyHandler类代码如下所示：

/**

*使用XMLReader和SAXParser解析

package com.xml.sax;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.XMLReaderFactory;

public class SaxParse {

public static void main(String[] args) throws Exception{

System.out.println("--使用XMLReader解析--");

//创建XMLReader解析器

XMLReader reader = XMLReaderFactory.createXMLReader();

//注册ContentHandler解析器

reader.setContentHandler(new MyHandler());

//注册DTDHandler监听器

reader.setDTDHandler(new MyHandler());

reader.parse("src/com/xml/sax/book.xml");

System.out.println("--使用SAXParser解析--");

//创建SAX解析器工厂

SAXParserFactory factory = SAXParserFactory.newInstance();

//创建SAX解析器工厂

SAXParser parser = factory.newSAXParser();

//开始解析XML文档

parser.parse("src/com/xml/sax/book.xml",new MyHandler());

}

package com.xml.sax;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class MyHandler extends DefaultHandler {

//定义一个成员变量来保存当前正在处理的Tag

private String currentTag;

//每当处理文本数据是将触发该方法

@Override

public void characters(char[] ch,int length)

throws SAXException {

String content = new String(ch,length);

if (content.trim().length() > 0) {

System.out.println("<" + currentTag + ">元素的值是：" + content.trim());

}

//处理文档结束时触发该方法

@Override

public void endDocument() throws SAXException {

System.out.println("解析文档结束！");

}

//处理文档结束时触发该方法

@Override

public void endElement(String uri,String qName)

throws SAXException {

System.out.println("处理元素结束：" + qName);

}

//处理元素里命名空间属性结束是触发该方法

@Override

public void endPrefixMapping(String prefix) throws SAXException {

System.out.println("<" + currentTag + ">元素的命名空间属性的前缀：" + prefix);

}

//处理元素内容中可忽略的空白是触发该方法

@Override

public void ignorableWhitespace(char[] ch,int length)

throws SAXException {

}

//解析处理指令是触发该方法

@Override

public void processingInstruction(String target,String data)

throws SAXException {

System.out.println("当前处理的指令是：" + target);

System.out.println("处理指令数据是：" + data);

}

//跳过实体时触发该方法

@Override

public void skippedEntity(String name) throws SAXException {

System.out.println("SAX解析器跳过的实体名是：" + name);

}

//开始解析文档时触发该方法

@Override

public void startDocument() throws SAXException {

System.out.println("解析文档开始！");

}

@Override

public void startElement(String uri,

Attributes attributes) throws SAXException {

System.out.println("开始处理元素：" + qName);

currentTag = qName;

// attributes代表该元素包含的所有属性

int len = attributes.getLength();

if (len > 0) {

System.out.println("<" + currentTag + ">元素的属性如下：");

for (int i = 0; i < len; i++) {

System.out.println(attributes.getQName(i) + "--->"

+ attributes.getValue(i));

}

//开始处理元素里命名空间属性是触发该方法

@Override

public void startPrefixMapping(String prefix,String uri)

throws SAXException {

System.out.println("<" + currentTag + ">元素的命名空间属性的前缀：" + prefix);

System.out.println("<" + currentTag + ">元素的命名空间属性的URI为：" + uri);

}

//当遇到DTD中的符号定义时触发该方法

@Override

public void notationDecl(String name,String publicId,String systemId)

throws SAXException {

System.out.println("当前符号的名字是：" + name);

System.out.println("当前符号的PUBLIC ID是：" + publicId);

System.out.println("当前符号的SYSTEM ID是：" + systemId);

}

@Override

public void unparsedEntityDecl(String name,

String systemId,String notationName) throws SAXException {

System.out.println("当前未解析实体的名字是：" + name);

System.out.println("当前未解析实体的PUBLIC ID是：" + publicId);

System.out.println("当前未解析实体的SYSTEM ID是：" + systemId);

System.out.println("当前未解析实体实体关联符号名是：" + notationName);

}

原文链接：https://www.f2er.com/xml/299743.html

1、xml发展历史

2、为什么需要学习xml

3、xml语法

3.1、文档声明

3.2、元素

3.3、属性

3.4、注释

3.5、CDATA区、特殊字符

3.6、处理指令（processing instruction）

4、xml文件约束

4.1、xml约束概述

4.2、DTD约束

4.3、属性

4.4、xml Schema

5、xml编程

5.1、xml解析技术的介绍

5.2、DOM编程

5.3、SAX编程

5.4、DOM4J编程

6、疯狂XML书中重要案例

6.1、DOM编程

6.2、SAX编程

猜你在找的XML相关文章