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中的特殊字符

** < 转义为 &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文件中的属性
- xmlns="http://www.w3.org/2001/XMLSchema"：表示当前xml是一个约束文件
- targetNamespace="http://www.hh.cn/20190319"：直接通过这个地址引入约束文件，这个地址随便写
- elementFormDefault="qualified"：表示质量良好
步骤
- 根节点为<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());
        }
    }
}

查看全文

相关阅读:
单点登录实现机制
 简单工厂
 单例模式
 Remoting
Redis编码问题
 减少手机页面跳转的方法（转）
失血模型，充血模型
 Hashtable
Why we don’t recommend using List<T> in public APIs
Aggregate累加器

原文地址：https://www.cnblogs.com/jyliu/p/10564862.html