首页 > 其他分享 >十四、XML

十四、XML

时间：2023-02-20 20:44:07浏览次数：41  
标签：XML name 对象 元素 System println 十四 out

一

XML用以存储数据，做数据交互的。

1. 申明/抬头 必须在第一行

2. 标签（元素），注意一个XML文件只能有一个根标签

3. 实体字符：在xml文件中，我们不能直接写小于号，等一些特殊字符会与xml文件本身的内容冲突报错，此时必须用转义的实体字符。

4. 字符数据区：在xml文件中，我们不能直接写小于号，等一些特殊字符会与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>

二

1. XML的约束技术：DTD（后缀：.dtd）

DTD是XML的约束文件

作用：约束XML文件格式的规范性
也就是说，生成根标签模板，框架中有规定好的子标签内容供填写。

缺陷：不能约束数据类型，数据可以瞎写。

2. XML的约束技术：Schema（后缀：.xsd）

Schema本身是XML文件

1. 相比于DTD，可以约束数据类型
2. 引用多个xsd文件时，xsd文件之中标签之间有冲突时，可以用别名区别

三

1.XML文件的解析方式

1. DOM解析

--JAXP
--JDOM
--Dom4J
--jsoup

2. SAX解析

2.DOM的解析原理:

  • 将整个XML文件加载到内存中，生成一棵DOM树，下面是根节点。
  • 通过Document对象来访问整个DOM树的节点和对应的数据!

3.Dom4J框架入门使用

使用前需要导入dom4j包

1.Dom4J解析根、子元素

步骤：

  1. 创建一个dom4j的解析器对象
  2. 通过解析器对象去加载xml文件数据，成为一个Document文档树对象
  3. 获取根元素对象
  4. 随后解析各级元素的解析

Element元素的API:

1. String getName():取元素的名称。
2. List<Element> elements():获取当前元素下的全部子元素（一级）
3. List<Element> elements(String name):获取当前元素下的指定名称的全部子元素（一级）
4. 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"));
    }
}

5.Dom4J解析属性

步骤：

  1. 创建一个dom4j的解析器对象
  2. 通过解析器对象去加载xml文件数据，成为一个Document文档树对象
  3. 获取根元素对象
  4. 随后获取元素的属性对象
    (5. 可以直接获取元素的属性对象)

Element元素的API:

  1. List attributes(): 获取元素的全部属性对象。
  2. Attribute attribute(String name):根据名称获取某个元素的属性对象。
  3. 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"));
    }
}

5.Dom4J解析文本值

步骤：

  1. 创建一个dom4j的解析器对象
  2. 通过解析器对象去加载xml文件数据，成为一个Document文档树对象
  3. 获取根元素对象
  4. 随后获取所需的元素的文本值

API:

1. String elementText(String name): 可以直接获取当前元素的子元素的文本内容
2. String elementTextTrim(String name):去前后空格,直接获取当前元素的子元素的文本内容
3. String getText():直接获取当前元素的文本内容。	
4. 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());// 去前后空格
    }
}

6.Dom4J解析案例

步骤：

  1. 创建一个dom4j的解析器对象
  2. 通过解析器对象去加载xml文件数据，成为一个Document文档树对象
  3. 获取根元素对象
  4. 获取根元素下的全部子元素
  5. 遍历子元素，封装成List集合对象（注意：Char类型转成String，用,.charAt(0)）
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);
    }
}

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

  • Dom4J可以用于解析整个XML的数据。
  • 但是如果要检索XML中的某些信息，建议使用Xpath。

XPath使用步骤：

  1. 导入dom4j框架。（XPath依赖于Dom4j技术,必须先导入dom4j框架！）
  2. 导入XPath独有的框架包。jaxen-1.1.2.jar

XPath常用API:
List selectNodes(String var1):检索出一批节点集合。
Node selectSingleNode(String var1)：检索出一个节点返回。

XPath提供的四种检索数据的写法：
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"));
    }
}

案例
Mybatis配置文件的解析

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,name,对象,元素,System,println,十四,out
From： https://www.cnblogs.com/Gege-1/p/17138863.html

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99