• 超全面的JavaWeb笔记day06<Schema&SAX&dom4j>


    1、Schema的简介和快速入门(了解)

    2、Schema文档的开发流程(了解)

    3、Schema文档的名称空间(了解)

    4、SAX解析原理分析(*********)

    5、SAX解析xml获得整个文档(会写)

    6、SAX解析xml获得某个节点(会写)

    (***************dom4j是重点************)

    7、dom4j简介(*********)

    ==========================================================

    8、dom4j查找元素(*********)

    9、dom4j添加元素(在特定位置添加)(*********)

      在末尾添加 使用 addElement setText

      在特定位置添加

        - 获取所有子标签 使用 elements()方法

        - 使用list里面add(位置,添加的元素)方法

    10、dom4j修改元素、删除节点和获得属性(*********)

      删除使用remove方法,但是删除通过父节点删除

      attributeValue方法

    11、dom4j对XPath的支持(****这个很重要******)

      selectNodes: 多个节点

      selectSingleNode:一个节点

      //id    //p1[@id='aaa']

    12、学生管理系统的代码实现(*********)

    1、schema约束

      dtd语法: <!ELEMENT 元素名称 约束>

      ** schema符合xml的语法,xml语句

      ** 一个xml中可以有多个schema,多个schema使用名称空间区分(类似于java包名)

      ** dtd里面有PCDATA类型,但是在schema里面可以支持更多的数据类型

        *** 比如 年龄 只能是整数,在schema可以直接定义一个整数类型

      *** schema语法更加复杂,schema目前不能替代dtd

    2、schema的快速入门

      * 创建一个schema文件 后缀名是 .xsd

        ** 根节点 <schema>

      ** 在schema文件里面

        ** 属性  xmlns="http://www.w3.org/2001/XMLSchema"

          - 表示当前xml文件是一个约束文件

        ** targetNamespace="http://www.itcast.cn/20151111"

          - 使用schema约束文件,直接通过这个地址引入约束文件

        ** elementFormDefault="qualified"

      步骤

        (1)看xml中有多少个元素

          <element>

        (2)看简单元素和复杂元素

          * 如果复杂元素

          <complexType>

            <sequence>

              子元素

            </sequence>

          </complexType>

        (3)简单元素,写在复杂元素的

          <element name="person">

          <complexType>

          <sequence>

            <element name="name" type="string"></element>

            <element name="age" type="int"></element>

          </sequence>

          </complexType>

          </element>

    1.xsd

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <schema xmlns="http://www.w3.org/2001/XMLSchema"
     3         targetNamespace="http://www.itcast.cn/20151111"
     4         elementFormDefault="qualified">
     5     <element name="person">
     6         <complexType>
     7             <sequence>
     8             <!-- <all> -->
     9             <!-- <choice> -->
    10                     <element name="name" type="string" maxOccurs="unbounded"></element>
    11                     <element name="age" type="int"></element>
    12             <!-- </choice> -->
    13             <!-- </all>     -->
    14             </sequence>
    15             <attribute name="id1" type="int" use="required"></attribute>
    16         </complexType>
    17     </element>
    18 </schema>

        (4)在被约束文件里面引入约束文件

    person.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     3         xmlns="http://www.itcast.cn/20151111"
     4         xsi:schemaLocation="http://www.itcast.cn/20151111 1.xsd" id1="123">
     5     
     6     <name>zhangsan</name>
     7     <name>zhangsan</name>
     8     <name>zhangsan</name>
     9     <age>20</age> 
    10 </person>

        <person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

        xmlns="http://www.itcast.cn/20151111"

        xsi:schemaLocation="http://www.itcast.cn/20151111 1.xsd">

        ** xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

          -- 表示xml是一个被约束文件

        ** xmlns="http://www.itcast.cn/20151111"

          -- 是约束文档里面 targetNamespace

        ** xsi:schemaLocation="http://www.itcast.cn/20151111 1.xsd">

          -- targetNamespace 空格  约束文档的地址路径

      * <sequence>:表示元素的出现的顺序

         <all>: 元素只能出现一次

         <choice>:元素只能出现其中的一个

         maxOccurs="unbounded": 表示元素的出现的次数

         <any></any>:表示任意元素

      * 可以约束属性

        * 写在复杂元素里面

        ***写在 </complexType>之前

        --

        <attribute name="id1" type="int" use="required"></attribute>

        - name: 属性名称

        - type:属性类型 int stirng

        - use:属性是否必须出现 required

      * 复杂的schema约束

    company.xsd

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <schema xmlns="http://www.w3.org/2001/XMLSchema" 
     3 targetNamespace="http://www.example.org/company" 
     4 elementFormDefault="qualified">
     5     <element name="company">
     6         <complexType>
     7             <sequence>
     8                 <element name="employee">
     9                     <complexType>
    10                         <sequence>
    11                             <!-- 引用任何一个元素 -->
    12                             <any></any>
    13                             <!-- 员工名称 -->
    14                             <element name="name"></element>
    15                         </sequence>
    16                         <!-- 为employee元素添加属性 -->
    17                         <attribute name="age" type="int"></attribute>
    18                     </complexType>
    19                 </element>
    20             </sequence>
    21         </complexType>
    22     </element>
    23 </schema>

      * 引入多个schema文件,可以给每个起一个别名

    company.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!-- 数据文件 引用多个Schema -->
     3 <company xmlns = "http://www.example.org/company"
     4     xmlns:dept="http://www.example.org/department"
     5     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
     6     xsi:schemaLocation="http://www.example.org/company company.xsd     http://www.example.org/department department.xsd" >
     7     <employee age="30">
     8         <!-- 部门名称 --> 
     9    <!--想要引入部门的约束文件里面的name,使用部门的别名 detp:元素名称-->
    10         <dept:name>100</dept:name>
    11         <!-- 员工名称 -->
    12         <name>王晓晓</name>
    13     </employee>
    14 </company>

    department.xsd

    1 <?xml version="1.0" encoding="UTF-8"?>
    2 <schema xmlns="http://www.w3.org/2001/XMLSchema"
    3      targetNamespace="http://www.example.org/department" 
    4      elementFormDefault="qualified">
    5  <!-- 部门名称 -->
    6  <element name="name" type="int"></element>
    7 </schema>

    3、sax解析的原理(********)

      * 解析xml有两种技术 dom 和sax

      * dom方式:根据xml的层级结构在内存中分配一个树形结构

      ** 把xml中标签,属性,文本封装成对象

      * sax方式:事件驱动,边读边解析

      * 在javax.xml.parsers包里面

        ** SAXParser

          此类的实例可以从 SAXParserFactory.newSAXParser() 方法获得

          - parse(File f, DefaultHandler dh)

            * 两个参数

            ** 第一个参数:xml的路径

            ** 事件处理器

        ** SAXParserFactory

          实例 newInstance() 方法得到

      * 画图分析一下sax执行过程

     

        * 当解析到开始标签时候,自动执行startElement方法

        * 当解析到文本时候,自动执行characters方法

        * 当解析到结束标签时候,自动执行endElement方法

    4、使用jaxp的sax方式解析xml(**会写**)

      * sax方式不能实现增删改操作,只能做查询操作

      ** 打印出整个文档

    p1.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <person> 
     3   <p1 id1="aaaa"> 
     4     <name>zhangsan</name>  
     5     <age>300</age>  
     6     <sex>nv</sex> 
     7   </p1>  
     8   <p1> 
     9     <name>lisi</name>  
    10     <age>30</age> 
    11   </p1> 
    12 </person>

    TestSax.java

     1 package com.li.jaxpsax;
     2 
     3 import javax.xml.parsers.ParserConfigurationException;
     4 import javax.xml.parsers.SAXParser;
     5 import javax.xml.parsers.SAXParserFactory;
     6 
     7 import org.xml.sax.Attributes;
     8 import org.xml.sax.SAXException;
     9 import org.xml.sax.helpers.DefaultHandler;
    10 
    11 public class TestSax {
    12     public static void main(String[] args) throws Exception {
    13         /*
    14          * 1、创建解析器工厂
    15          * 2、创建解析器
    16          * 3、执行parse方法
    17          * 
    18          * 4、自己创建一个类,继承DefaultHandler
    19          * 5、重写类里面的三个方法
    20          * */
    21         //创建解析器工厂
    22         SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
    23         //创建解析器
    24         SAXParser saxParser = saxParserFactory.newSAXParser();
    25         //执行parse方法
    26         saxParser.parse("src/p1.xml", new MyDefault2());    
    27     }    
    28 }
    29 class MyDefault1 extends DefaultHandler {
    30 
    31     @Override
    32     public void startElement(String uri, String localName, String qName,
    33             Attributes attributes) throws SAXException {
    34         System.out.print("<"+qName+">");
    35     }
    36     
    37     @Override
    38     public void characters(char[] ch, int start, int length)
    39             throws SAXException {
    40         System.out.print(new String(ch,start,length));
    41     }
    42 
    43     @Override
    44     public void endElement(String uri, String localName, String qName)
    45             throws SAXException {
    46         System.out.print("</"+qName+">");
    47     }
    48 }

     *** 执行parse方法,第一个参数xml路径,第二个参数是 事件处理器

        *** 创建一个类,继承事件处理器的类

        ***重写里面的三个方法

      ** 获取到所有的name元素的值

        ** 定义一个成员变量 flag= false

        ** 判断开始方法是否是name元素,如果是name元素,把flag值设置成true

        ** 如果flag值是true,在characters方法里面打印内容

        ** 当执行到结束方法时候,把flag值设置成false

       * 获取第一个name元素的值

        ** 定义一个成员变量 idx=1

        ** 在结束方法时候,idx+1 idx++

        ** 想要打印出第一个name元素的值,

          - 在characters方法里面判断,

          -- 判断flag=true 并且 idx==1,在打印内容

     1 //实现获取所有(第一个)的name元素的值
     2 class MyDefault2 extends DefaultHandler {
     3     boolean flag = false;
     4     int idx = 1;
     5     @Override
     6     public void startElement(String uri, String localName, String qName,
     7             Attributes attributes) throws SAXException {
     8         //判断qName是否是name元素
     9         if("name".equals(qName)) {
    10             flag = true;            
    11         }
    12     }
    13     @Override
    14     public void characters(char[] ch, int start, int length)
    15             throws SAXException {
    16         //当flag值是true时候,表示解析到name元素
    17         //索引是1    实现获取第一个的name元素的值
    18         if(flag == true && idx == 1) {
    19             System.out.println(new String(ch,start,length));
    20         }
    21     }
    22     
    23     @Override
    24     public void endElement(String uri, String localName, String qName)
    25             throws SAXException {
    26         //把flag设置成false,表示name元素结束
    27         if("name".equals(qName)) {
    28             flag = false;
    29             idx++;
    30         }
    31     }
    32 }

    5、使用dom4j解析xml

      * dom4j,是一个组织,针对xml解析,提供解析器 dom4j

       * dom4j不是javase的一部分,想要使用第一步需要怎么做?

        *** 导入dom4j提供jar包

        -- 创建一个文件夹 lib

        -- 复制jar包到lib下面,

        -- 右键点击jar包,build path -- add to build path

        -- 看到jar包,变成奶瓶样子,表示导入成功

       * 得到document

        SAXReader reader = new SAXReader();

        Document document = reader.read(url);

      * document的父接口是Node

        * 如果在document里面找不到想要的方法,到Node里面去找

       * document里面的方法 getRootElement() :获取根节点 返回的是Element

       * Element也是一个接口,父接口是Node

        - Element和Node里面方法

        ** getParent():获取父节点

        ** addElement:添加标签

         * element(qname)

          ** 表示获取标签下面的第一个子标签

          ** qname:标签的名称

        * elements(qname)

          ** 获取标签下面是这个名称的所有子标签(一层)

          ** qname:标签名称

        * elements()

          ** 获取标签下面的所有一层子标签

    6、使用dom4j查询xml

      * 解析是从上到下解析

      * 查询所有name元素里面的值

      /*

      1、创建解析器

      2、得到document

      3、得到根节点  getRootElement() 返回Element

      4、得到所有的p1标签

        * elements("p1") 返回list集合

        * 遍历list得到每一个p1

      5、得到name

        * 在p1下面执行 element("name")方法 返回Element

      6、得到name里面的值

        * getText方法得到值

      */

     1   //查询xml中所有name元素的值
     2     public static void selectName() throws Exception {
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 3、得到根节点
     7          * 
     8          * 4、得到p1
     9          * 5、得到p1下面的name
    10          * 6、得到name里面的值
    11          * */
    12         //创建解析器
    13         SAXReader saxReader = new SAXReader();
    14         //得到document
    15         Document document = saxReader.read("src/p1.xml");
    16         //得到根节点
    17         Element root = document.getRootElement();
    18         
    19         //得到p1
    20         List<Element> list = root.elements("p1");
    21         //遍历list
    22         for (Element element : list) {
    23             //element是每一个p1元素
    24             //得到p1下面的name元素
    25             Element name1 = element.element("name");
    26             //得到name里面的值
    27             String s = name1.getText();
    28             System.out.println(s);
    29         }
    30     }

      * 查询第一个name元素的值

      /*

       * 1、创建解析器

       * 2、得到document

       * 3、得到根节点

       * 4、得到第一个p1元素  

        ** element("p1")方法 返回Element

       * 5、得到p1下面的name元素

        ** element("name")方法 返回Element

       * 6、得到name元素里面的值

        ** getText方法

       * */

     1   //获取到一个name元素里面的值
     2     public static void selectSin() throws Exception {        
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 3、得到根节点
     7          * 
     8          * 4、得到第一个p1元素
     9          * 5、得到p1下面的name元素
    10          * 6、得到name元素里面的值
    11          * */
    12         //创建解析器
    13         SAXReader saxReader = new SAXReader();
    14         //得到document
    15         Document document = saxReader.read("src/p1.xml");
    16         //得到根节点
    17         Element root = document.getRootElement();
    18         //得到第一个p1
    19         Element p1 = root.element("p1");
    20         //得到p1下面的name元素
    21         Element name1 = p1.element("name");
    22         //得到name的值
    23         String s1 = name1.getText();
    24         System.out.println(s1);
    25     }

      * 获取第二个name元素的值

      /*

       * 1、创建解析器

       * 2、得到document

       * 3、得到根节点

       *  4、得到所有的p1

        ** 返回 list集合

       *  5、遍历得到第二个p1

        ** 使用list下标得到 get方法,集合的下标从 0 开始,想要得到第二个值,下标写 1

       *  6、得到第二个p1下面的name

        ** element("name")方法 返回Element

       *  7、得到name的值

        ** getText方法

       * */

     1   //获取第二个name元素里面的值
     2     public static void selectSecond() throws Exception {    
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 3、得到根节点
     7          * 
     8          *  4、得到所有的p1
     9          *  5、遍历得到第二个p1
    10          *  6、得到第二个p1下面的name
    11          *  7、得到name的值
    12          * */
    13         //创建解析器
    14         SAXReader saxReader = new SAXReader();
    15         //得到document
    16         Document document = saxReader.read("src/p1.xml");
    17         //得到根节点
    18         Element root = document.getRootElement();
    19         //得到所有的p1
    20         List<Element> list = root.elements("p1");
    21         //得到第二个p1 list集合下标从0开始
    22         Element p2 = list.get(1);
    23         //得到p1下面的name
    24         Element name2 = p2.element("name");
    25         //得到name里面的值
    26         String s2 = name2.getText();
    27         System.out.println(s2);
    28     }

    7、使用dom4j实现添加操作

    Dom4jUtils.java

     1 package com.li.utils;
     2 
     3 import java.io.FileOutputStream;
     4 
     5 import org.dom4j.Document;
     6 import org.dom4j.DocumentException;
     7 import org.dom4j.io.OutputFormat;
     8 import org.dom4j.io.SAXReader;
     9 import org.dom4j.io.XMLWriter;
    10 
    11 public class Dom4jUtils {
    12     public static final String PATH = "src/p1.xml";
    13     //返回document
    14     public static Document getDocument(String path) {
    15         try {
    16             //创建解析器
    17             SAXReader reader = new SAXReader();
    18             //得到document
    19             Document document = reader.read(path);
    20             return document;
    21         } catch (Exception e) {
    22             e.printStackTrace();
    23         }
    24         return null;
    25     }
    26     
    27     //回写xml的方法
    28     public static void xmlWriters(String path,Document document) {
    29         try {
    30             OutputFormat format = OutputFormat.createPrettyPrint();
    31             XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path), format);
    32             xmlWriter.write(document);
    33             xmlWriter.close();
    34         }catch(Exception e) {
    35             e.printStackTrace();
    36         }
    37     }
    38 }

      * 在第一个p1标签末尾添加一个元素 <sex>nv</sex>

      * 步骤

      /*

       * 1、创建解析器

       * 2、得到document

       * 3、得到根节点

       * 4、获取到第一个p1

        * 使用element方法

       * 5、在p1下面添加元素

        * 在p1上面直接使用 addElement("标签名称")方法 返回一个Element

       * 6、在添加完成之后的元素下面添加文本

        *在sex上直接使用 setText("文本内容")方法

       * 7、回写xml

        * 格式化 OutputFormat,使用 createPrettyPrint方法,表示一个漂亮的格式

        * 使用类XMLWriter 直接new 这个类 ,传递两个参数

          *** 第一个参数是xml文件路径 new FileOutputStream("路径")

          *** 第二个参数是格式化类的值

       * */

     1   //在第一个p1标签末尾添加一个元素 <sex>nv</sex>
     2     public static void addSex() throws Exception {
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 3、得到根节点
     7          * 
     8          * 4、获取到第一个p1
     9          * 5、在p1下面添加元素
    10          * 6、在添加完成之后的元素下面添加文本
    11          * 
    12          * 7、回写xml
    13          * */
    14         //创建解析器
    15 //        SAXReader reader = new SAXReader();
    16         //得到document
    17 //        Document document = reader.read("src/p1.xml");
    18         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
    19         //得到根节点
    20         Element root = document.getRootElement();
    21         //得到第一个p1元素
    22         Element p1 = root.element("p1");
    23         //在p1下面直接添加元素
    24         Element sex1 = p1.addElement("sex");
    25         //在sex下面添加文本
    26         sex1.setText("nv");
    27         
    28         //回写xml
    29 //        OutputFormat format = OutputFormat.createPrettyPrint(); //可以有缩进的效果
    30 ////        OutputFormat format = OutputFormat.createCompactFormat();    //压缩
    31 //        XMLWriter  xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"), format);
    32 //        xmlWriter.write(document);
    33 //        xmlWriter.close();
    34         Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
    35     }

    8、使用dom4j实现在特定位置添加元素

      * 在第一个p1下面的age标签之前添加 <school>ecit.edu.cn</schlool>

      * 步骤

       /*

       * 1、创建解析器

       * 2、得到document

       * 3、得到根节点

       * 4、获取到第一个p1

       * 5、获取p1下面的所有的元素

          ** elements()方法 返回 list集合

          ** 使用list里面的方法,在特定位置添加元素

          ** 首先创建元素 在元素下面创建文本

            - 使用DocumentHelper类方法createElement创建标签

            - 把文本添加到标签下面 使用 setText("文本内容")方法

             *** list集合里面的 add(int index, E element)

             - 第一个参数是 位置 下标,从0开始

             - 第二个参数是 要添加的元素

       * 6、回写xml

       * */

     1     //在第一个p1下面的age标签之前添加 <school>ecit.edu.cn</schlool>
     2     public static void addAgeBefore() throws Exception {
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 3、得到根节点
     7          * 4、获取到第一个p1
     8          * 
     9          * 5、获取p1下面的所有的元素
    10          *         ** elements()方法 返回 list集合
    11          *      ** 使用list里面的方法,在特定位置添加元素
    12          *      ** 创建元素 在元素下面创建文本
    13          *          *** add(int index, E element)
    14          *              - 第一个参数是 位置 下标,从0开始
    15          *              - 第二个参数是 要添加的元素
    16          * 6、回写xml
    17          * */
    18         //创建解析器
    19 //        SAXReader saxReader = new SAXReader();
    20         //得到document
    21 //        Document document = saxReader.read("src/p1.xml");
    22         
    23         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
    24         //得到根节点
    25         Element root = document.getRootElement();
    26         //获取到第一个p1
    27         Element p1 = root.element("p1");
    28         //获取p1下面的所有元素
    29         List<Element> list = p1.elements();
    30         //创建元素 使用
    31         Element school = DocumentHelper.createElement("school");
    32         //在school下面创建文本
    33         school.setText("ecit");    
    34         //在特定位置添加
    35         list.add(1, school);
    36         //回写xml
    37         /*OutputFormat format = OutputFormat.createPrettyPrint();
    38         XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"), format);
    39         xmlWriter.write(document);
    40         xmlWriter.close();*/
    41         Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
    42     }

      ** 可以对得到document的操作和 回写xml的操作,封装成方法

      ** 也可以把传递的文件路径,封装成一个常量

      *** 好处:可以提高开发速度,可以提交代码可维护性

        - 比如想要修改文件路径(名称),这个时候只需要修改常量的值就可以了,其他代码不需要做任何改变

    9、使用dom4j实现修改节点的操作

      * 修改第一个p1下面的age元素的值 <age>30</age>

      * 步骤

      /*

       * 1、得到document

       * 2、得到根节点,然后再得到第一个p1元素

       * 3、得到第一个p1下面的age

        element("")方法

       * 4、修改值是 30

         ** 使用setText("文本内容")方法

       * 5、回写xml

       * */

     1     //修改第一个p1下面的age元素的值 <age>30</age>
     2     public static void modifyAge() throws Exception {
     3         /*
     4          * 1、得到document
     5          * 2、得到根节点,然后再得到第一个p1元素
     6          * 3、得到第一个p1下面的age
     7          * 4、修改值是 30
     8          * 
     9          * 5、回写xml
    10          * 
    11          * */
    12         //得到document
    13         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
    14         //得到第一个根节点
    15         Element root = document.getRootElement();
    16         //得到第一个p1
    17         Element p1 = root.element("p1");
    18         //得到p1下面的age
    19         Element age = p1.element("age");
    20         //修改age的值
    21         age.setText("30");
    22         //回写xml
    23         Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
    24     }    

    10、使用dom4j实现删除节点的操作

      * 删除第一个p1下面的<school>ecit</school>元素

      * 步骤

      /*

       * 1、得到document

       * 2、得到根节点

       * 3、得到第一个p1标签

       * 4、得到第一个p1下面的school元素

       * 5、删除(使用p1删除school)

        * 得到school的父节点

          - 第一种直接得到p1

          - 使用方法 getParent方法得到

        * 删除操作

          - 在p1上面执行remove方法删除节点

       * 6、回写xml

      * */

     1     //删除第一个p1下面的<school>ecit</school>元素
     2     public static void delSch() throws Exception {
     3         /*
     4          * 1、得到document
     5          * 2、得到根节点
     6          * 3、得到第一个p1标签
     7          * 4、得到第一个p1下面的school元素
     8          * 5、删除(使用p1删除school)
     9          * 
    10          * 6、回写xml
    11          * */
    12         //得到document    ctrl shift o 快速导包
    13         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
    14         //得到根节点
    15         Element root = document.getRootElement();
    16         //得到第一个p1元素
    17         Element p1 = root.element("p1");
    18         //得到p1下面的school标签
    19         Element sch = p1.element("school");
    20         //删除school元素
    21         //通过父节点删除 
    22         //获取父节点的方法
    23         //sch.getParent(); //获取到school的父节点p1
    24         p1.remove(sch);
    25         //回写xml
    26         Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
    27     }

    11、使用dom4j获取属性的操作

      * 获取第一个p1里面的属性id1的值

      * 步骤

      /*

       * 1、得到document

       * 2、得到根节点

       * 3、得到第一个p1元素

       * 4、得到p1里面的属性值

        - p1.attributeValue("id1");

        - 在p1上面执行这个方法,里面的参数是属性名称

      * */

     1     //获取第一个p1里面的属性id1的值
     2     public static void getValues() throws Exception {
     3         /*
     4          * 1、得到document
     5          * 2、得到根节点
     6          * 3、得到第一个p1元素
     7          * 4、得到p1里面的属性值
     8          * */
     9         //得到document
    10         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
    11         //得到根节点
    12         Element root = document.getRootElement();
    13         //得到第一个p1元素
    14         Element p1 = root.element("p1");
    15         //得到p1里面的属性值
    16         String value = p1.attributeValue("id1");
    17         System.out.println(value);
    18     }

    12、使用dom4j支持xpath的操作

      * 可以直接获取到某个元素

    查看XPath.chm得知:

      * 第一种形式

        /AAA/DDD/BBB: 表示一层一层的,AAA下面 DDD下面的BBB

      * 第二种形式

        //BBB: 表示和这个名称相同,表示只要名称是BBB,都得到

      * 第三种形式

        /*: 所有元素

      * 第四种形式

        ** BBB[1]: 表示第一个BBB元素

        ×× BBB[last()]:表示最后一个BBB元素

      * 第五种形式

        ** //BBB[@id]: 表示只要BBB元素上面有id属性,都得到

      * 第六种形式

        ** //BBB[@id='b1'] 表示元素名称是BBB,在BBB上面有id属性,并且id的属性值是b1

    13、使用dom4j支持xpath具体操作

      ** 默认的情况下,dom4j不支持xpath

      ** 如果想要在dom4j里面是有xpath

        * 第一步需要,引入支持xpath的jar包,使用 jaxen-1.1-beta-6.jar

        ** 需要把jar包导入到项目中

      ** 在dom4j里面提供了两个方法,用来支持xpath

        *** selectNodes("xpath表达式")

          - 获取多个节点

        *** selectSingleNode("xpath表达式")

          - 获取一个节点

      ** 使用xpath实现:查询xml中所有name元素的值

        ** 所有name元素的xpath表示: //name

        ** 使用selectNodes("//name");

        ** 代码和步骤

     1     //查询xml中所有name元素的值
     2     public static void test1() throws Exception {
     3         /*
     4          * 1、得到document
     5          * 2、直接使用selectNodes("//name")方法得到所有的name元素
     6          * */
     7         //得到document
     8         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
     9         //使用selectNodes("//name")方法得到所有的name元素
    10         List<Node> list = document.selectNodes("//name");
    11         //遍历list集合
    12         for (Node node : list) {
    13             //node是每一个name元素
    14             //得到name元素里面的值
    15             String s = node.getText();
    16             System.out.println(s);
    17         }
    18     }

      ** 使用xpath实现:获取第一个p1下面的name的值

        * //p1[@id1='aaaa']/name

        * 使用到 selectSingleNode("//p1[@id1='aaaa']/name")

        * 步骤和代码

     1     //使用xpath实现:获取第一个p1下面的name的值
     2     public static void test2() throws Exception {
     3         /*
     4          * 1、得到document
     5          * 2、直接使用selectSingleNode方法实现
     6          *     - xpath : //p1[@id1='aaaa']/name
     7          * */
     8         //得到document
     9         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
    10         //直接使用selectSingleNode方法实现
    11         Node name1 = document.selectSingleNode("//p1[@id1='aaaa']/name"); //name的元素
    12         //得到name里面的值
    13         String s1 = name1.getText();
    14         System.out.println(s1);
    15     }

    14、实现简单的学生管理系统

      ** 使用xml当做数据,存储学生信息

      ** 创建一个xml文件,写一些学生信息

    student.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <sudent> 
     3     <stu> 
     4         <id>100</id>  
     5         <name>zhangsan</name>  
     6             <age>20</age> 
     7       </stu>  
     8       <stu> 
     9             <id>101</id>  
    10             <name>lisi</name>  
    11             <age>30</age> 
    12       </stu> 
    13 </sudent>

      ** 增加操作

        /*

         * 1、创建解析器

         * 2、得到document

         * 3、获取到根节点

         * 4、在根节点上面创建stu标签

         * 5、在stu标签上面依次添加id name age

          ** addElement方法添加

         * 6、在id name age上面依次添加值

          ** setText方法

         * 7、回写xml

         * */

    Student.java

     1 package com.li.vo;
     2 public class Student {
     3     private String id;
     4     private String name;
     5     private String age;
     6     
     7     public String getId() {
     8         return id;
     9     }
    10     public void setId(String id) {
    11         this.id = id;
    12     }
    13     public String getName() {
    14         return name;
    15     }
    16     public void setName(String name) {
    17         this.name = name;
    18     }
    19     public String getAge() {
    20         return age;
    21     }
    22     public void setAge(String age) {
    23         this.age = age;
    24     }
    25     @Override
    26     public String toString() {
    27         return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    28     }
    29 }

    StuService.java

     1 import java.util.List;
     2 
     3 import org.dom4j.Document;
     4 import org.dom4j.DocumentException;
     5 import org.dom4j.Element;
     6 import org.dom4j.Node;
     7 import org.dom4j.io.OutputFormat;
     8 import org.dom4j.io.SAXReader;
     9 import org.dom4j.io.XMLWriter;
    10 
    11 import cn.itcast.vo.Student;
    12 
    13 public class StuService {
    14     //增加
    15     public static void addStu(Student student) throws Exception {
    16         /*
    17          * 1、创建解析器
    18          * 2、得到document
    19          * 3、获取到根节点
    20          * 4、在根节点上面创建stu标签
    21          * 5、在stu标签上面依次添加id name age
    22          * 6、在id name age上面依次添加值
    23          * 
    24          * 7、回写xml
    25          * */
    26         //创建解析器
    27         SAXReader saxReader = new SAXReader();
    28         //得到document
    29         Document document = saxReader.read("src/student.xml");
    30         //得到根节点
    31         Element root = document.getRootElement();
    32         //在根节点上面添加stu
    33         Element stu = root.addElement("stu");
    34         //在stu标签上面依次添加id name age标签
    35         Element id1 = stu.addElement("id");
    36         Element name1 = stu.addElement("name");
    37         Element age1 = stu.addElement("age");
    38         //在id name age上面依次添加值
    39         id1.setText(student.getId());
    40         name1.setText(student.getName());
    41         age1.setText(student.getAge());
    42         //回写xml
    43         OutputFormat format = OutputFormat.createPrettyPrint();
    44         XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/student.xml"), format);
    45         xmlWriter.write(document);
    46         xmlWriter.close();
    47     }
    48 }

    TestStu.java

    1     //测试添加方法
    2     public static void testAdd() throws Exception {
    3         //设置值
    4         Student stu = new Student();
    5         stu.setId("103");
    6         stu.setName("wangwu");
    7         stu.setAge("40");
    8         StuService.addStu(stu);
    9     }

      ** 删除操作(根据id删除)

        /*

         * 1、创建解析器

         * 2、得到document

         * 3、获取到所有的id

           * 使用xpath //id 返回 list集合

         * 4、遍历list集合

         * 5、判断集合里面的id和传递的id是否相同

         * 6、如果相同,把id所在的stu删除

         * */

    StuService.java

     1     //删除 根据学生的id删除
     2     public static void delStu(String id) throws Exception {
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 
     7          * 3、获取到所有的id    
     8          *     使用xpath //id 返回 list集合
     9          * 4、遍历list集合
    10          * 5、判断集合里面的id和传递的id是否相同
    11          * 6、如果相同,把id所在的stu删除
    12          * 
    13          * */
    14         //创建解析器
    15         SAXReader saxReader = new SAXReader();
    16         //得到document
    17         Document document = saxReader.read("src/student.xml");
    18         //获取所有的id  xpath: //id
    19         List<Node> list = document.selectNodes("//id");
    20         //遍历list集合
    21         for (Node node : list) { //node是每一个id的元素
    22             //得到id的值
    23             String idv = node.getText();
    24             //判断idv和传递的id是否相同
    25             if(idv.equals(id)) { //id相同
    26                 //得到stu节点
    27                 Element stu = node.getParent();
    28                 //获取stu的父节点
    29                 Element student = stu.getParent();
    30                 //删除stu
    31                 student.remove(stu);
    32             }        
    33         }
    34         //回写xml
    35         OutputFormat format = OutputFormat.createPrettyPrint();
    36         XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/student.xml"), format);
    37         xmlWriter.write(document);
    38         xmlWriter.close();
    39     }

    TestStu.java

        //测试删除方法
        public static void testDel() throws Exception {
            StuService.delStu("103");        
        }

      ** 查询操作(根据id查询)

        /*

         * 1、创建解析器

         * 2、得到document

         * 3、获取到所有的id

         * 4、返回的是list集合,遍历list集合

         * 5、得到每一个id的节点

         * 6、id节点的值

         * 7、判断id的值和传递的id值是否相同

         * 8、如果相同,先获取到id的父节点stu

         * 9、通过stu获取到name age值

           ** 把这些值封装到一个对象里面 返回对象

         * */

    StuService.java

     1     //查询 根据id查询学生信息
     2     public static Student getStu(String id) throws Exception {
     3         /*
     4          * 1、创建解析器
     5          * 2、得到document
     6          * 
     7          * 3、获取到所有的id
     8          * 4、返回的是list集合,遍历list集合
     9          * 5、得到每一个id的节点
    10          * 6、id节点的值
    11          * 7、判断id的值和传递的id值是否相同
    12          * 8、如果相同,先获取到id的父节点stu
    13          * 9、通过stu获取到name age值
    14          * 
    15          * */
    16         //创建解析器
    17         SAXReader saxReader = new SAXReader();
    18         //得到document
    19         Document document = saxReader.read("src/student.xml");
    20         //获取所有的id
    21         List<Node> list = document.selectNodes("//id");
    22         //创建student对象
    23         Student student = new Student();
    24         //遍历list
    25         for (Node node : list) { //node是每一个id节点
    26             //得到id节点的值
    27             String idv = node.getText();
    28             //判断id是否相同
    29             if(idv.equals(id)) { 
    30                 //得到id的父节点 stu
    31                 Element stu = node.getParent();
    32                 //通过stu获取name和age
    33                 String namev = stu.element("name").getText();
    34                 String agev = stu.element("age").getText();
    35                 student.setId(idv);
    36                 student.setName(namev);
    37                 student.setAge(agev);
    38             }
    39         }
    40         return student;
    41     }

    TestStu.java

        //测试查询方法
        public static void testSelect() throws Exception {
            Student stu = StuService.getStu("100");
            System.out.println(stu.toString());
        }
  • 相关阅读:
    跟我一起学Go系列:gRPC 全局数据传输和超时处理
    跟我一起学Go系列:Go gRPC 安全认证方式-Token和自定义认证
    c++中的继承关系
    数值型模板参数的应用
    [源码解析] 机器学习参数服务器Paracel (3)------数据处理
    [源码解析] PyTorch 分布式(2) --- 数据加载之DataLoader
    [源码解析] PyTorch 分布式(1) --- 数据加载之DistributedSampler
    [源码解析] 机器学习参数服务器 Paracel (2)--------SSP控制协议实现
    [源码解析] 机器学习参数服务器 Paracel (1)-----总体架构
    [源码解析]机器学习参数服务器ps-lite(4) ----- 应用节点实现
  • 原文地址:https://www.cnblogs.com/justdoitba/p/7593243.html
Copyright © 2020-2023  润新知