02 xml

已于 2022-03-15 11:21:15 修改
阅读量357 收藏 1
点赞数
分类专栏： 大数据高并发基础 文章标签： xml html 前端
于 2022-01-09 16:41:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37636107/article/details/122393640
版权

xml

1.1. 概念

XML 指的是，Extensible Markup Language 可扩展标记语言。
XML 被发明的目的是传输和存储数据，而不是展示数据；
KML 的标签必须自定义，但是在写标签名的时候一定要有含义；
XML 是W3c推举的数据传输格式；
可扩展：标签都是自定义的。

1.2. 功能

存储数据，配置文件，在网络中传输。

1.3. xml与html的区别

xml 不是为了展示数据，
html 才是为了展示数据用的。
html(Hypertext Marked Language)xml(Extensible Markup Language)都属于w3c万维网联盟。
1：HTML标签不能自定义，XML标签只能自定义；
2：HTML 语法要求不严格；XML语法要求极其严格，必须是成对标签
3：xml 用来传输和存储数据，HTML用来展示数据；

1.4. XML语法要求

1.4.1.基本语法

(1). xml文档的后缀名 .xml
(2). xml第一行必须定义为文档声明
对于XML文档来说，<？处理指令必须要顶格写，前面不能有任何的空白
(3). XML必须有根节点；根节点就是其他所有节点的父级节点；
(4). 属性值必须使用引号(单双都可)引起来
(5). 标签必须正确关闭
(6). xml标签名称区分大小写

1.4.2.课堂案例

User.xml

<?xml version='1.0' encoding='gbk' standalone='yes'?>
<users>
	<user id='1'>
		<name>zhangsan</name>
		<age>23</age>
		<gender>male</gender>
		<br/>
	</user>
		<user id='2'>
		<name>lisi</name>
		<age>24</age>
		<gender>female</gender>
	</user>
</users>

1.5.组成结构

1.5.1. 文档声明

格式：
属性列表：version：版本号，主流版本1.0，之后出了1.1版兼容性不好，必须的属性。
encoding：编码方式。告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1。
standalone：是否独立。取值：yes不依赖其他文件，no依赖其他文件(约束文件)。

1.5.2. 指令

结合css

<?xml-stylesheet type="text/css" href="a.css" ?>
1.5.2.1课堂案例

添加css样式(了解)
a.css

name{
color:red;
}

User-2.xml

<?xml version="1.0" encoding="gbk" standalone="yes"?>
<?xml-stylesheet type="text/css" href="a.css" ?>
<users>
	<user id='1'>
		<name>zhangsan</name>
		<age>23</age>
		<gender>male</gender>
		<br/>
	</user>
		<user id='2'>
		<name>lisi</name>
		<age>24</age>
		<gender>female</gender>
		</user>
</users>

1.5.3. 标签

规则（标签名称自定义的）：
(1).名称可以包含字母、数字以及其他的字符
(2).名称不能以数字或者标点符号开始
(3).名称不能以字母 xml（或者 XML、Xml 等等）开始
(4).名称不能包含空格

1.5.4. 属性

id属性值唯一

1.5.5. 文本

CDATA区：在该区域中的数据会被原样展示
格式：

1.5.5.1课堂案例

向XML中添加文本内容。

<?xml version="1.0" encoding="gbk" standalone="yes"?>
<users>
	<user id='1'>
		<name>zhangsan</name>
		<age>23</age>
		<gender>male</gender>
		<br/>
	</user>
	<user id='2'>
		<name>lisi</name>
		<age>24</age>
		<gender>female</gender>
		<code>
		<!--if(a &lt;b &amp;&amp;a &gt; c){}-->
		<![CDATA[
		if(a < b && a>c){}
		]]>
		</code>
	</user>
</users>

1.5.6.约束

概念：规定xml文档的书写规则。
学习目标：能够在xml中引入约束文档，能够简单的读懂约束文档。

1.5.6.1 DTD约束

DTD（Document TypeDefinition），文档类型定义，用来约束XML文档，DTD是一种简单的
约束技术。
DTD引入方式：
内部dtd：将约束规则定义在xml文档中
外部dtd：将约束的规则定义在外部的dtd文件中

本地：

<!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">

网络：

<!DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">
1.5.6.2 Schema约束

XML Schema也被称为XML Schema定义（XML Schema Definition，XSD），一种复杂的约束
技术。
优势：
XML Schema 可针对未来的需求进行扩展
XML Schema 更完善，功能更强大
XML Schema 基于 XML 编写 （schema本质上就是一个 xml文件）
XML Schema 支持数据类型 （提供的更加丰富的数据类型）
XML Schema 支持命名空间
引入：
1.填写xml文档的根元素
2.引入xsi前缀. xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
3.引入xsd文件命名空间. xsi:schemaLocation=“http://www.tmooc.cn/xml student.xsd”
4.为每一个xsd约束声明一个前缀,作为标识 xmlns=“http://www.tmooc.cn/xml”

1.5.6.3 课堂案例

约束文件student.dtd

<!ELEMENT students (student+) >
<!ELEMENT student (name,age,sex)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!ATTLIST student number ID #REQUIRED>

小贴士：通过ELEMENT定义标签，ATTLIST定义属性。例如：students (student*) 表示标签
students 下允许出现student子标签星号代表0次到多次（和正则相似），student
(name,age,sex)表示student标签下只能按照顺序出现一次，name (#PCDATA) PCDATA表示name
标签下的标签体为字符串，表示student标签下有属性名称为number类型为ID表示number的值
必须唯一 #REQUIRED表示number属性必须出现。

XML文件student-1.xml，外部内部的方式引入dtd文件

<?xml version="1.0" encoding="UTF-8" ?>
<!-- 外部dtd引入方式 -->
<!DOCTYPE students SYSTEM "student.dtd">
<!-- 内部dtd引入方式 -->
<!--<!DOCTYPE students [
<!ELEMENT students (student+) >
<!ELEMENT student (name,age,sex)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!ATTLIST student number ID #REQUIRED>
]>-->
<students>
	<student number="s001">
		<name>zhangsan</name>
		<age>abc</age>
		<sex>hehe</sex>
	</student>
	<student number="s002">
		<name>lisi</name>
		<age>24</age>
		<sex>female</sex>
	</student>
</students>

小贴士：The content of element type “students” is incomplete, it must match “(student)+”. 表
示元素类型“students”的内容不完整，必须匹配student标签。Attribute “number” is required
and must be specified for element type "student"表示属性“number”是必需的，并且必须为元
素类型“student”指定。

1.5.6.4 课堂案例

schema约束文件student.xsd

<?xml version="1.0"?>
<xsd:schema xmlns="http://www.tmooc.cn/xml"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.tmooc.cn/xml"
elementFormDefault="qualified">
<xsd:element name="students" type="studentsType"/>
<xsd:complexType name="studentsType">
<xsd:sequence>
<xsd:element name="student" type="studentType" minOccurs="0"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="studentType">
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="age" type="ageType" />
<xsd:element name="sex" type="sexType" />
</xsd:sequence>
<xsd:attribute name="number" type="numberType" use="required"/>
</xsd:complexType>
<xsd:simpleType name="sexType">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="male"/>
<xsd:enumeration value="female"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="ageType">
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value="0"/>
<xsd:maxInclusive value="256"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="numberType">
<xsd:restriction base="xsd:string">
<xsd:pattern value="danei_\d{4}"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>

小贴士: <xsd:element name=“students” type=“studentsType”/>表示定义标签students类型
studentType自定义类型， <xsd:complexType name=“studentsType”> xsd:sequence
<xsd:element name=“student” type=“studentType” minOccurs=“0”
maxOccurs=“unbounded”/>
/xsd:sequence代表 按照顺序出现student 类型为自定义studentType 最小出现0次 最大不限。

XML文件student-2.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--
1.填写xml文档的根元素
2.引入xsi前缀. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.引入xsd文件命名空间. xsi:schemaLocation="http://www.tmooc.cn/xml
student.xsd"
4.为每一个xsd约束声明一个前缀,作为标识 xmlns="http://www.tmooc.cn/xml"
-->
<students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:a="http://www.tmooc.cn/xml"
xmlns:b="http://www.tmooc.cn/xml1"
xsi:schemaLocation="http://www.tmooc.cn/xml student.xsd
http://www.tmooc.cn/xml1 student1.xsd">
<student number="danei_0001">
<a:name>tom</a:name>
<age>11</age>
<sex>male</sex>
</student>
</students>

1.5.7课后作业

现有多条Emp信息数据，如表-1所示：

表- 1 Emp信息数据

idnameagegendersalary
1张三34男3000
2李四21女4000
3王五46女6500
4赵六28男4400
5钱七53男12000

表-1中，每一行数据表示一条Emp信息。要求完成表-1中Emp信息数据的XML描述。
步骤
实现此案例需要按照如下步骤进行。
步骤一：创建XML文件
首先，创建名为EmpList.xml的XML文件；然后，在该文件中使用处理指令设置属性version以及属性
encoding的值，代码如下所示：

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

步骤二：确定根元素
XML要求必须有根元素，所谓根元素就是不被其它元素包围，并且根元素只能有一个。本案例使用作为
根元素，表示该元素内可以包含多条子元素作为Emp信息数据，代码如下所示：

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

注意，在该文档中，不能再定义与list平级的XML元素。
步骤三：定义表示Emp信息数据的元素
首先，在根元素 下，定义一个子元素 ，用于表示一条Emp信息，代码如下所示：

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

步骤四：为 元素定义 id 属性
为元素 定义属性id，用于表示Emp信息数据中的id，代码如下所示：

<?xml version="1.0" encoding="UTF-8"?>
	<list>
		<emp id="1">
		</emp>
	</list>

步骤五：为 元素定义子元素
为元素 定义子元素 、、 和 ，分别表示Emp信息数据中的name、age、gender以及salary。并为这四
个子元素添加文本信息，以记载 Emp 的相关信息数据，代码如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<list>
	<emp id="1">
		<name>张三</name>
		<age>34</age>
		<gender>男</gender>
		<salary>3000</salary>
	</emp>
</list>

步骤六：实现多条Emp信息数据的XML描述
一个 元素表示一条 Emp 数据，因此，可以用多个 元素来描述剩余的多条Emp信息数据。代码如下所
示：

<?xml version="1.0" encoding="UTF-8"?>
<list>
	<emp id="1">
		<name>张三</name>
		<age>34</age>
		<gender>男</gender>
		<salary>3000</salary>
	</emp>
	<emp id="2">
		<name>李四</name>
		<age>34</age>
		<gender>男</gender>
		<salary>3000</salary>
	</emp>
	<emp id="3">
		<name>王五</name>
		<age>34</age>
		<gender>男</gender>
		<salary>3000</salary>
	</emp>
	<emp id="4">
		<name>赵六</name>
		<age>34</age>
		<gender>男</gender>
		<salary>3000</salary>
	</emp>
	<emp id="5">
		<name>钱七</name>
		<age>34</age>
		<gender>男</gender>
		<salary>3000</salary>
	</emp>
</list>

1.6.解析

1.6.1 解析详解

概念：操作xml文档，将文档中的数据读取到内存中。
操作xml文档

  1. 解析(读取)：将文档中的数据读取到内存中。
  2. 写入：将内存中的数据保存到xml文档中，持久化的存储。
    解析xml的方式：
  3. DOM：(Document Object Model)将标记语言文档一次性加载进内存，在内存中形成一颗
    dom树
    优点：操作方便，可以对文档进行CRUD的所有操作
    缺点：占内存
  4. SAX：（Simple API for XML）逐行读取，基于事件驱动的。
    优点：不占内存。
    缺点：只能读取，不能增删改
    xml常见的解析器：
  5. JAXP：sun公司提供的解析器，支持dom和sax两种思想。
  6. DOM4J：一款非常优秀的解析器。
  7. Jsoup：jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。
  8. PULL：Android操作系统内置的解析器，sax方式的。

1.6.2 课堂案例

读取XML文档解析Emp信息
问题
解析上一案例中创建的XML文档EmpList.xml。首先，将每一个节点中的属性和子元素封装为一个Emp
对象；然后，将Emp对象存储到List集合中并输出到控制台。
方案
dom4j是一个Java的XML API，用来读写XML文件。dom4j是一个非常优秀的Java XML API，具有性能
优异、功能强大和极端易用的特点，同时它也是一个开放源代码的软件。使用dom4j来实现对XML文档
的解析，详细过程如下：
1）使用dom4j需要导入dom4j对应的jar包。
jar 的下载
https://mvnrepository.com/artifact/dom4j/dom4j/1.6.1

2）创建SAXReader类的对象来实现读取XML文档，代码如下：

SAXReader reader = new SAXReader();

3）使用SAXReader类的read方法获取Document对象，Document 对象是一棵文档树的根，可为我们
提供对文档数据的最初（或最顶层）的访问入口，代码如下：

Document doc = reader.read(new File("EmpList.xml"));

4）使用Document对象的getRootElement方法获取要解析的XML文档的根元素，该方法返回值类型为
Element。Element 对象表示 XML文档中的元素。元素可包含属性、其它元素或文本。如果元素含有文
本，则在文本节点中表示该文本，代码如下：

 Element root = doc.getRootElement();

5）接下来，可以使用Element对象提供的方法继续解析XML文档，例如：其elements方法用来获取当
前元素下的所有子元素，代码如下：

List<Element> elements = root.elements()

步骤
实现此案例需要按照如下步骤进行。
步骤一：导入dom4j对应的jar包
在当前工程下导入dom4j对应的jar包。
步骤二：新建类及测试方法
首先，新建类TestDom；然后在该类中新建测试方法testReadXml，代码如下所示：

import org.junit.Test;
public class TestDom {
/**
\* 使用DOM解析XML文件
*/
@Test
public void testReadXml() {
}

步骤三：创建SAXReader类的对象，获取Document对象
创建SAXReader类的对象来实现读取XML文档；然后，使用SAXReader类的read方法获取Document对
象，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
/**
\* 使用DOM解析XML文件
*/
	@Test
	public void testReadXml() {
		try {
			// 创建SAXReader
			SAXReader reader = new SAXReader();
			// 读取指定文件
			Document doc = reader.read(new File("EmpList.xml"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤四：获取根元素
使用Document对象的getRootElement方法获取EmpList.xml文档的根元素，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

public class TestDom {
/**
\* 使用DOM解析XML文件
*/
@Test
	public void testReadXml() {
		try {
		// 创建SAXReader
			SAXReader reader = new SAXReader();
			// 读取指定文件
			Document doc = reader.read(new File("EmpList.xml"));
			// 获取根节点list
			Element root = doc.getRootElement();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤五：获取节点下的所有子元素
使用Element对象的elements方法获取节点下的所有子元素，即所有的节点，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
	/**
	\* 使用DOM解析XML文件
	*/
	@Test
	public void testReadXml() {
		try {
			// 创建SAXReader
			SAXReader reader = new SAXReader();
			// 读取指定文件
			Document doc = reader.read(new File("EmpList.xml"));
			// 获取根节点list
			Element root = doc.getRootElement();
			// 获取list下的所有子节点emp
			List<Element> elements = root.elements();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤六：封装Emp对象，存储到List集合中
1）创建存储的数据类型为Emp类型的List集合emps；
2）循环上一步中的elements集合，每循环一次获取一个emp元素。在循环中使用Element对象的
attribute方法获取id属性对应的Attribute对象，再使用Attribute对象的getValue方法就可以获取到属性
id对应的文本信息，即Emp对象的属性id的信息；
3）在循环中，使用Element对象的elementText方法获取节点、、以及对应的文本信息，即Emp对象的
属性name、age、gender以及salary。
4）在循环中，将上述获取到的信息封装为Emp对象，存储到集合emps中。
代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
/**
\* 使用DOM解析XML文件
*/
	@Test
	public void testReadXml() {
		try {
			// 创建SAXReader
			SAXReader reader = new SAXReader();
			// 读取指定文件
			Document doc = reader.read(new File("EmpList.xml"));
			// 获取根节点list
			Element root = doc.getRootElement();
			// 获取list下的所有子节点emp
			List<Element> elements = root.elements();
			// 保存所有员工对象的集合
			List<Emp> emps = new ArrayList<Emp>();
			for (Element element : elements) {
			int id = Integer.parseInt(element.attribute("id").getValue());
			String name = element.elementText("name");
			int age = Integer.parseInt(element.elementText("age"));
			String gender = element.elementText("gender");
			double salary =
			Double.parseDouble(element.elementText("salary"));
			Emp emp = new Emp(id, name, age, gender, salary);
			emps.add(emp);
		}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤七：输出集合
将emps集合的信息输出到控制台，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
/**
\* 使用DOM解析XML文件
*/
	@Test
	public void testReadXml() {
		try {
			// 创建SAXReader
			SAXReader reader = new SAXReader();
			// 读取指定文件
			Document doc = reader.read(new File("EmpList.xml"));
			// 获取根节点list
			Element root = doc.getRootElement();
			// 获取list下的所有子节点emp
			List<Element> elements = root.elements();
			// 保存所有员工对象的集合
			List<Emp> emps = new ArrayList<Emp>();
			for (Element element : elements) {
				int id = Integer.parseInt(element.attribute("id").getValue());
				String name = element.elementText("name");
				int age = Integer.parseInt(element.elementText("age"));
				String gender = element.elementText("gender");
				double salary =
				Double.parseDouble(element.elementText("salary"));
				Emp emp = new Emp(id, name, age, gender, salary);
				emps.add(emp);
			}
			System.out.println("解析完毕");
			System.out.println(emps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤八：运行
运行testReadXml方法，控制台输出结果如下所示：
解析完毕

[Emp [id=1,name=张三, age=34, gender=男, salary=3000.0], Emp [id=2,name=李四,
age=21, gender=女, salary=4000.0], Emp [id=3,name=王五, age=46, gender=女,
salary=6500.0], Emp [id=4,name=赵六, age=28, gender=男, salary=4400.0], Emp
[id=5,name=钱七, age=53, gender=男, salary=12000.0]]

从输出结果可以看出，已经对EmpList.xml文档进行解析，将每一个节点中的属性和子元素封装为一个
Emp对象并将Emp对象存储到List集合中。

1.6.3 课堂案例

将Emp（存放在List中）对象转换为XML文档
问题
在List集合中存储了如下数据：

List<Emp> emps = new ArrayList<Emp>();
emps.add(new Emp(1, "张三", 33, "男", 9000));
emps.add(new Emp(2, "李四", 26, "男", 5000));
emps.add(new Emp(3, "王五", 48, "男", 34000));

请将集合emps中的所有Emp对象转换为XML文件的形式。

方案
使用dom4j建立XML文档的过程如下：
1）创建文档对象，代码如下：

Document doc = DocumentHelper.createDocument();

2）创建根节点，代码如下：

Element root = doc.addElement("list");

3）在节点下添加注释、属性、子节点，Element提供如下方法：
addComment：方法添加注释
addAttribute：添加属性
addElement：添加子元素
4）通过XMLWriter 生成物理文件。
步骤
实现此案例需要按照如下步骤进行。
步骤一：添加测试方法testWriteXml
首先在TestDom类中新建测试方法testWriteXml；然后在该测试方法中，添加List集合存储Emp对象的
代码，代码如下所示：

import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
public class TestDom {
/**
\* 测试写xml
*/
	@Test
	public void testWriteXml() {
		List<Emp> emps = new ArrayList<Emp>();
		emps.add(new Emp(1, "张三", 33, "男", 9000));
		emps.add(new Emp(2, "李四", 26, "男", 5000));
		emps.add(new Emp(3, "王五", 48, "男", 34000));
	}
}

步骤二：创建文档对象
使用DocumentHelper类的静态方法createDocument创建文档对象Document，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
/**
\* 测试写xml
*/
	@Test
	public void testWriteXml() {
		List<Emp> emps = new ArrayList<Emp>();
		emps.add(new Emp(1, "张三", 33, "男", 9000));
		emps.add(new Emp(2, "李四", 26, "男", 5000));
		emps.add(new Emp(3, "王五", 48, "男", 34000));
		try {
			Document doc = DocumentHelper.*createDocument*();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤三：创建根节点
使用Document类的addElement方法，创建根节点，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
/**
\* 测试写xml
*/
@Test
public void testWriteXml() {
	list<Emp> emps = new ArrayList<Emp>();
	emps.add(new Emp(1, "张三", 33, "男", 9000));
	emps.add(new Emp(2, "李四", 26, "男", 5000));
	emps.add(new Emp(3, "王五", 48, "男", 34000));
	try {
		Document doc = DocumentHelper.*createDocument*();
		// 添加根标记
		Element root = doc.addElement("list");
	} catch (Exception e) {
		e.printStackTrace();
	}
}

步骤四：添加子元素
首先，循环集合emps，在循环中获取Emp对象的信息；然后，在循环中使用Element类的addAttribute
方法在该元素下添加属性，属性的值为对应Emp对象中的成员变量的值；使用addElement方法在该元
素下添加子元素；使用addText方法为该子元素添加文本，该文本也为对应Emp对象中成员变量的值，
代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
	/**
	\* 测试写xml
	*/
	@Test
	public void testWriteXml() {
		List<Emp> emps = new ArrayList<Emp>();
		emps.add(new Emp(1, "张三", 33, "男", 9000));
		emps.add(new Emp(2, "李四", 26, "男", 5000));
		emps.add(new Emp(3, "王五", 48, "男", 34000));
		try {
			Document doc = DocumentHelper.*createDocument*();
			// 添加根标记
			Element root = doc.addElement("list");
			for (Emp emp : emps) {
				// 向根元素中添加名为emp的子元素
				Element ele = root.addElement("emp");
				// 为emp元素添加属性id,其值为cp
				ele.addAttribute("id", emp.getId() + "");
				ele.addElement("name").addText(emp.getName());
				ele.addElement("age").addText(emp.getAge() + "");
				ele.addElement("gender").addText(emp.getGender());
				ele.addElement("salary").addText(emp.getSalary() + "");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤五：生成物理文件
通过XMLWriter 生成物理文件，代码如下所示：

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class TestDom {
	/**
	\* 测试写xml
	*/
	@Test
	public void testWriteXml() {
		List<Emp> emps = new ArrayList<Emp>();
		emps.add(new Emp(1, "张三", 33, "男", 9000));
		emps.add(new Emp(2, "李四", 26, "男", 5000));
		emps.add(new Emp(3, "王五", 48, "男", 34000));
		try {
			Document doc = DocumentHelper.*createDocument*();
			// 添加根标记
			Element root = doc.addElement("list");
			for (Emp emp : emps) {
				// 向根元素中添加名为emp的子元素
				Element ele = root.addElement("emp");
				// 为emp元素添加属性id,其值为cp
				ele.addAttribute("id", emp.getId() + "");
				ele.addElement("name").addText(emp.getName());
				ele.addElement("age").addText(emp.getAge() + "");
				ele.addElement("gender").addText(emp.getGender());
				ele.addElement("salary").addText(emp.getSalary() + "");
			}
			// 写出
			XMLWriter writer = new XMLWriter();
			FileOutputStream fos = new FileOutputStream("emps.xml");
			writer.setOutputStream(fos);
			writer.write(doc);
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

步骤六：运行
运行testWriteXml方法，会在当前工程目录下生成emps.xml文件，该文件中的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<list>
	<emp id="1">
		<name>张三</name>
		<age>33</age>
		<gender>男</gender>
		<salary>9000.0</salary>
	</emp>
	<emp id="2">
		<name>李四</name>
		<age>26</age>
		<gender>男</gender>
		<salary>5000.0</salary>
	</emp>
	<emp id="3">
		<name>王五</name>
		<age>48</age>
		<gender>男</gender>
		<salary>34000.0</salary>
	</emp>
</list>

1.6.4 课外扩展

Jsoup解析器解析
步骤：

  1. 导入jar包
  2. 获取Document对象
  3. 获取对应的标签Element对象
  4. 获取数据

代码：

//2.1获取student.xml的path
String path =
JsoupDemo1.class.getClassLoader().getResource("student.xml").getPath();
//2.2解析xml文档，加载文档进内存，获取dom树--->Document
Document document = Jsoup.parse(new File(path), "utf-8");
//3.获取元素对象 Element
Elements elements = document.getElementsByTag("name");
System.out.println(elements.size());
//3.1获取第一个name的Element对象
Element element = elements.get(0);
//3.2获取数据
String name = element.text();
System.out.println(name);

对象的使用：
5. Jsoup：工具类，可以解析html或xml文档，返回Document

1 parse：解析html或xml文档，返回Document

  • parse(File in, String charsetName)： 解析xml或html文件的。
    对象的使用：
  • parse(String html)： 解析xml或html字符串
    parse(URL url, int timeoutMillis)： 通过网络路径获取指定的html或xml的文档
    对象

2 Document：文档对象。代表内存中的dom树

  • 获取Element对象
    • getElementById(String id)： 根据id属性值获取唯一的element对象
    • getElementsByTag(String tagName)： 根据标签名称获取元素对象集合
    • getElementsByAttribute(String key)： 根据属性名称获取元素对象集合
    • getElementsByAttributeValue(String key, String value)： 根据对应的属性名
      和属性值获取元素对象集合
  1. Elements：元素Element对象的集合。可以当做 ArrayList来使用
  2. Element：元素对象
    (1).获取子元素对象
    getElementById(String id)： 根据id属性值获取唯一的element对象
    getElementsByTag(String tagName)： 根据标签名称获取元素对象集合
    getElementsByAttribute(String key)： 根据属性名称获取元素对象集合
  • getElementsByAttributeValue(String key, String value)： 根据对应的属性名和属性值获
    取元素对象集合
    (2).获取属性值
    String attr(String key)： 根据属性名称获取属性值
    (3).获取文本内容
    快捷查询方式：
    String text(): 获取文本内容
    String html(): 获取标签体的所有内容(包括字标签的字符串内容)
  1. Node：节点对象
    是Document和Element的父类。
    快捷查询方式：
1. selector:选择器
* 使用的方法：Elements select(String cssQuery)
* 语法：参考Selector类中定义的语法
  1. XPath：XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某
    部分位置的语言
    使用Jsoup的Xpath需要额外导入jar包。
    查询w3cshool参考手册，使用xpath的语法完成查询
    代码：
//1.获取student.xml的path
String path =
JsoupDemo6.class.getClassLoader().getResource("student.xml").getPath();
//2.获取Document对象
Document document = Jsoup.parse(new File(path), "utf-8");
//3.根据document对象，创建JXDocument对象
JXDocument jxDocument = new JXDocument(document);
//4.结合xpath语法查询
//4.1查询所有student标签
List<JXNode> jxNodes = jxDocument.selN("//student");
for (JXNode jxNode : jxNodes) {
System.out.println(jxNode);
}
System.out.println("--------------------");
//4.2查询所有student标签下的name标签
List<JXNode> jxNodes2 = jxDocument.selN("//student/name");
for (JXNode jxNode : jxNodes2) {
System.out.println(jxNode);
}
System.out.println("--------------------");
//4.3查询student标签下带有id属性的name标签
List<JXNode> jxNodes3 = jxDocument.selN("//student/name[@id]");
for (JXNode jxNode : jxNodes3) {
System.out.println(jxNode);
}
System.out.println("--------------------");
//4.4查询student标签下带有id属性的name标签 并且id属性值为itcast
List<JXNode> jxNodes4 =
jxDocument.selN("//student/name[@id='itcast']");
for (JXNode jxNode : jxNodes4) {
System.out.println(jxNode);
}

1.7.面试精选

1.简述SAX和DOM解析方式的不同？

参考答案:
DOM：(Document Object Model, 即文档对象模型) 是 W3C 组织推荐的处理 XML 的一种方式。
DOM解析器在解析XML文档时，会把文档中的所有元素，按照其出现的层次关系，解析成各个Node对
象(节点)。
优点:把xml文件在内存中构造树形结构，可以遍历和修改节点
缺点：如果文件比较大，内存有压力，解析的时间会比较长
SAX（simple API for XML）是一种XML解析的替代方法。相比于DOM，SAX是一种速度更快，更有效
的方法。它逐行扫描文档，一边扫描一边解析。而且相比于DOM，SAX可以在解析文档的任意时刻停止
解析。
优点： 解析可以立即开始，速度快，没有内存压力
缺点： 不能对节点做修改

2.DTD 与 与 XML Schema 有什么区别？

参考答案：
DTD 与 XML Schema 有以下区别：DTD 不使用 XML 编写而 XML Schema 本身就是 xml 文件，这
意味着XML解析器等已有的XML工具可以用来处理XML Schema。而且XML Schema 是设计于 DTD 之
后的，它提供了更多的类型来映射 xml 文件不同的数据类型。DTD 即文档类型描述(Document Type
definition)是定义 XML 文件结构的传统方式。

XYDrestart
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DTD约束&schema约束学习
weixin_43521028的博客
09-18 1031
DTD约束 概念 ​ DTD是文档类型定义（Document Type Definition）。DTD 可以定义在 XML 文档中出现的元素、这些元素出现的次序、它们如何相互嵌套以及XML文档结构的其它详细信息。 约束体验 体验效果说明：当编写xml文档时不符合指定dtd约束时，进行提示xml编写错误，如下图： 体验步骤: 步骤1：复制bookshelf.dtd文件 步骤2：bookshelf.dtd文件内容如下 <!ELEMENT 书架 (书+)> <!ELEMENT 书 (书名,作者
day02_eesy_02xml_IOC.zip
12-28
spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这...
Schema xsd约束文档例子
梦想还是要有的，万一实现了呢！
02-28 1121
根据Schema写出xsd xml约束文档来，难点在于xml文件如何引入schema约束，下面分享一个例子 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.itheima.com/b...
XML_DTD约束和XML_Schema约束以及使用dom4j解析
qq_26219679的博客
03-23 481
一、XML的简单介绍    XML全称为Extensible Markup Language 可扩展的标记语言。XML语法上和HTML比较相似，但HTML的元素是固定的，而XML的标签是可以由用户自定义的。二、DTD约束    DTD(Document Type Definition),文档类型定义，用来约束XML文档，规定XML文档中元素的名称，子元素的名称及顺序，元素的属性等。三、Schema...
XML和Dom4j
weixin_41942838的博客
12-14 281
XML和Dom4j 在数据传输的时候直接传输字符串是不可行的, 所以我们使用一种特别的方式来传输, 就是XML. XML 指可扩展标记语言（EXtensible Markup Language） XML 是一种标记语言，很类似 HTML，HTML文件也是XML文档 XML 的设计宗旨是传输数据，而非显示数据 XML 标签没有被预定义。您需要自行定义标签。 XML 被设计为具有自我描述性(就是易于阅读)。 XML 是 W3C 的推荐标准 W3C在1988年2月发布1.0版本，200
XML与设计模式
lmz的博客
12-19 491
XML与设计模式
超全面javaweb第4天- 02 xml的简介
08-31
超全面javaweb第4天-_02_xml的简介
疯狂XML讲义 02
05-17
疯狂XML讲义 02
C# XML解析方式
06-06
根据给定文件中的标题、描述、标签以及部分内容，可以总结并深入探讨以下关于C#中XML解析的关键知识点： ### C#中的XML解析方式 #### 1. XML Text Reader（流式解析） - **简介**：在.NET框架中，`XMLTextReader`...
02.xml解析1
08-08
《XML解析技术详解》 XML（eXtensible Markup Language），是一种用于标记数据的语言，它在软件开发领域中被广泛应用，特别是在数据交换、配置文件、文档存储等方面。XML的格式清晰，具有良好的容错性和可扩展性，...
Dom4j使用简介
02-21
Dom4j使用简介，日志 开发java必看，初级高级开发必看
dom4j详细使用用法
12-12
dom4j用法 很实用
Dom4j完整教程
每一次对问题的深究，总会收获新的知识和体会
02-28 2862
转载自：http://blog.csdn.net/chenweitang123/article/details/6255108 Dom4j的相关知识点.比较系统.     目录 1、DOM4J简介 2、XML文档操作1       2.1、读取XML文档：       2.2、获取根节点       2.3、. 新增一个节点以及其下的子节点与数据       2.4
学习：Dom4j和Xpath
weixin_34186950的博客
06-09 196
1、DOM4J简介     DOM4J是 dom4j.org 出品的一个开源 XML 解析包。DOM4J应用于 Java 平台，采用了 Java 集合框架并完全支持 DOM，SAX 和 JAXP。     DOM4J 使用起来非常简单。只要你了解基本的 XML-DOM 模型，就能使用。     Dom：把整个文档作为一个对象。   DOM4J 最大的特色是使用大量的接口。它的主要接口都...
DOM4J的用法
热门推荐
随笔_博客
09-13 3万+
一、基本使用方式     语法     1、获取根元素 Element root = document.getRootElement();     2、获取某个元素下的子元素 Element db_element = root.element("db");     3、获取元素的子元素集合1 List&lt;Element&gt; db_list = db_element.eleme...
Dom4j 使用 详解~~
洪文聊架构
04-01 1744
DOM4J是dom4j.org出品的一个开源XML解析包。Dom4j是一个易用的、开源的库，用于XML，XPath和XSLT。它应用于Java平台，采用了Java集合框架并完全支持DOM，SAX和JAXP。 DOM4J下载jar包：http://downloads.sourceforge.net/dom4j/dom4j-1.6.1.jar JAXEN（对XPath的支持）：http://dis
使用dom4j解析XML文档的方法详解
weixin_47847063的博客
07-13 5002
dom4j是一个基于Java的开源XML解析器，它提供了一种简单而灵活的方式来解析和操作XML文档。它使用了DOM（Document Object Model）模型，使开发者能够轻松地读取、写入和修改XML数据。本文将详细介绍dom4j的使用方法，并提供示例代码来说明各种操作。
Dom4j基本使用
一叶知春秋
05-06 3069
 Dom4j基本使用2.1概述Dom4j是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。    Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。现在很多软件采用的Dom4j，例如Hibern...
手把手教您Dom4j的使用
最新发布
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
09-20 358
DOM4J使用起来非常简单。只要你了解基本的XML-DOM模型，就能使用。然而他自己带的指南只有短短一页（html），不过说的到挺全。国内的中文资料很少。因而俺写这个短小的教程方便大家使用。
XML文档结构解析与语法规范
在"8-02.xml"案例中，展示了如何使用属性来增加元素的信息，比如 `<姓名类别="专职">`，`类别`属性用于进一步描述`姓名`元素。 "形式良好的"XML文件意味着它符合XML的语法规则，例如，所有元素都正确关闭，属性值都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XYDrestart

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

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

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

抵扣说明：

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

余额充值