XML--java高级技术_xml文档的标签为什么不像html标签有确定的语意-CSDN博客

本文链接：https://blog.csdn.net/weixin_42137874/article/details/115877702

XML介绍

什么是XML

XML 指可扩展标记语言（EXtensible Markup Language）
XML 是一种标记语言，很类似 HTML，HTML文件也是XML文档
XML 的设计宗旨是传输数据，而非显示数据
XML 标签没有被预定义。您需要自行定义标签。
XML 被设计为具有自我描述性(就是易于阅读)。
XML 是 W3C 的推荐标准
W3C在1988年2月发布1.0版本，2004年2月又发布1.1版本，单因为1.1版本不能向下兼容1.0版本，所以1.1没有人用。同时，在2004年2月W3C又发布了1.0版本的第三版。我们要学习的还是1.0版本。

XML 与 HTML 的主要差异

XML 不是 HTML 的替代。
XML 和 HTML 为不同的目的而设计。
XML 被设计为传输和存储数据，其焦点是数据的内容。
HTML 被设计用来显示数据，其焦点是数据的外观。
HTML 旨在显示信息，而 XML 旨在传输信息。

XML作用

XML在企业开发中主要有两种应用场景：
1）XML可以存储数据 , 作为数据交换的载体(使用XML格式进行数据的传输)。
2）XML也可以作为配置文件，例如后面框架阶段我们学习的Spring框架的配置(applicationContext.xml)都是通过XML进行配置的（企业开发中经常使用的）

XML的组成元素

XML文件中常见的组成元素有:文档声明、元素、属性、注释、转义字符、字符区。

文档声明

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

使用IDE创建xml文件时就带有文档声明.
文档声明必须为<?xml开头，以？>结束
文档声明必须从文档的0行0列位置开始
文档声明中常见的两个属性：
- version：指定XML文档版本。必须属性，这里一般选择1.0；
- enconding：指定当前文档的编码，可选属性，默认值是utf-8；

元素element

格式1:<person></person>
格式2:<person/>

元素是XML文档中最重要的组成部分；
普通元素的结构由开始标签、元素体、结束标签组成。
元素体：元素体可以是元素，也可以是文本，例如：<person><name>张三</name></person>
空元素：空元素只有标签，而没有结束标签，但元素必须自己闭合，例如：<sex/>
元素命名
- 区分大小写
- 不能使用空格，不能使用冒号
- 不建议以XML、xml、Xml开头
格式化良好的XML文档，有且仅有一个根元素。

属性

<person id="110">

属性是元素的一部分，它必须出现在元素的开始标签中
属性的定义格式：属性名=“属性值”，其中属性值必须使用单引或双引号括起来
一个元素可以有0~N个属性，但一个元素中不能出现同名属性
属性名不能使用空格 , 不要使用冒号等特殊字符，且必须以字母开头

注释

<!--注释内容-->

XML的注释与HTML相同，既以结束。

转义字符

XML中的转义字符与HTML一样。因为很多符号已经被文档结构所使用，所以在元素体或属性值中想使用这些符号就必须使用转义字符（也叫实体字符），例如：">"、"<"、"’"、"""、"&"。

字符	预定义的转义字符	说明
<	`<`	小于
>	`>`	大于
"	`"`	双引号
’	`'`	单引号
&	`&`	和号

注意：严格地讲，在 XML 中仅有字符 “<“和”&” 是非法的。省略号、引号和大于号是合法的，但是把它们替换为实体引用是个好的习惯。
转义字符应用示例：
假如您在 XML 文档中放置了一个类似 “<” 字符，那么这个文档会产生一个错误，这是因为解析器会把它解释为新元素的开始。因此你不能这样写：

<message>if salary < 1000 then</message>

为了避免此类错误，需要把字符 “<” 替换为实体引用，就像这样：

<message>if salary &lt; 1000 then</message>

字符区(了解)

<![CDATA[
	文本数据
]]>

CDATA 指的是不应由 XML 解析器进行解析的文本数据（Unparsed Character Data）
CDATA 部分由 “<![CDATA[" 开始，由 "]]>” 结束；
当大量的转义字符出现在xml文档中时，会使XML文档的可读性大幅度降低。这时如果使用CDATA段就会好一些。

注意：

CDATA 部分不能包含字符串 “]]>”。也不允许嵌套的 CDATA 部分。

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

XML文件的约束

在XML技术里，可以编写一个文档来约束一个XML文档的书写规范，这称之为XML约束。

常见的xml约束：DTD、Schema

注意:我们对于约束的要求是能通过已写好的约束文件编写xml文档.
| 字符 | 预定义的转义字符 | 说明 |
| :–: | :--------------: | :----: |
| < | < | 小于 |
| > | > | 大于 |
| " | " | 双引号 |
| ’ | ' | 单引号 |
| & | & | 和号 |

<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/css" href="../css/xml.css" ?>
<!-- 7.处理指令：导入外部的css样式控制xml的界面效果，没有啥用，xml不是为了展示好看的！-->
<!-- 1.申明 抬头 必须在第一行-->
<!-- 2.注释，本处就是注释，必须用前后尖括号围起来 -->
<!-- 3.标签（元素），注意一个XML文件只能有一个根标签-->
<student>
    <!-- 4.属性信息：id , desc-->
    <name id="1" desc="高富帅">西门庆</name>
    <age>32</age>
    <!-- 5.实体字符：在xml文件中，我们不能直接写小于号，等一些特殊字符
        会与xml文件本身的内容冲突报错，此时必须用转义的实体字符。
    -->
    <sql>
       <!-- select * from student where age < 18 && age > 10; -->
        select * from student where age &lt; 18 &amp;&amp; age &gt; 10;
    </sql>
    <!-- 6.字符数据区：在xml文件中，我们不能直接写小于号，等一些特殊字符
        会与xml文件本身的内容冲突报错，此时必须用转义的实体字符
        或者也可以选择使用字符数据区，里面的内容可以随便了！
        -->
    <sql2>
        <![CDATA[
             select * from student where age < 18 && age > 10;
        ]]>
    </sql2>
</student>

<!ELEMENT 书架 (书+)>
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>
<!ELEMENT 作者 (#PCDATA)>
<!ELEMENT 售价 (#PCDATA)>

<?xml version="1.0" encoding="UTF-8" ?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.itcast.cn"
        elementFormDefault="qualified" >
    <!-- targetNamespace:申明约束文档的地址（命名空间）-->
    <element name='书架'>
        <!-- 写子元素 -->
        <complexType>
            <!-- maxOccurs='unbounded': 书架下的子元素可以有任意多个！-->
            <sequence maxOccurs='unbounded'>
                <element name='书'>
                    <!-- 写子元素的！ -->
                    <complexType>
                        <!-- 子元素必须有序-->
                        <sequence>
                            <element name='书名' type='string'/>
                            <element name='作者' type='string'/>
                            <element name='售价' type='double'/>
                        </sequence>
                    </complexType>
                </element>
            </sequence>
        </complexType>
    </element>
</schema>

<?xml version="1.0" encoding="UTF-8" ?>
<person>
    <name>王熙凤</name>
    <age>29</age>
    <sex>女</sex>
    <hobby>笑的很犀利</hobby>
</person>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE 书架 SYSTEM "books.dtd">
<书架>
    <书>
        <书名>JavaEE SSM</书名>
        <作者>NewBoy</作者>
        <售价>30</售价>
    </书>
    <书>
        <书名>人鬼情喂鸟</书名>
        <作者>李四</作者>
        <售价>300</售价>
    </书>
</书架>

<?xml version="1.0" encoding="UTF-8" ?>
<书架 xmlns:it="http://www.itcast.cn"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.itcast.cn books02.xsd"
     >
    <!-- xmlns="http://www.itcast.cn"  基本位置
         xsi:schemaLocation="http://www.itcast.cn books02.xsd" 具体的位置
        -->
    <书>
        <书名>mybatis深入剖析</书名>
        <作者>Dlei</作者>
        <售价>99.9</售价>
    </书>
    <书>
        <书名>mybatis深入剖析</书名>
        <作者>Dlei</作者>
        <售价>99.9</售价>
    </书>
</书架>

DTD约束

概念

DTD是文档类型定义（Document Type Definition）。DTD 可以定义在 XML 文档中出现的元素、这些元素出现的次序、它们如何相互嵌套以及XML文档结构的其它详细信息。

dom4j: 获取Document对象和根元素

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
/**
    目标：dom4j: 获取Document对象和根元素
    dom4j属于第三方技术，必须导入该框架！！
    dom4j安装步骤：
        a.去dom4j官网下载dom4j的框架：都是一些jar包。
        b.把dom4j的核心jar包导入到当前项目中去。
        c.在项目中创建一个文件夹：lib
        d.将dom4j-2.1.1.jar文件复制到 lib 文件夹
        e.在jar文件上点右键，选择 Add as Library -> 点击OK
        f.在类中导包使用
    Java提供了Class下的一个方法：
         public InputStream getResourceAsStream(String path)
            -- 用于加载文件成为一个字节输入流返回！！
    Document文档：
         Element getRootElement()：获取根元素。

    小结：
        先导入dom4j框架。
        创建一个dom4j的解析对象：SAXReader
        通过解析对象把xml文件解析成Document文档对象。
        从Document文档对象中获取我们想要的xml信息。
 */
public class Dom4JDemo01 {
    public static void main(String[] args) throws Exception {
        // 需求：解析books.xml文件成为一个Document文档树对象，得到根元素对象。
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第一种方式（简单）：通过解析器对象去加载xml文件数据，成为一个Document文档树对象。
        //Document document = saxReader.read(new File("Day13Demo/src/books.xml"));

        // 3.第二种方式（代码多点）先把xml文件读成一个字节输入流
        // 这里的“/”是直接去src类路径下寻找文件。
        InputStream is = Dom4JDemo01.class.getResourceAsStream("/books.xml");
        Document document = saxReader.read(is);

        System.out.println(document);

        // 4.从document文档树对象中提取根元素对象
        Element root = document.getRootElement();
        System.out.println(root.getName());
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<books>
    <book id="0001" desc="第一本书">
        <name>  JavaWeb开发教程</name>
        <author>    张孝祥</author>
        <sale>100.00元   </sale>
    </book>
    <book id="0002">
        <name>三国演义</name>
        <author>罗贯中</author>
        <sale>100.00元</sale>
    </book>
    <user>
    </user>
</books>

Dom4j解析XML的子元素

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.List;
/**
    目标：Dom4j解析XML的子元素
    Element元素的API:
        String getName():取元素的名称。
        List<Element> elements():获取当前元素下的全部子元素（一级）
        List<Element> elements(String name):获取当前元素下的指定名称的全部子元素（一级）
        Element element(String name):获取当前元素下的指定名称的某个子元素，默认取第一个（一级）
 */
public class Dom4JDemo {
    public static void main(String[] args) throws Exception {
        // 需求：解析books.xml文件成为一个Document文档树对象，得到根元素对象。
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第一种方式（简单）：通过解析器对象去加载xml文件数据，成为一个Document文档树对象。
        Document document = saxReader.read(new File("Day13Demo/src/books.xml"));

        // 3.获取根元素对象
        Element root = document.getRootElement();
        System.out.println(root.getName());

        // 4.获取根元素下的全部子元素
        List<Element> sonElements = root.elements();
        for (Element sonElement : sonElements) {
            System.out.println(sonElement.getName());
        }

        System.out.println("-------------------");
        // 5.获取根源下的全部book子元素
        List<Element> sonElements1 = root.elements("book");
        for (Element sonElement : sonElements1) {
            System.out.println(sonElement.getName());
        }
        System.out.println("-------------------");
        // 6.获取根源下的指定的某个元素
        Element son = root.element("user");
        System.out.println(son.getName());

        // 默认会提取第一个名称一样的子元素对象返回！
        Element son1 = root.element("book");
        System.out.println(son1.attributeValue("id"));
    }
}

Dom4j解析XML的属性

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.List;

/**
    目标：Dom4j解析XML的属性;

    Element元素的API:
        List<Attribute> attributes(): 获取元素的全部属性对象。
        Attribute attribute(String name):根据名称获取某个元素的属性对象。
        String attributeValue(String var1):直接获取某个元素的某个属性名称的值。

    Attribute对象的API:
        String getName():  获取属性名称。
        String getValue(): 获取属性值。

 */
public class Dom4JDemo {
    public static void main(String[] args) throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第一种方式（简单）：通过解析器对象去加载xml文件数据，成为一个Document文档树对象。
        Document document = saxReader.read(new File("Day13Demo/src/books.xml"));

        // 3.获取根元素对象。
        Element root = document.getRootElement();

        // 4.获取book子元素
        Element bookEle = root.element("book");

        // 5.获取book元素的全部属性对象
        List<Attribute> attributes = bookEle.attributes();
        for (Attribute attribute : attributes) {
            System.out.println(attribute.getName()+"=>"+attribute.getValue());
        }

        // 6.获取Book元素的某个属性对象
        Attribute descAttr = bookEle.attribute("desc");
        System.out.println(descAttr.getName()+"--->"+descAttr.getValue());

        // 7.可以直接获取元素的属性值
        System.out.println(bookEle.attributeValue("id"));
        System.out.println(bookEle.attributeValue("desc"));
    }
}

Dom4j解析XML的文本

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;

/**
    目标：Dom4j解析XML的文本;

    Element:
        String elementText(String name): 可以直接获取当前元素的子元素的文本内容
        String elementTextTrim(String name): 去前后空格,直接获取当前元素的子元素的文本内容
        String getText():直接获取当前元素的文本内容。
        String getTextTrim():去前后空格,直接获取当前元素的文本内容。
 */
public class Dom4JDemo {
    public static void main(String[] args) throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第一种方式（简单）：通过解析器对象去加载xml文件数据，成为一个Document文档树对象。
        Document document = saxReader.read(new File("Day13Demo/src/books.xml"));

        // 3.获取根元素对象。
        Element root = document.getRootElement();

        // 4.得到第一个子元素book
        Element bookEle = root.element("book");

        // 5.直接拿到当前book元素下的子元素文本值
        System.out.println(bookEle.elementText("name"));
        System.out.println(bookEle.elementTextTrim("name")); // 去前后空格
        System.out.println(bookEle.elementText("author"));
        System.out.println(bookEle.elementTextTrim("author")); // 去前后空格
        System.out.println(bookEle.elementText("sale"));
        System.out.println(bookEle.elementTextTrim("sale")); // 去前后空格

        // 6.先获取到子元素对象，再获取该文本值
        Element bookNameEle = bookEle.element("name");
        System.out.println(bookNameEle.getText());
        System.out.println(bookNameEle.getTextTrim());// 去前后空格
    }
}

Dom4j解析XML文件:Contacts.xml成为一个Java的对象（集合对象）

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
   目标：Dom4j解析XML文件:Contacts.xml成为一个Java的对象（集合对象）

   Contacts.xml 解析成===> List<Contact>

    分析：
        1.定义一个联系人类封装联系人数据。
        2.解析成List集合。
 */
public class Dom4JDemo {
    public static void main(String[] args) throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第一种方式（简单）：通过解析器对象去加载xml文件数据，成为一个Document文档树对象。
        Document document = saxReader.read(new File("Day13Demo/src/Contacts.xml"));

        // 3.获取根元素对象。
        Element root = document.getRootElement();

        // 4.获取根元素下的全部子元素
        List<Element> sonElements = root.elements();

        // 5.遍历子元素 封装成List集合对象
        List<Contact> contactList = new ArrayList<>();
        if(sonElements != null && sonElements.size() > 0) {
            for (Element sonElement : sonElements) {
                Contact contact = new Contact();
                contact.setId(Integer.valueOf(sonElement.attributeValue("id")));
                contact.setVip(Boolean.valueOf(sonElement.attributeValue("vip")));
                contact.setName(sonElement.elementText("name"));
                contact.setSex(sonElement.elementText("gender").charAt(0));
                contact.setEmail(sonElement.elementText("email"));
                contactList.add(contact);
            }
        }
        System.out.println(contactList);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<contactList>
    <contact id="1" vip="true">
        <name>潘金莲</name>
        <gender>女</gender>
        <email>panpan@itcast.cn</email>
    </contact>
    <contact id="2" vip="false">
        <name>武松</name>
        <gender>男</gender>
        <email>wusong@itcast.cn</email>
    </contact>
    <contact id="3" vip="false">
        <name>武大狼</name>
        <gender>男</gender>
        <email>wuda@itcast.cn</email>
    </contact>
</contactList>

/**
 <contact id="1" vip="true">
     <name>潘金莲</name>
     <gender>女</gender>
     <email>panpan@itcast.cn</email>
 </contact>
 */
public class Contact {
    private int id ;
    private boolean vip;
    private String name ;
    private char sex ;
    private String email ;

    public Contact() {
    }

    public Contact(int id, boolean vip, String name, char sex, String email) {
        this.id = id;
        this.vip = vip;
        this.name = name;
        this.sex = sex;
        this.email = email;
    }

    /**
     * 获取
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     * @return vip
     */
    public boolean isVip() {
        return vip;
    }

    /**
     * 设置
     * @param vip
     */
    public void setVip(boolean vip) {
        this.vip = vip;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return sex
     */
    public char getSex() {
        return sex;
    }

    /**
     * 设置
     * @param sex
     */
    public void setSex(char sex) {
        this.sex = sex;
    }

    /**
     * 获取
     * @return email
     */
    public String getEmail() {
        return email;
    }

    /**
     * 设置
     * @param email
     */
    public void setEmail(String email) {
        this.email = email;
    }

    public String toString() {
        return "Contact{id = " + id + ", vip = " + vip + ", name = " + name + ", sex = " + sex + ", email = " + email + "}";
    }
}

XPath检索XML中的信息

import com.itheima._01Dom4J解析XML文档根元素.Dom4JDemo01;
import org.dom4j.*;
import org.dom4j.io.SAXReader;
import org.junit.Test;

import java.io.File;
import java.io.InputStream;
import java.util.List;

/**
    目标：XPath检索XML中的信息啊。

    引入：
        Dom4J可以用于解析整个XML的数据。
        但是如果要检索XML中的某些信息，建议使用XPath.
    XPath使用步骤：
        1.导入dom4j框架。（XPath依赖于Dom4j技术,必须先倒入dom4j框架！）
        2.导入XPath独有的框架包。jaxen-1.1.2.jar
    XPath常用API:
        List<Node> selectNodes(String var1):检索出一批节点集合。
        Node selectSingleNode(String var1)：检索出一个节点返回。
    XPath提供的四种检索数据的写法：
        1.绝对路径。
        2.相对路径。
        3.全文搜索。
        4.属性查找。

    小结：
         1.绝对路径： /根元素/子元素/子元素。
         2.相对路径： ./子元素/子元素。 (.代表了当前元素)
         3.全文搜索：
                //元素  在全文找这个元素
                //元素1/元素2  在全文找元素1下面的一级元素2
                //元素1//元素2  在全文找元素1下面的全部元素2
         4.属性查找。
                //@属性名称  在全文检索属性对象。
                //元素[@属性名称]  在全文检索包含该属性的元素对象。
                //元素[@属性名称=值]  在全文检索包含该属性的元素且属性值为该值的元素对象。
 */
public class XPathDemo {

    //  1.绝对路径： /根元素/子元素/子元素。
    @Test
    public void path01() throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第二种方式（代码多点）先把xml文件读成一个字节输入流
        // 这里的“/”是直接去src类路径下寻找文件。
        InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
        Document document = saxReader.read(is);
        // 3.使用绝对路径定位全部的name名称
        List<Node> nameNodes = document.selectNodes("/contactList/contact/name");
        for (Node nameNode : nameNodes) {
            System.out.println(nameNode.getText());
        }
    }

    // 2.相对路径： ./子元素/子元素。 (.代表了当前元素)
    @Test
    public void path02() throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第二种方式（代码多点）先把xml文件读成一个字节输入流
        // 这里的“/”是直接去src类路径下寻找文件。
        InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
        Document document = saxReader.read(is);

        // 3.得到根元素对象
        Element root = document.getRootElement();

        // 4.从根元素开始检索
        // .代表当前根元素对象路径！直接找其下的contact下的name
        List<Node> nameNodes = root.selectNodes("./contact/name");
        for (Node nameNode : nameNodes) {
            System.out.println(nameNode.getText());
        }
    }

    // 3.全文搜索：
    //                "//元素"  在全文找这个元素
    //                "//元素1/元素2"  在全文找元素1下面的一级元素2
    //                "//元素1//元素2"  在全文找元素1下面的全部元素2
    @Test
    public void path03() throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第二种方式（代码多点）先把xml文件读成一个字节输入流
        // 这里的“/”是直接去src类路径下寻找文件。
        InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
        Document document = saxReader.read(is);

        // 3.//name是指在整个xml文件中检索name节点！
        List<Node> nameNodes = document.selectNodes("//name");
        for (Node nameNode : nameNodes) {
            System.out.println(nameNode.getText());
        }
        System.out.println("-----------------");
        // 4.在全文中检索所有contact下的直接name节点
        List<Node> nameNodes1 = document.selectNodes("//contact/name");
        for (Node nameNode : nameNodes1) {
            System.out.println(nameNode.getText());
        }
        System.out.println("-----------------");
        // 5.在全文中检索所有contact下的所有name节点
        List<Node> nameNodes2 = document.selectNodes("//contact//name");
        for (Node nameNode : nameNodes2) {
            System.out.println(nameNode.getText());
        }
    }

    //   4.属性查找。
    //         //@属性名称  在全文检索属性对象。
    //          //元素[@属性名称]  在全文检索包含该属性的元素对象。
    //          //元素[@属性名称=值]  在全文检索包含该属性的元素且属性值为该值的元素对象。
    @Test
    public void path04() throws Exception {
        // 1.创建一个dom4j的解析器对象：代表整个dom4j框架。
        SAXReader saxReader = new SAXReader();

        // 2.第二种方式（代码多点）先把xml文件读成一个字节输入流
        // 这里的“/”是直接去src类路径下寻找文件。
        InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
        Document document = saxReader.read(is);

        // 3.检索全部属性对象
        List<Node> attributs = document.selectNodes("//@id");
        for (Node attribut : attributs) {
            Attribute attr = (Attribute) attribut;
            System.out.println(attr.getName() + "--->"+attr.getValue());
        }
        System.out.println("---------------");
        // 4.//元素[@属性名称]  在全文检索包含该属性的元素对象
        List<Node> nodeEles = document.selectNodes("//contact[@id]");
        for (Node nodeEle : nodeEles) {
            System.out.println(nodeEle.getName());
        }

        System.out.println("---------------");
        // 5. //元素[@属性名称=值]  在全文检索包含该属性的元素且属性值为该值的元素对象。
        Node nodeEle = document.selectSingleNode("//contact[@id=2]");
        Element ele = (Element) nodeEle;
        System.out.println(ele.elementTextTrim("name"));
    }
}

<?xml vers"1.0" encodingion=="UTF-8"?>
<contactList>
    <contact id="1">
        <name>潘金莲</name>
        <gender>女</gender>
        <email>panpan@itcast.cn</email>
    </contact>
    <contact id="2">
        <name>武松</name>
        <gender>男</gender>
        <email>wusong@itcast.cn</email>
        <sql id="sql4">
            <name>sql语句</name>
        </sql>
    </contact>
    <contact id="3">
        <name>武大狼</name>
        <gender>男</gender>
        <email>wuda@itcast.cn</email>
    </contact>
    <contact></contact>
    <name>外面的名称</name>
</contactList>

XML解析Mybatis框架的核心配置文件信息;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.SAXWriter;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

import java.io.FileOutputStream;
import java.util.List;
import java.util.regex.Pattern;

/**

 */
public class ParseXMLConfig {
    @Test
    public void parseXML() throws Exception {
        // 1.创建一个解析器对象
        SAXReader saxReader = new SAXReader();
        // 2.加载类路径下的xml文件成为一个document文档对象。
        Document document = saxReader.read(ParseXMLConfig.class.getResourceAsStream("/sqlMapConfig.xml"));
        // 3.得到根元素对象
        Element root = document.getRootElement();
        // 4.获取子元素environments
        Element environments = root.element("environments");
        // 5.获取子元素environment
        Element environment = environments.element("environment");
        // 6.获取子元素dataSource
        Element dataSource = environment.element("dataSource");
        // 7.获取 dataSource下的全部子元素
        List<Element>  properties = dataSource.elements();
        // 8.遍历他们
        for (Element property : properties) {
            System.out.println(property.attributeValue("name")
                    +"==>"+property.attributeValue("value"));
        }
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--mybatis环境的配置
        default:代表默认使用的是mysql环境操作数据库
    -->
    <environments default="mysql">
        <!--通常我们只需要配置一个就可以了， id是环境的名字 -->
        <environment id="mysql">
            <!--事务管理器：由JDBC来管理，默认开启了事物 -->
            <transactionManager type="JDBC"/>
            <!--配置连接池：数据源的配置：mybatis自带的连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/day17"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--加载其它的映射文件:实现对象关系映射的-->
        <mapper resource="com/itheima/dao/UserMapper.xml"></mapper>
    </mappers>
</configuration>