XML解析(DOM4j)&检索(Xpath)

Surpass余sheng军

已于 2023-05-01 19:49:16 修改

阅读量879

点赞数

文章标签： xml 前端 java

于 2023-04-30 22:54:30 首次发布

By Mr.Gao

本文链接：https://blog.csdn.net/weixin_53622554/article/details/130449464

版权

XML在以后更多的是用来作为配置文件的。

一. 配置文件

什么是配置文件

用来保存程序在运行时需要的一些参数。

当配置信息比较复杂的时候，我们就可以用XML。

二. XML概述

三. XML的创建、语法规则

根标签就是写在最外面的标签。

<?xml version="1.0" encoding="UTF-8" ?>
<student>
<!--    下面表示第一个学生的信息-->
    <studnet id = "1">
        <name>1&lt;2</name>
        <age><![CDATA[<<<<<<  >>>>>>  &&&& '''' """"]]></age>
    </studnet>
</student>

四. XML文档约束

XML文件可以作为软件的配置文件，软件刚开始运行的时候第一步要去读取并解析XML文件里面的内容，所以XML文件的编写方式要按照软件规定的格式 / 要求来进行书写，否则软件无法解析！
软件所规定的要求 / 格式专业用语就叫文档约束。约束本身也是一个文件。

4.1 XML文档约束方式一-DTD约束[了解]

4.2 XML文档约束方式二-schema约束[了解]

什么是复杂的标签？就是标签里面还可以有标签。
sequence表示这个里面所有的标签必须按照顺序来书写。

简单的引入方式：

复杂的引入方式：

五. XML解析技术

5.1 XML解析技术概述

在我们的XML文件当中，不管是删除还是添加，都要通过它的父节点，也就是父元素去操作。

DOM的缺点在我们现在的硬件当中可以是忽略不计的，因为现在我们的内存都非常地大。

在我们整个XML文件当中，所有的内容都可以认为是节点。

5.2 Dom4J解析XML文件

5.3 Dom4J解析XML文件中的各种节点

Dom4J获取文档对象并解析XML：

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

    <person id = "1">
        <name>zhangsan</name>
        <age>23</age>
    </person>

    <person id = "2">
        <name>lisi</name>
        <age>24</age>
    </person>

    <person id = "3">
        <name>wangwu</name>
        <age>25</age>
    </person>

    <a></a>

</persons>

package com.dom4j;

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

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

public class Dom4jDemo {
    public static List<Person> list = new ArrayList<>();
    public static void main(String[] args) throws DocumentException {
        // 1.创建解析器对象
        SAXReader saxReader = new SAXReader();

        // 2.利用解析器去读取xml文件,并返回文档对象
        File file = new File("practice-app\\src\\com\\dom4j\\person.xml");
        Document document = saxReader.read(file);

        // 拿到了document表示我已经拿到了xml文件的整体
        // 3.打印文档对象
        System.out.println("文档对象:" + document);

        // 4.自己解析的时候一定要一层一层的去解析
        // 5.获取根元素 / 根标签对象
        Element rootElement = document.getRootElement();
        System.out.println("根标签对象:" + rootElement);
        String rootElementName = rootElement.getName();
        System.out.println("根标签对象名:" + rootElementName); // 根标签对象名:persons

        // 6.获取当前根标签下所有的子标签
        /*List<Element> elements = rootElement.elements();
        for (Element element : elements) {
            System.out.println(element.getName());
        }*/

        // 7.获取当前根标签下指定名字的子标签返回集合
        List<Element> elements = rootElement.elements("person");
        for (Element element : elements) {
            // 7.继续获取子标签里面的内容
            // 获取指定属性的对象
            Attribute id = element.attribute("id");
            // 获取该属性的属性名
            String idName = id.getName();
            // 获取该属性的文本内容 / 属性值
            String idValue = id.getText();
            System.out.println("子标签名:" + element.getName() + "     属性名:" + idName + "  属性值:" + idValue);

            // name标签
            Element name = element.element("name");
            // 获取name标签的文本内容
            String nameValue = name.getText();
            System.out.println("标签名:" + name.getName() + "  文本内容:" + nameValue);

            // age标签
            Element age = element.element("age");
            // 获取age标签的文本内容
            String ageValue = age.getText();
            System.out.println("标签名:" + age.getName() + "   文本内容:" + ageValue);
            System.out.println(idValue + " , " + nameValue + " , " + ageValue);


            // 创建Person对象
            Person p = new Person(idValue, nameValue, Integer.valueOf(ageValue));
            // 把Person对象添加到集合当中去
            list.add(p);
        }
        // 打印输出list集合
//        System.out.println(list);
        // 使用Stream流的方式进行打印
        list.stream().forEach(s -> System.out.println(s));
    }
}

package com.dom4j;

public class Person {
    private String id;
    private String name;
    private int age;


    public Person() {
    }

    public Person(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }


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

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

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

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

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{id = " + id + ", name = " + name + ", age = " + age + "}";
    }
}

5.4 Dom4J解析XML文件-案例实战

解析XML文件并登录：

<?xml version="1.0" encoding="UTF-8" ?>
<users>
   <user id = "1">
       <username>zhangsan</username>
       <password>123</password>
       <!--身份证号码-->
       <personid>12794372194721124135281</personid>
       <phoneid>12746821789412</phoneid>
       <!--权限,是否为管理员-->
       <admin>true</admin>
   </user>

    <user id = "2">
        <username>lisi</username>
        <password>123</password>
        <personid>127371293472194147410183</personid>
        <phoneid>12269846128941</phoneid>
        <admin>false</admin>
    </user>
</users>

package com.dom4j;

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

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

/**
   Document表示整个文档对象
   Element表示标签 / 元素 / 节点
   Attribute表示属性
   Text表示文本
   Element、Attribute、Text共同的父类:Node(节点)
   每一个标签、属性、文本都可以看作是一个节点
 */
public class Dom4jDemo2 {
    // 创建List集合存储从XML文件当中解析出来的用户对象信息
    public static List<User> list = new ArrayList<>();
    public static void main(String[] args) throws DocumentException {
        // 1.创建一个解析器对象
        SAXReader saxReader = new SAXReader();
        // 2.利用解析器去获取xml文件,获得一个文档对象
        File file = new File("practice-app\\src\\com\\dom4j\\user.xml");
        Document document = saxReader.read(file);
        // 思想:从外面开始一层一层的扒开(脱衣服)
        // 3.获取根标签
        Element rootElement = document.getRootElement();
        System.out.println("根标签名:" + rootElement.getName()); // 根标签名:users
        // 4.进入根标签,获取里面的user标签
        List<Element> elements = rootElement.elements("user");
        System.out.println("user标签个数:" + elements.size()); // user标签个数:2
        // 5.遍历集合得到每一个usre标签
        for (Element element : elements) {
            // 6.获取user标签的属性id
            Attribute id = element.attribute("id");

            // 获取该属性id的属性名
            String idName = id.getName();
            // 获取该属性id的属性值 / 文本内容
           String idValue = id.getText();

            // 获取用户名标签
            Element username = element.element("username");
            // 获取该标签的文本内容
            String usernameValue = username.getText();

            // 获取密码标签
            Element password =  element.element("password");
            // 获取密码标签的文本内容
            String passwordValue = password.getText();

            // 获取personid标签
            Element personid = element.element("personid");
            // 获取该标签的文本内容
            String personidValue = personid.getText();

            // 获取phoneid
            Element phoneid = element.element("phoneid");
            // 获取该标签的文本内容
            String phoneidValue = phoneid.getText();

            // 获取权限admin,是否为管理员
            Element admin = element.element("admin");
            // 获取该标签的文本内容
            String adminValue =  admin.getText();

            // 创建User对象
            User u = new User(usernameValue, passwordValue,
                    personidValue, phoneidValue, Boolean.valueOf(adminValue));
            // 把User对象添加到集合中去
            list.add(u);
        }
        // 利用Stream流打印输出list集合
        list.stream().forEach(s -> System.out.println(s));

        // 登录操作
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = sc.nextLine();
        System.out.println("请输入密码:");
        String password = sc.nextLine();

        // 1.判断用户名是否存在,如果不存在提示用户名未注册
        int index = getIndex(list, username);
        if(index == -1){
            System.out.println("该用户名未注册");
        }else{
            // 表示存在
            User user = list.get(index);
            if(user.getPassword().equals(password)){
                System.out.println("登录成功!");
            }else{
                System.out.println("密码错误,登录失败!");
            }
        }
    }

    /**
     * 查询username在List集合当中的索引
     * @param list:存储User对象的集合
     * @param username:传进来的用户名
     * @return:如果存在返回索引,如果不存在返回-1
     */
    public static int getIndex(List<User> list, String username){
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if(user.getUsername().equals(username)){
                return i;
            }
        }
        return -1;
    }

}

六. XML检索技术：Xpath

Xpath技术可以快速的获取XML文件当中的某一个值

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

    <person id = "1">
         <name>zhangsan</name>
         <age>23</age>
    </person>

    <person id = "2">
        <name>lisi</name>
        <age>24</age>
    </person>

    <person id = "3">
        <name>wangwu</name>
        <age>25</age>
    </person>

</persons>

1.绝对路径检索

package com.xpath;

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

import java.io.File;

/**
   利用Xpath技术检索XML文件
 */
public class XpathDemo {
    public static void main(String[] args) throws DocumentException {
        // 1.需要创建解析器对象
        SAXReader saxReader = new SAXReader();
        // 2.利用解析器对象去读取本地的xml文件,获得一个文档对象
        File file = new File("practice-app\\src\\com\\xpath\\person.xml");
        Document document = saxReader.read(file);

        // 3.获取到一个文档对象,然后就可以利用xpath方式来进行快速检索
        //   两个方法:
        //      1.检索单个  document.selectSingleNode("路径表达式")
        //      2.检索多个  document.selectNodes("路径表达式")

        // 1.绝对路径检索:从根节点开始逐层的查找
        // 不能写成 \ 符号,\符号在Java当中我们叫做转义字符
        /*List<Node> list =  document.selectNodes("/persons/person/name");
        System.out.println(list.size()); // 3
        for (Node node : list) {
            System.out.println("标签名:" + node.getName() + "  文本内容:" + node.getText());
        }*/
        // 检索单个
        Element element = (Element) document.selectSingleNode("/persons/person/name");
        System.out.println("标签名:" + element.getName() + "    文本内容:" + element.getText());
    }
}

2. 相对路径检索

package com.xpath;

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

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

/**
   利用Xpath技术检索XML文件
 */
public class XpathDemo2 {
    public static void main(String[] args) throws DocumentException {
        // 1.需要创建解析器对象
        SAXReader saxReader = new SAXReader();
        // 2.利用解析器对象去读取本地的xml文件,获得一个文档对象
        Document document = saxReader.read(new File("practice-app\\src\\com\\xpath\\person.xml"));

        // 3.获取到一个文档对象,然后就可以利用xpath方式来进行快速检索
        //   两个方法:
        //      1.检索单个  document.selectSingleNode("路径表达式")
        //      2.检索多个  document.selectNodes("路径表达式")

        // 利用相对路径进行检索
        // 相对路径它是有一个参照物,参照物:自己本身
        Element rootElement = document.getRootElement();

        // 相对于自己去往下查找
        // 检索单个
//        Element element = (Element) rootElement.selectSingleNode("./person/age");
        // 检索所有
        List<Node> list =  rootElement.selectNodes("./person/age");
        for (Node node : list) {
            System.out.println(node.getText());
        }
//        System.out.println("标签名:" + element.getName() + "   文本内容:" + element.getText());
    }
}

3. 全文检索

package com.xpath;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

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

/**
   利用Xpath技术检索XML文件
 */
public class XpathDemo3 {
    public static void main(String[] args) throws DocumentException {
        // 1.需要创建解析器对象
        SAXReader saxReader = new SAXReader();
        // 2.利用解析器对象去读取本地的xml文件,获得一个文档对象
        Document document = saxReader.read(new File("practice-app\\src\\com\\xpath\\person.xml"));

        // 3.获取到一个文档对象,然后就可以利用xpath方式来进行快速检索
        //   两个方法:
        //      1.检索单个  document.selectSingleNode("路径表达式")
        //      2.检索多个  document.selectNodes("路径表达式")


        // 总结:
        //     路径里面如果只有一个/表示单级的路径
        //     路径里面如果有//表示,单级的可以,多级的也可以

        // 全文检索
        // 1.//contact	找contact元素，无论元素在哪里
       /* List<Node> list = document.selectNodes("//name");
        System.out.println(list.size()); // 4
        for (Node node : list) {
            System.out.println(node.getText());
        }*/

        // 2.//contact/name	找contact，无论在哪一级，但name一定是contact的子节点
//        List<Node> list =  document.selectNodes("//person/name");
//        for (Node node : list) {
//            System.out.println(node.getName());
//        }

        // 3.//contact//name	contact无论在哪一种，name只要是contact的子孙元素都可以找到
        List<Node> list = document.selectNodes("//person//name");
        System.out.println(list.size());
    }
}

4. 属性检索

package com.xpath;

import org.dom4j.*;
import org.dom4j.io.SAXReader;

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

/**
 利用Xpath技术检索XML文件
 */
public class XpathDemo4 {
    public static void main(String[] args) throws DocumentException {
        // 1.需要创建解析器对象
        SAXReader saxReader = new SAXReader();
        // 2.利用解析器对象去读取本地的xml文件,获得一个文档对象
        Document document = saxReader.read(new File("practice-app\\src\\com\\xpath\\person.xml"));

        // 3.获取到一个文档对象,然后就可以利用xpath方式来进行快速检索
        //   两个方法:
        //      1.检索单个  document.selectSingleNode("路径表达式")
        //      2.检索多个  document.selectNodes("路径表达式")

        // 属性查找
        // 查找属性和带属性查找
        // 1.//@属性名:查属性
//        List<Node> list = document.selectNodes("//@id");
//        System.out.println(list.size()); // 3
//        for (Node node : list) {
//            System.out.println(node.getText());
//        }

        // 2.//元素[@属性名]:查的是带有指定属性的标签
        /*List<Node> list = document.selectNodes("//person[@name]");
        System.out.println(list.size()); // 0
        for (Node node : list) {
            System.out.println(node.getText());
        }*/
        List<Node> list1 = document.selectNodes("//person[@id]");
        System.out.println(list1.size());
        for (Node node : list1) {
            // 将父类node节点向下转型为子类Element标签
            Element element = (Element) node;
            // 获取该标签的标签名
            System.out.println(element.getName());
            // 获取该标签的id属性
            Attribute id = element.attribute("id");
            // 获取该标签的属性名以及属性值
            System.out.println("标签名:" + element.getName() + "  属性名:" + id.getName() + "  属性值:" + id.getText());
        }
        System.out.println("===========================================================");
        // 3.//元素[@属性名=‘值’]:查的是带有指定属性和属性值的标签
        List<Node> list2 = document.selectNodes("//person[@id='1']");
        for (Node node : list2) {
            // 将父类node节点向下转型为子类Element标签
            Element element = (Element) node;
            // 获取该标签的标签名
            String elementName = element.getName();
            // 获取该标签的属性
            Attribute id = element.attribute("id");
            // 获取该标签的属性名以及属性值
            String idName = id.getName();
            String idValue = id.getText();
            System.out.println("标签名:" + elementName + "  属性名:" + idName + "  属性值:" + idValue);
        }
    }
}

Xpath的小结：

Xpath底层依赖于dom4j。在刚开始导包的时候一定要把dom4j的jar包一起导入。
有两个检索的方法：

selectNodes("路径")：查询所有
selectSingleNode("路径")：查询单个的，如果结果有多个，默认返回第一个。

3. 四种检索方式：

/ ：单级路径

// ：多级路径

@ 属性

绝对路径：一定是从根节点开始

相对路径：从现在的自己节点开始的。

用根节点调用selectNodes，那么此时就是相对于根节点而言。

用name节点调用selectNodes，那么此时就是相对于name标签而言。

全文检索：只要xml文件中存在就可以找到

//name 在整个xml文件中找name这个标签

扩展用法：

//person/name：先找person，再找person的子标签name。

//person//name：先找person，再找person的子标签name，但是此时 name可以是孙标签。

带属性的查询：

查属性： //@属性名在全文中找指定的属性

查带有指定属性的标签： //标签名[@属性名]

查带有指定属性值的标签：//标签名[@属性名= ' 值 ' ]