XML概念定义以及如何定义xml文件编写约束条件java解析xml DTD XML Schema JAXP java xml解析 dom4j 解析 xpath dom sax

时间 2019-11-25

标签 xml 概念定义以及如何文件编写约束条件 java 解析 dtd schema jaxp dom4j dom xpath sax 栏目 XML 繁體版

原文原文链接

本文主要涉及:xml概念描述,xml的约束文件,dtd,xsd文件的定义使用,如何在xml中引用xsd文件,如何使用java解析xml,解析xml方式dom sax,dom4j解析xml文件css

XML来源SGML

SGML(SGM)标准通用标记语言html

是一种定义电子文档结构和描述其内容的国际标准语言,具备极好的扩展性java

是全部电子文档标记语言的起源，早在万维网发明以前“通用标言”就已存在node

是1986年国际标准化组织出版发布的一个信息管理方面的国际标准（ISO 8879:1986 信息处理）git

简单的理解就是对于数据进行结构化组织呈现,用于描述文档的显示式样或者描述文档中文字的用途github

XML概念

可扩展标记语言，是一种用于标记电子文件使其具备结构性的标记语言。web

与HTML同样都是标准通用标记语言的子集，spring

只不过超文本标记语言被设计用来显示数据数据库

XML被设计用来传输和存储数据.浏览器

语法上和HTML也是类似的，但HTML中的元素是固定的，而XML的标签是能够由用户自定义的。

逻辑上来讲SGML是很是适合用于Web项目中的

可是SGML的固有缺点,复杂/庞大/学习成本高等

因此XML这一SGML的子集,应运而生.

W3C在1998年2月发布1.0版本

W3C在2004年2月发布1.1版本，但由于1.1版本不能向下兼容1.0版本

因此如今使用的仍旧是1.0版本

W3school XML在线文档

http://www.w3school.com.cn/xml/index.asp

W3C组织

W3C是万维网联盟(World Wide Web Consortium)英文的缩写

它成立于1994年10月，以开放论坛的方式来促进开发互通技术(包括规格、指南、软件和工具)，开发网络的所有潜能。

万维网联盟(W3C)从1994年成立以来，已发布了90多份Web技术规范，领导着Web技术向前发展。

W3C认为自身不是官方组织，所以将它正式发布的规范称为推荐(建议)标准，意思是进一步标准化的建议，

可是因为组织自身的权威性每每成为事实上的标准。

XML用法以及特色

XML在web中主要用途就是存储数据,只要能方便的存储数据,天然能够交换数据.

目前经常使用用法:

程序的配置文件（这也是最后你们使用XML最多见的目的）；

数据交换：不一样语言之间用来交换数据,由于他是统一的格式

小型数据库：用来当数据库存储数据。

XML与HTML比较

HTML的元素都是固定的，而XML能够自定义元素；

HTML用浏览器来解析执行， XML的解析器一般须要本身来写（由于元素是自定义的）；

HTML只能用来表示网页，而XML能够作的事情不少。

XML和properties比较

属性文件只能存储平面信息，而XML能够存储结构化信息；

解析属性文件只须要使用Properties类就能够了，而解析XML文档是很复杂的。

XML总结:

XML是一种灵活的结构化数据存储和传输格式,没有预置的标签(HTML就是预置的固定的,浏览器负责解析)

因此须要自定义标签,

既然是自定义标签 ,天然须要本身去动手解析

也就是说:

在Web项目中,想要使用XML做为程序的一部分

XML三要素

1.语法格式 这个没什么好说的,必须遵照基本的XML规范

2.约束文件

任何的程序都不会是固定不变的,你的解析程序和XML文件也绝对不多是彻底不变的

好比可能你的XML文件须要用户书写,而后程序进行解析

若是用户随意书写,不可能存在什么程序可以保证彻底正确的解读用户的输入

因此须要约束,也正是这个约束让XML的内容的书写,和XML的解析程序达到了解耦的目的

只要引入了约束标准,XML文件的内容就不容许随意书写

只要遵循约束标准,解析程序就承诺必定能够正确的解读数据

3.解析 你本身定义的标签,天然只有你本身才懂得每一个数据的含义

一个简单的XML文档格式

目前仍旧使用的是XML 1.0

一个基本的XML 形如:

<?xml version="1.0" encoding="ISO-8859-1"?>
 <note>
 <to>George</to> 
<from>John</from> 
<heading>Reminder</heading> 
<body>Don't forget the meeting!</body>
 </note>

XML是一个树形结构,并且必须是一个树形结构必须有根元素

<bookstore> 
<book category="COOKING">
 <title lang="en">Everyday Italian</title> 
<author>Giada De Laurentiis</author> 
<year>2005</year> 
<price>30.00</price> 
</book> 
<book category="CHILDREN"> 
<title lang="en">Harry Potter</title> 
<author>J K. Rowling</author> 
<year>2005</year> 
<price>29.99</price> 
</book>
 <book category="WEB">
 <title lang="en">Learning XML</title> 
<author>Erik T. Ray</author> 
<year>2003</year>
 <price>39.95</price>
 </book> 
</bookstore>

XML-语法

文档声明

元素

属性

注释

CDATA区、特殊字符

处理指令（PI:Processing Instruction）

文档声明:

在编写XML文档时，须要先使用文档声明来声明XML文档。且必须出如今文档的第一行。

最简单的语法:<?xml version=“1.0”?>

用encoding属性说明文档所使用的字符编码。保存在磁盘上的文件编码要与声明的编码一致。

如：<?xml version=“1.0” encoding=“GB2312”?>

用standalone属性说明文档是否独立，便是否依赖其余文档。

如：<?xml version=“1.0” standalone=“yes”?>

没有xml文档声明的xml文档，不是格式良好的xml文档

xml文档声明必须从xml文档的1行1列开始也就是必须第一行顶格写

编码属性应当被指定为文档被保存时所使用的编码

最好的避免错误的建议是：

使用支持编码的编辑器

肯定编辑器使用的编码

在您的 XML 文档中使用相同的编码属性

XML元素

XML中的每个标签,就是一个元素

元素指的是从（且包括）开始标签直到（且包括）结束标签的部分

元素可包含其余元素、文本或者二者的混合物。元素也能够拥有属性。

要求:

1.全部元素都必须有关闭标签,省略关闭标签是非法的。声明不是XML的元素,因此第一行的声明,并不须要关闭标签

2.XML 标签对大小写敏感

3.XML 必须正确地嵌套

4.XML 文档必须有且只有一个根元素

命名规则：

1.名称能够含字母、数字以及其余的字符

2.名称不能以数字或者标点符号开始

3.名称不能以字符 “xml”（或者 XML、Xml）开始

4.名称不能包含空格

5.可以使用任何名称，没有保留的字词。

命名建议:

名称应该具备描述性,而且在此基础上尽量简短,可使用下划线 _

避免使用连字符 - ,好比 a-b 有些可能会仅仅解析到a

不要使用英文句号 .

不要使用英文冒号 : 会被当作命名空间解析

XML属性

一个元素(标签)能够有多个属性

XML的属性是键值对的形式,

属性由属性名与属性值构成，中间用等号链接好比 sex="male"

他的属性值必须加引号

单引号和双引号都可使用

若是属性值自己包含双引号，那么有必要使用单引号

究竟是使用元素仍是属性?

建议是若是能够,尽量的使用元素,而不是属性

由于:

属性没法包含多重的值(元素能够包含多个)

属性没法描述树的结构(元素则是树结构的一部分)

属性不容易扩展

数据自己设置为元素,数据的数据才去设置为属性

XML注释

注释的语法与 HTML 的语法很类似：

注释不能嵌套

CDATA区、特殊字符

全部 XML 文档中的文本均会被解析器解析。

只有 CDATA 区段（CDATA section）中的文本会被解析器忽略。

CDATA 部分中的全部内容都会被解析器忽略。 CDATA 部分由 "<![CDATA[" 开始，由 "]]>" 结束

CDATA 部分不能包含字符串 "]]>"。也不容许嵌套的 CDATA 部分。

标记 CDATA 部分结尾的 "]]>" 不能包含空格或折行。

在 XML 中，文档中的空格不会被删除,都会保留

因此，在编写XML文件时，使用换行和缩进等方式来让原文件中的内容清晰可读的“良好”书写习惯在这个地方并非一件好事

XML 以 LF 存储换行

特殊字符

在 XML 中，一些字符拥有特殊的意义。

若是你把字符 "<" 放在 XML 元素中，会发生错误，这是由于解析器会把它看成新元素的开始

预约义的实体

实体是用于定义引用普通文本或特殊字符的快捷方式的变量。

实体引用是对实体的引用。

实体可在内部或外部进行声明。

&开头 ; 结尾

处理指令

处理指令，简称PI(Processing Instruction)。了解一下

做用：用来指挥软件如何解析XML文档。

语法：必须以“<?”做为开头，以“?>”做为结尾。与声明是同样

经常使用处理指令：

XML声明：<?xml version=“1.0” encoding=“GB2312”?>

xml-stylesheet指令：

做用：指示XML文档所使用的CSS样式XSL。

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

注：对中文命名的标签元素不起做用

XML-验证约束

验证方式有两种:

DTD

XML Schema

要理解限制自己的含义,限制是对于XML文档结构的限制

XML中文档的主要内容能够说是元素和属性

限制也是针对元素和限制来进行的

一个XML文档有哪些元素?
有哪些属性?
哪些属性在哪些元素上?
哪些元素能够包含哪些元素?
被包含的元素可出现的次数是多少?
属性的值能够是多少?
.......

大体也就是这些方面的限制

因此若是你想要给你的XML文档编写限制文件,你须要先肯定你本身的逻辑规则

也就是上面提到的这几个主要问题

而后查找文档用对应的方法书写出来便可

不一样的限制方式天然有不一样的语法,也就有不一样的特色

XML Schema 比 DTD 更强大是DTD的替代者

XML Schema 可针对将来的需求进行扩展

XML Schema 更完善，功能更强大

XML Schema 基于 XML 编写

XML Schema 支持数据类型

XML Schema 支持命名空间

DTD w3c文档

http://www.w3school.com.cn/dtd/dtd_intro.asp

XML Schema w3c文档

http://www.w3school.com.cn/schema/schema_intro.asp

dtd xsd约束的引用

DTD文件引用

有三种方式

内部

外部(在本地)

公共(也是外部只不过不在本地)

内部直接定义在DOCUTYPE内,格式为:

<!DOCUTYPE 根元素名称[

]>

外部本地

<!DOCTYPE 根元素名称 SYSTEM "dtd文档路径">

好比

<!DOCTYPE student SYSTEM "test.dtd">

公共DTD也就是网络上的,本质也是外部

<!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL" >

好比 mybatis的mapper文件

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

通常都是使用第三方提供的技术框架等,使用XML进行数据配置,使用他们提供的DTD进行约束限制

XML Schema xsd文件引用

XSD文档中是建立元素和属性的地方；

XML文档中是使用元素和属性的地方。

因此在XML文档中须要说明使用了哪些XSD文档。

在 XML 文档中引用 Schema, 引用信息是设置到根元素的开始标签内

<根元素名称此处为引用信息

>

此处为xml文件的正文内容

</根元素名称>

想要弄清楚引用方式必须了解清楚xsd schema文档的定义格式

每一个xsd文件都是一个XML文件

schema是全部文件的根元素

一个 schema 声明每每看上去相似这样

<?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3school.com.cn" xmlns="http://www.w3school.com.cn" elementFormDefault="qualified"> ... ... </xs:schema>

其中:

xmlns="http://www.w3school.com.cn" 表示默认的命名空间是"http://www.w3school.com.cn"

xmlns:xs="http://www.w3.org/2001/XMLSchema" 显示 schema 中用到的元素和数据类型来自命名空间 "http://www.w3.org/2001/XMLSchema"。

同时它还规定了来自命名空间 "http://www.w3.org/2001/XMLSchema" 的元素和数据类型应该使用前缀 xs：

targetNamespace="http://www.w3school.com.cn" 表示被此 schema 定义的元素来自命名空间： "http://www.w3school.com.cn"

elementFormDefault="qualified" 任何 XML 实例文档所使用的且在此 schema 中声明过的元素必须被命名空间限定

好比Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">

beans为根元素,整个文档的结构为:

<beans>

</beans>

全部的引用信息设置在开始标签 <beans> 内

xmlns 与xmlns:xxx 是同样的,只不过是xmlns是默认的命名空间,也就是省略了前缀的元素使用的命名空间

它的值也就是xsd文件中的targetNamespace 的值

还须要设置

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

一旦您拥有了可用的 XML Schema 实例命名空间

您就可使用 schemaLocation 属性了。

此属性有两个值。第一个值是须要使用的命名空间。第二个值是供命名空间使用的 XML schema 的位置

须要引用xsd文档的大体步骤

1,先确立你的根元素

好比:

<beans>

</beans>

2.而后选择你的默认的命名空间

xmlns=""

3.默认的只有一个若是你还有更多,你须要设置别名

xmlns:xxx="" 能够设置多个

可能还须要指定位置

4,须要给约束指定位置,指定位置的前提就是先包含XML Schema 实例命名空间:

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

5.使用xsi:schemaLocation="" 指定具体的位置

到底什么是名称空间?

名称空间是用来处理XML元素或属性的名字冲突问题。你能够理解为Java中的包！包的做用就是用来处理类的名字冲突问题。

不管是在XML中，仍是在XSD中，都须要声明名称空间。这与Java中使用import来导包是一个道理。

若是被定义的元素在声明时没有指定目标名称空间，那么就是在无名称空间中，

那么咱们在使用这些在无名称空间中的元素时，就不用再去声明名称空间了。

声明名称空间使用xmlns

例如：xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"。

这表示声明了一个名称空间，至关与Java中的import。

可是，Java中的import的含义是在下面使用的类，若是没有给出包名，那么就是import导入的这个类。

而xmlns表示，下面使用xsi为前缀的元素或属性，都是来自http://www.w3.org/2001/XMLSchema-instance名称空间。

也就是说给名称空间起了一个简称别名前缀指定了就必须使用这个

例如在XSD文件中，xmlns:xsd="http://www.w3.org/2001/XMLSchema"就是声明名称空间，

而这个名称空间是W3C的名称空间，无需关联文件就能够直接声明！

在XSD文件中全部使用xsd为前面的元素和属性都是来自http://www.w3.org/2001/XMLSchema名称空间。

名称空间命名：通常名称空间都是以公司的URL来命名，即网址！固然也能够给名称空间命名为aa、bb之类的名字，但这可能会致使名称空间的重名问题。

前缀命名：前缀的命名没有什么要求，但通常对http://www.w3.org/2001/XMLSchema名称空间的前缀都是使用xs或xsd。

http://www.w3.org/2001/XMLSchema-instance的前缀使用xsi。

默认名称空间

所谓默认名称空间就是在声明名称空间时，不指定前缀，也能够理解为前缀为空字符串的意思。

这样定义元素时，若是没有指定前缀的元素都是在使用默认名称空间中的元素。

xmlns=”http://www.w3.org”

当在文档中使用<xxx>时，那么<xxx>元素就是http://www.w3.org名称空间中声明的元素。

注意：没有指定前缀的属性不表示在默认名称空间中，而是表示没有名称空间。也就是说，默认名称空间不会涉及到属性，只对元素有效！

XML解析

DOM：Document Object Model，文档对象模型。这种方式是W3C推荐的处理XML的一种方式。

SAX：Simple API for XML。这种方式不是官方标准，属于开源社区XML-DEV,属于事实上的标准

这是两种操做逻辑,是一种规范描述,是一组标准接口

这并非针对java语言解析dom的技术

DOM和SAX只是定义了一些接口，以及某些接口的缺省实现，而这个缺省实现只是用空方法来实现接口。

一个应用程序若是须要DOM或SAX来访问XML文档，还须要一个实现了DOM或SAX的解析器，

也就是说这个解析器须要实现DOM或SAX中定义的接口以可以提供DOM或SAX中定义的功能。

DOM解析原理

DOM要求解析器把整个XML文档装载到一个Document对象中。

Document对象包含文档元素，即根元素，根元素包含N多个子元素…

一个XML文档解析后对应一个Document对象，

这说明使用DOM解析XML文档方便使用，由于元素与元素之间还保存着结构关系。

优先：使用DOM，XML文档的结构在内存中依然清晰。元素与元素之间的关系保留了下来！

缺点：若是XML文档过大，那么把整个XML文档装载进内存，可能会出现内存溢出的现象！

SAX解析原理

DOM会一行一行的读取XML文档，最终会把XML文档全部数据存放到Document对象中。

SAX也是一行一行的读取XML文档，可是当XML文档读取结束后，SAX不会保存任何数据，同时整个解析XML文档的工做也就结束了。

可是，SAX在读取一行XML文档数据后，就会给感兴趣的用户一个通知！这是一种回调的形式

例如当SAX读取到一个元素的开始时，会通知用户当前解析到一个元素的开始标签。

而用户能够在整个解析的过程当中完成本身的业务逻辑，当SAX解析结束，不会保存任何XML文档的数据。

优先：使用SAX，不会占用大量内存来保存XML文档数据，效率也高。

缺点：当解析到一个元素时，上一个元素的信息已经丢弃，也就是说没有保存元素与元素之间的结构关系，这也大大限制了SAX的使用范围。

若是只是想查询XML文档中的数据，那么使用SAX是最佳选择！

JAXP

JAXP（Java API for XMLProcessing，意为XML处理的Java API）是Java XML程序设计的应用程序接口之一

JAXP是sun提供的用于隐藏底层解析器的实现

java要求XML解析器去实现JAXP提供的接口,这样可让用户使用解析器时不依赖特定的XML解析器

JAXP自己不是解析器

也不是解析方式（DOM或SAX），它只是让用户在使用DOM或SAX解析器时不依赖特色的解析器。

因此能够说是JAXP是java提供的统一的解析XML的接口规范

你不在须要关注任何的具体的XML解析器的细节

只须要使用JAXP接口规范定义的API便可

JAXP DOM解析

jdk中 javax.xml.parsers包下,四个类:

其中DOM方式:

DocumentBuilder 解析器类

DocumentBuilderFactory 解析器工厂

DocumentBuilder 抽象类,可使用DocumentBuilderFactory.newDocumentBuilder() 得到

DocumentBuilderFactory 抽象类,可使用他的newInstance()方法获取实例

parse方法返回Document接口,父接口是Node

示例:

 1 import javax.xml.parsers.DocumentBuilder;
 2 import javax.xml.parsers.DocumentBuilderFactory;
 3 import javax.xml.transform.Transformer;
 4 import javax.xml.transform.TransformerFactory;
 5 import javax.xml.transform.dom.DOMSource;
 6 import javax.xml.transform.stream.StreamResult;
 7 
 8 import org.w3c.dom.Document;
 9 import org.w3c.dom.Element;
10 import org.w3c.dom.Node;
11 import org.w3c.dom.NodeList;
12 import org.w3c.dom.Text;
13 
14 public class DomParseTest {
15 
16 public static void main(String[] args) throws Exception {
17 
18  
19 
20 //建立解析器工厂
21 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
22 //使用工厂建立解析器
23 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
24 //使用解析器解析XML文件获得Document对象
25 Document document = documentBuilder.parse("src/dom/test.xml");
26 //根据标签名获取 NodeList是一个集合 集合中的元素时Node 使用item() 获取元素
27 NodeList nodeList = document.getElementsByTagName("name");
28 for(int i=0;i<nodeList.getLength();i++) {
29 Node node = nodeList.item(i);
30 //获得标签里面的内容
31 System.out.println(node.getTextContent());
32 }
33 
34 //给第一个学生增长一个性别属性
35 //查找第一个学生
36 Node firstStudent = document.getElementsByTagName("student").item(0);
37 //建立性别标签
38 Element sexElement = document.createElement("sex");
39 //建立性别标签对应的文本
40 Text sexElementText= document.createTextNode("男");
41 //文本添加到标签上
42 sexElement.appendChild(sexElementText);
43 //标签添加到第一个学生节点上
44 firstStudent.appendChild(sexElement);
45 
46 //回写数据
47 //须要使用transformer 抽象类 由工厂建立,工厂也是抽象类由newInstance()方法建立
48 TransformerFactory transformerFactory = TransformerFactory.newInstance();
49 Transformer transformer = transformerFactory.newTransformer();
50 //拥有tranform()方法进行传输数据
51 //transform(Source xmlSource, Result outputTarget)
52 //Source的实现类DOMSource有构造方法
53 //Result接口有实现类StreamResult
54 transformer.transform(new DOMSource(document), new StreamResult("src/dom/test.xml"));
55 
56 
57 }
58 
59 }

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

        <student>

                <name>张三</name>

                <age>18</age>

        </student>

        <student>

                <name>李四</name>

                <age>28</age>

        </student>

</students>

虽然方法有不少,可是本质很简单,解析器,解析器工厂

解析器解析出来文档结构

既然是DOM树,天然都是节点

Document Element Text Attr 也都是节点 Node 类型的

NodeList 是包含Node 的集合可使用item方法获取节点因此说一旦解析出来文档

一切皆是Node 针对于操做方法都在这个体系内了

再详细一点的说就是:

不管使用什么DOM解析器，最终用户都须要获取到Document对象，一个Document对象对应整个XML文档。也能够这样说，Document对象就是XML文档在内存中的表示形式。

在DOM中提供了不少接口，用来描述XML文档中的组成部分。

其中包括：文档（Document）、元素（Element）、属性（Attr）、文本（Text）、注释（Comment）、CDATA段（CDATASection）等等。

不管是哪一种XML文档组成部分，都是节点（Node）的子接口。

Node方法介绍

Node基本方法：

l String getNodeName()：获取当前节点的名字。若是当前节点是Element，那么返回元素名称。若是当前节点是Text那么返回#text。若是当前节点是Document那么返回#document；

l String getNodeValue()：获取当前节点的值。只有文本节点有值，其它节点的值都为null；

l String getTextContext()：获取当前节点的文本字符串。若是当前节点为Text，那么获取节点内容。若是当前节点为Element，那么获取元素中全部Text子节点的内容。例如当前节点为：<name>zhangSan</name>，那么本方法返回zhangSan。若是当前节点为：<student><name>zhangSan</name><age>23</age><sex>male</sex></student>，那么本方法返回zhangSan23male。

l short getNodeType()：获取当前节点的类型。Node中有不少short类型的常量，能够经过与这些常量的比较来判断当前节点的类型。if(node.getNodeType() == Node.ELEMENT_NODE)；

Node获取子节点和父节点方法，只有Document和Element才能使用这些方法：

l NodeList getChildNodes()：获取当前节点的全部子节点。NodeList表示节点列表，它有两个方法：

l int getLength()：获取集合长度；

l Node item(int index)：获取指定下标的节点。

l Node getFirstNode()：获取当前节点的第一个子节点；

l Node getLastNode()：获取当前节点的最后一个子节点；

l Node getParentNode()：获取当前节点的父节点。注意Document的父节点为null。

Node获取弟兄节点的方法，只有Element才能使用这些方法：

l Node getNextSibling()：获取当前节点的下一个兄弟节点；

l Node getPreviousSibling()：获取当前节点的上一个兄弟节点。

Node添加、替换、删除子节点方法：

l Node appendChild(Node newChild)：把参数节点newChild添加到当前节点的子节点列表的末尾处。返回值为被添加的子节点newChild对象，方便使用链式操做。若是newChild在添加以前已经在文档中存在，那么就是修改节点的位置了；

l Node insertBefore(Node newChild, Node refNode)：把参数节点newChild添加到当前节点的子节点refNode以前。返回值为被添加的子节点newChild对象，方便使用链式操做。若是refNode为null，那么本方法与appendNode()方法功能相同。若是newChild节点在添加以前已经在文档中存在，那么就是修改节点的位置了。

l Node removeNode(Node oldChild)：从当前节点中移除子元素oldChild。返回值为被添加的子节点oldChild对象，方便使用链式操做。

l Node replaceNode(Node newChild, Node oldChild)：将当前节点的子节点oldChild替换为newChild。

Node获取属性集合方法，只有Element可使用：

l NamedNodeMap getAttributes()：返回当前节点的属性集合。NamedNodeMap表示属性的集合，方法以下：

int getLength()：获取集合中属性的个数；

Node item(int index)：获取指定下标位置上的属性节点；

Node getNamedItem(String name)：获取指定名字的属性节点；

Node removeNamedItem(String name)：移除指定名字的属性节点，返回值为移除的属性节点；

Node setNamedItem(Node arg)：添加一个属性节点，返回值为添加的属性节点。

Node的判断方法：

l boolean hasChildNodes()：判断当前节点是否有子节点；

l boolean hasAttribute()：判断当前节点是否有属性。

Docment方法介绍

建立节点方法：

l Attr createAttribute(String name)：建立属性节点；

l CDATASection createCDATASection(String data)：建立CDATA段节点；

l Comment createComment(String data)：建立注释；

l Element createElement(String tagName)：建立元素节点；

l Text createTextNode(String data)：建立文本节点；

获取子元素方法：

l Element getElementById(String elementId)：经过元素的ID属性获取元素节点，若是没有DTD指定属性类型为ID，那么这个方法将返回null；

| NodeList getElementsByTagName(String tagName)：获取指定元素名称的全部元素；

l Element getDocumentElement()：获取文档元素，即获取根元素。

文档声明相关方法：

l String getXmlVersion()：获取文档声明的version属性值；

l String getXmlEncoding()：获取文档声明的encoding属性值；

l String getXmlStandalone()：获取文档声明的standalone属性值；

l void setXmlVersion()：设置文档声明version属性值；

l void setXmlStandalone()：设置文档声明standalone属性值。

Element方法介绍

获取方法：

l NodeList getElementsByTagName(String tagName)：获取当前元素的指定元素名称的全部子元素；

l String getTagName()：获取当前元素的元素名。调用元素节点的getNodeName()也是返回名；

属性相关方法：

l String getAttribute(String name)：获取当前元素指定属性名的属性值；

l Attr getAttributeNode(String name)：获取当前元素指定属性名的属性节点；

l boolean hasAttribute(String name)：判断当前元素是否有指定属性；

l void removeAttribute(String name)：移除当前元素的指定属性；

l void removeAttributeNode(Attr attr)：移除当前元素的指定属性；

l void setAttribute(String name, String value)：为当前元素添加或修改属性；

l Attr setAttributeNode(Attr attr)：为当前元素添加或修改属性，返回值为添加的属性；

Attr方法介绍

l String getName()：获取当前属性节点的属性名；

l String getValue()：获取当前属性节点的属性值；

l void setValue(String value)：设置当前属性节点的属性值；

l boolean isId()：判断当前属性节点是否为ID类型属性。

JAXP SAX解析

SAXParser 解析器类

SAXParserFactory 解析器工厂

SAX是事件驱动型XML解析的一个标准接口

对文档进行顺序扫描，当扫描到文档（document）开始与结束、元素（element）开始与结束、文档（document）结束等地方时通知事件处理函数

咱们须要作的就是实现这些回调的方法体

示例:

public static void SaxParse() throws Exception {

                //建立解析器工厂
                SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
                //建立解析器
                SAXParser saxParser = saxParserFactory.newSAXParser();
                //执行parse方法 此方法依赖DefaultHandler,因此须要自定义类实现DefaultHandler
                //其中qName 是标签的名称
                saxParser.parse("src/dom/test.xml", new DefaultHandler() {

                        @Override
                        public void startElement(String uri, String localName, String qName, Attributes attributes)
                                        throws SAXException {
                                System.out.println("<"+qName+">");
                        }

                        @Override
                        public void endElement(String uri, String localName, String qName) throws SAXException {
                                System.out.println("<"+qName+"/>");

                        }

                        @Override
                        public void characters(char[] ch, int start, int length) throws SAXException {
                                System.out.print(new String(ch,start,length));
                        }


                });
        }

DefaultHandler中还有不少的其余方法

使用DOM解析主要就是获取文档后对于全部的节点进行操做

使用SAX解析主要就是根据各个事件发生时,进行所须要的响应

若是想要对文档进行复杂的操做设置更多的须要查询Node下相关的实现类 Document Text 等

若是想要对文档进行复杂的筛选查询,那么须要精心的利用DefaultHandler处理各个事件

注意:既然说JAXP是一个接口规范,为何能够直接使用其来进行解析?

上面咱们已经提到了工厂类都是抽象类,并非本身实现的或者建立的,调用的newInstance建立的,他其实使用的是java提供给咱们的默认实现的解析器工做的

JAXP仍是接口规范,并非一组实现API

JDOM和DOM4J

这是两种第三方的解析工具仅仅用于java

JDOM与DOM4J相比，DOM4J完胜！！！因此，咱们应该在从此的开发中，把DOM4J视为首选。

DOM4J也是Hibernate使用的解析XML的方式

DOM4J查找解析器的过程

DOM4J首先会去经过JAXP的查找方法去查找解析器，若是找到解析器，那么就使用之；

不然会使用本身的默认解析器Aelfred2。

https://github.com/dom4j/dom4j/wiki/FAQ 中有关于解析器的说明

DOM4J对DOM和SAX都提供了支持

能够把DOM解析后的Document对象转换成DOM4J的Document对象，固然了能够把DOM4J的Document对象转换成DOM的Document对象。

DOM4J使用SAX解析器把XML文档加载到内存，生成DOM对象。固然也支持事件驱动的方式来解析XML文档。

在DOM4J中，也有Node、Document、Element等接口，结构上与DOM中的接口比较类似。

但仍是有不少的区别：

在DOM4J中，全部XML组成部分都是一个Node，

其中Branch表示能够包含子节点的节点，

例如Document和Element都是能够有子节点的，它们都是Branch的子接口。

Attribute是属性节点，CharacterData是文本节点，

文本节点有三个子接口，分别是CDATA、Text、Comment。

dom4J 官网 https://dom4j.github.io/

刚才提到的工做原理

DOM4J使用SAX解析器把XML文档加载到内存，生成DOM对象。固然也支持事件驱动的方式来解析XML文档。

这句话是重点,他两种解析方式均可以,并且,他是使用的SAX解析方式建立了一棵DOM4J树,此树中的对象能够转换成DOM树中的对象

dom4j 2.1.1 API

https://dom4j.github.io/javadoc/2.1.1/overview-summary.html

第三方的工具使用必然须要查看他的介绍方法

基本的使用在官网上已经有了很清晰的介绍

官网 https://dom4j.github.io/

获取指定元素标签的内容

        
//查询元素
public static void dom4jParseSelectNames() throws Exception {
                //1.导入包  import org.dom4j.io.SAXReader;
                //2.建立解析器
                SAXReader saxReader = new SAXReader();
                //3.使用解析器解析文档
                Document document = saxReader.read("src/dom/test.xml");
                //4.获得根节点
                Element root = document.getRootElement();

                //5.获得指定元素的列表
                List<Element> list = root.elements("student");
                //6.遍历list
                for (Element element : list) {
                        //element是每个student元素 获得student下面的name元素
                        Element name = element.element("name");
                        //获得name里面的值
                        String s = name.getText();
                        System.out.println(s);
                }


        }
}

//增长一个元素
public static void dom4jParseAdd() throws Exception {
                //1.导入包  import org.dom4j.io.SAXReader;
                //2.建立解析器
                SAXReader saxReader = new SAXReader();
                //3.使用解析器解析文档
                Document document = saxReader.read("src/dom/test.xml");
                //4.获得根节点
                Element root = document.getRootElement();

                //5.获得第一个student元素
                Element studentElement = root.element("student");
                //6.在student下面直接添加元素
                Element sexElement = studentElement.addElement("sex");
                //7.在sex下面添加文本
                sexElement.setText("男");

                //8.回写数据
                OutputFormat format = OutputFormat.createPrettyPrint();
                XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/dom/test.xml"), format);
                xmlWriter.write(document);
                xmlWriter.close();

        }

使用Dom4J格式都没有变乱

XPATH

什么是 XPath?

XPath 使用路径表达式在 XML 文档中进行导航

XPath 包含一个标准函数库

XPath 是 XSLT 中的主要元素

XPath 是一个 W3C 标准

http://www.w3school.com.cn/xpath/index.asp

XPath即为XML路径语言（XML Path Language），它是一种用来肯定XML文档中某部分位置的语言。

XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。

起初 XPath 的提出的初衷是将其做为一个通用的、介于XPointer与XSL间的语法模型。可是 XPath 很快的被开发者采用来看成小型查询语言。

就按照他的名字XML Path Language 理解就能够彻底掌握这个概念

在 XPath 中，有七种类型的节点：元素、属性、文本、命名空间、处理指令、注释以及文档节点（或称为根节点）。

类型都是节点类型的

其中直接值也就是常量 ,好比xml中的<year>2018</year> 2018就是基本值原子值

节点之间的相互关系有 :

父每一个元素以及属性都有一个父。

子元素节点可有零个、一个或多个子。

同胞拥有相同的父的节点

先辈某节点的父、父的父，等等

后代某个节点的子，子的子，等等。

DOM4J对XPath的支持

在DOM4J中，Node接口中的三个方法最为经常使用：　

 List selectNodes(String xpathExpression)：在当前节点中查找知足XPath表达式的全部子节点；

 Node selectSingleNode(String xpathExpression)：在当前节点中查找知足XPath表达式的第一个子节点；

 String valueOf(String xpathExpression)：在当前节点中查找知足XPath表达式的第一个子节点的文本内容；

语法格式能够根据w3school中的语法形式进行选择

http://www.w3school.com.cn/xpath/xpath_syntax.asp

想要在DOM4J中解析XPATH还须要另一个包 Jaxen

能够去中央仓库下载或者随便搜索一下 jaxen-1.1-beta-6.jar

不然就会报错

Jaxen是一个用Java编写的XPath引擎，用于处理各类基于XML的对象模型，如DOM，dom4j和JDOM以及Java Bean。

public static void dom4jParseXpath() throws Exception {
                //1.导入包  import org.dom4j.io.SAXReader;
                //2.建立解析器
                SAXReader saxReader = new SAXReader();
                //3.使用解析器解析文档
                Document document = saxReader.read("src/dom/test.xml");
                //4.获得根节点
                List<Node> nodes = document.selectNodes("//name");
                //5.遍历list
                for (Node node : nodes) {
                        //获得name里面的值
                        String s = node.getText();
                        System.out.println(s);
                }

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


                List<Node> nodess = document.selectNodes("//student");
                //5.遍历list
                for (Node node : nodess) {

                        //获得name里面的值
                        String s = node.getStringValue();
                        System.out.println(s);
                }
        }
}