关键词：xml、DTD约束、Schema约束、dom解析、sax解析、jaxp解析器、dom4j解析器
一、xml的简介
1、eXtensible Markup Language:可扩展标记型语言
①标记型语言：HTML是标记型语言，即使用标签来操作。
②可扩展：
- HTML里面的标签是固定，每个标签都有特定的含义<h1><br/><hr/>
- 标签可以自己定义，可以写中文的标签<person></person>、<猫></猫>
2、xml用途
①HTML是用于显示数据，xml也可以显示数据（不是主要功能）
②xml主要功能，为了储存数据
3、xml是W3C组织发布的技术，目前有两个版本1.0、1.1
目前使用的都是1.0版本（1.1版本不能向下兼容）
二、xml的应用
1、不同的系统之间传输数据
2、用来表示生活中有关系的数据
3、经常用在配置文件，如：现在连接数据库，肯定知道数据库的用户名和密码，数据库名称，如果修改数据的信息，不需要修改源代码，只要修改配置文件就可以了。
三、xml的语法
1、xml的文档声明
①创建一个文件 后缀名是 .xml
②如果写xml，第一步必须要有一个文档声明（写了文档声明之后，表示写xml文件的内容）
<?xml version="1.0" encoding="gbk"?>
- 在“<”和“？”之间、“？”和“>”之间和“xml”之间不能有空格。
- 文档声明必须写在第一行第一列
- 属性：
- version:xml的版本1.0（使用）1.1
- encoding：xml编码gbk utf-8 iso8859-1(不包含中文)
- standalone:是否需要依赖其他文件yes/no
③xml的中文乱码问题解决：保存时候和设置打开时的编码一致，不会出现乱码
2、定义元素（标签）
①标签定义
- 标签定义有开始必须有结束：<person></person>
- 标签没有内容，可以在标签内结束：<aa/>
- 标签可以嵌套，必须要合理嵌套
- 合理嵌套：<aa><bb></bb></aa>
- 不合理嵌套：<aa><bb></aa></bb>,这种方式是错误的
- 一个xml中，只能有一个根标签，其他标签都是这个标签下面的标签
- 在xml中把空格和换行都当成内容来解析，
- 下面这两段代码含义是不一样的
<aa>1111111</aa> <aa> 1111111 </aa>
②xml中标签的命名规则（可以用中文）
-
- xml代码区分大小写，如<p><P>是两个不同的标签
- 不能以数字或“_”（下划线）开头
- 不能以xml（或XML、或Xml等）开头
- 不能包含空格
- 名称中间不能包含冒号（：）。
3、定义属性
①在xml文档中，可以为元素定义属性
<person id1="aa" id2="bb"></person>
②属性定义要求
- 一个标签上可以有多个属性，如：<person id1="aa" id2="bb"></person>
- 属性名称不能相同，如<person id="aa" id="bb"></person>，出现错误
- 属性名称和属性值之间使用=，属性值使用引号包起来（可以是单引号，也可以双引号）
- xml属性的命名规范和元素的命名规范一致
4、注释
写法：<!-- 注释信息 -->
- 注释不能放到第一行，第一行必须放文档说明
- 注释不能出现在标记中，如非法写法： <greeting <!--Begin greet-->></greeting>
- 字符串“--”不能出现在注释中，如非法写法： <!--This is a Example--Hello World-->
- 在xml中，不允许注释以“--->”结尾。
- 注释不嵌套
5、特殊字符
利用转义字符
| 特殊符号 | 预定义实体 | 特殊符号 | 预定义实体 |
| & | & | " | " |
| < | < | ' | &apos |
| > | > |
6、CDATA区
可以解决多个字符都需要转义的操作 if （a<b && b<c && d>f）{}
把这些内容放到CDATA区里面，不需要转义了
写法：
<![CDATA[ 内容 ]]>
如：
<![CDATA[ <b>if (a<b && b<c && d>f）{} </b> ]]>
把特殊字符当做文本内容，而不是标签
7、PI指令（处理指令)（了解）
可以在xml中设置样式
写法：
<?xml-stylesheet type="text/css" href="css的路径"?>
设置样式，只能对英文标签名称起作用，对于中文的标签名称不起作用的。
8、xml语法总结：
- 所有xml元素都必须有关闭标签
- xml 标签对大小写敏感
- xml 必须正确嵌套顺序
- xml文档必须有根元素（只有一个）
- xml 的属性值需加引号
- 特殊字符必须转义 ----CDATA
- xml 中的空格、回车换行会解析时被保留
四、xml的约束
约束的作用：
如现在定义一个person的xml文件，只想要这个文件里面保存人的信息，比如name age等，但是如果在xml文件中写一个标签<猫>，发现可以正常显示，因为符合语法规范。但是猫肯定不是人的信息，xml的标签是自定义的，需要技术来规定xml中只能出现的元素，这个时候需要约束。
xml的约束的技术：DTD约束 和Schema约束。
1、DTD的快速入门
创建一个文件，后缀名为“.dtd”
步骤：
(1) 看xml中有几个元素，有几个元素，在dtd文件中写几个<!ELEMENT>
(2) 判断元素是简单元素还是复杂元素
-复杂元素：有子元素的元素
<!ELEMENT 元素名称 (子元素)>
-简单元素：没有子元素
<!ELEMENT 元素名称 (#PCDATA)>
(3)需要在xml文件中引入dtd文件三种引入方式：
①引入外部的dtd文件
<!DOCTYPE 根元素名称 SYSTEM “dtd文件的路径”>
②使用内部的dtd文件
<!DOCTYPE 书架 [ <!ELEMENT 书架 (书+)> <!ELEMENT 书 (书名,作者,售价)> <!ELEMENT 书名 (#PCDATA)> <!ELEMENT 作者 (#PCDATA)> <!ELEMENT 售价 (#PCDATA)> ]>
③使用外部的dtd文件（网络上的dtd文件）
<!DOCTYPE 根元素名称 PUBLIC "DTD名称" “DTD文件的URL”>
在框架struts2使用配置文件 使用外部的dtd文件
示例：
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE 书架 SYSTEM "book.dtd"> <书架> <书> <书名>Java就业培训教程</书名> <作者>张孝祥</作者> <售价>58.00元</售价> <!--如果添加dtd中无添加的元素，就会报错，即为约束--> </书> <书> <书名>EJB3.0入门经典</书名> <作者>黎活明</作者> <售价>39.00元</售价> </书> </书架>
book.dtd :
<!ELEMENT 书架 (书+)> <!ELEMENT 书 (书名,作者,售价)> <!ELEMENT 书名 (#PCDATA)> <!ELEMENT 作者 (#PCDATA)> <!ELEMENT 售价 (#PCDATA)>
2、使用dtd定义元素
语法：
<!ELEMENT 元素名 约束>
-简单元素：没有子元素
<!ELEMENT 元素名称 (#PCDATA)>
-
- （#PCDATA）:约束元素为字符串类型
- EMPTY：约束元素为空
- ANY：任意
-复杂元素：有子元素的元素
<!ELEMENT 元素名称 (子元素)>
表示子元素出现的次数
-
- +：表示一次或者多次
- ？：表示零次或者一次
- *：表示零次或者多次
子元素直接使用逗号“，”进行隔开，表示元素出现的顺序
子元素直接使用“|”隔开，表示元素只能出现其中的任意一个
括号“（）”，用于给元素进行分组
示例：
<!ELEMENT person (name+,age?,sex*,school)>
3、使用dtd定义属性
①语法：
<!ATTLIST 元素名称 属性名称 属性类型 属性的约束 >
②属性类型：
-CDATA：字符串
<!ATTLIST birthday ID1 CDATA #REQUIRED >
-枚举：表示只能在一定范围内出现值，但是只能每次出现其中的一个
如：红绿灯效果、（aa|bb|cc）
<!ATTLIST age ID2 (AA|BB|CC) #REQUIRED >
-ID：值只能是字母或下划线开头
<!ATTLIST name ID3 ID #REQUIRED>
③属性的约束
-#REQUIRED:属性必须存在
-#IMPLIED：属性可有可无
-#FIXED：表示一个固定值 ,如#FIXED "AAA"
属性的值必须是设置的这个固定值
<!ATTLIST sex ID4 CDATA #FIXED "AAA">
-直接值
不写属性，使用直接值
写了属性，使用设置那个值
<!ATTLIST school ID5 CDATA “WWW”>
4、实体的定义
语法：
<!ENTITY 实体名称 “实体的值”>
<!ENTITY TEST "HAHAHA">
使用实体 &实体名称； 比如： &TEST；
注意：定义实体需要写在内部dtd里面，如果写在外部的dtd里面，在某些浏览器下，内容无法显示。
五、xml解析的简介
1、xml是标记型文档
2、js使用dom解析标记型文档？
根据html的层级结构，在内存中分配一个树形结构，把html的标签，树形结构，把html的标签，属性和文本都封装成对象
document对象、element对象、属性对象、文本对象、Node节点对象
3、xml的解析方式（技术）：dom和sax
①dom解析和sax解析区别：
dom方式解析：根据xml的层级结构在内存中分配一个树形结构，把xml的标签，属性和文本都封装成对象
缺点：如果文件过大，造成内存溢出
优点：很方便实现增删改操作
sax方式解析：采用事件驱动，边读边解析，
从上到下，一行一行的解析，解析到某一个对象，把对象名称返回
缺点：不能实现增删改操作
优点：如果文件过大不会造成内存溢出，实现查询操作
②xml解析器：不同的公司和组织提供了针对dom和sax方式的解析器，通过api方式提供
- sun公司提供了针对dom和sax解析器 jaxp
- dom4j组织，针对dom和sax解析器 dom4j（实际开发中使用）
- jdom组织，针对dom和sax解析器 jdom
4、jaxp的api的查看
jaxp是javase中的一部分，jaxp解析器在jdk的javax.xml.parsers包里面
四个类：分别是针对dom和sax解析使用的类
①dom:
DocumentBuilder:解析器类
-抽象类，不能new
此类的实例可以从DocumentBuilderFactory.newDocumentBuilder() 方法获取
-一个方法，可以解析xml parse（“xml”路径） 返回是Document整个文档
-返回的document是一个接口，父节点是Node，如果在document里面找不到想要的方法，到Node里面去找
-在document里面方法
getElementsByTagName（String tagname）
--这个方法可以得到标签
--返回集合NodeList
createElement(String tagName)
--创建标签
createTextNode(String data)
--创建文本
appendChild(Node newChild)
--把文本添加到标签下面
removeChild(Node oldChild)
--删除节点
getParentNode（）
--获取父节点
getTextContent()
--得到标签里面的内容
DocumentBuilderFactory:解析器工厂
②sax：
SAXParser: 解析器类
SAXParserFactory:解析器工厂
5、使用jaxp实现增删改查操作
①、使用jaxp实现查询操作
查询xml中所有的name元素的值
步骤：
1、创建解析器工厂
DocumentBuilderFactory.newInstance();
2、根据解析器工厂创建解析器
builderFactory.newDocumentBuilder();
3、解析xml返回document
Document document = builder.parse(uri);
4、得到所有的name元素
使用document.getElementsByTagName("name");
5、返回集合，遍历集合，得到每一个name元素
-遍历 getLength() item()
-得到元素里面值 使用getTextContent()
查询xml中第一个name元素的值
步骤：
1、创建解析器工厂
2、根据解析器工厂创建解析器
3、解析xml返回document
4、得到所有的name元素
5、使用返回集合，里面方法item，下标获取具体的元素
Nodelist.item（下标）：集合下标从0开始
6、得到具体的值，使用getTextContent方法
②使用jaxp添加节点
在第一个p1下面（末尾）添加<sex>nv</sex>
步骤：
1、创建解析器工厂
2、根据解析器工厂创建解析器
3、解析xml返回document
4、得到第一个p1（得到所有p1，使用item方法下标得到）
5、创建sex标签createElementNode
6、串及文本createTextNode
7、把文本添加到sex下面appendChild
8、把sex添加到第一个p1下面
9、回写xml
③使用jaxp修改节点
修改第一p1下面的sex内容是男
步骤：
1、创建解析器工厂
2、根据解析器工厂创建解析器
3、解析xml返回document
4、得到sex item方法
5、修改sex里面的值setTextContent方法
6、回写xml
④使用jaxp删除节点
删除<sex>男</sex>节点
步骤：
1、创建解析器工厂
2、根据解析器工厂创建解析器
3、解析xml返回document
4、获取sex元素
5、获取sex的父节点,使用getParentNode方法
6、删除，使用父节点删除removeChild方法
7、回写xml
⑤使用jaxp遍历节点
遍历节点，把xml中的所有元素名称打印出来
步骤：
1、创建解析器工厂
2、根据解析器工厂创建解析器
3、解析xml返回document
===使用递归实现======
4、得到根节点
5、得到根节点子节点
6、得到根节点子节点的子节点
遍历方法：
private static void list1(Node node) { //判断元素类型时候才打印 if (node.getNodeType() == Node.ELEMENT_NODE){ System.out.println(node.getNodeName()); } //得到一层子节点 NodeList list = node.getChildNodes(); //遍历list for(int i=0; i<list.getLength();i++){ //继续得到node1的子节点 Node node1 = list.item(i); list1(node1); } }
实例：
xml文档：
<?xml version="1.0" encoding="UTF-8" standalone="no"?><person> <p1> <name>zhangsan</name> <age>20</age> <sex>女</sex> </p1> <p1> <name>lisi</name> <age>30</age> </p1> </person>}
1 package jaxptest; 2 import org.w3c.dom.*; 3 import javax.xml.parsers.DocumentBuilder; 4 import javax.xml.parsers.DocumentBuilderFactory; 5 import javax.xml.transform.Transformer; 6 import javax.xml.transform.TransformerFactory; 7 import javax.xml.transform.dom.DOMSource; 8 import javax.xml.transform.stream.StreamResult; 9 10 public class TestJaxp { 11 public static void main(String[] args) throws Exception{ 12 String uri = "src/person.xml"; 13 // selectAll(uri); 14 // selectSin(uri); 15 // addSex(uri); 16 // modifySex(uri); 17 // delSex(uri); 18 listElement(uri); 19 } 20 //解析dom方法解析xml文档方法 21 private static Document jaxpParseXml(String uri) throws Exception { 22 //创建解析器工厂 23 DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance(); 24 //创建解析器 25 DocumentBuilder builder = builderFactory.newDocumentBuilder(); 26 //解析xml返回document 27 Document document = builder.parse(uri); 28 return document; 29 } 30 //回写xml方法 31 private static void writeBack(Document document,String uri) throws Exception{ 32 TransformerFactory transformerFactory = TransformerFactory.newInstance(); 33 Transformer transformer = transformerFactory.newTransformer(); 34 transformer.transform(new DOMSource(document),new StreamResult(uri)); 35 } 36 //查询所有name元素的值 37 public static void selectAll(String uri) throws Exception { 38 //查询所有name元素的值 39 /* 40 * 1、创建解析器工厂 41 * 2、根据解析器工厂创建解析器 42 * 3、解析xml返回document 43 * 4、得到所有的name元素 44 * 5、返回集合，遍历集合，得到每一个name元素 45 * */ 46 Document document = jaxpParseXml(uri); 47 //得到name元素 48 NodeList list = document.getElementsByTagName("name"); 49 //遍历集合 50 for(int i=0;i<list.getLength();i++) { 51 Node name1 = list.item(i); 52 //得到name1元素里面的值 53 String s = name1.getTextContent(); 54 System.out.println(s); 55 } 56 } 57 //查询xml中第一个name元素的值 58 public static void selectSin(String uri) throws Exception{ 59 /* 60 * 1、创建解析器工厂 61 * 2、根据解析器工厂创建解析器 62 * 3、解析xml返回document 63 * 4、得到所有的name元素 64 * 5、使用返回集合，里面方法item，下标获取具体的元素 65 * 6、得到具体的值，使用getTextContent方法 66 * */ 67 Document document = jaxpParseXml(uri); 68 NodeList list = document.getElementsByTagName("name"); 69 Node name1 = list.item(0); 70 String s1 = name1.getTextContent(); 71 System.out.println(s1); 72 } 73 //在第一个p1下面（末尾）添加<sex>nv</sex> 74 public static void addSex(String uri) throws Exception { 75 /* 76 * 1、创建解析器工厂 77 * 2、根据解析器工厂创建解析器 78 * 3、解析xml返回document 79 * 4、得到第一个p1（得到所有p1，使用item方法下标得到） 80 * 5、创建sex标签createElementNode 81 * 6、串及文本createTextNode 82 * 7、把文本添加到sex下面appendChild 83 * 8、把sex添加到第一个p1下面 84 * 9、回写xml 85 * */ 86 Document document = jaxpParseXml(uri); 87 NodeList list = document.getElementsByTagName("p1"); 88 Node p1 = list.item(0); 89 Element sex1 = document.createElement("sex"); 90 Text text = document.createTextNode("女"); 91 sex1.appendChild(text); 92 p1.appendChild(sex1); 93 writeBack(document,uri); 94 } 95 //修改第一p1下面的sex内容是男 96 public static void modifySex(String uri) throws Exception{ 97 /* 98 * 1、创建解析器工厂 99 * 2、根据解析器工厂创建解析器 100 * 3、解析xml返回document 101 * 4、得到sex item方法 102 * 5、修改sex里面的值setTextContent方法 103 * 6、回写xml 104 * */ 105 Document document = jaxpParseXml(uri); 106 Node sex1 = document.getElementsByTagName("sex").item(0); 107 sex1.setTextContent("男"); 108 writeBack(document,uri); 109 } 110 //删除<sex>男</sex>节点 111 public static void delSex(String uri) throws Exception{ 112 /* 113 * 1、创建解析器工厂 114 * 2、根据解析器工厂创建解析器 115 * 3、解析xml返回document 116 * 4、获取sex元素 117 * 5、获取sex的父节点,使用getParentNode方法 118 * 6、删除，使用父节点删除removeChild方法 119 * 7、回写xml 120 * */ 121 Document document = jaxpParseXml(uri); 122 Node sex1 = document.getElementsByTagName("sex").item(0); 123 Node p1 = sex1.getParentNode(); 124 p1.removeChild(sex1); 125 writeBack(document,uri); 126 } 127 //遍历节点，把xml中的所有元素名称打印出来 128 public static void listElement(String uri) throws Exception { 129 /* 130 * 1、创建解析器工厂 131 * 2、根据解析器工厂创建解析器 132 * 3、解析xml返回document 133 * ===使用递归实现====== 134 * 4、得到根节点 135 * 5、得到根节点子节点 136 * 6、得到根节点子节点的子节点 137 * */ 138 Document document = jaxpParseXml(uri); 139 //编写一个方法实现遍历操作 140 list1(document); 141 } 142 private static void list1(Node node) { 143 //判断元素类型时候才打印 144 if (node.getNodeType() == Node.ELEMENT_NODE){ 145 System.out.println(node.getNodeName()); 146 } 147 //得到一层子节点 148 NodeList list = node.getChildNodes(); 149 //遍历list 150 for(int i=0; i<list.getLength();i++){ 151 //继续得到node1的子节点 152 Node node1 = list.item(i); 153 list1(node1); 154 } 155 }
六、Schema约束
（一）schema介绍
dtd语法：<!ELEMENT 元素名称 约束>
schema符号xml的语法，xml语句
一个xml中可以有多个schema，多个schema使用名称空间区分（类似于Java包名）
dtd里面有PCDATA类型，但是在schema里面可以支持更多的数据类型
比如年龄只能是整数，在schema中可以直接定义一个整数类型
schema语法更加复杂，schema目前不能替代dtd
(二)schema的快速入门
创建一个schema文件，后缀名是“.xsd”
根节点<schema>
1、在schema文件中
属性 xmlns="http://www.w3.org/2001/XMLSchema"
-表示当前xml是一个约束文件
targetNamespace="http://www.itcast.cn/201711111"
-使用schema约束文件，直接通过这个地址引入约束文件
elementFormDefault="qualified"
2、步骤：
①看xml中有多少个元素
<element>
②看简单元素和复杂元素
如复杂元素：
<complexType> <sequence> 子元素 </sequence> </complexType>
③简单元素，写在复杂元素的子元素位置
<element name="person"> <complexType> <sequence> <element name="name" type="string"></element> <element name="age" type="int"></element> </sequence> </complexType> </element>
④在被约束文件里面引入约束文件
<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.itcast.cn/201711111" xsi:schemaLocation="http://www.itcast.cn/201711111 1.xsd">
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" --表示xml是一个被约束文件
- xmlns="http://www.itcast.cn/201711111" --是约束文档中targetNamespace
- xsi:schemaLocation="http://www.itcast.cn/201711111 1.xsd" --targetNamespace 空格 约束文档的地址
3、XMLSchema复杂元素指示器
-
- <sequence>:表示元素的出现的顺序
- <all>:元素只能出现一次
- <choice>:元素只能出现其中的一个
- maxOccurs="unbounded" :表示元素的出现的次数,如：<element name="name" type="string" maxOccurs="unbounded"></element>
- <any></any>:表示任意元素
可以约束属性
写在复杂元素里面
写在</complexType>之前
--
<attribute name="id1" type="int" use="required"></attribute>
-name :属性名称
-type：属性类型int string
-use：属性是否必须出现 required
4、复杂的schema约束
<company xmlns = "http://www.example.org/company"
xmlns:dept = "http://www.example.org/department"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.example.org/company company.xsd http://www.example.org/department denpartment.xsd">
*引入多个schema文件，可以给每个起一个别名
如：
<employee age="30">
<!-- 部门名称 -->
<dept:name>100</dept:name>
*想要引入部门的约束文件里的那么，使用部门的别名 detp：元素名称
<!-- 员工名称 -->
<name>张三</name>
</employee>
示例：
xml文档
<?xml version="1.0" encoding="UTF-8" ?> <person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.itcast.cn/201711111" xsi:schemaLocation="http://www.itcast.cn/201711111 1.xsd"> <name>zhangsan</name> <age>20</age> </person>
xsd文档
<?xml version="1.0" encoding="UTF-8" ?> <schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.itcast.cn/201711111" elementFormDefault="qualified"> <element name="person"> <complexType> <sequence> <element name="name" type="string"></element> <element name="age" type="int"></element> </sequence> </complexType> </element> </schema>
七、sax解析
1、sax解析
解析xml有两种技术 dom和sax
dom方式解析：
根据xml的层级结构在内存中分配一个树形结构，
把xml的标签，属性和文本都封装成对象
sax方式解析：
采用事件驱动，边读边解析，
在java.xml.parsers包里面
-SAXParser
此类的实例可以从SAXParserFactory.newSAXParser（）方法获得
-parse（File f,DefaultHandler dh）
第一个参数：xml的路径
第二个参数：事件处理器
-SAXParserFactory
实例newInstance（）方法得到
sax执行过程：
2、使用jaxp的sax方式解析xml
sax方式不能实现增删改操作，只能做查询操作
打印出整个文档
-执行parse方法，第一个参数xml路径，第二个参数是事件处理器
-创建一个类，继承事件处理器的类，重写里面的三个方法
获取到所有的name元素的值
-定义一个成员变量flag=false
-判断开始方法是否是name元素，如果是name元素，把flag值设置成true
-如果flag值是true，在characters方法里面打印内容
-当执行到结束方法时候，把flag值设置成false
获取第一个name元素的值
-定义一个成员变量idx=1
-在结束方法时候，idx++
-想要打印出第一个name元素的值，在characters方法里面判断
实例：
1 import org.xml.sax.Attributes; 2 import org.xml.sax.SAXException; 3 import org.xml.sax.helpers.DefaultHandler; 4 import javax.xml.parsers.SAXParser; 5 import javax.xml.parsers.SAXParserFactory; 6 7 public class TestSax { 8 public static void main(String[] args) throws Exception { 9 /* 10 * 1、创建解析工厂 11 * 2、创建解析器 12 * 3、执行parse方法 13 * 4、自己创建一个类，继承DefaultHandler 14 * 5、重写里面的三个方法 15 * */ 16 SAXParserFactory saxParserFactory = SAXParserFactory.newInstance(); 17 SAXParser saxParser = saxParserFactory.newSAXParser(); 18 saxParser.parse("src/p1.xml",new MyDefault2()); 19 saxParser.parse("src/p1.xml",new MyDefault1()); 20 } 21 } 22 //实现获取第一个name元素 23 class MyDefault2 extends DefaultHandler { 24 boolean flag = false; 25 int index = 1; 26 @Override 27 public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException { 28 //判断qName是否是name元素 29 if ("name".equals(qName)) { 30 flag = true ; 31 } 32 } 33 @Override 34 public void characters(char[] ch, int start, int length) throws SAXException { 35 //当flag值是true时候，表示解析到name元素 36 if (flag == true && index == 1){ 37 System.out.println(new String(ch,start,length)); 38 } 39 } 40 @Override 41 public void endElement(String uri, String localName, String qName) throws SAXException { 42 //把flag设置成false，表示name元素结束 43 if ("name".equals(qName)) { 44 flag = false; 45 } 46 index++; 47 } 48 }
//获取所有name元素 49 class MyDefault1 extends DefaultHandler { 50 @Override 51 public void startElement(String uri, String localName, String qName, 52 Attributes attributes) throws SAXException { 53 System.out.print("<"+qName+">"); 54 } 55 @Override 56 public void characters(char[] ch, int start, int length) throws SAXException { 57 System.out.print(new String(ch,start,length)); 58 } 59 @Override 60 public void endElement(String uri, String localName, String qName) throws SAXException { 61 System.out.print("</"+ qName+">"); 62 } 63 }
xml文件：
<?xml version="1.0" encoding="UTF-8" ?> <person> <p1> <name>zhangsan</name> <age>20</age> </p1> <p1> <name>lisi</name> <age>25</age> </p1> </person>
八、使用dom4j解析xml
1、dom4j
dom4j使用一个组织，针对xml解析，提供解析器dom4j，非javase的一部分，需导入jar包
得到document
SAXReader reader = new SAXReader();
Document document = reader.read(url);
document的父接口是Node
如果在document里面找不到想要的方法，到Node里面去找
document里面的方法getRootElement（）：获取根节点返回的是Element
Element也是一个接口，父接口是Node
-Element和Node里面方法
getParent（）：获取父节点
addElement：添加标签
2、使用dom4j对xml进行增删改查操作
①查询所有name元素里面的值
步骤：
1、创建解析器
2、得到document
3、得到根节点 getRootElement()
4、得到所有的p1标签
-element(qname)
-表示获取标签下面的第一个子标签
-qname:标签名称
-elements（qname）
-获取标签下面是这个名称的所有子标签（一层）
-qname：标签名称
-elements（）
-获取标签下面的所有一层子标签
5、得到name
6、得到name里面的值
②使用dom4j对xml进行增删改查操作示例以及方法的封装
xml文档：
<?xml version="1.0" encoding="UTF-8"?> <person> <p1 id1="aaa"> <name>zhangsan</name> <age>30</age> <sex>女</sex> </p1> <p1> <name>lisi</name> <age>25</age> </p1> </person>
java文档：
1 package testDom4j; 2 3 import dom4jutils.Dom4jUtils; 4 import org.dom4j.Document; 5 import org.dom4j.DocumentHelper; 6 import org.dom4j.Element; 7 import org.dom4j.io.OutputFormat; 8 import org.dom4j.io.SAXReader; 9 import org.dom4j.io.XMLWriter; 10 11 import java.io.FileOutputStream; 12 import java.util.List; 13 14 public class TestDom4j { 15 public static void main(String[] args) throws Exception { 16 // selectName(); 17 // selectSin(); 18 // selectSecond(); 19 // addSex(); 20 // addAgeBefore(); 21 // modifyAge(); 22 // deleteSchool(); 23 getValues(); 24 } 25 //查询xml中所有name元素的值 26 public static void selectName() throws Exception{ 27 /* 28 * 1、创建解析器 29 * 2、得到document 30 * 3、得到根节点 getRootElement() 返回Element 31 * 4、得到所有的p1标签 32 * -elements（"p1"） 返回Element 33 * 5、得到name 34 * -在p1下面执行element（"name"）的方法返回Element 35 * 6、得到name里面的值 36 * -getText方法得到值 37 * */ 38 //创建解析器 39 SAXReader reader = new SAXReader(); 40 //得到document 41 Document document = reader.read("src/p1.xml"); 42 //得到根节点 43 Element root = document.getRootElement(); 44 //得到p1 45 List<Element> list = root.elements("p1"); 46 //遍历list 47 for(Element element : list) { 48 //element是每一个p1 49 //得到p1下面的name元素 50 Element name1 = element.element("name") ; 51 //得到name里面的值 52 String s = name1.getText(); 53 System.out.println(s); 54 } 55 } 56 57 //获取得到第一个name元素的值 58 public static void selectSin() throws Exception { 59 /* 60 * 1、创建解析器 61 * 2、得到document 62 * 3、得到根节点 63 * 4、得到第一个p1标签 64 * 5、得到p1下面的name元素 65 * 6、得到name里面的值 66 * */ 67 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 68 Element root = document.getRootElement(); 69 Element p1 = root.element("p1"); 70 Element name1 = p1.element("name"); 71 System.out.println(name1.getText()); 72 } 73 //获取得到第二个name元素的值 74 public static void selectSecond() throws Exception { 75 /* 76 * 1、创建解析器 77 * 2、得到document 78 * 3、得到根节点 79 * 4、得到所有的p1 80 * 5、遍历得到第二p1 81 * 6、得到第二个p1下面的name 82 * 7、得到name的值 83 * */ 84 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 85 Element root = document.getRootElement(); 86 List<Element> list = root.elements("p1"); 87 Element p2 = list.get(1); 88 Element name2 = p2.element("name"); 89 System.out.println(name2.getText()); 90 } 91 92 //在第一个p1标签末尾添加一个元素<sex>女</sex> 93 public static void addSex() throws Exception { 94 /* 95 * 1、创建解析器 96 * 2、得到document 97 * 3、得到根节点 98 * 4、获取第一个p1 99 * 5、在p1下面添加元素 100 * 6、在添加完成之后的元素下面添加文本 101 * 7、回写xml 102 * */ 103 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 104 Element root = document.getRootElement(); 105 //得到第一个p1元素 106 Element p1 = root.element("p1"); 107 //在p1下面直接添加元素 108 Element sex1 = p1.addElement("sex"); 109 //在sex下面添加文本 110 sex1.setText("女"); 111 //回写xml 112 OutputFormat format = OutputFormat.createPrettyPrint(); 113 XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"),format); 114 xmlWriter.write(document); 115 xmlWriter.close(); 116 } 117 118 //在特定位置添加元素，在第一个p1下面的age标签之前添加<school>ecit</school> 119 public static void addAgeBefore() throws Exception { 120 /* 121 * 1、创建解析器 122 * 2、得到document 123 * 3、得到根节点 124 * 4、获取第一个p1 125 * 5、在p1下面所有的元素 126 * 6、在指定位置添加元素 127 * 7、回写xml 128 * */ 129 //获得document 130 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 131 Element root = document.getRootElement(); 132 Element p1 = root.element("p1") ; 133 //获取p1下所有元素的集合 134 List<Element> list = p1.elements(); 135 //创建元素 136 Element school = DocumentHelper.createElement("school"); 137 school.setText("ecit"); 138 //在指定位置添加元素 139 list.add(1,school); 140 //回写xml 141 Dom4jUtils.xmlWriters(Dom4jUtils.PATH,document); 142 } 143 //修改节点的操作，修改第一个p1下面的age元素值为30 144 public static void modifyAge() throws Exception { 145 /* 146 * 1、得到document 147 * 2、得到根节点 148 * 3、获取第一个p1 149 * 4、得到p1下面的age 150 * 5、修改为30 151 * 6、回写xml 152 * */ 153 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 154 Element root = document.getRootElement(); 155 Element p1 = root.element("p1"); 156 Element age = p1.element("age"); 157 //使用setText（）方法修改文本内容 158 age.setText("30"); 159 Dom4jUtils.xmlWriters(Dom4jUtils.PATH,document); 160 } 161 //使用dom4j实现删除节点的操作，删除第一个p1下面的<school>ecit<school>元素 162 public static void deleteSchool() throws Exception{ 163 /* 164 * 1、得到document 165 * 2、得到根节点 166 * 3、获取第一个p1 167 * 4、得到第一个p1下面的school 168 * 5、删除（使用p1删除school） 169 * -得到school的父节点 170 * -第一种直接得到p1 171 * -使用方法getParent方法 172 * -在p1上面执行remove方法删除节点 173 * 6、回写xml 174 * */ 175 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 176 Element root = document.getRootElement(); 177 Element p1 = root.element("p1"); 178 Element sch = p1.element("school"); 179 //通过父节点删除 180 p1.remove(sch); 181 Dom4jUtils.xmlWriters(Dom4jUtils.PATH,document); 182 } 183 //使用dom4j获取属性的操作，获取第一个p1的属性id1的值 184 public static void getValues() throws Exception { 185 /* 186 * 1、得到document 187 * 2、得到根节点 188 * 3、获取第一个p1 189 * 4、得到第一个p1的值 190 * */ 191 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 192 Element root = document.getRootElement(); 193 Element p1 = root.element("p1"); 194 String value = p1.attributeValue("id1"); 195 System.out.println(value); 196 } 197 }
1 package dom4jutils; 2 3 import org.dom4j.Document; 4 import org.dom4j.DocumentException; 5 import org.dom4j.io.OutputFormat; 6 import org.dom4j.io.SAXReader; 7 import org.dom4j.io.XMLWriter; 8 9 import java.io.FileOutputStream; 10 import java.io.IOException; 11 12 public class Dom4jUtils { 13 public static final String PATH="src/p1.xml"; 14 //返回document 15 public static Document getDocument(String path) { 16 try { 17 //创建解析器 18 SAXReader reader = new SAXReader(); 19 //得到document 20 Document document = reader.read(path); 21 return document; 22 } catch (DocumentException e) { 23 e.printStackTrace(); 24 } 25 return null; 26 } 27 //回写xml 28 public static void xmlWriters(String path,Document document) { 29 try { 30 OutputFormat format = OutputFormat.createPrettyPrint(); 31 XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path),format); 32 xmlWriter.write(document); 33 xmlWriter.close(); 34 } catch (IOException e) { 35 e.printStackTrace(); 36 } 37 } 38 }
3、使用dom4j支持xpath的操作
可以直接获取到某个元素
第一种形式
/AAA/DDD/BBB：表示一层一层的，AAA下面DDD下面的BBB
第二种形式
//BBB：表示和这个名称相同，只要是名称是BBB，都得到
第三种形式
/* ：所有元素
第四种形式
** BBB[1] ：表示第一个BBB元素
** BBB[last()] :表示最后一个BBB元素
第五种形式
** //BBB[@id]：表示只要BBB元素上面有id属性，都得到
第六种形式
** //BBB[@id='b1'] ：表示元素名称是BBB，在BBB上面有id属性，并且id的属性值是b1
①具体操作：
默认情况下，dom4j不支持xpath，需导入jaxen-1.1-beta-6.jar
在dom4j里面提供了两个方法，用来支持xpath
-selectNodes("xpath表达式") ，获取多个节点
-selectionSingleNode（“xpath”表达式），获取一个节点
*使用xpath实现：查询xml中所有name元素的值
-所有name元素的xpath表示：//name
-使用selectionNodes（“//name”）;
代码和步骤：
/* * 1、得到document * 2、直接使用selectNodes("//name")方法的到所有的name元素 * */ //得到document Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); //使用selectNodes（"//name"）方法得到所有的name元素 List<Node> list = document.selectNodes("//name"); for (Node node : list){ //node是每一个name元素 String s = node.getText(); System.out.println(s); }
*使用xpath实现：获取第一个p1下面的name的值
-//p1[@id1='aaa']/name
-使用到selectSingleNode（“//p1[@id1='aaa']/name”）
九、实现简单的学生管理系统
1、xml文档，用于储存信息：
<?xml version="1.0" encoding="UTF-8"?> <student> <stu> <id>100</id> <name>zhangsan</name> <age>20</age> </stu> <stu> <id>101</id> <name>zhangsan</name> <age>30</age> </stu> </student>
2、构建service jar包用于查询、添加、删除方法的存储
1 package service; 2 3 import org.dom4j.Document; 4 import org.dom4j.Element; 5 import org.dom4j.Node; 6 import vo.Student; 7 import java.util.List; 8 9 public class StuService { 10 11 //查询 根据id查询学生信息 12 public static Student getStu(String id) throws Exception { 13 /* 14 * 1、创建解析器 15 * 2、得到document 16 * 3、获取所有的id 17 * 18 * 4、返回list集合，遍历list集合 19 * 5、得到每一个id的节点 20 * 6、id节点的值 21 * 7、判断id的值和传递的id值是否相同 22 * 8、如果相同，先获取到id的父节点stu 23 * 9、通过stu获取到name age值 24 * */ 25 Document document = StudentUtils.getDocument(StudentUtils.PATH); 26 List<Node> list = document.selectNodes("//id"); 27 Student student = new Student(); 28 for (Node node : list) { 29 String idv = node.getText(); 30 if (idv.equals(id)) { 31 Element stu = node.getParent(); 32 String namev = stu.element("name").getText(); 33 String agev = stu.element("age").getText(); 34 student.setId(idv); 35 student.setName(namev); 36 student.setAge(agev); 37 } 38 } 39 return student; 40 } 41 //增加 42 public static void addStu(Student student) throws Exception { 43 /* 44 * 1、创建解析器 45 * 2、得到document 46 * 3、获得根节点 47 * 4、在根节点上面创建stu标签 48 * 5、在stu标签上面依次添加id、name、age 49 * 6、在id name age上面依次添加值 50 * */ 51 Document document = StudentUtils.getDocument(StudentUtils.PATH); 52 Element root = document.getRootElement(); 53 Element stu = root.addElement("stu"); 54 Element id1 = stu.addElement("id"); 55 Element name1 = stu.addElement("name"); 56 Element age1 = stu.addElement("age"); 57 id1.setText(student.getId()); 58 name1.setText(student.getName()); 59 age1.setText(student.getAge()); 60 StudentUtils.xmlWriters(StudentUtils.PATH,document); 61 } 62 //删除，根据学生的id删除 63 public static void delStu(String id) throws Exception{ 64 /* 65 * 1、创建解析器 66 * 2、得到document 67 * 3、获取所有的id 68 * 使用xpath //id 返回list集合 69 * 4、遍历list集合 70 * 5、判断集合里面的id和传递的id是否相同 71 * 6、如果相同，把id所在的stu删除 72 * */ 73 Document document = StudentUtils.getDocument(StudentUtils.PATH); 74 List<Node> list = document.selectNodes("//id"); 75 for (Node node : list) { 76 String idv = node.getText(); 77 if (idv.equals(id)) { 78 Element stu = node.getParent(); 79 Element student = stu.getParent(); 80 student.remove(stu); 81 } 82 } 83 StudentUtils.xmlWriters(StudentUtils.PATH,document); 84 } 85 }
StuService操作类：
1 package service; 2 import org.dom4j.Document; 3 import org.dom4j.DocumentException; 4 import org.dom4j.io.OutputFormat; 5 import org.dom4j.io.SAXReader; 6 import org.dom4j.io.XMLWriter; 7 import java.io.FileOutputStream; 8 import java.io.IOException; 9 10 public class StudentUtils { 11 public static final String PATH="src/student.xml"; 12 //返回document 13 public static Document getDocument(String path) { 14 try { 15 //创建解析器 16 SAXReader reader = new SAXReader(); 17 //得到document 18 Document document = reader.read(path); 19 return document; 20 } catch (DocumentException e) { 21 e.printStackTrace(); 22 } 23 return null; 24 } 25 //回写xml 26 public static void xmlWriters(String path,Document document) { 27 try { 28 OutputFormat format = OutputFormat.createPrettyPrint(); 29 XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path),format); 30 xmlWriter.write(document); 31 xmlWriter.close(); 32 } catch (IOException e) { 33 e.printStackTrace(); 34 } 35 } 36 }
3、构建对象的封装包，用于对象设置与获取。
1 package vo; 2 3 public class Student { 4 private String id; 5 private String name; 6 private String age; 7 public String getId() {return id; } 8 public String getName() {return name; } 9 public String getAge() { return age;} 10 public void setId(String id) {this.id = id;} 11 public void setName(String name) { this.name = name;} 12 public void setAge(String age) { this.age = age;} 13 14 @Override 15 public String toString() { 16 return "Student{" + 17 "id='" + id + '\'' + 18 ", name='" + name + '\'' + 19 ", age='" + age + '\'' + 20 '}'; 21 } 22 }
4、构建测试包
1 package test; 2 3 import service.StuService; 4 import vo.Student; 5 6 public class TestStu { 7 public static void main(String[] args) throws Exception{ 8 testSelect(); 9 // testAdd(); 10 // testDel(); 11 } 12 //测试查询方法 13 public static void testSelect() throws Exception { 14 Student stu = StuService.getStu("100"); 15 System.out.println(stu.toString()); 16 } 17 //测试添加方法 18 public static void testAdd() throws Exception { 19 Student stu = new Student(); 20 stu.setId("103"); 21 stu.setName("wanwu"); 22 stu.setAge("25"); 23 StuService.addStu(stu); 24 } 25 //测试添加方法 26 public static void testDel() throws Exception{ 27 StuService.delStu("103"); 28 } 29 }
扫一扫
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
