(JAXP、DOM4J、Jsoup、JsoupXPath等常用XML解析器的使用)
XML概述
XML(Extensible Markup Language)，可扩展标记语言。XML具有标签自定义，语法严格，适用于存储数据与传输数据等特点。
组成部分
1.文档声明
格式：<?xml 属性列表 ?>
属性列表：
version：版本号，必须的属性
encoding：编码方式。告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1
standalone：是否独立 yes：不依赖其他文件 no：依赖其他文件
2.指令
用于结合css：<?xml-stylesheet type="text/css" href="xml.css" ?>
3.标签
标签名称自定义，需遵循规则：
名称可以包含字母、数字以及其他的字符
名称不能以数字或者标点符号开始
名称不能以字母 xml（或者 XML、Xml 等等）开始
名称不能包含空格
4.属性
id属性值唯一
5.文本
CDATA区：在该区域中的数据会被原样展示
格式： <![CDATA[ 展示数据]]>
语法
xml文档的后缀名 .xml
xml第一行必须定义为文档声明，可选部分，如果存在需要放在文档的第一行
xml文档中有且仅有一个根标签，是所有其他元素的父元素
属性值必须使用引号(单双都可)引起来
标签必须正确关闭，所有的XML元素都必须有一个关闭标签
xml标签名称区分大小写
XML示例
<?xml version="1.0" encoding="UTF-8" ?>
<students>
<student id='1'>
<name>小白</name>
<age>20</age>
</student>
<student id='2'>
<name>大白</name>
<age>30</age>
</student>
</students>
约束
约束是规定xml文档的书写规则。约束分为：DTD（一种简单的约束技术）与Schema（一种复杂的约束技术）共两类。
DTD
students.dtd
<!ELEMENT students (student+) >
<!ELEMENT student (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ATTLIST student name ID #REQUIRED>
引入方式：
内部dtd：将约束规则定义在xml文档中
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE students [
<!ELEMENT students (student+) >
<!ELEMENT student (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ATTLIST student name ID #REQUIRED>
]>
<students>
<student name="xb">
<name>小白</name>
<age>20</age>
</student>
<student name="db">
<name>大白</name>
<age>30</age>
</student>
</students>
外部dtd：将约束的规则定义在外部的dtd文件中
本地：<!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE students SYSTEM "student.dtd">
<students>
<student name="xb">
<name>小白</name>
<age>20</age>
</student>
<student name="db">
<name>大白</name>
<age>30</age>
</student>
</students>
网络：<!DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">
Schema
1.填写xml文档的根元素 <?xml version="1.0" encoding="UTF-8"?>
2.引入xsi前缀 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.引入xsd文件命名空间 xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"
4.为每一个xsd约束声明一个前缀,作为标识 xmlns:mvc="http://www.springframework.org/schema/mvc"
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<bean></bean>
<mvc:annotation-driven />
</beans>
XML的解析
解析就是操作xml文档，将文档中的数据读取到内存中，再将内存中的数据保存到xml文档中，持久化存储。
解析方式
1. DOM：将标记语言文档一次性加载进内存，在内存中形成一颗dom树。操作方便，可以对文档进行CRUD的操作，但占用内存。
2. SAX：逐行读取，基于事件驱动的，其优点不占用内容，但是只能读取，不能增删改。
常见解析器
1. JAXP：sun公司提供的解析器，支持dom和sax两种思想
2. DOM4J：是一个十分优秀的Java XML API，用来读写XML文件，具有性能优异、功能强大和极其易使用的特点。
3. Jsoup：jsoup 是一款Java的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。
4. JsoupXPath：XPath即为XML路径语言（XML Path Language），它是一种用来确定XML文档中某部分位置的语言。
JAXP的使用
准备student.xml文件
创建student.xml文件，用于XML解析、写入测试。
<?xml version="1.0" encoding="UTF-8" ?>
<students>
<student id='1'>
<name>小白</name>
<age>20</age>
</student>
<student id='2'>
<name>大白</name>
<age>30</age>
</student>
</students>
解析XML文档
解析XML文档的步骤：
使用javax.xml.parsers包下的DocumentBuilderFactory类中的newInstance()方法获得一个解析器工厂对象
使用解析器工厂对象的newDocumentBuilder()方法获得一个解析器对象
用解析器对象的parse(String uri)方法解析指定XML文档并返回一个org.w3c.dom包下的Document对象
使用Document对象的getElementsByTagName(String tagname)方法获得指定标签名的NodeList列表
使用NodeList列表的item(int index)方法得到指定角标的节点对象
使用Node接口中的一系列方法对其进行操作
public static void main(String[] args) throws Exception {
String path = ApplicationTests.class.getClassLoader().getResource("students.xml").getPath();
// 创建解析器工厂对象
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
// 创建解析器对象
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
// 解析指定XML文档返回document
Document document = documentBuilder.parse(new File(path));
// 获得指定标签名的NodeList列表
NodeList students = document.getElementsByTagName("name");
// 得到指定角标的节点对象
for (int i = 0; i < students.getLength(); i++) {
Node node = students.item(i);
// TODO 使用Node接口中的一系列方法对其进行操作
System.out.println("node name = " + node.getTextContent());
}
}
写入XML文档
写入XML文档的步骤：
创建sex标签节点
创建sex标签对应文本值
对sex标签添加text
对某个节点添加sex标签节点
通过javax.xml.transform包下的TransformerFactory.newInstance()方法得到一个回写转换器对象工厂
通过回写转换器对象工厂的newTransformer()方法得到回写转换器对象
使用回写转换器对象的transform(Source xmlSource, Result outputTarget)方法将内存中内容回写入XML文档。
Source参数通过new DOMSource(文档对象)方法获得
Result参数可以通过javax.xml.tramsform.stream包下的StreamResult(String URL)方法获得
public static void main(String[] args) throws Exception {
String path = ApplicationTests.class.getClassLoader().getResource("students.xml").getPath();
// 创建解析器工厂对象
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
// 创建解析器对象
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
// 解析指定XML文档返回document
Document document = documentBuilder.parse(new File(path));
//创建sex标签
Node sex = document.createElement("sex");
//创建文本
Text text = document.createTextNode("男");
// sex标签添加text
sex.appendChild(text);
Node node = document.getElementsByTagName("student").item(0);
// student标签添加sex节点
node.appendChild(sex);
// 得到回写转换器对象工厂
TransformerFactory transformerFactory = TransformerFactory.newInstance();
// 得到回写转换器对象
Transformer transformer = transformerFactory.newTransformer();
// 将内存中内容回写入XML文档
transformer.transform(new DOMSource(document), new StreamResult(new File(path)));
}
dom4j的使用
dom4j是一个开源的XML处理框架，集成了XPath，全面支持DOM、SAX、JAXP和Java平台。是一个十分优秀的Java XML API，用来读写XML文件，具有性能优异、功能强大和极其易使用的特点。
GitHub地址:https://github.com/dom4j/dom4j
Document对象获取方式
解析XML过程是通过获取Document对象，然后继续获取各个节点以及属性等操作，获取Document对象是第一步，总共有三种方式。
1.使用DocumentHelper.createDocument()创建Document对象
Document document = DocumentHelper.createDocument();
//其中students是根节点，可以继续添加其他节点等操作。
Element root = document.addElement("students");
2.建SAXReader对象然后转换成Document对象
//创建SAXReader对象
SAXReader reader = new SAXReader();
//读取文件 转换成Document
Document document = reader.read(new File("XXXX.xml"));
3.读取XML文本内容获取Document对象
String xmlStr = "<students>......</students>";
Document document = DocumentHelper.parseText(xmlStr);
引入依赖
<!-- https://mvnrepository.com/artifact/org.dom4j/dom4j -->
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>2.1.3</version>
</dependency>
解析XML文档
public static void main(String[] args) throws Exception {
String path = XmlTest.class.getClassLoader().getResource("students.xml").getPath();
//UTF-8编码
String filePath = URLDecoder.decode(path, "UTF-8");
//xml解析器
SAXReader saxReader = new SAXReader();
Document read = saxReader.read(filePath);
//拿到根节点
Element rootElement = read.getRootElement();
//getNodes(rootElement);
getALLNodes(rootElement);
}
static public void getNodes(Element rootElement) {
System.out.println("节点名称:" + rootElement.getName());
//拿到节点属性
List<Attribute> attributes = rootElement.attributes();
for (Attribute attribute : attributes) {
System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
}
//节点名称 <name>大白</name>节点中的值
if (!rootElement.getTextTrim().equals("")) {
System.out.println(rootElement.getName() + "---" + rootElement.getText());
}
//迭代器遍历
Iterator<Element> elementIterator = rootElement.elementIterator();
while (elementIterator.hasNext()) {
//获取当前节点值
Element next = elementIterator.next();
getNodes(next);
}
}
static public void getALLNodes(Element rootElement) {
System.out.println("根节点名称:" + rootElement.getName());
//根节点下的节点
List<Element> elements = rootElement.elements();
for (Element element : elements) {
//拿到节点属性
List<Attribute> attributes = element.attributes();
for (Attribute attribute : attributes) {
System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
}
//根节点下的节点的节点
List<Element> sonElements = element.elements();
for (Element sonElement : sonElements) {
//节点名称 <name>大白</name>节点中的值
if (!sonElement.getTextTrim().equals("")) {
System.out.println(sonElement.getName() + "---" + sonElement.getText());
}
}
}
}
文档写入XML
public static void main(String[] args) throws Exception {
String path = ApplicationTests.class.getClassLoader().getResource("students.xml").getPath();
//UTF-8编码
String filePath = URLDecoder.decode(path, "UTF-8");
//xml解析器
SAXReader saxReader = new SAXReader();
Document read = saxReader.read(filePath);
createStudentNode(read, path);
}
/**
* 创建新的student节点
*
* @param document
*/
public static void createStudentNode(Document document, String path) {
try (Writer writer = new OutputStreamWriter(new FileOutputStream(path), "UTF-8")) {
// 获取根节点
Element root = document.getRootElement();
// 添加根节点的子节点 新的student节点
Element b = root.addElement("student");
// 创建student节点的各个子节点
// 添加子节点的属性
b.addAttribute("id", "3");//原有长度+1
// 添加子节点的的子节点name
b.addElement("name").setText("createNode");
// 添加子节点的子节点age
b.addElement("age").setText("22");
// 写入XML
document.write(writer);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
Jsoup的使用
GitHub地址：https://github.com/jhy/jsoup
官网：https://jsoup.org
jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。
Jsoup主要功能
从一个URL，文件或字符串中解析HTML
使用DOM或CSS选择器来查找、取出数据
可操作HTML元素、属性、文本
引入依赖
<!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.13.1</version>
</dependency>
核心对象
1.Jsoup
Jsoup是一个工具类，可以解析html或xml文档，返回Document。
常用方法：
//解析xml或html字符串
public static Document parse(String html) {
return Parser.parse(html, "");
}
//解析xml或html文件
public static Document parse(File in, String charsetName) throws IOException {
return DataUtil.load(in, charsetName, in.getAbsolutePath());
}
//通过网络路径获取指定的html或xml的文档对象
public static Document parse(URL url, int timeoutMillis) throws IOException {
Connection con = HttpConnection.connect(url);
con.timeout(timeoutMillis);
return con.get();
}
2.Document
Document是指文档对象，代表内存中的dom树。
常用方法：
//根据id属性值获取唯一的element对象
public Element getElementById(String id) {
Validate.notEmpty(id);
Elements elements = Collector.collect(new Id(id), this);
return elements.size() > 0 ? (Element)elements.get(0) : null;
}
//根据标签名称获取元素对象集合
public Elements getElementsByTag(String tagName) {
Validate.notEmpty(tagName);
tagName = Normalizer.normalize(tagName);
return Collector.collect(new org.jsoup.select.Evaluator.Tag(tagName), this);
}
//根据属性名称获取元素对象集合
public Elements getElementsByAttribute(String key) {
Validate.notEmpty(key);
key = key.trim();
return Collector.collect(new Attribute(key), this);
}
//根据对应的属性名和属性值获取元素对象集合
public Elements getElementsByAttributeValue(String key, String value) {
return Collector.collect(new AttributeWithValue(key, value), this);
}
3.Elements与Element
Element是元素对象，Elements是元素Element对象的集合，可以当做 ArrayList<Element>使用。
常用方法：
//根据id属性值获取唯一的element对象
public Element getElementById(String id) {
Validate.notEmpty(id);
Elements elements = Collector.collect(new Id(id), this);
return elements.size() > 0 ? (Element)elements.get(0) : null;
}
//根据class属性值获取elements对象集合
public Elements getElementsByClass(String className) {
Validate.notEmpty(className);
return Collector.collect(new Class(className), this);
}
//根据标签名称获取元素对象集合
public Elements getElementsByTag(String tagName) {
Validate.notEmpty(tagName);
tagName = Normalizer.normalize(tagName);
return Collector.collect(new org.jsoup.select.Evaluator.Tag(tagName), this);
}
//根据属性名称获取元素对象集合
public Elements getElementsByAttribute(String key) {
Validate.notEmpty(key);
key = key.trim();
return Collector.collect(new Attribute(key), this);
}
//根据对应的属性名和属性值获取元素对象集合
public Elements getElementsByAttributeValue(String key, String value) {
return Collector.collect(new AttributeWithValue(key, value), this);
}
//根据属性名称获取属性值
public String attr(String attributeKey) {
Validate.notNull(attributeKey);
if (!this.hasAttributes()) {
return "";
} else {
String val = this.attributes().getIgnoreCase(attributeKey);
if (val.length() > 0) {
return val;
} else {
return attributeKey.startsWith("abs:") ? this.absUrl(attributeKey.substring("abs:".length())) : "";
}
}
}
//获取文本内容
public String text() {
StringBuilder sb = new StringBuilder();
Element element;
for(Iterator var2 = this.iterator(); var2.hasNext(); sb.append(element.text())) {
element = (Element)var2.next();
if (sb.length() != 0) {
sb.append(" ");
}
}
return sb.toString();
}
//获取标签体的所有内容(包括字标签的字符串内容)
public String html() {
StringBuilder sb = new StringBuilder();
Element element;
for(Iterator var2 = this.iterator(); var2.hasNext(); sb.append(element.html())) {
element = (Element)var2.next();
if (sb.length() != 0) {
sb.append("\n");
}
}
return sb.toString();
}
解析XML文档
public static void main(String[] args) throws IOException {
//根据xml文档获取，获取Document对象
String path = JsoupDemo1.class.getClassLoader().getResource("student.xml").getPath();
//解析xml文档，加载文档进内存
Document document = Jsoup.parse(new File(path), "utf-8");
//获取元素对象Element
Elements elements = document.getElementsByTag("name");
//循环得到每一个element对象
for (Element element : elements) {
//获取数据
String name = element.text();
System.out.println(name);
}
//获取属性名为id的元素对象们
Elements elements1 = document.getElementsByAttribute("id");
System.out.println(elements1);
//获取id属性值为2的元素对象
Elements elements2 = document.getElementsByAttributeValue("id", "2");
System.out.println(elements2);
//获取id属性值的元素对象
Element elements3 = document.getElementById("2");
System.out.println(elements3);
//通过Element对象获取子标签对象
Elements ele_name = elements3.getElementsByTag("name");
System.out.println(ele_name);
//获取student对象的属性值
String id = elements3.attr("id");
System.out.println(id);
//获取文本内容
String text = ele_name.text();
System.out.println(text);
String html = ele_name.html();
System.out.println(html);
}
JsoupXPath的使用
GitHub地址：https://github.com/zhegexiaohuozi/JsoupXpath
XPath即为XML路径语言（XML Path Language），它是一种用来确定XML文档中某部分位置的语言。
XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。
引入依赖
<!-- https://mvnrepository.com/artifact/cn.wanghaomiao/JsoupXpath -->
<dependency>
<groupId>cn.wanghaomiao</groupId>
<artifactId>JsoupXpath</artifactId>
<version>2.4.3</version>
</dependency>
解析XML文档
public static void main(String[] args) throws IOException, XpathSyntaxErrorException {
//获取student.xml的path
String path = JsoupDemo6.class.getClassLoader().getResource("student.xml").getPath();
//获取Document对象
Document document = Jsoup.parse(new File(path), "utf-8");
//根据document对象，创建JXDocument对象
JXDocument jxDocument = new JXDocument(document);
//查询所有student标签
List<JXNode> jxNodes = jxDocument.selN("//student");
for (JXNode jxNode : jxNodes) {
System.out.println(jxNode);
}
//查询所有student标签下的name标签
List<JXNode> jxNodes2 = jxDocument.selN("//student/name");
for (JXNode jxNode : jxNodes2) {
System.out.println(jxNode);
}
//查询带有id属性的student标签
List<JXNode> jxNodes3 = jxDocument.selN("//student[@id]");
for (JXNode jxNode : jxNodes3) {
System.out.println(jxNode);
}
//查询带有id属性的student标签并且id属性值为1
List<JXNode> jxNodes4 = jxDocument.selN("//student[@id='1']");
for (JXNode jxNode : jxNodes4) {
System.out.println(jxNode);
}
}