几种常用XML文档解析方案的使用操作

XML概述
- 组成部分
- XML示例
- 约束
- - DTD
  - Schema
解析XML
- 解析方式
- 常见解析器
JAXP的使用
- 准备student.xml文件
- 解析XML文档
- 写入XML文档
dom4j的使用
- Document对象获取方式
- 引入依赖
- 解析XML文档
- 文档写入XML
Jsoup的使用
- 引入依赖
- 核心对象
- 解析XML文档
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使用。

常用方法：

//根据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);
        }
    }