XML基本介绍

概述

XML即可扩展标记语言（Extensible Markup Language）

  • W3C在1998年2月发布1.0版本，2004年2月又发布1.1版本，但因为1.1版本不能向下兼容1.0版 本，所以1.1没有人用。同时，在2004年2月W3C又发布了1.0版本的第三版。我们要学习的还是 1.0版本 !

特点

  • 可扩展的, 标签都是自定义的
  • 语法十分严格

    XML的作用

    XML能做什么?
功能 说明
存储数据 通常，我们在数据库中存储数据。不过，如果希望数据的可移植性更强，我们可以 把数据存储 XML 文件中
配置文件 作为各种技术框架的配置文件使用 (最多)
在网络中传输 客户端可以使用XML格式向服务器端发送数据,服务器接收到xml格式数据,进行解析

XML的语法

XML文档声明格式

  • 文档声明必须为结束；
  • 文档声明必写在第一行；

  1. 语法格式:

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

  2. 属性说明:

  • versioin：指定XML文档版本。必须属性，因为我们不会选择1.1，只会选择1.0；
  • encoding：指定当前文档的编码。可选属性，默认值是utf-8；

    元素

    Element 元素: 是XML文档中最重要的组成部分元素的命名规则
  1. 不能使用空格，不能使用冒号
  2. xml 标签名称区分大小写
  3. XML 必须有且只有一个根元素

语法格式:

  1. <users><users>
  1. XML 必须有且只有一个根元素，它是所有其他元素的父元素，比如以下实例中 users 就是根元素： ```xml <?xml version=”1.0” encoding=”utf-8” ?> 

  2. 2. 普通元素的结构开始标签、元素体、结束标签组成。
  3. ```xml
  4. <hello> 大家好 </hello>

  1. 元素体：元素体可以是元素，也可以是文本 ```xml

    你好

  2. 4. 空元素：空元素只有开始标签，而没有结束标签，但元素必须自己闭合
  3. ```xml
  4. <close/>

属性

  1. <bean id="" class=""> </bean>
  1. 属性是元素的一部分，它必须出现在元素的开始标签中
  2. 属性的定义格式：属性名=属性值，其中属性值必须使用单引或双引
  3. 一个元素可以有0~N个属性，但一个元素中不能出现同名属性

  4. 属性名不能使用空格、冒号等特殊字符，且必须以字母开头

    注释

    XML的注释，以“ ”结束。注释内容会被XML解析器忽略！
    任务三_XML - 图1使用XML 描述数据表中的数据 ```xml <?xml version=”1.0” encoding=”UTF-8” ?>

    林黛玉 20 女 5000 2010-01-01 杜甫 40 男 15000 2010-01-01 

  1. <a name="p02as"></a>
  2. # XML约束
  4. - 在XML技术里，可以编写一个文档来约束一个XML文档的书写规范，这称之为XML约束。      
  5. - 常见的xml约束：
  7. DTD<br />Schema
  9. - 作为程序员只要掌握两点
  11. 会阅读<br />会引入<br />不用自己编写
  13. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616305768348-ff539dc3-9ec2-4a4e-8254-2b2c30ccc0ac.jpeg#align=left&display=inline&height=896&margin=%5Bobject%20Object%5D&originHeight=896&originWidth=1280&status=done&style=none&width=1280)
  15. <a name="tdbqN"></a>
  16. ## DTD约束
  17. DTD（Document Type Definition），文档类型定义，用来约束XML文档。规定XML文档中元素的名称，子元素的名称及顺序，元素的属性等。
  18. <a name="4PWmH"></a>
  19. ### 编写DTD
  20. 开发中，我们不会自己编写DTD约束文档<br />常情况我们都是通过框架提供的DTD约束文档，编写对应的XML文档。常见框架使用DTD约束有：<br />Struts2、hibernate等。<br />创建约束文件 student.dtd
  21. ```java
  22. <!ELEMENT students (student+) >
  23. <!ELEMENT student (name,age,sex)>
  24. <!ELEMENT name (#PCDATA)>
  25. <!ELEMENT age (#PCDATA)>
  26. <!ELEMENT sex (#PCDATA)>
  27. <!ATTLIST student number ID #REQUIRED>
  28. <!--
  29. ELEMENT: 用来定义元素
  30. students (student+) : 代 表 根 元 素 必 须 是 <students> student+ : 根标签中至少有一个 student子元素, + 代表至少一个student (name,age,sex): student 标签中包含的子元素,按顺序出现#PCDATA: 是普通文本内容
  31. ATTLIST: 用来定义属性
  32. student number ID #REQUIRED
  33. student子元素中 有一个ID属性叫做 number,是必须填写的ID: 唯一 值只能是字母或者下划线开头
  34. -->

引入DTD

引入dtd文档到xml文档中,两种方式
内部dtd：将约束规则定义在xml文档中
外部dtd：将约束的规则定义在外部的dtd文件中
本地： 网络：
student.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE students SYSTEM "student.dtd">
  3. <students>
  4.     <student number="S1">
  5.         <name>长海</name>
  6.         <age>20</age>
  7.         <sex>男</sex>
  8.     </student>
  10.     <student number="S2">
  11.         <name>大玲子</name>
  12.         <age>18</age>
  13.         <sex>女</sex>
  14.     </student>
  16. </students>

Schema约束

什么是Schema

  1. Schema是新的XML文档约束, 比DTD强大很多，是DTD 替代者；
  2. Schema本身也是XML文档，但Schema文档的扩展名为xsd，而不是xml。
  3. Schema 功能更强大，内置多种简单和复杂的数据类型

  4. Schema 支持命名空间 (一个XML中可以引入多个约束文档)

    Schema约束示例

    student.xsd

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <xsd:schema xmlns="http://www.lagou.com/xml"
    3.          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    4.          targetNamespace="http://www.lagou.com/xml" elementFormDefault="qualified">
    6.  <xsd:element name="students" type="studentsType"/>
    7.  <xsd:complexType name="studentsType">
    8.      <xsd:sequence>
    9.          <xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/>
    10.      </xsd:sequence>
    11.  </xsd:complexType>
    12.  <xsd:complexType name="studentType">
    13.      <xsd:sequence>
    14.          <xsd:element name="name" type="xsd:string"/>
    15.          <xsd:element name="age" type="ageType" />
    16.          <xsd:element name="sex" type="sexType" />
    17.      </xsd:sequence>
    18.      <xsd:attribute name="number" type="numberType" use="required"/>
    19.  </xsd:complexType>
    20.  <xsd:simpleType name="sexType">
    21.      <xsd:restriction base="xsd:string">
    22.          <xsd:enumeration value="male"/>
    23.          <xsd:enumeration value="female"/>
    24.      </xsd:restriction>
    25.  </xsd:simpleType>
    26.  <xsd:simpleType name="ageType">
    27.      <xsd:restriction base="xsd:integer">
    28.          <xsd:minInclusive value="0"/>
    29.          <xsd:maxInclusive value="200"/>
    30.      </xsd:restriction>
    31.  </xsd:simpleType>
    32.  <xsd:simpleType name="numberType">
    33.      <xsd:restriction base="xsd:string">
    34.          <xsd:pattern value="hehe_\d{4}"/>
    35.      </xsd:restriction>
    36.  </xsd:simpleType>
    37. </xsd:schema>

    任务三_XML - 图2Xml Schema的根元素：

    XML引入Schema约束

    xml中引入schema约束的步骤：

  5. 查看schema文档，找到根元素，在xml中写出来 ```xml <?xml version=”1.0” encoding=”UTF-8” ?>

  2. 2. 根元素来自哪个命名空间。使用**xmlns**指令来声明
  3. ```xml
  4. <?xml version="1.0" encoding="UTF-8" ?>
  5. <students
  6.           xmlns="http://www.lagou.com/xml"
  7. >
  8. </students>

  1. 引入 w3c的标准命名空间, 复制即可

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <students
    3.        xmlns="http://www.lagou.com/xml" 
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5. >
    6. </students>

  2. 引入的命名空间跟哪个xsd文件对应？

使用schemaLocation来指定：两个取值：第一个为命名空间 第二个为xsd文件的路径

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <students
  3.           xmlns="http://www.lagou.com/xml" 
  4.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  5.           xsi:schemaLocation="http://www.lagou.com/xml student.xsd"
  6. >
  7. </students>
  1. 命名空间

指的是一个环境,所用的标签来自于哪个环境定义的。

  1. student.xml ```xml <?xml version=”1.0” encoding=”UTF-8” ?>

张三 200 male 

  1. <student number="hehe_4567">
  2.     <name>张三</name>
  3.     <age>200</age>
  4.     <sex>male</sex>
  5. </student>

  1. <a name="CAAxV"></a>
  2. # XML 解析
  3. <a name="MmDu2"></a>
  4. ## 解析概述
  5. 当将数据存储在XML后，我们就希望通过程序获得XML的内容。如果我们使用Java基础所学习的IO知识是可以完成的，不过你需要非常繁琐的操作才可以完成，且开发中会遇到不同问题（只读、读写）。  人们为不同问题提供不同的解析方式，并提交对应的解析器，方便开发人员操作XML。
  6. <a name="7Vovp"></a>
  7. ## XML解析方式
  8. 开发中比较常见的解析方式有两种，如下：
  10. - DOM：要求解析器把整个XML文档装载到内存，并解析成一个Document对象。    
  12. 优点：元素与元素之间保留结构关系，故可以进行增删改查操作。<br />缺点：XML文档过大，可能出现内存溢出显现。                                                           
  14. - SAX：是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。并以事件驱动的方式进行具体解析，每执行一行，都将触发对应的事件。（了解）
  16. 优点：占用内存少 处理速度快，可以处理大文件<br />缺点：只能读，逐行后将释放资源。<br />![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616305769114-683fa20d-ea0f-43ba-9943-b65b3ca21e90.jpeg#align=left&display=inline&height=704&margin=%5Bobject%20Object%5D&originHeight=704&originWidth=1744&status=done&style=none&width=1744)
  19. <a name="1lxA2"></a>
  20. ## XML常见的解析器
  21. 解析器：就是根据不同的解析方式提供的具体实现。有的解析器操作过于繁琐，为了方便开发人员，  有提供易于操作的解析开发包
  23. - JAXP：sun公司提供的解析器，支持DOM和SAX两种思想
  24. - **DOM4J**：一款非常优秀的解析器 , Dom4j是一个易用的、开源的库，用于XML，XPath和XSLT。它应用于Java平台，采用了Java集合框架并完全支持DOM，SAX和JAXP。
  25. - Jsoup：jsoup 是一款Java 的HTML解析器 ,也可以解析XML 
  26. - PULL：Android内置的XML解析方式，类似SAX。
  27. <a name="VoxZz"></a>
  28. ## dom4j 的使用
  29. <a name="9AZJ8"></a>
  30. ### 导入JAR包
  31. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616305769465-d33d2de9-eb67-4fe2-b1e9-ca683cc63ae4.jpeg#align=left&display=inline&height=42&margin=%5Bobject%20Object%5D&originHeight=42&originWidth=1156&status=done&style=none&width=1156)
  33.       1. **API介绍**
  35. 使用核心类SaxReader加载xml文档获得Document，通过Document 对象获得文档的根元素，然后就可以操作了<br />常用API如下：
  37. - SaxReader对象
  39. read(…) 加载执行xml文档
  41. - Document对象
  43. getRootElement() 获得根元素
  45. - Element对象
  47. elements(…) 获得指定名称的所有子元素。可以不指定名称<br />element(…) 获得指定名称的第一个子元素。可以不指定名称<br />getName() 获得当前元素的元素名<br />attributeValue(…) 获得指定属性名的属性值<br />elementText(…) 获得指定名称子元素的文本值<br />getText() 获得当前元素的文本内容
  48. <a name="8pMx5"></a>
  49. ### 准备xml文件
  50. 编写user.xsd schema约束
  51. ```xml
  52. <?xml version="1.0" encoding="UTF-8" ?>
  53. <xsd:schema xmlns="http://www.lagou.com/xml"
  54.             xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  55.             targetNamespace="http://www.lagou.com/xml" elementFormDefault="qualified">
  57.     <xsd:element name="users" type="usersType"/>
  58.     <xsd:complexType name="usersType">
  59.         <xsd:sequence>
  60.             <xsd:element name="user" type="userType" minOccurs="0" maxOccurs="unbounded"/>
  61.         </xsd:sequence>
  62.     </xsd:complexType>
  64.     <xsd:complexType name="userType">
  65.         <xsd:sequence>
  66.             <xsd:element name="name" type="xsd:string"/>
  67.             <xsd:element name="age" type="ageType" />
  68.             <xsd:element name="hobby" type="hobbyType" />
  69.         </xsd:sequence>
  70.         <xsd:attribute name="id" type="numberType" use="required"/>
  71.     </xsd:complexType>
  73.     <xsd:simpleType name="ageType">
  74.         <xsd:restriction base="xsd:integer">
  75.             <xsd:minInclusive value="0"/>
  76.             <xsd:maxInclusive value="100"/>
  77.         </xsd:restriction>
  78.     </xsd:simpleType>
  80.     <xsd:simpleType name="hobbyType">
  81.         <xsd:restriction base="xsd:string">
  82.             <xsd:enumeration value="抽烟"/>
  83.             <xsd:enumeration value="喝酒"/>
  84.             <xsd:enumeration value="烫头"/>
  85.         </xsd:restriction>
  86.     </xsd:simpleType>
  88.     <xsd:simpleType name="numberType">
  89.         <xsd:restriction base="xsd:string">
  90.             <xsd:pattern value="\d{3}"/>
  91.         </xsd:restriction>
  92.     </xsd:simpleType>
  94. </xsd:schema>

编写user.xml 引入约束

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <users
  3.         xmlns="http://www.lagou.com/xml"
  4.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.         xsi:schemaLocation="http://www.lagou.com/xml user.xsd"
  6. >
  7.     <user id="001">
  8.         <name>张百万</name>
  9.         <age>25</age>
  10.         <hobby>抽烟</hobby>
  11.     </user>
  13.     <user id="002">
  14.         <name>于谦</name>
  15.         <age>55</age>
  16.         <hobby>烫头</hobby>
  17.     </user>
  19.     <user id="003">
  20.         <name>小斌</name>
  21.         <age>25</age>
  22.         <hobby>喝酒</hobby>
  23.     </user>
  26. </users>

读取XML

  1. package com.lagou.xml03;
  3. import org.dom4j.Document;
  4. import org.dom4j.DocumentException;
  5. import org.dom4j.Element;
  6. import org.dom4j.io.SAXReader;
  7. import org.junit.Test;
  9. import java.util.List;
  11. public class TestDOM4j {
  13.     //获取XML文件中的 所有的元素名称(标签)
  14.     @Test
  15.     public void test1() throws DocumentException {
  17.         //1.获取XML解析对象
  18.         SAXReader reader = new SAXReader();
  20.         //2.解析XML 获取 文档对象 document
  21.         Document document = reader.read("/Users/pingmao/Desktop/wen/Learn/java/jdbc_work/jdbc_task03/src/com/lagou/xml03/user.xml");
  23.         //3.获取根元素
  24.         Element rootElement = document.getRootElement();
  26.         //获取根元素名称
  27.         System.out.println(rootElement.getName());
  29.         //获取 根元素下的标签
  30.         List<Element> elements = rootElement.elements();
  31.         for (Element element : elements) {
  32.             System.out.println("根标签下的子节点: " + element.getName());
  34.             List<Element> eList = element.elements();
  35.             for (Element e : eList) {
  36.                 System.out.println("user标签下的子节点" + e.getName());
  37.             }
  39.             break;
  40.         }
  42.     }
  44.     //获取XML中标签的文本信息 和 属性信息
  45.     @Test
  46.     public void test2() throws DocumentException {
  48.         //1.获取解析XML的 SAXReader
  49.         SAXReader reader = new SAXReader();
  51.         //2.获取文档对象
  52.         Document document = reader.read("/Users/pingmao/Desktop/wen/Learn/java/jdbc_work/jdbc_task03/src/com/lagou/xml03/user.xml");
  54.         //3.获取根节点
  55.         Element rootElement = document.getRootElement();
  57.         //4.获取子节点 user
  58.         List<Element> elements = rootElement.elements();
  60.         //5.获取集合中的第一个 子节点
  61.         Element user = elements.get(0);
  63.         //6.获取节点中的文本信息
  64.         String id = user.attributeValue("id");//获取属性 id的值
  65.         String name = user.elementText("name");
  66.         String age = user.elementText("age");
  67.         String hobby = user.element("hobby").getText();
  69.         //打印
  70.         System.out.println(id + " " + name +" " + age + " " + hobby);
  71.     }
  72. }

xpath方式读取xml

xpath介绍

XPath 是一门在 XML 文档中查找信息的语言。 可以是使用xpath查找xml中的内容。
XPath 的好处
由于DOM4J在解析XML时只能一层一层解析，所以当XML文件层数过多时使用会很不方便，结合
任务三_XML - 图3XPATH就可以直接获取到某个元素
1）需要再导入 jaxen-1.1-beta-6.jar
任务三_XML - 图4

XPath基本语法介绍

使用dom4j支持xpath的操作的几种主要形式

语法 说明
/AAA/DDD/BBB 表示一层一层的，AAA下面 DDD下面的BBB
//BBB 表示和这个名称相同，表示只要名称是BBB，都得到
//* 所有元素
BBB[1] , BBB[last()] 第一种表示第一个BBB元素, 第二种表示最后一个BBB元素
//BBB[@id] 表示只要BBB元素上面有id属性，都得到
//BBB[@id=’b1’] 表示元素名称是BBB,在BBB上面有id属性，并且id的属性值是b1

API介绍

  1. 常用方法：
  • selectSingleNode(query): 查找和 XPath 查询匹配的一个节点。

参数是Xpath 查询串。

  • selectNodes(query): 得到的是xml根节点下的所有满足 xpath 的节点；

参数是Xpath 查询串。

  • Node: 节点对象

    Xpath读取XML

  1. 数据准备 book.xml

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <bookstore>
    3.  <book id="book1">
    4.      <name>金瓶梅</name>
    5.      <author>金圣叹</author>
    6.      <price>99</price>
    7.  </book>
    8.  <book id="book2">
    9.      <name>红楼梦</name>
    10.      <author>曹雪芹</author>
    11.      <price>69</price>
    12.  </book>
    13.  <book id="book3">
    14.      <name>Java编程思想</name>
    15.      <author>埃克尔</author>
    16.      <price>59</price>
    17.  </book>
    18. </bookstore>

  2. 代码示例

使用selectSingleNode方法 查询指定节点中的内容

  1.     /*
  2.     *  使用selectSingleNode() 方法 查询自定的节点信息
  3.     *
  4.     * */
  5.     @Test
  6.     public void test1() throws DocumentException {
  8.         //1.创建XML解析对象
  9.         SAXReader reader = new SAXReader();
  11.         //2.解析XML 获取 文档对象
  12.         Document document = reader.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml04\\book.xml");
  14.         //3.通过selectSingleNode() 方法获取 name节点
  15.         Node node1 = document.selectSingleNode("/bookstore/book/name");
  16.         System.out.println("节点的名称: " + node1.getName());
  17.         System.out.println("书名: " + node1.getText());
  19.         //4.获取第二本书的书名
  20.         Node node2 = document.selectSingleNode("/bookstore/book[3]/name");
  21.         System.out.println("书名: " + node2.getText());
  22.     }

使用selectSingleNode方法 获取属性值,或者属性值对应的节点

  1.    /*
  2.     * 使用 selectSIngleNode() 方法获取 属性值 或者 通过属性值获取到节点信息
  3.     *
  4.     * */
  5.     @Test
  6.     public void test2() throws DocumentException {
  8.         SAXReader reader = new SAXReader();
  10.         Document document = reader.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml04\\book.xml");
  12.         //1.获取第一个booke节点中的  id属性的值
  13.         Node node1 = document.selectSingleNode("/bookstore/book/attribute::id");
  14.         System.out.println("第一个book的id属性值: " + node1.getText() );
  16.         //2.获取最后一个book节点的 id属性值
  17.         Node node2 = document.selectSingleNode("/bookstore/book[last()]/attribute::id");
  18.         System.out.println("最后一个book节点中的属性值: " + node2.getText());
  20.         //3.通过id的值 获取book2节点 中的书名
  21.         Node node3 = document.selectSingleNode("/bookstore/book[@id='book2']");
  23.         String name = node3.selectSingleNode("name").getText();
  24.         System.out.println("id为book2的 节点的书名是: " + name);
  26.     }

使用 selectNodes()方法 获取对应名称的所有节点

  1.    /*
  2.     *  使用selectNodes() 获取所有指定名称 的节点
  3.     *
  4.     * */
  5.     @Test
  6.     public void test3() throws DocumentException {
  8.         SAXReader reader = new SAXReader();
  10.         Document document = reader.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml04\\book.xml");
  12.         //1.查询所有的节点
  13.         List<Node> list = document.selectNodes("//*");
  15.         for (Node node : list) {
  16.             System.out.println("节点名: " + node.getName());
  17.         }
  19.         //2.获取所有的书名
  20.         List<Node> list1 = document.selectNodes("//name");
  21.         for (Node node : list1) {
  22.             System.out.println("书名: " + node.getText());
  23.         }
  25.         //3.获取 id值为 book1 的节点中的所有内容
  26.         List<Node> list2 = document.selectNodes("/bookstore/book[@id='book1']//*");
  27.         for (Node node : list2) {
  28.             System.out.println(node.getName() + " = " + node.getText());
  29.         }
  30.     }
  1. package com.lagou.xml04;
  3. import org.dom4j.Document;
  4. import org.dom4j.DocumentException;
  5. import org.dom4j.Node;
  6. import org.dom4j.io.SAXReader;
  7. import org.junit.Test;
  9. import java.util.List;
  11. public class TestXPath {
  13.     /*
  14.     *  使用selectSingleNode() 方法 查询自定的节点信息
  15.     *
  16.     * */
  17.     @Test
  18.     public void test1() throws DocumentException {
  20.         //1.创建XML解析对象
  21.         SAXReader reader = new SAXReader();
  23.         //2.解析XML 获取 文档对象
  24.         Document document = reader.read("/Users/pingmao/Desktop/wen/Learn/java/jdbc_work/jdbc_task03/src/com/lagou/xml04/book.xml");
  26.         //3.通过selectSingleNode() 方法获取 name节点
  27.         Node node1 = document.selectSingleNode("/bookstore/book/name");
  28.         System.out.println("节点的名称: " + node1.getName());
  29.         System.out.println("书名: " + node1.getText());
  31.         //4.获取第二本书的书名
  32.         Node node2 = document.selectSingleNode("/bookstore/book[3]/name");
  33.         System.out.println("书名: " + node2.getText());
  34.     }
  37.     /*
  38.     * 使用 selectSIngleNode() 方法获取 属性值 或者 通过属性值获取到节点信息
  39.     *
  40.     * */
  41.     @Test
  42.     public void test2() throws DocumentException {
  44.         SAXReader reader = new SAXReader();
  46.         Document document = reader.read("/Users/pingmao/Desktop/wen/Learn/java/jdbc_work/jdbc_task03/src/com/lagou/xml04/book.xml");
  48.         //1.获取第一个booke节点中的  id属性的值
  49.         Node node1 = document.selectSingleNode("/bookstore/book/attribute::id");
  50.         System.out.println("第一个book的id属性值: " + node1.getText() );
  52.         //2.获取最后一个book节点的 id属性值
  53.         Node node2 = document.selectSingleNode("/bookstore/book[last()]/attribute::id");
  54.         System.out.println("最后一个book节点中的属性值: " + node2.getText());
  56.         //3.通过id的值 获取book2节点 中的书名
  57.         Node node3 = document.selectSingleNode("/bookstore/book[@id='book2']");
  59.         String name = node3.selectSingleNode("name").getText();
  60.         System.out.println("id为book2的 节点的书名是: " + name);
  62.     }
  64.     /*
  65.     *  使用selectNodes() 获取所有指定名称 的节点
  66.     *
  67.     * */
  68.     @Test
  69.     public void test3() throws DocumentException {
  71.         SAXReader reader = new SAXReader();
  73.         Document document = reader.read("/Users/pingmao/Desktop/wen/Learn/java/jdbc_work/jdbc_task03/src/com/lagou/xml04/book.xml");
  75.         //1.查询所有的节点
  76.         List<Node> list = document.selectNodes("//*");
  78.         for (Node node : list) {
  79.             System.out.println("节点名: " + node.getName());
  80.         }
  82.         //2.获取所有的书名
  83.         List<Node> list1 = document.selectNodes("//name");
  84.         for (Node node : list1) {
  85.             System.out.println("书名: " + node.getText());
  86.         }
  88.         //3.获取 id值为 book1 的节点中的所有内容
  89.         List<Node> list2 = document.selectNodes("/bookstore/book[@id='book1']//*");
  90.         for (Node node : list2) {
  91.             System.out.println(node.getName() + " = " + node.getText());
  92.         }
  93.     }
  94. }

JDBC自定义XML

定义配置文件

  1. 创建自定义xml 文件, 保存 数据库连接信息

jdbc-config.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <jdbc>
  3.     <property name="driverClass">com.mysql.jdbc.Driver</property>
  4.     <property name="jdbcUrl">jdbc:mysql://192.168.197.4:3306/db5?characterEncoding=UTF-8</property>
  5.     <property name="user">root</property>
  6.     <property name="password">123456</property>
  7. </jdbc>

编写工具类(配置式)

  1. 编写工具类 ,使用xpath 读取数据库信息 ```java package com.lagou.xml05;

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

import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException;

public class JDBCUtils {

  1. //1.定义字符串变量 保存连接信息
  2. public static String DRIVERNAME;
  3. public static String URL;
  4. public static String USER;
  5. public static String PASSWORD;
  7. //2.静态代码块
  8. static{
  9.     //使用 XPath语法 对xml中的数据进行读取
  10.     SAXReader reader = new SAXReader();
  11.     try {
  12.         Document document = reader.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml05\\jdbc-config.xml");
  14.         //1.获取驱动名称
  15.         Node driver = document.selectSingleNode("/jdbc/property[@name='driverClass']");
  16.         DRIVERNAME = driver.getText();
  18.         //2.获取URL
  19.         Node url = document.selectSingleNode("/jdbc/property[@name='jdbcUrl']");
  20.         URL = url.getText();
  22.         //3.获取用户名
  23.         Node user = document.selectSingleNode("/jdbc/property[@name='user']");
  24.         USER = user.getText();
  26.         //4.获取密码
  27.         Node password = document.selectSingleNode("/jdbc/property[@name='password']");
  28.         PASSWORD = password.getText();
  30.         //注册驱动
  31.         Class.forName(DRIVERNAME);
  33.     } catch (Exception e) {
  34.         e.printStackTrace();
  35.     }
  37. }
  40. //获取连接
  41. public static Connection getConnection(){
  43.     try {
  45.         Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
  47.         return connection;
  48.     } catch (SQLException e) {
  49.         e.printStackTrace();
  50.         return null;
  51.     }
  53. }

}

  1. <a name="TYrgI"></a>
  2. ## 测试工具类
  4. 3. 测试 : 获取所有员工的姓名
  5. ```java
  6. package com.lagou.xml05;
  8. import java.sql.Connection;
  9. import java.sql.ResultSet;
  10. import java.sql.SQLException;
  11. import java.sql.Statement;
  13. public class TestJDBC {
  15.     //查询所有员工信息
  16.     public static void main(String[] args) throws SQLException {
  18.         //1.获取连接
  19.         Connection connection = JDBCUtils.getConnection();
  21.         //2.获取Statement 对象 执行SQL
  22.         Statement statement = connection.createStatement();
  23.         ResultSet resultSet = statement.executeQuery("select * from employee");
  25.         //3.处理结果集
  26.         while(resultSet.next()){
  28.             String name = resultSet.getString("ename");
  29.             System.out.println("员工的姓名: " + name);
  30.         }
  32.         //4.关闭资源
  33.         resultSet.close();
  34.         statement.close();
  35.         connection.close();
  37.     }
  39. }