1.xml的简介(了解)
* eXtensible Markup Language(XML):可扩展标记型语言** 标记型语言:html是标记型语言
- 也是使用标签来操作
** 可扩展:
- html里面的标签是固定,每个标签都有特定的含义 <h1> <br/> <hr/>
- 标签可以自己定义,可以写中文的标签 <person></person、<猫></猫>
* xml用途
** html是用于显示数据,xml也可以显示数据(不是主要功能)
** xml主要功能,为了存储数据
* xml是w3c组织发布的技术
* xml有两个版本 1.0 1.1
- 使用都是1.0版本,(1.1版本不能向下兼容)
2、xml的应用
* 不同的系统之间传输数据** qq之间数据的传输
** 画图分析过程
* 用来表示生活中有关系的数据
* 经常用在文件配置
* 比如现在连接数据库 肯定知道数据库的用户名和密码,数据名称
* 如果修改数据库的信息,不需要修改源代码,只要修改配置文件就可以了
3、xml的语法
(1)xml的文档声明(***)
* 创建一个文件 后缀名是 .xml* 如果写xml,第一步 必须要有 一个文档声明(写了文档声明之后,表示写xml文件的内容)
** <?xml version="1.0" encoding="gbk"?>
*** 文档声明必须写在 第一行第一列
* 属性
- version:xml的版本 1.0(使用) 1.1
- encoding:xml编码 gbk utf-8 iso8859-1(不包含中文)
- standalone:是否需要依赖其他文件 yes/no
* xml的中文乱码问题解决
** 保存XML文件时候的编码和设置打开时候的编码一致,不会出现乱码
(2)定义元素(标签)(***)
** 标签定义
** 标签定义有开始必须要有结束:<person></person>
** 标签没有内容,可以在标签内结束 ; <aa/>
** 标签可以嵌套,必须要合理嵌套
*** 合理嵌套 <aa><bb></bb></aa>
*** 不合理嵌套 <aa><bb></aa></bb>: 这种方式是不正确的
** 一个xml中,只能有一个根标签,其他标签都是这个标签下面的标签
** 在xml中把空格和换行都当成内容来解析,
**** 下面这两段代码含义是不一样的
* <aa>1111111</aa>
* <aa>
11111111111
</aa>
** xml标签可以是中文
** xml中标签的名称规则
(1)xml代码区分大小写
<p> <P>:这两个标签是不一样的
(2)xml的标签不能以数字和下划线(_)开头
<2a> <_aa>: 这样是不正确的
(3)xml的标签不能以xml、XML、Xml等开头
<xmla> <XmlB> <XMLC>: 这些都是不正确的
(4)xml的标签不能包含空格和冒号
<a b> <b:c> : 这些是不正确的
** 标签定义有开始必须要有结束:<person></person>
** 标签没有内容,可以在标签内结束 ; <aa/>
** 标签可以嵌套,必须要合理嵌套
*** 合理嵌套 <aa><bb></bb></aa>
*** 不合理嵌套 <aa><bb></aa></bb>: 这种方式是不正确的
** 一个xml中,只能有一个根标签,其他标签都是这个标签下面的标签
** 在xml中把空格和换行都当成内容来解析,
**** 下面这两段代码含义是不一样的
* <aa>1111111</aa>
* <aa>
11111111111
</aa>
** xml标签可以是中文
** xml中标签的名称规则
(1)xml代码区分大小写
<p> <P>:这两个标签是不一样的
(2)xml的标签不能以数字和下划线(_)开头
<2a> <_aa>: 这样是不正确的
(3)xml的标签不能以xml、XML、Xml等开头
<xmla> <XmlB> <XMLC>: 这些都是不正确的
(4)xml的标签不能包含空格和冒号
<a b> <b:c> : 这些是不正确的
(3)定义属性(***)
* html是标记型文档,可以有属性
* xml也是标记型文档,可以有属性
* <person id1="aaa" id2="bbb"></person>
** 属性定义的要求
(1)一个标签上可以有多个属性
<person id1="aaa" id2="bbb"></person>
(2)属性名称不能相同
<person id1="aaa" id1="bbb"></person>:这个是不正确,不能有两个id1
(3)属性名称和属性值之间使用= ,属性值使用引号包起来 (可以是单引号,也可以是双引号 )
(4)xml属性的名称规范和元素的名称规范一致
(4)注释(***)
* 写法 <!-- xml的注释 -->
** 注释也不能放到第一行,第一行第一列必须放文档声明
(5)特殊字符(***)
* 如果想要在xml中现在 a<b ,不能正常显示,因为把<当做标签
* 如果就想要显示,需要对特殊字符 < 进行转义
* < <
> >
(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的路径"?>
* 设置样式,只能对英文标签名称起作用,对于中文的标签名称不起作用的。
* 写法: <?xml-stylesheet type="text/css" href="css的路径"?>
* 设置样式,只能对英文标签名称起作用,对于中文的标签名称不起作用的。
*
* xml的语法的总结
所有 XML 元素都须有关闭标签
XML 标签对大小写敏感
XML 必须正确地嵌套顺序
XML 文档必须有根元素(只有一个)
XML 的属性值须加引号
特殊字符必须转义 --- CDATA
XML 中的空格、回车换行会解析时被保留
所有 XML 元素都须有关闭标签
XML 标签对大小写敏感
XML 必须正确地嵌套顺序
XML 文档必须有根元素(只有一个)
XML 的属性值须加引号
特殊字符必须转义 --- CDATA
XML 中的空格、回车换行会解析时被保留
4.xml的约束
规定xml中只能出现的元素,这个时候需要约束。
* xml的约束的技术 : dtd约束 和 schema约束
(1)dtd约束
A.dtd的创建
* 创建一个文件 后缀名 .dtd
步骤:
(1)看xml中有多少个元素 ,有几个元素,在dtd文件中写几个 <!ELEMENT>
(2)判断元素是简单元素还是复杂元素
- 复杂元素:有子元素的元素
<!ELEMENT 元素名称 (子元素)>
- 简单元素:没有子元素
<!ELEMENT 元素名称 (#PCDATA)>
(3)需要在xml文件中引入dtd文件
<!DOCTYPE 根元素名称 SYSTEM "dtd文件的路径">
步骤:
(1)看xml中有多少个元素 ,有几个元素,在dtd文件中写几个 <!ELEMENT>
(2)判断元素是简单元素还是复杂元素
- 复杂元素:有子元素的元素
<!ELEMENT 元素名称 (子元素)>
- 简单元素:没有子元素
<!ELEMENT 元素名称 (#PCDATA)>
(3)需要在xml文件中引入dtd文件
<!DOCTYPE 根元素名称 SYSTEM "dtd文件的路径">
下图就是dtd约束文档完整的样式,只要看懂,并根据其写出xml文件就可以了
<!ELEMENT TVSCHEDULE (CHANNEL+)>//复杂元素
<!ELEMENT CHANNEL (BANNER,DAY+)>
<!ELEMENT BANNER (#PCDATA)>
<!ELEMENT DAY (DATE,(HOLIDAY|PROGRAMSLOT+)+)>
<!ELEMENT HOLIDAY (#PCDATA)>
<!ELEMENT DATE (#PCDATA)>
<!ELEMENT PROGRAMSLOT (TIME,TITLE,DESCRIPTION?)>
<!ELEMENT TIME (#PCDATA)>
<!ELEMENT TITLE (#PCDATA)>
<!ELEMENT DESCRIPTION (#PCDATA)>
<!ATTLIST TVSCHEDULE NAME CDATA #REQUIRED>
<!ATTLIST CHANNEL CHAN CDATA #REQUIRED>
<!ATTLIST PROGRAMSLOT VTR CDATA #IMPLIED>
<!ATTLIST TITLE RATING CDATA #IMPLIED>
<!ATTLIST TITLE LANGUAGE CDATA #IMPLIED>
B.dtd的三种引入方式
(1)引入外部的dtd文件(一个xml文件,一个dtd文件)<!DOCTYPE 根元素名称 SYSTEM "dtd路径">
(2)使用内部的dtd文件(在xml文件里面写)
- <!DOCTYPE 根元素名称 [
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
]>
(3)使用外部的dtd文件(网络上的dtd文件)
<!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL">
- 后面学到框架 struts2 使用配置文件 使用 外部的dtd文件
- <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
C.使用dtd定义元素
* 语法: <!ELEMENT 元素名 约束>* 简单元素:没有子元素的元素
<!ELEMENT name (#PCDATA)>
*** (#PCDATA): 约束name是字符串类型
*** EMPTY : 元素为空(没有内容)
- <sex></sex>
*** ANY:任意
* 复杂元素:
<!ELEMENT person (name,age,sex,school)>
- 子元素只能出现一次
* <!ELEMENT 元素名称 (子元素)>
* 表示子元素出现的次数
+ : 表示一次或者多次
? :表示零次或者一次
* :表示零次或者多次
* 子元素直接使用逗号进行隔开 ,
** 表示元素出现的顺序
* 子元素直接使用|隔开
** 表示元素只能出现其中的任意一个
D.使用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 "ABC"
>
- 直接值
* 不写属性,使用直接值
* 写了属性,使用设置那个值
- <!ATTLIST school
ID5 CDATA "WWW"
>
F.实体的定义
* 语法: <!ENTITY 实体名称 "实体的值">*** <!ENTITY TEST "HAHAHEHE">
*** 使用实体 &实体名称; 比如 &TEST;
** 注意
* 定义实体需要写在内部dtd里面,
如果写在外部的dtd里面,有某些浏览器下,内容得不到
(2)、schema约束
** schema符合xml的语法,xml语句** 一个xml中可以有多个schema,多个schema使用名称空间区分(类似于java包名)
** dtd里面有PCDATA类型,但是在schema里面可以支持更多的数据类型
*** 比如 年龄 只能是整数,在schema可以直接定义一个整数类型
*** schema语法更加复杂,schema目前不能替代dtd
A.schema的快速入门
* 创建一个schema文件 后缀名是 .xsd** 根节点 <schema>
** 在schema文件里面
** 属性 xmlns="http://www.w3.org/2001/XMLSchema"
- 表示当前xml文件是一个约束文件
** targetNamespace="http://www.itcast.cn/20151111"
- 使用schema约束文件,直接通过这个地址引入约束文件
** elementFormDefault="qualified"
步骤
(1)看xml中有多少个元素
<element>
(2)看简单元素和复杂元素
* 如果复杂元素
<complexType>
<sequence>
子元素
</sequence>
</complexType>
(3)简单元素,写在复杂元素的
<element name="person">
<complexType>
<sequence>
<element name="name" type="string"></element>
<element name="age" type="int"></element>
</sequence>
</complexType>
</element>
(4)在被约束文件里面引入约束文件
<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.itcast.cn/20151111"
xsi:schemaLocation="http://www.itcast.cn/20151111 1.xsd">
** xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-- 表示xml是一个被约束文件
** xmlns="http://www.itcast.cn/20151111"
-- 是约束文档里面 targetNamespace
** xsi:schemaLocation="http://www.itcast.cn/20151111 1.xsd">
-- targetNamespace 空格 约束文档的地址路径
* <sequence>:表示元素的出现的顺序
<all>: 元素只能出现一次
<choice>:元素只能出现其中的一个
maxOccurs="unbounded": 表示元素的出现的次数
<any></any>:表示任意元素
* 可以约束属性
* 写在复杂元素里面
***写在 </complexType>之前
--
<attribute name="id1" type="int" use="required"></attribute>
- name: 属性名称
- type:属性类型 int stirng
- use:属性是否必须出现 required
* 复杂的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 department.xsd"
>
* 引入多个schema文件,可以给每个起一个别名
<employee age="30">
<!-- 部门名称 -->
<dept:name>100</dept:name>
* 想要引入部门的约束文件里面的name,使用部门的别名 detp:元素名称
<!-- 员工名称 -->
<name>王晓晓</name>
</employee>
<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.itcast.cn/20151111"
elementFormDefault="qualified">
<element name="person">
<complexType>
<sequence>
<!-- <all> -->
<!-- <choice> -->
<element name="name" type="string" maxOccurs="unbounded"></element>
<element name="age" type="int"></element>
<!-- </choice> -->
<!-- </all> -->
</sequence>
<attribute name="id1" type="int" use="required"></attribute>
</complexType>
</element>
</schema>
5.XML的解析简介
* xml的解析方式(技术):dom 和 sax
*** dom解析和sax解析区别:
*** dom解析和sax解析区别:
** dom方式解析
* 根据xml的层级结构在内存中分配一个树形结构,把xml的标签,属性和文本都封装成对象
* 缺点:如果文件过大,造成内存溢出
* 优点:很方便实现增删改操作
** sax方式解析
* 采用事件驱动,边读边解析
- 从上到下,一行一行的解析,解析到某一个对象,返回对象名称
* 缺点:不能实现增删改操作
* 优点:如果文件过大,不会造成内存溢出,方便实现查询操作
* 想要解析xml,首先需要解析器
** 不同的公司和组织提供了 针对dom和sax方式的解析器,通过api方式提供
*** sun公司提供了针对dom和sax解析器 jaxp
*** dom4j组织,针对dom和sax解析器 dom4j(*** 实际开发中****)
*** jdom组织,针对dom和sax解析器 jdom
** 不同的公司和组织提供了 针对dom和sax方式的解析器,通过api方式提供
*** sun公司提供了针对dom和sax解析器 jaxp
*** dom4j组织,针对dom和sax解析器 dom4j(*** 实际开发中****)
*** jdom组织,针对dom和sax解析器 jdom
解析下面的xml文件
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<person>
<p1>
<name>zhangsan</name>
<age>20</age>
</p1>
<p1>
<name>lisi</name>
<age>30</age>
</p1>
</person>
(1)jaxp解析(dom方式)
** jaxp是javase的一部分
** jaxp解析器在jdk的javax.xml.parsers包里面
** 四个类:分别是针对dom和sax解析使用的类
** jaxp解析器在jdk的javax.xml.parsers包里面
** 四个类:分别是针对dom和sax解析使用的类
第一步都是要写下面的代码
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml返回document
* 2、根据解析器工厂创建解析器
* 3、解析xml返回document
//创建解析器工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//解析xml返回document
Document document = builder.parse("src/person.xml");
得到Document后可以使用方法查询根据标签查询自己需要的信息了
在document里面方法
getElementsByTagName(String tagname)
-- 这个方法可以得到标签
-- 返回集合 NodeList
createElement(String tagName)
-- 创建标签
createTextNode(String data)
-- 创建文本
appendChild(Node newChild)
-- 把文本添加到标签下面
removeChild(Node oldChild)
-- 删除节点
getParentNode()
-- 获取父节点
NodeList list
- getLength() 得到集合的长度
- item(int index)下标取到具体的值
for(int i=0;i<list.getLength();i++) {
list.item(i)
}
getTextContent()
- 得到标签里面的内容
getElementsByTagName(String tagname)
-- 这个方法可以得到标签
-- 返回集合 NodeList
createElement(String tagName)
-- 创建标签
createTextNode(String data)
-- 创建文本
appendChild(Node newChild)
-- 把文本添加到标签下面
removeChild(Node oldChild)
-- 删除节点
getParentNode()
-- 获取父节点
NodeList list
- getLength() 得到集合的长度
- item(int index)下标取到具体的值
for(int i=0;i<list.getLength();i++) {
list.item(i)
}
getTextContent()
- 得到标签里面的内容
如果修改xml的文件的信息就必须回写xml,执行下面的代码
<span style="color:#ff0000;"> </span> //回写xml
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
下面示范代码
<span style="font-size:14px;">package cn.itcast.jaxptest;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;
/**
* 实现jaxp操作xml
* @author asus
*
*/
public class TestJaxp {
public static void main(String[] args) throws Exception {
//selectAll();
//selectSin();
//addSex();
//modifySex();
//delSex();
listElement();
}
//遍历节点,把所有元素名称打印出来
public static void listElement() throws Exception {
/*
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml,返回document
*
* ====使用递归实现=====
* 4、得到根节点
* 5、得到根节点子节点
* 6、得到根节点子节点的子节点
* */
//创建解析器工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//得到document
Document document = builder.parse("src/person.xml");
//编写一个方法实现遍历操作
list1(document);
}
//递归遍历的方法
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++) {
//得到每一个节点
Node node1 = list.item(i);
//继续得到node1的子节点
//node1.getChildNodes()
list1(node1);
}
}
//删除<sex>nan</sex>节点
public static void delSex() throws Exception {
/*
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml,返回document
*
* 4、获取sex元素
* 5、获取sex的父节点
* 6、删除使用父节点删除 removeChild方法
*
* 7、回写xml
* */
//创建解析器工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//得到document
Document document = builder.parse("src/person.xml");
//得到sex元素
Node sex1 = document.getElementsByTagName("sex").item(0);
//得到sex1父节点
Node p1 = sex1.getParentNode();
//删除操作
p1.removeChild(sex1);
//回写xml
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
}
//修改第一个p1下面的sex内容是nan
public static void modifySex() throws Exception {
/*
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml,返回document
*
* 4、得到sex item方法
* 5、修改sex里面的值 setTextContent方法
*
* 6、回写xml
* */
//创建解析器工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//得到document
Document document = builder.parse("src/person.xml");
//得到sex
Node sex1 = document.getElementsByTagName("sex").item(0);
//修改sex值
sex1.setTextContent("nan");
//回写xml
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
}
//在第一个p1下面(末尾)添加 <sex>nv</sex>
public static void addSex() throws Exception {
/*
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml,返回document
*
* 4、得到第一个p1
* - 得到所有p1,使用item方法下标得到
* 5、创建sex标签 createElement
* 6、创建文本 createTextNode
* 7、把文本添加到sex下面 appendChild
* 8、把sex添加到第一个p1下面
*
* 9、回写xml
* */
//创建解析器工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//得到document
Document document = builder.parse("src/person.xml");
//得到所有的p1
NodeList list = document.getElementsByTagName("p1");
//得到第一个p1
Node p1 = list.item(0);
//创建标签
Element sex1 = document.createElement("sex");
//创建文本
Text text1 = document.createTextNode("nv");
//把文本添加到sex1下面
sex1.appendChild(text1);
//把sex1添加到p1下面
p1.appendChild(sex1);
//回写xml
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
}
//查询xml中第一个name元素的值
public static void selectSin() throws Exception {
/*
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml,返回document
*
* 4、得到所有name元素
* 5、使用返回集合,里面方法 item,下标获取具体的元素
* 6、得到具体的值,使用 getTextContent方法
*
* */
//创建解析器工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//解析xml,得到document
Document document = builder.parse("src/person.xml");
//得到所有的name元素
NodeList list = document.getElementsByTagName("name");
//使用下标 得到第一个元素
Node name1 = list.item(1);
//得到name里面的具体的值
String s1 = name1.getTextContent();
System.out.println(s1);
}
//查询所有name元素的值
private static void selectAll() throws Exception {
//查询所有name元素的值
/*
* 1、创建解析器工厂
* 2、根据解析器工厂创建解析器
* 3、解析xml返回document
*
* 4、得到所有的name元素
* 5、返回集合,遍历集合,得到每一个name元素
* */
//创建解析器工厂 atl / : 代码提示
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//解析xml返回document
Document document = builder.parse("src/person.xml");
//得到name元素
NodeList list = document.getElementsByTagName("name");
//遍历集合
for(int i=0;i<list.getLength();i++) {
Node name1 = list.item(i); //得到每一个name元素
//得到name元素里面的值
String s = name1.getTextContent();
System.out.println(s);
}
}
}</span><span style="font-size:18px;">
</span>
(2)jaxp解析(sax方式)
* sax方式:事件驱动,边读边解析
* 在javax.xml.parsers包里面
** SAXParser
此类的实例可以从 SAXParserFactory.newSAXParser() 方法获得
- parse(File f, DefaultHandler dh)
* 两个参数
** 第一个参数:xml的路径
** 事件处理器
** SAXParserFactory
实例 newInstance() 方法得到
* 当解析到开始标签时候,自动执行startElement方法
* 当解析到文本时候,自动执行characters方法
* 当解析到结束标签时候,自动执行endElement方法
* 在javax.xml.parsers包里面
** SAXParser
此类的实例可以从 SAXParserFactory.newSAXParser() 方法获得
- parse(File f, DefaultHandler dh)
* 两个参数
** 第一个参数:xml的路径
** 事件处理器
** SAXParserFactory
实例 newInstance() 方法得到
* 当解析到开始标签时候,自动执行startElement方法
* 当解析到文本时候,自动执行characters方法
* 当解析到结束标签时候,自动执行endElement方法
* sax方式不能实现增删改操作,只能做查询操作
实例代码
<span style="font-size:14px;color:#333333;">package cn.itcast.jaxpsax;
import javax.xml.parsers.ParserConfigurationException;
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 TestSax {
public static void main(String[] args) throws Exception {
/*
* 1、创建解析器工厂
* 2、创建解析器
* 3、执行parse方法
*
* 4、自己创建一个类,继承DefaultHandler
* 5、重写类里面的三个方法
* */
//创建解析器工厂
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
//创建解析器
SAXParser saxParser = saxParserFactory.newSAXParser();
//执行parse方法
saxParser.parse("src/p1.xml", new MyDefault2());
}
}
//实现获取所有的name元素的值
class MyDefault2 extends DefaultHandler {
boolean flag = false;
int idx = 1;
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
//判断qName是否是name元素
if("name".equals(qName)) {
flag = true;
}
}
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
//当flag值是true时候,表示解析到name元素
//索引是1
if(flag == true && idx == 2) {
System.out.println(new String(ch,start,length));
}
}
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
//把flag设置成false,表示name元素结束
if("name".equals(qName)) {
flag = false;
idx++;
}
}
}
class MyDefault1 extends DefaultHandler {
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
System.out.print("<"+qName+">");
}
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
System.out.print(new String(ch,start,length));
}
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
System.out.print("</"+qName+">");
}
}</span><span style="color:#ff0000;font-size:18px;">
</span>
(3)dom4j解析
使用dom4j解析xml要导入其包
package cn.itcast.dom4jtest;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import cn.itcast.utils.Dom4jUtils;
public class TestDom4j {
public static void main(String[] args) throws Exception {
// selectName();
// selectSin();
// selectSecond();
// addSex();
// addAgeBefore();
// modifyAge();
// delSch();
getValues();
}
//获取第一个p1里面的属性id1的值
public static void getValues() throws Exception {
/*
* 1、得到document
* 2、得到根节点
* 3、得到第一个p1元素
* 4、得到p1里面的属性值
* */
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//得到根节点
Element root = document.getRootElement();
//得到第一个p1元素
Element p1 = root.element("p1");
//得到p1里面的属性值
String value = p1.attributeValue("id1");
System.out.println(value);
}
//删除第一个p1下面的<school>ecit</school>元素
public static void delSch() throws Exception {
/*
* 1、得到document
* 2、得到根节点
* 3、得到第一个p1标签
* 4、得到第一个p1下面的school元素
* 5、删除(使用p1删除school)
*
* 6、回写xml
* */
//得到document ctrl shift o 快速导包
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//得到根节点
Element root = document.getRootElement();
//得到第一个p1元素
Element p1 = root.element("p1");
//得到p1下面的school标签
Element sch = p1.element("school");
//删除school元素
//通过父节点删除
//获取父节点的方法
//sch.getParent(); //获取到school的父节点p1
p1.remove(sch);
//回写xml
Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
}
//修改第一个p1下面的age元素的值 <age>30</age>
public static void modifyAge() throws Exception {
/*
* 1、得到document
* 2、得到根节点,然后再得到第一个p1元素
* 3、得到第一个p1下面的age
* 4、修改值是 30
*
* 5、回写xml
*
* */
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//得到第一个根节点
Element root = document.getRootElement();
//得到第一个p1
Element p1 = root.element("p1");
//得到p1下面的age
Element age = p1.element("age");
//修改age的值
age.setText("300");
//回写xml
Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
}
//在第一个p1下面的age标签之前添加 <school>ecit.edu.cn</schlool>
public static void addAgeBefore() throws Exception {
/*
* 1、创建解析器
* 2、得到document
* 3、得到根节点
* 4、获取到第一个p1
*
* 5、获取p1下面的所有的元素
* ** elements()方法 返回 list集合
* ** 使用list里面的方法,在特定位置添加元素
* ** 创建元素 在元素下面创建文本
* *** add(int index, E element)
* - 第一个参数是 位置 下标,从0开始
* - 第二个参数是 要添加的元素
* 6、回写xml
* */
//创建解析器
// SAXReader saxReader = new SAXReader();
//得到document
// Document document = saxReader.read("src/p1.xml");
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//得到根节点
Element root = document.getRootElement();
//获取到第一个p1
Element p1 = root.element("p1");
//获取p1下面的所有元素
List<Element> list = p1.elements();
//创建元素 使用
Element school = DocumentHelper.createElement("school");
//在school下面创建文本
school.setText("ecit");
//在特定位置添加
list.add(1, school);
//回写xml
/*OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"), format);
xmlWriter.write(document);
xmlWriter.close();*/
Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
}
//在第一个p1标签末尾添加一个元素 <sex>nv</sex>
public static void addSex() throws Exception {
/*
* 1、创建解析器
* 2、得到document
* 3、得到根节点
*
* 4、获取到第一个p1
* 5、在p1下面添加元素
* 6、在添加完成之后的元素下面添加文本
*
* 7、回写xml
* */
//创建解析器
// SAXReader reader = new SAXReader();
//得到document
// Document document = reader.read("src/p1.xml");
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//得到根节点
Element root = document.getRootElement();
//得到第一个p1元素
Element p1 = root.element("p1");
//在p1下面直接添加元素
Element sex1 = p1.addElement("sex");
//在sex下面添加文本
sex1.setText("nv");
//回写xml
// OutputFormat format = OutputFormat.createPrettyPrint(); //可以有缩进的效果
OutputFormat format = OutputFormat.createCompactFormat();
// XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"), format);
// xmlWriter.write(document);
// xmlWriter.close();
Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
}
//获取第二个name元素里面的值
public static void selectSecond() throws Exception {
/*
* 1、创建解析器
* 2、得到document
* 3、得到根节点
*
* 4、得到所有的p1
* 5、遍历得到第二个p1
* 6、得到第二个p1下面的name
* 7、得到name的值
* */
//创建解析器
SAXReader saxReader = new SAXReader();
//得到document
Document document = saxReader.read("src/p1.xml");
//得到根节点
Element root = document.getRootElement();
//得到所有的p1
List<Element> list = root.elements("p1");
//得到第二个p1 list集合下标从0开始
Element p2 = list.get(1);
//得到p1下面的name
Element name2 = p2.element("name");
//得到name里面的值
String s2 = name2.getText();
System.out.println(s2);
}
//获取到一个name元素里面的值
public static void selectSin() throws Exception {
/*
* 1、创建解析器
* 2、得到document
* 3、得到根节点
*
* 4、得到第一个p1元素
* 5、得到p1下面的name元素
* 6、得到name元素里面的值
* */
//创建解析器
SAXReader saxReader = new SAXReader();
//得到document
Document document = saxReader.read("src/p1.xml");
//得到根节点
Element root = document.getRootElement();
//得到第一个p1
Element p1 = root.element("p1");
//得到p1下面的name元素
Element name1 = p1.element("name");
//得到name的值
String s1 = name1.getText();
System.out.println(s1);
}
//查询xml中所有name元素的值
public static void selectName() throws Exception {
/*
* 1、创建解析器
* 2、得到document
* 3、得到根节点
*
* 4、得到p1
* 5、得到p1下面的name
* 6、得到name里面的值
* */
//创建解析器
SAXReader saxReader = new SAXReader();
//得到document
Document document = saxReader.read("src/p1.xml");
//得到根节点
Element root = document.getRootElement();
//得到p1
List<Element> list = root.elements("p1");
//遍历list
for (Element element : list) {
//element是每一个p1元素
//得到p1下面的name元素
Element name1 = element.element("name");
//得到name里面的值
String s = name1.getText();
System.out.println(s);
}
}
}
(4)dom4j解析(支持Xpath)
A.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
* 第一种形式
/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
B.使用dom4j支持xpath具体操作
** 默认的情况下,dom4j不支持xpath
** 如果想要在dom4j里面是有xpath
* 第一步需要,引入支持xpath的jar包,使用 jaxen-1.1-beta-6.jar
** 需要把jar包导入到项目中
** 在dom4j里面提供了两个方法,用来支持xpath
*** selectNodes("xpath表达式")
- 获取多个节点
*** selectSingleNode("xpath表达式")
** 如果想要在dom4j里面是有xpath
* 第一步需要,引入支持xpath的jar包,使用 jaxen-1.1-beta-6.jar
** 需要把jar包导入到项目中
** 在dom4j里面提供了两个方法,用来支持xpath
*** selectNodes("xpath表达式")
- 获取多个节点
*** selectSingleNode("xpath表达式")
- 获取一个节点
示范代码
package cn.itcast.dom4jtest;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Node;
import cn.itcast.utils.Dom4jUtils;
public class TestDom4jXpath {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// test1();
test2();
}
//使用xpath实现:获取第一个p1下面的name的值
public static void test2() throws Exception {
/*
* 1、得到document
* 2、直接使用selectSingleNode方法实现
* - xpath : //p1[@id1='aaaa']/name
* */
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//直接使用selectSingleNode方法实现
Node name1 = document.selectSingleNode("//p1[@id1='aaaa']/name"); //name的元素
//得到name里面的值
String s1 = name1.getText();
System.out.println(s1);
}
//查询xml中所有name元素的值
public static void test1() throws Exception {
/*
* 1、得到document
* 2、直接使用selectNodes("//name")方法得到所有的name元素
*
* */
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//使用selectNodes("//name")方法得到所有的name元素
List<Node> list = document.selectNodes("//name");
//遍历list集合
for (Node node : list) {
//node是每一个name元素
//得到name元素里面的值
String s = node.getText();
System.out.println(s);
}
}
}
6.综合项目演练
创建一个存储学生信息的xml文件
要求:1.查询 根据id查询学生信息
2.增加学生信息
3.删除 根据学生的id删除
student.xml
<?xml version="1.0" encoding="UTF-8"?>
<sudent>
<stu>
<id>100</id>
<name>zhangsan</name>
<age>20</age>
</stu>
<stu>
<id>101</id>
<name>lisi</name>
<age>30</age>
</stu>
</sudent>
StuService.java
package cn.itcast.service;
import java.io.FileOutputStream;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import cn.itcast.vo.Student;
public class StuService {
//查询 根据id查询学生信息
public static Student getStu(String id) throws Exception {
/*
* 1、创建解析器
* 2、得到document
*
* 3、获取到所有的id
* 4、返回的是list集合,遍历list集合
* 5、得到每一个id的节点
* 6、id节点的值
* 7、判断id的值和传递的id值是否相同
* 8、如果相同,先获取到id的父节点stu
* 9、通过stu获取到name age值
*
* */
//创建解析器
SAXReader saxReader = new SAXReader();
//得到document
Document document = saxReader.read("src/student.xml");
//获取所有的id
List<Node> list = document.selectNodes("//id");
//创建student对象
Student student = new Student();
//遍历list
for (Node node : list) { //node是每一个id节点
//得到id节点的值
String idv = node.getText();
//判断id是否相同
if(idv.equals(id)) {
//得到id的父节点 stu
Element stu = node.getParent();
//通过stu获取name和age
String namev = stu.element("name").getText();
String agev = stu.element("age").getText();
student.setId(idv);
student.setName(namev);
student.setAge(agev);
}
}
return student;
}
//增加
public static void addStu(Student student) throws Exception {
/*
* 1、创建解析器
* 2、得到document
* 3、获取到根节点
* 4、在根节点上面创建stu标签
* 5、在stu标签上面依次添加id name age
* 6、在id name age上面依次添加值
*
* 7、回写xml
* */
//创建解析器
SAXReader saxReader = new SAXReader();
//得到document
Document document = saxReader.read("src/student.xml");
//得到根节点
Element root = document.getRootElement();
//在根节点上面添加stu
Element stu = root.addElement("stu");
//在stu标签上面依次添加id name age标签
Element id1 = stu.addElement("id");
Element name1 = stu.addElement("name");
Element age1 = stu.addElement("age");
//在id name age上面依次添加值
id1.setText(student.getId());
name1.setText(student.getName());
age1.setText(student.getAge());
//回写xml
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/student.xml"), format);
xmlWriter.write(document);
xmlWriter.close();
}
//删除 根据学生的id删除
public static void delStu(String id) throws Exception {
/*
* 1、创建解析器
* 2、得到document
*
* 3、获取到所有的id
* 使用xpath //id 返回 list集合
* 4、遍历list集合
* 5、判断集合里面的id和传递的id是否相同
* 6、如果相同,把id所在的stu删除
*
* */
//创建解析器
SAXReader saxReader = new SAXReader();
//得到document
Document document = saxReader.read("src/student.xml");
//获取所有的id xpath: //id
List<Node> list = document.selectNodes("//id");
//遍历list集合
for (Node node : list) { //node是每一个id的元素
//得到id的值
String idv = node.getText();
//判断idv和传递的id是否相同
if(idv.equals(id)) { //id相同
//得到stu节点
Element stu = node.getParent();
//获取stu的父节点
Element student = stu.getParent();
//删除stu
student.remove(stu);
}
}
//回写xml
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/student.xml"), format);
xmlWriter.write(document);
xmlWriter.close();
}
}
TestStu.java
package cn.itcast.test;
import cn.itcast.service.StuService;
import cn.itcast.vo.Student;
public class TestStu {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// testAdd();
// testDel();
testSelect();
}
//测试查询方法
public static void testSelect() throws Exception {
Student stu = StuService.getStu("100");
System.out.println(stu.toString());
}
//测试删除方法
public static void testDel() throws Exception {
StuService.delStu("103");
}
//测试添加方法
public static void testAdd() throws Exception {
//设置值
Student stu = new Student();
stu.setId("103");
stu.setName("wangwu");
stu.setAge("40");
StuService.addStu(stu);
}
}
Student.java
package cn.itcast.vo;
public class Student {
private String id;
private String name;
private String age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}