zoukankan      html  css  js  c++  java
  • JavaWeb之XML

    作者:刘婧怡

    时间:2019.03.20

    主机环境:MacBookPro


     

    XML

    1. xml的简介

    • xml是可扩展标记型语言。与html一样都使用标签来操作,但html的标签是固定的(有特定的含义),xml的标签可以自己定义(也可以写中文的标签)

    • xml的用途

      ** html用于显示数据,xml也可以显示数据,但这不是主要功能

      ** xml主要为了存储数据

    • xml的应用

      ** 利用xml格式进行不同系统之间数据的传输,利于程序的维护

      ** 用来表示生活中有关系的数据,比如中国、北京、陕西的关系

      ** 经常用在配置文件中,比如连接数据库

     

    2. xml的语法

    • xml的文档声明

       ** 后缀名为.xml

       ** 在写xml之前,必须要有文档声明,必须在第一行

    <?xmlversion="1.0" encoding="utf-8" ?>

       version:xml的版本,有1.0和1.1

       encoding:xml编码 gbk utf-8 iso8859-1(不包含中文)

       standalone:是否需要依赖其他文件(yes、no)

    • xml的元素(标签)定义

      ** 有开始必须要写结束:<person></person>

      ** 标签没有内容,可以在标签内部结束:<aa/>

      ** 标签可以嵌套

      ** 一个xml文档必须有且只有一个根标签

      ** 在xml中空格和换行都被作为原始内容解析,下面这两段代码不同:

    <person>aa</person>
    <person>
    aa
    </person>

       ** xml标签的命名规则:

        1.xml区分大小写

        2.标签不能以数字和下划线开头

        3.标签不能以xml、XML、Xml开头

        4.标签不能包括空格和冒号

    • xml中属性的定义

      ** 一个标签上可以有多个属性,但属性名称不能相同

      ** 属性名称="属性值" 或 属性名称='属性值'

      ** 属性的命名规则与元素的命名规则一样

    • xml中的注释

      ** 写法:<!--xml注释-->

      ** 注释不能嵌套,也不能放在第一行

    • xml中的特殊字符

      ** < 转义为 &lt;> 转义为 &gt;

    • CDATA区

      ** 作用:可以解决多个字符都需要转义的操作,将这些操作放在CDATA区就不用转义了

      ** 写法:

     

    <![CDATA[a < b & c & d > e]]>
    • PI指令(处理指令)

       ** 可以在xml设置样式,但只能对英文标签起作用

    <?xml-stylesheettype="text/css" href="css文件路径名"?>

     

    3. xml的约束

    • 为什么需要约束?

      比如现在定义一个person的xml文件,这里面只能保存人的信息(比如name、age),但如果在xml文件中写了一个标签<cat>,这也可以正常显示,这就需要约束来规定xml中只能出现的元素

    • xml的约束的技术:dtd约束 & schema约束

     

    4. dtd约束

    • 创建一个文件,后缀名为.dtd

    • 步骤:

      ** 确定xml中元素的个数,有多少个元素,就在dtd文件中写多少个<!ELEMENT>

      ** 判断元素是简单元素还是负责元素

      简单元素:没有子元素,<!ELEMENT 元素名称 (#PCDATA)>

      复杂元素:有子元素,<!ELEMENT 元素名称 (子元素)>

      ** 需要在xml文件中引入dtd文件,<!DOCTYPE 根元素名称 SYSTEM "dtd路径">

      xml代码:

    <?xmlversion="1.0" encoding="UTF-8" ?>
    <!DOCTYPE person SYSTEM "person.dtd">
    <person>
       <name>hh</name>
       <age>20</age>
    </person>

    dtd代码:

    <!ELEMENTperson(name,age)>
    <!ELEMENTname(#PCDATA)>
    <!ELEMENTage(#PCDATA)>

      浏览器只负责校验语法,不负责校验约束

    • dtd的三种引入方式

      ** 引入外部的dtd文件,<!DOCTYPE 根元素名称 SYSTEM "dtd路径">

      ** 在xml文件内写dtd

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPEperson[
           <!ELEMENTperson(name,age)>
           <!ELEMENTname(#PCDATA)>
           <!ELEMENTage(#PCDATA)>
          ]>
    <person>
       <name>hh</name>
       <age>20</age>
    </person>

    ** 使用外部的dtd文件(网络上的dtd文件),<!DOCTYPE 根元素 PUBLIC "dtd名称" "dtd文档的URL">,在框架struts2中使用

    • dtd定义元素

      ** 语法格式:<!ELEMENT 元素名称 约束>

      • 简单元素的约束:

        (#PCDATA):约束name是字符串类型

        EMPTY:元素值为空,如<sex></sex>

        ANY:可以有值也可以没有值

      • 复杂元素的约束:

        (子元素):子元素只能出现一次,若出现不止一次,需要用特殊符号,如(name+,age?,sex*):

        +:表示可以出现一次或者多次

        ?:表示可以出现零次或者一次

        *:表示可以出现零次或者一次或者多次

        子元素用逗号隔开,表示出现的顺序;用竖线隔开,表示只能出现其中的一个

    • dtd定义属性

      ** 语法:<!ATTLIST 元素名称 属性名称 属性类型 属性的约束>

      ** 属性的类型

      • CDATA:字符串

      • 枚举:(值|值|值),表示只能在一定的范围内出现值,但是只能出现其中一个

      • ID:表示属性的值不能重复,属性的值只能由字母、下划线开始,不能出现空白字符

      ** 属性的约束

      • #REQUIRED:表示该属性必须出现

      • #IMPLIED:表示该属性可有可无

      • #FIXED:表示一个固定值

      • 直接值:默认该属性值,可以不用该默认值

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPEperson[
           <!ELEMENTperson(name,age,birthday)>
           <!ELEMENTname(#PCDATA)>
           <!ATTLISTname
                   id3ID#IMPLIED>
           <!ELEMENTage(#PCDATA)>
           <!ATTLISTage
                   id2(aa|bb|cc) #REQUIRED>
           <!ELEMENTbirthday(#PCDATA)>
           <!ATTLISTbirthday
                   id1CDATA#FIXED"aa"
              id4CDATA"www"
                  >
          ]>
    <person>
       <nameid3="a">hh</name>
       <ageid2="aa">20</age>
       <birthdayid1="aa"id4="fff">2015</birthday>
    </person>
    • dtd实体定义

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPEperson[
           <!ELEMENTperson(name)>
           <!ELEMENTname(#PCDATA)>
           <!ATTLISTname
                   id3ID#IMPLIED>
           <!ENTITYTEST"hh">
          ]>
    <person>
       <nameid3="a">&TEST;</name>
    </person>
    注意:定义的实体需要写在内部dtd中,若写在外部dtd中,有些浏览器不兼容

     

    5. schema约束

    • 简介

      • schema遵循xml语法,后缀名为.xsd

      • 一个xml只能用一个dtd,但可以有多个schema,使用名称空间区分

      • dtd里有PCDATA类型,在schema有多种数据类型

      • schema比dtd更加复杂,约束更加严格

    • schema文件中的属性

    • 步骤

      • 根节点为<schema>,w3c提供了一些元素和属性

      • 看xml中有多少个元素,就有多少个<element>

      • 判断是简单元素还是复杂元素,简单元素写在复杂元素中

      • 在被约束文件(xml)中引入约束文件(schema)

      xml代码:

    <?xmlversion="1.0" encoding="UTF-8" ?>
    <personxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns="http://www.hh.cn/20190319"
           xsi:schemaLocation="http://www.hh.cn/20190319 1.xsd">
       <name>hh</name>
       <age>20</age>
    </person>
    schema代码:
    <?xmlversion="1.0" encoding="UTF-8" ?>
    <schemaxmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.hh.cn/20190319"
    elementFormDefault="qualified">
       <elementname="person">
           <complexType>
               <sequence>
                   <elementname="name"type="string"></element>
                   <elementname="age"type="int"></element>
               </sequence>
           </complexType>
       </element>
    </schema>

      注意:

      1.xsi这个名字可以随便起

      2.<sequence>表示元素出现的顺序

       <all>表示元素只能出现一次

       <choice>表示只能出现其中一个

      3.在简单元素中有属性maxOccurs="unbounded"表示出现的次数没有限制

    • schema约束属性

      • 该属性必须是复杂元素

      • 写在</complexType>上面

    
    
    <attributename="id"type="int"use="required"></attribute>

     

    6. xml解析的简介

    • xml的解析方式(两种):dom和sax

    • dom解析

      ** 根据xml的层级关系,在内存中分配一个树形结构,把xml中的每个部分都封装称对象

      ** 使用dom方式解析xml会存在如果文件过大,内存溢出的问题,但很方便进行增删改的操作

    • sax解析

      ** 采用事件驱动,边读边解析。从上到下,一行一行解析,解析到某一个对象,把对象名称返回

      ** 使用sax解析不会造成内存溢出,可以查询,但不能进行增删改操作

    • 解析xml需要使用解析器,不同的公司提供了针对dom和sax的解析器,通过api提供

      ** sun公司提供了 jaxp

      ** dom4j公司提供了dom4j(实际开发中使用最多的)

      ** jdom公司提供了jdom

     

    7. JAXP

    • jaxp的api

      ** jaxp是javase的一部分

      ** jaxp解析器在jdk的java.xml.parsers包中,有四个类

      • 针对dom的类:DocumentBuilder(解析器类)、DocumentBuilderFactory(解析器工厂)

      • 针对sax的类:SAXParser(解析器类)、SAXParserFactory(解析器工厂)

      ** DocumentBuilder

      • 是一个抽象类,可以使用DocumentBuilderFactory.DocumentBuilder()得到

      • 利用parse("xml路径")可以解析xml文件,返回document对象,该document是一个接口,父接口为node

      ** DocumentBuilderFactory

      • 是一个抽象类,可以通过newInstance()得到

      ** SAXParser

      • 是一个抽象类,可以使用SAXParserFactory.newSAXParser()得到

      • 利用parse(File f,DefaultHandler dh)可以解析xml文件,第一个参数为xml路径,第二个参数为事件处理器

      • 当解析到开始标签时,自动执行startElement()方法,参数qName返回标签名称

        当解析到文本内容时,自动执行characters()方法,通过string的构造方法返回内容

        当解析到结束标签时,自动执行endElement()方法,参数qName返回标签名称

      ** SAXParserFactory

      • 是一个抽象类,可以通过newInstance()得到

    • 使用jaxp实现查询操作(dom)

      ** xml文件如下:

    <?xmlversion="1.0" encoding="utf-8" standalone="no"?>
    <person>
       <pid="p1">
           <name>lisa</name>
           <age>20</age>
       <p>
           <name>hh</name>
           <age>22</age>
       </p>
    </person>
      ** 步骤

        1. 利用DocumentBuilderFactory.newInstance()创建解析器工厂DocumentBuilderFactory

        2. 根据解析器,利用builderFactory.newDocumentBuilder()工厂创建解析器DocumentBuilder

        3. 利用parse()函数解析xml文件,返回值为Document

        4. 得到所有元素,返回值为NodeList

        5. 遍历集合 getLength(),item()

        6. 利用getTextContent()函数得到元素的值

      ** 代码如下

     

    package jaxp;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import java.io.IOException;
    
    public class select {
        public static void main(String[] args) throws ParserConfigurationException, IOException, SAXException {
            //查询所有name元素的值
            //步骤:
            //1、创建解析器工厂
            //2、根据解析器工厂创建解析器
            //3、解析xml返回document
            //4、得到所有的name元素
            //5、遍历集合
    
            //创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            //创建解析器
            DocumentBuilder documentBuilder = builderFactory.newDocumentBuilder();
            //解析xml
            Document document = documentBuilder.parse("src/person.xml");
            //得到所有的name元素
            NodeList nodeList = document.getElementsByTagName("name");
            //遍历集合
            for(int i = 0;i < nodeList.getLength();i++){
                Node name = nodeList.item(i);
                //得到name元素的值
                String value = name.getTextContent();
                System.out.println(value);
            }
        }
    }
    • 使用jaxp添加元素(dom)

        ** 步骤:

          1. 创建析器工厂,根据解析器工厂创建解析器,解析xml返回document

          2. 得到第一个元素

          3. 创建sex标签

          4. 创建文本

          5. 将文本加入标签

          6. 将标签加入p标签

          7. 回写xml

        ** 代码如下

    package jaxp;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;
    import org.w3c.dom.Text;
    import org.xml.sax.SAXException;
    
    import javax.xml.crypto.dsig.Transform;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerConfigurationException;
    import javax.xml.transform.TransformerException;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
    import java.io.IOException;
    
    public class addSex {
        //在第一个元素后面加sex元素
        public static void main(String[] args) throws ParserConfigurationException, IOException, SAXException, TransformerException {
    //        1、创建解析器工厂
    //        2、根据解析器工厂创建解析器
    //        3、解析xml返回document
    //        4、得到第一个元素
    //        5、创建sex标签
    //        6、创建文本
    //        7、将文本加入标签
    //        8、将标签加入p标签
    //        9、回写
    
    
            //创建解析器工厂
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            //根据解析器工厂创建解析器
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            //解析xml返回document
            Document document = documentBuilder.parse("src/person.xml");
            //得到第一个元素
            Node p1 = document.getElementsByTagName("p").item(0);
            //创建sex标签
            Element sex = document.createElement("sex");
            //创建文本
            Text str = document.createTextNode("man");
            //将文本加入标签
            sex.appendChild(str);
            //将标签加入p标签
            p1.appendChild(sex);
            //回写
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.transform(new DOMSource(document),new StreamResult("src/person.xml"));
        }
    }
    • 使用jaxp修改元素(dom)

      ** 步骤

      • 创建解析器工厂,根据解析器工厂创建解析器,解析xml返回document

      • 得到第一个sex

      • 利用setTextNode()函数修改sex值

      • 回写

      ** 代码如下:

    package jaxp;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
    
    public class modifySex {
        public static void main(String[] args) throws Exception {
            //1、创建解析器工厂
            //2、根据解析器工厂创建解析器
            //3、解析xml返回document
            //4、得到第一个sex
            //5、修改sex值
            //6、回写
    
            //创建解析器工厂
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            //根据解析器工厂创建解析器
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            //解析xml返回document
            Document document = documentBuilder.parse("src/person.xml");
            //得到第一个sex
            Node sex1 = document.getElementsByTagName("sex").item(0);
            //修改sex的值
            sex1.setTextContent("woman");
            //回写
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.transform(new DOMSource(document),new StreamResult("src/person.xml"));
        }
    }
    • 使用jaxp删除节点(dom)

      ** 步骤:

      • 创建解析器工厂,根据解析器工厂创建解析器,解析xml返回document

      • 得到sex节点

      • 得到sex父节点

      • 删除sex

      • 回写

      ** 代码如下:

    package jaxp;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
    
    public class removeSex {
        public static void main(String[] args) throws Exception{
            //创建解析器工厂
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            //根据解析器工厂创建解析器
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            //解析xml返回document
            Document document = documentBuilder.parse("src/person.xml");
            //得到第一个sex
            Node sex1 = document.getElementsByTagName("sex").item(0);
            //得到父节点
            Node sexFather = sex1.getParentNode();
            //删除
            sexFather.removeChild(sex1);
            //回写
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.transform(new DOMSource(document),new StreamResult("src/person.xml"));
        }
    }
    • 使用jaxp遍历节点(dom)

    package jaxp;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    public class travleNode {
        public static void main(String[] args) throws Exception{
            //1、创建解析器工厂
            //2、根据解析器工厂创建解析器
            //3、解析xml返回document
            //4、得到根节点,根结点的子节点... 递归
            //创建解析器工厂
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            //根据解析器工厂创建解析器
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            //解析xml返回document
            Document document = documentBuilder.parse("src/person.xml");
            travle(document);
        }
    
        public static void travle(Node node) throws Exception{
            //判断是元素类型在打印
            if(node.getNodeType() == Node.ELEMENT_NODE) {
                System.out.println(node.getNodeName());
            }
            //得到一层子节点
            NodeList nodeList = node.getChildNodes();
            //遍历nodeList
            for(int i = 0;i < nodeList.getLength();i++){
                //得到每一个节点
                Node node1 = nodeList.item(i);
                //递归
                travle(node1);
            }
        }
    }

     

    • 使用jaxp查询元素(sax)

    ** 步骤:

      • 创建解析器工厂

      • 根据解析器工厂创建解析器

      • 执行parse方法

      • 创建一个类,继承DefaultHandler,重新三个方法

    package jaxp;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    public class sax_select {
        public static void main(String[] args) throws Exception{
            //创建解析器工厂
            SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
            //创建解析器
            SAXParser saxParser = saxParserFactory.newSAXParser();
            //执行parse方法
            saxParser.parse("src/person.xml",new MyDefaultHandler());
        }
    }
    
    class MyDefaultHandler extends DefaultHandler{
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            System.out.print("<" + qName + ">");
        }
    
        public void characters(char[] ch,int start,int length) throws  SAXException{
            System.out.print(new String(ch,start,length));
        }
    
        public void endElement(String uri, String localName, String qName) throws SAXException{
            System.out.print("</" + qName + ">");
        }
    }

     

    8. dom4j

    • 不是javase的一部分,需要导入dom4j的jar包

    • 解析是从上到下解析的

    • 使用dom4j得到document & 回写操作

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.io.SAXReader;
    
    public class getDoc {
        public Document getDocument(String url) throws Exception{
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(url);
            return document;
        }
        public void write(String url,Document document) throws Exception{
            OutputFormat outputFormat = OutputFormat.createPrettyPrint();
            XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(url),outputFormat);
            xmlWriter.write(document);
            xmlWriter.close();
        }
    }
    createPrettyPrint():表示有缩紧的格式
    • 使用dom4j查询元素的值

     

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    
    import java.util.List;
    
    //查询name标签里面的值
    public class select {
        public static void main(String[] args) throws Exception{
    
            //1、得到document
            //2、得到根结点
            //3、得到p标签
            //4、得到name标签
            //5、得到name标签的值
    
            //得到document
            String url = "src/person.xml";
            getDoc doc = new getDoc();
            Document document = doc.getDocument(url);
            //得到根节点
            Element root = document.getRootElement();
            //得到p标签
            List<Element> p = root.elements("p");
            //遍历p
            for(Element e : p){
                //得到p下面的name元素
                Element name = e.element("name");
                //得到name标签的值
                String value = name.getText();
                System.out.println(value);
            }
        }
    }
    • 使用dom4j添加元素

     

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    
    //向第一个p标签后添加sex元素
    public class addSex {
        public static void main(String[] args) throws Exception{
    
            //1、得到document
            //2、得到person标签
            //3、得到第一个p标签
            //4、向p标签添加sex元素,直接使用addElement()
            //5、在sex下面添加文本,直接使用setText()
            //6、回写
    
            //得到document
            String url = "src/person.xml";
            getDoc doc = new getDoc();
            Document document = doc.getDocument(url);
            //得到person标签
            Element root = document.getRootElement();
            //得到第一个p标签
            Element p1 = root.element("p");
            //向p标签添加sex元素
            Element sex = p1.addElement("sex");
            //在sex下面添加文本
            sex.setText("woman");
            //回写
            doc.write(url,document);
        }
    }
    • 在特定的位置添加元素

     

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    
    import java.util.List;
    
    
    //在第一个p下面的age前面添加school标签
    public class addBeforeAge {
        public static void main(String[] args) throws Exception{
    
            //1、得到document
            //2、得到person标签
            //3、得到第一个p标签
            //4、获取p下面所有的元素,elements()方法
            //5、创建school元素,使用DocumentHelper类中的createElement()方法
            //6、将文本添加进标签,setText()方法
            //7、在list中在特定位置添加元素
            //8、回写
    
            //得到document
            String url = "src/person.xml";
            getDoc doc = new getDoc();
            Document document = doc.getDocument(url);
            //得到person标签
            Element root = document.getRootElement();
            //得到第一个p标签
            Element p1 = root.element("p");
            //得到p下面所有标签
            List<Element> list = p1.elements();
            //创建元素
            Element school = DocumentHelper.createElement("school");
            //创建文本
            school.setText("xidian");
            //在age前面添加元素
            list.add(1,school);
            //回写
            doc.write(url,document);
        }
    }
    • 修改元素的值
    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    
    //修改第一个p标签中age的值
    public class modifyAge {
        public static void main(String[] args) throws Exception{
    
            //1、得到document
            //2、得到person标签
            //3、得到第一个p标签
            //4、得到age标签
            //5、修改age标签的值
            //6、回写
    
            //得到document
            String url = "src/person.xml";
            getDoc doc = new getDoc();
            Document document = doc.getDocument(url);
            //得到person标签
            Element root = document.getRootElement();
            //得到第一个p标签
            Element p1 = root.element("p");
            //得到age标签
            Element age = p1.element("age");
            //修改age的值
            age.setText("30");
            //回写
            doc.write(url,document);
        }
    }
    • 删除节点

     

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    
    //删除第一个p下面的sex标签
    public class removeSex {
        public static void main(String[] args) throws Exception{
    
            //1、得到document
            //2、得到person标签
            //3、得到第一个p标签
            //4、得到sex标签
            //5、删除sex标签
            //6、回写
    
            //得到document
            String url = "src/person.xml";
            getDoc doc = new getDoc();
            Document document = doc.getDocument(url);
            //得到person标签
            Element root = document.getRootElement();
            //得到第一个p标签
            Element p1 = root.element("p");
            //得到school标签
            Element sex = p1.element("sex");
            //删除school标签
            p1.remove(sex);
            //回写
            doc.write(url,document);
        }
    }
    • 获得属性

     

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    
    //得到第一个p标签的id属性值
    public class getAttribute {
        public static void main(String[] args) throws Exception {
            //查询name标签里面的值
    
            //1、得到document
            //2、得到根结点
            //3、得到p标签
            //4、获取p标签id的属性值,attributeValue()方法
    
            //得到document
            String url = "src/person.xml";
            getDoc doc = new getDoc();
            Document document = doc.getDocument(url);
            //得到根节点
            Element root = document.getRootElement();
            //得到p标签
            Element p1 = root.element("p");
            //获取p标签id的属性值
            System.out.println(p1.attributeValue("id"));
        }
    }
    • 使用dom4j支持XPath的操作
      • 可以直接获取到某个元素,不用一层一层解析

      • ​书写形式

        1. /AA/DD:表示一层一层的,AA下面的BB

        1. //AA:表示所有的AA,不管位置

        1. /AA/*:表示AA下面的所有元素

        1. /AA[1]:表示AA下面的第一个元素

          /AA[last()]:表示AA下面的最后一个元素

        2. //@id:表示所有有id属性的元素.         //BB[@id="bbb"]:表示BB标签中id属性为bbb的元素

      • 在默认情况下,dom4j不支持XPath,需要引入jar包

      • 两个方法XPath

        ** selectNodes("xpath表达方式"):获取多个节点

        ** selectSingleNode("xpath表达方式"):获取单一节点

      • 使用xpath查询所有name节点

    package dom4j;
    
    import org.dom4j.Document;
    import org.dom4j.Node;
    
    import java.util.List;
    
    public class select_xpath {
        public static void main(String[] args) throws Exception {
            //得到document
            getDoc doc = new getDoc();
            Document document = doc.getDocument("src/person.xml");
            //得到所有的name标签
            String str = "//name";
            List<Node> names = document.selectNodes(str);
            //遍历name标签
            for(Node name : names){
                //打印所有的name的值
                System.out.println(name.getText());
            }
        }
    }

     

     

  • 相关阅读:
    Java实现 蓝桥杯 算法训练 画图(暴力)
    Java实现 蓝桥杯 算法训练 画图(暴力)
    Java实现 蓝桥杯 算法训练 相邻数对(暴力)
    Java实现 蓝桥杯 算法训练 相邻数对(暴力)
    Java实现 蓝桥杯 算法训练 相邻数对(暴力)
    Java实现 蓝桥杯 算法训练 Cowboys
    Java实现 蓝桥杯 算法训练 Cowboys
    55. Jump Game
    54. Spiral Matrix
    50. Pow(x, n)
  • 原文地址:https://www.cnblogs.com/jyliu/p/10564862.html
Copyright © 2011-2022 走看看