XML文档

一、概念

1.1 基础概念

  • 概念：用于框架或者一些全局的配置文件，用来将一些全局的数据配置在xml文档中，整个工程都能解析出来xml文档中的数据。比如：C3P0连接池，里面的c3p0config.xml文件就是作用全局的配置文件。一般配置数据源和参数等。xml配置文件在框架中必用。
  • 其他的配置文件：properties、txt文档

  • 需要引入xml配置文件的必要性：主要是在一般业务逻辑中，不会是简单的键值对数据，而是有关系的层级数据，只能使用xml配置文件进行配置。

    1.2 文档举例

    1. -- 举例说明层级关系
    2. <city>
    3.   <四川>
    4.       <成都>cd</成都>
    5.       <绵阳>my</绵阳>
    6.       <宜宾>yb</宜宾>
    7.   </四川>
    8.   <重庆>
    9.       <渝北>yb</渝北>
    10.       <江北>jaingbei</江北>
    11.   </重庆>
    12. </city>

    1.3 编写示例文档

    1. <?xml version="1.0" encoding="utf-8" ?>
    2. <city>
    3.   <四川>
    4.       <成都>cd</成都>
    5.       <绵阳>my</绵阳>
    6.       <宜宾>yb</宜宾>
    7.   </四川>
    8.   <重庆>
    9.       <渝北>yb</渝北>
    10.       <江北>jaingbei</江北>
    11.   </重庆>
    12. </city>

    1.4 xml文档组成部分（了解）

  • 组成部分：声明、自定义标签（元素）、属性（写在开始标签之间的）、内容部分（两个尖括号之间的文本）、转义字符、CDATA区

  • 声明：必须放在xml文件的第一行，在它之前连注释都不能有

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

  • 注释：在正常开发中，必须有注释

    1. 在xml文件中编写注释内容
    2. <!--注释内容-->

  • 自定义标签,:xml文档是可扩展的标记语言，标签可以随意写任何内容，只要是前后一致，开始标签+结束标签，结束标签要加/

    1. <name></name>
    2. <age></age>

  • 属性:放在开始标签里面的，用来标记该标签的内容

    1. //  其中name表示属性，等号里面跟的是属性值
    2. <property name="url">jdbc:mysql://localhost:3306/shop</property>

  • 内容部分:在两个标签之间，编写一些文本内容

    1. <name>张三</name>
    2. <age>18</age>

  • 转义字符:在xml文档中，用转义标签一些特殊的符号，在页面显示出来对应的符号

    1. <name>></name>-----><name>&gt</name>
    2. &amp;
    3. &gt;
    4. &lt;

    二、解析XML文档（重点）

    2.1 XML解析方式

  • 方式1：DOM解析

特点：不管代码中是否要全部使用，都会一次性将所有内容解析成文档树，存储在内存中，提高查询效率，缺点是会造成内存的占用。

  • 方式2：SAX解析

特点：按需解析，需要什么样数的数据，每一次解析一部分，如果找到了需要的内容，则不再解析。缺点：效率较低。优点：节约内存

2.2 使用java代码解析xml文件

  • 使用的类：

DocumentBuilderFactory类：工厂类，需要通过newInstance()方法获取一个工厂对象
DocumentBuilder类：解析xml文档的类，通过工厂对象调用newDocumentBuilder()方法获得
Document类：文档树，存储在内存中的文档树，通过解析类对象调用parse()获得。

2.2 获取文本内容的示例代码

  1. public class Demo1 {
  2.     public static void main(String[] args) throws Exception{
  3.         //1、创建文档工厂对象
  4.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  6.         //2、通过工厂对象获取解析对象
  7.         DocumentBuilder builder = factory.newDocumentBuilder();
  9.         //3、通过解析文档对象获取文档树对象
  10.         Document document = builder.parse(new File("src/user.xml"));
  12.         //从document文档树中获取数据.NodeList里面存的都是Node对象
  13.         NodeList list = document.getElementsByTagName("userName");
  14.         //调用item(index),表示从里面获取第几个标签，得到的是Node对象
  15.         Node node = list.item(0);
  16.         //获取标签之间的文本内容
  17.         String text = node.getTextContent();
  19.         System.out.println(text);
  20.     }
  21. }

2.3 读取xml配置文件步骤

  • 步骤1：获取工厂对象

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

  • 步骤2：通过工厂对象，获取解析对象

DocumentBuilder builder = factory.newDocumentBuilder();

  • 步骤3：通过解析对象，将xml文档解析成文档树存储在内存中

Document document = builder.parse(new File(“路径”));

  • 步骤4：操作document对象，通过标签名获取节点列表对象

NodeList list = document.getElementsByTagName(“标签名称”);

  • 步骤5：一般都是为了获取标签之间的文本内容，获取文本内容使用getTextContent();

String text = list.item(index).getTextContent();

2.4 xml文档的其他操作

  • 如果用程序对xml文件进行增、删、改操作，必须使用Transformer对象进行将内存中的内容更新到硬盘中。

    2.4.1 修改xml文档

    ```java public class UpdateXML { public static void main(String[] args) throws Exception{

    1.   //1、获取工厂
    2.   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    4.   //2、获取解析对象
    5.   DocumentBuilder builder = factory.newDocumentBuilder();
    7.   //获取文档树
    8.   Document document = builder.parse(new File("src/user.xml"));
    10.   //将李四改成：李雷，将张三改成：李华
    11.   document.getElementsByTagName("userName").item(0).setTextContent("李华");
    12.   document.getElementsByTagName("userName").item(1).setTextContent("李雷");
    14.   //创建TransformerFactory对象
    15.   TransformerFactory tf = TransformerFactory.newInstance();
    16.   Transformer former = tf.newTransformer();
    17.   /*
    18.    * transform(Source xmlSource, Result outputTarget) 
    19.    *     xmlSource:指的是内存中的document文档树源
    20.    * outputTarget：对应的更新硬盘中的xml文件
    21.    */
    22.   former.transform(new DOMSource(document), new StreamResult(new File("src/user.xml")));

    } }

  1. <a name="JeUIT"></a>
  2. ### 2.4.2 对xml文档新增内容(一)
  4. - 如果使用父目录标签名中的方法：appendChild(element)在一个父目录下的最后位置添加新的元素和文本内容
  5. ```java
  6. public class OtherXML {
  7.     //向xml文档中新增一个标签及内容
  8.     @Test
  9.     public void addElement() {
  10.         try {
  11.             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  12.             DocumentBuilder builder = factory.newDocumentBuilder();
  13.             Document document = builder.parse(new File("src/user.xml"));
  15.             //新增元素（标签）：相当于在xml文件中新增一个<password></password>
  16.             Element element = document.createElement("password");
  17.             //设置标签之间的文本内容
  18.             element.setTextContent("admin");
  20.             //将创建好的标签及内容挂载到父目录下
  21.             Node parent = document.getElementsByTagName("u1").item(0);
  22.             //在父目录标签下，添加一个孩子标签
  23.             parent.appendChild(element);
  25.             //将内存中的内容更新到硬盘中
  26.             TransformerFactory tf = TransformerFactory.newInstance();
  27.             Transformer former = tf.newTransformer();
  28.             former.transform(new DOMSource(document), new StreamResult(new File("src/user.xml")));
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

2.4.3 在xml文档中的任意位置添加新的标签及内容(二)

  1. public class OtherXML {
  2.     //向xml文档中任意位置添加新的标签及内容
  3.     @Test
  4.     public void addElement2() {
  5.         try {
  6.             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  7.             DocumentBuilder builder = factory.newDocumentBuilder();
  8.             Document document = builder.parse(new File("src/user.xml"));
  10.             //新建一个标签
  11.             Element element = document.createElement("address");
  12.             element.setTextContent("重庆");
  13.             //获取要添加在哪个标签之前的兄弟标签
  14.             Node node = document.getElementsByTagName("age").item(0);
  15.             Node parent = document.getElementsByTagName("u1").item(0);
  16.             //在node标签之前添加进去，父标签添加子标签，要指定在该标签下的哪个标签之前添加
  17.             //第一个参数：要添加的新标签及内容
  18.             //第二个参数：指定哪个标签之前添加
  19.             parent.insertBefore(element, node);
  21.             TransformerFactory tf = TransformerFactory.newInstance();
  22.             Transformer former = tf.newTransformer();
  23.             former.transform(new DOMSource(document), new StreamResult(new File("src/user.xml")));
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28. }

2.4.4 删除xml文档中的指定标签

  1. public class OtherXML {
  2.     //删除某个节点
  3.     @Test
  4.     public void delete() {
  5.         try {
  6.             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  7.             DocumentBuilder builder = factory.newDocumentBuilder();
  8.             Document document = builder.parse(new File("src/user.xml"));
  10.             //获取要删除的标签（节点）
  11.             Node node = document.getElementsByTagName("address").item(0);
  12.             //删除
  13.             node.getParentNode().removeChild(node);
  15.             TransformerFactory tf = TransformerFactory.newInstance();
  16.             Transformer former = tf.newTransformer();
  17.             former.transform(new DOMSource(document), new StreamResult(new File("src/user.xml")));
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }