【简记】Java Web 内幕——XML介绍，解析XML，DOM和SAX解析

本文链接：https://blog.csdn.net/qqqqq1993qqqqq/article/details/74981650

本章内容：

xml概述
DOM解析方法
SAX解析方法
DOM和SAX区别

DOM和SAX的不同：
1.DOM是基于内存的，不管文件有多大，都会将所有的内容预先装载到内存中。从而消耗很大的内存空间。而SAX是基于事件的。当某个事件被触发时，才获取相应的XML的部分数据，从而不管XML文件有多大，都只占用了少量的内存空间。
2.DOM可以读取XML也可以向XML文件中插入数据，而SAX却只能对XML进行读取，而不能在文件中插入数据。这也是SAX的一个缺点。
3.SAX的另一个缺点：DOM我们可以指定要访问的元素进行随机访问，而SAX则不行。SAX是从文档开始执行遍历的。并且只能遍历一次。也就是说我们不能随机的访问XML文件，只能从头到尾的将XML文件遍历一次（当然也可以中间截断遍历）。（由第一点不同决定，因为DOM会把XML文件全部存到内存后再解析）

DOM解析	SAX解析
原理：一次性加载xml文档，不适合大容量的文件读取	原理：加载一点，读取一点，处理一点。适合大容量文件的读取
DOM解析可以任意进行增删改成	SAX解析只能读取
DOM解析任意读取任何位置的数据，甚至往回读	SAX解析只能从上往下，按顺序读取，不能往回读
DOM解析面向对象的编程方法（Node，Element，Attribute）,Java开发者编码比较简单。	SAX解析基于事件的编程方法。java开发编码相对复杂。

HTML和XML的区别

HTML

名称： HyperText Markup Languae（超文本标记语言）
标签：标签是w3c组成指定，固定的，约100来个
作用：负责网页的结构

XML
名称： Extend Markup Languge（可扩展标签语言）
标签：标签由开发者自己制定的（要按照一定的语法定义）
作用：
1）描述带关系的数据（作为软件的配置文件）: 包含与被包含的关系

properties文件： key-value name=eric password=123456

<user>
<name>eric</name>                                                                   <password>123456</password>
</user>

场景： tomcat struts Hibernate spring （三大框架）

2）作为数据的载体（存储数据，小型的“数据库”）

<teacher>   
<name>张三</name>                             <email>zhangsan@qq.com</email>
<workage>2</workage>
</teacher>

XML语法

属性

语法： <Student name="eric">student</Student>
注意：
1）属性值必须以引号包含，不能省略，也不能单双引号混用！！！
2）一个标签内可以有多个属性，但不能出现重复的属性名！！！

文档声明

语法： <?xml version="1.0" encoding="utf-8"?>

version: xml的版本号
encoding：解析xml文件时查询的码表（解码过程时查询的码表）

XML解析之DOM解析

DOM解析:
1）JAXP （oracle-Sun公司官方）
2）JDOM工具（非官方）
3）Dom4J工具（非官方）
三大框架（默认读取xml的工具就是Dom4j）

DOM解析原理：xml解析器一次性把整个xml文档加载进内存，然后在内存中构建一颗Document的对象树，通过Document对象，得到树上的节点对象，通过节点对象访问（操作）到xml文档的内容。

SAX解析：
1）Sax解析工具（oracle-sun公司官方）

DOM适于解析比较简单的XML而SAX则适于解析较复杂的XML文件。各有各的好。

SAXReader是xml解析。

import java.io.File;

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

/**
 * 第一个Dom4j读取xml文档的例子
 * @author APPle
 *
 */
public class Demo1 {


    public static void main(String[] args) {
        try {
            //1.创建一个xml解析器对象
            SAXReader reader = new SAXReader();
            //2.读取xml文档，返回Document对象
            Document doc = reader.read(new File("./src/contact.xml"));

            System.out.println(doc);
        } catch (DocumentException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }       
    }
}

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.junit.Test;

/**
 * 第二个dom4j读取xml文件内容
 * 节点
 * 标签
 * 属性
 * 文本
 * @author APPle
 *
 */
public class Demo2 {

    /**
     * 得到节点信息
     */
    @Test
    public void test1() throws Exception{
        //1.读取xml文档，返回Document对象
        SAXReader reader = new SAXReader();
        Document doc = reader.read(new File("./src/contact.xml"));

        //2.nodeIterator: 得到当前节点下的所有子节点对象(不包含孙以下的节点)
        Iterator<Node> it = doc.nodeIterator();
        while(it.hasNext()){//判断是否有下一个元素
            Node node = it.next();//取出元素
            String name = node.getName();//得到节点名称
            //System.out.println(name);

            //System.out.println(node.getClass());
            //继续取出其下面的子节点
            //只有标签节点才有子节点
            //判断当前节点是否是标签节点
            if(node instanceof Element){
                Element elem = (Element)node;
                Iterator<Node> it2 = elem.nodeIterator();
                while(it2.hasNext()){
                    Node n2 = it2.next();
                    System.out.println(n2.getName());
                }
            }
        }
    }

    /**
     * 遍历xml文档的所有节点
     * @throws Exception
     */
    @Test
    public void test2() throws Exception{
        //1.读取xml文档，返回Document对象
        SAXReader reader = new SAXReader();
        Document doc = reader.read(new File("./src/contact.xml"));

        //得到根标签
        Element rooElem = doc.getRootElement();

        getChildNodes(rooElem);

    }

    /**
     * 获取 传入的标签下的所有子节点
     * @param elem
     */
    private void getChildNodes(Element elem){
        System.out.println(elem.getName());

        //得到子节点
        Iterator<Node> it = elem.nodeIterator();
        while(it.hasNext()){
            Node node = it.next();

            //1.判断是否是标签节点
            if(node instanceof Element){
                Element el = (Element)node;
                //递归
                getChildNodes(el);
            }
        };
    }

    /**
     * 获取标签
     */
    @Test
    public void test3() throws Exception{
        //1.读取xml文档，返回Document对象
        SAXReader reader = new SAXReader();
        Document doc = reader.read(new File("./src/contact.xml"));

        //2.得到根标签
        Element  rootElem = doc.getRootElement();
        //得到标签名称
        String name = rootElem.getName();
        System.out.println(name);

        //3.得到当前标签下指定名称的第一个子标签
        /*
        Element contactElem = rootElem.element("contact");
        System.out.println(contactElem.getName());
        */

        //4.得到当前标签下指定名称的所有子标签
        /*
        Iterator<Element> it = rootElem.elementIterator("contact");
        while(it.hasNext()){
            Element elem = it.next();
            System.out.println(elem.getName());
        }
        */

        //5.得到当前标签下的的所有子标签
        List<Element> list = rootElem.elements();
        //遍历List的方法
        //1)传统for循环  2）增强for循环 3）迭代器
        /*for(int i=0;i<list.size();i++){
            Element e = list.get(i);
            System.out.println(e.getName());
        }*/

    /*  for(Element e:list){
            System.out.println(e.getName());
        }*/
        /*
        Iterator<Element> it = list.iterator(); 
        while(it.hasNext()){
            Element elem = it.next();
            System.out.println(elem.getName());
        }*/

        //获取更深层次的标签(方法只能一层层地获取)
        Element nameElem = doc.getRootElement().
                    element("contact").element("name");
        System.out.println(nameElem.getName());

    }

    /**
     * 获取属性
     */
    @Test
    public void test4() throws Exception{
        //1.读取xml文档，返回Document对象
        SAXReader reader = new SAXReader();
        Document doc = reader.read(new File("./src/contact.xml"));

        //获取属性：（先获的属性所在的标签对象，然后才能获取属性）
        //1.得到标签对象
        Element contactElem = doc.getRootElement().element("contact");
        //2.得到属性
        //2.1  得到指定名称的属性值
        /*
        String idValue = contactElem.attributeValue("id");
        System.out.println(idValue);
        */

        //2.2 得到指定属性名称的属性对象
        /*Attribute idAttr = contactElem.attribute("id");
        //getName： 属性名称    getValue：属性值
        System.out.println(idAttr.getName() +"=" + idAttr.getValue());*/

        //2.3 得到所有属性对象,返回List集合
        /*List<Attribute> list = contactElem.attributes();
        //遍历属性
        for (Attribute attr : list) {
            System.out.println(attr.getName()+"="+attr.getValue());
        }*/

        //2.4 得到所有属性对象，返回迭代器
        Iterator<Attribute> it = contactElem.attributeIterator();
        while(it.hasNext()){
            Attribute attr = it.next();
            System.out.println(attr.getName()+"="+attr.getValue());
        }

    }

    /**
     * 获取文本
     */
    @Test
    public void test5() throws Exception{
        //1.读取xml文档，返回Document对象
        SAXReader reader = new SAXReader();

        Document doc = reader.read(new File("./src/contact.xml"));


        /**
         * 注意: 空格和换行也是xml的内容
         */
        String content = doc.getRootElement().getText();
        System.out.println(content);


        //获取文本（先获取标签，再获取标签上的文本）
        Element nameELem = 
            doc.getRootElement().element("contact").element("name");
        //1. 得到文本
        String text = nameELem.getText();
        System.out.println(text);

        //2. 得到指定子标签名的文本内容
        String text2 = 
            doc.getRootElement().element("contact").elementText("phone");
        System.out.println(text2);

    }


}

节点：
Iterator Element.nodeIterator(); //获取当前标签节点下的所有子节点

标签：
Element Document.getRootElement(); //获取xml文档的根标签
Element ELement.element(“标签名”) //指定名称的第一个子标签
Iterator Element.elementIterator(“标签名”);// 指定名称的所有子标签
List Element.elements(); //获取所有子标签

属性：
String Element.attributeValue(“属性名”) //获取指定名称的属性值
Attribute Element.attribute(“属性名”)；//获取指定名称的属性对象
Attribute.getName() //获取属性名称
Attibute.getValue() //获取属性值
List< Attribute> Element.attributes(); //获取所有属性对象
Iterator< Attribute> Element.attibuteIterator(); //获取所有属性对象

文本：
Element.getText(); //获取当前标签的文本
Element.elementText(“标签名”) //获取当前标签的指定名称的子标签的文本内容

Dom4j修改xml文档

写出内容到xml文档
XMLWriter writer = new XMLWriter(OutputStream, OutputForamt)
wirter.write(Document);

修改xml文档的API
增加：
DocumentHelper.createDocument() 增加文档
addElement(“名称”) 增加标签
addAttribute(“名称”，“值”) 增加属性
修改：
Attribute.setValue(“值”) 修改属性值
Element.addAtribute(“同名的属性名”,”值”) 修改同名的属性值
Element.setText(“内容”) 修改文本内容
删除
Element.detach(); 删除标签
Attribute.detach(); 删除属性

写出内容到xml文档

import java.io.File;
import java.io.FileOutputStream;

import org.dom4j.Document;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * 第一个写出内容到xml文档
 * @author APPle
 *
 */
public class Demo1 {

    public static void main(String[] args) throws Exception{
        //一、读取或创建一个Document对象
        //读取day07项目的xm文件
        Document doc = new SAXReader().read(new File("./src/contact.xml"));


        //二、修改Document对象内容


        //三、把修改后的Document对象写出到xml文档中
        //指定文件输出的位置
        FileOutputStream out = new FileOutputStream("e:/contact.xml");
        //1.创建写出对象
        XMLWriter writer = new XMLWriter(out);

        //2.写出对象
        writer.write(doc);
        //3.关闭流
        writer.close();
    }

}

讨论写出内容到xml文档的细节

import java.io.File;
import java.io.FileOutputStream;

import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
/**
 * 讨论写出内容到xml文档的细节
 * @author APPle
 *
 */
public class Demo2 {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        Document doc = new SAXReader().read(new File("./src/contact.xml"));
        //指定文件输出的位置
        FileOutputStream out = new FileOutputStream("e:/contact.xml");
        /**
         * 1.指定写出的格式
         */
        OutputFormat format = OutputFormat.createCompactFormat(); //紧凑的格式.去除空格换行.项目上线的时候
        //OutputFormat format = OutputFormat.createPrettyPrint(); //漂亮的格式.有空格和换行.开发调试的时候
        /**
         * 2.指定生成的xml文档的编码
         *    同时影响了xml文档保存时的编码  和  xml文档声明的encoding的编码（xml解析时的编码）
         *    结论： 使用该方法生成的xml文档避免中文乱码问题。
         */
        format.setEncoding("utf-8");


        //1.创建写出对象
        XMLWriter writer = new XMLWriter(out,format);

        //2.写出对象
        writer.write(doc);
        //3.关闭流
        writer.close();
    }

}

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

/**
 * 修改xml内容
 * 增加：文档，标签 ，属性
 * 修改：属性值，文本
 * 删除：标签，属性
 * @author APPle
 *
 */
public class Demo3 {

    /**
     * 增加：文档，标签 ，属性
     */
    @Test
    public void test1() throws Exception{
        /**
         * 1.创建文档
         */
        Document doc = DocumentHelper.createDocument();
        /**
         * 2.增加标签
         */
        Element rootElem = doc.addElement("contactList");
        //doc.addElement("contactList");
        Element contactElem = rootElem.addElement("contact");
        contactElem.addElement("name");
        /**
         * 3.增加属性
         */
        contactElem.addAttribute("id", "001");
        contactElem.addAttribute("name", "eric");

        //把修改后的Document对象写出到xml文档中
        FileOutputStream out = new FileOutputStream("e:/contact.xml");
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
        XMLWriter writer = new XMLWriter(out,format);
        writer.write(doc);
        writer.close();
    }

    /**
     * 修改：属性值，文本
     * @throws Exception
     */
    @Test
    public void test2() throws Exception{
        Document doc = new SAXReader().read(new File("./src/contact.xml"));

        /**
         * 方案一： 修改属性值   1.得到标签对象 2.得到属性对象 3.修改属性值
         */
        //1.1  得到标签对象
        /*
        Element contactElem = doc.getRootElement().element("contact");
        //1.2 得到属性对象
        Attribute idAttr = contactElem.attribute("id");
        //1.3 修改属性值
        idAttr.setValue("003");
        */
        /**
         * 方案二： 修改属性值
         */
        //1.1  得到标签对象
        /*
        Element contactElem = doc.getRootElement().element("contact");
        //1.2 通过增加同名属性的方法，修改属性值
        contactElem.addAttribute("id", "004");
        */

        /**
         * 修改文本 1.得到标签对象 2.修改文本
         */
        Element nameElem = doc.getRootElement().
            element("contact").element("name");
        nameElem.setText("李四");



        FileOutputStream out = new FileOutputStream("e:/contact.xml");
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
        XMLWriter writer = new XMLWriter(out,format);
        writer.write(doc);
        writer.close();
    }


    /**
     * 删除：标签，属性
     * @throws Exception
     */
    @Test
    public void test3() throws Exception{
        Document doc = new SAXReader().read(new File("./src/contact.xml"));

        /**
         * 1.删除标签     1.1 得到标签对象  1.2 删除标签对象    
         */
        // 1.1 得到标签对象
        /*
        Element ageElem = doc.getRootElement().element("contact")
                    .element("age");

        //1.2 删除标签对象
        ageElem.detach();
        //ageElem.getParent().remove(ageElem);
        */
        /**
         * 2.删除属性   2.1得到属性对象  2.2 删除属性
         */
        //2.1得到属性对象
        //得到第二个contact标签
        Element contactElem = (Element)doc.getRootElement().
            elements().get(1);
        //2.2 得到属性对象
        Attribute idAttr = contactElem.attribute("id");
        //2.3 删除属性
        idAttr.detach();
        //idAttr.getParent().remove(idAttr);

        FileOutputStream out = new FileOutputStream("e:/contact.xml");
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
        XMLWriter writer = new XMLWriter(out,format);
        writer.write(doc);
        writer.close();
    }
}

xPath技术

问题：当使用dom4j查询比较深的层次结构的节点（标签，属性，文本），比较麻烦！！！

xPath作用
主要是用于快速获取所需的节点对象。

在dom4j中如何使用xPath技术
1）导入xPath支持jar包。 jaxen-1.1-beta-6.jar
2）使用xpath方法

List<Node>  selectNodes("xpath表达式");   查询多个节点对象

Node       selectSingleNode("xpath表达式");  查询一个节点对象

xPath语法
/ 绝对路径表示从xml的根位置开始或子元素（一个层次结构）
// 相对路径表示不分任何层次结构的选择元素。
* 通配符表示匹配所有元素
[] 条件表示选择什么条件下的元素
@ 属性表示选择属性节点
and 关系表示条件的与关系（等价于&&）
text() 文本表示选择文本内容

/**
         * 需求: 删除id值为2的学生标签
         */
        Document doc = new SAXReader().read(new File("e:/student.xml"));

        //1.查询id为2的学生标签
        //使用xpath技术
        Element stuElem = (Element)doc.selectSingleNode("//Student[@id='2']");

Demo

<?xml version="1.0" encoding="UTF-8"?>
<users>
<user id="001" password="123456" name="eric"/>
<user id="002" password="123456" name="rose"/>
<user id="003" password="123456" name="jack"/>
</users>

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * xpath案例： 模拟用户登录效果
 * @author APPle
 *
 */
public class Demo3 {

    public static void main(String[] args)throws Exception{
        //1.获取用户输入的用户名和密码
        BufferedReader br = 
                new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入用户名：");
        String name = br.readLine();

        System.out.println("请输入密码：");
        String password = br.readLine();

        //2.到“数据库”中查询是否有对应的用户
        //对应的用户：  在user.xml文件中找到一个
           //name属性值为‘用户输入’，且password属性值为‘用户输入’的user标签
        Document doc = new SAXReader().read(new File("./src/user.xml"));
        Element userElem = (Element)doc.selectSingleNode("//user[@name='" +name +"' and @password='"+password+"']");

        if(userElem!=null){
            //登录成功
            System.out.println("登录成功");
        }else{
            //登录失败
            System.out.println("登录失败");
        }
    }

}

XML解析之SAX解析

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
 * SAX处理程序（如何解析xml文档）
 * @author APPle
 *
 */
public class MyDefaultHandler extends DefaultHandler {

    /**
     * 开始文档时调用
     */
    @Override
    public void startDocument() throws SAXException {
        System.out.println("MyDefaultHandler.startDocument()");
    }

    /**
     * 开始标签时调用
     * @param qName: 表示开始标签的标签名
     * @param attributes: 表示开始标签内包含的属性列表
     */
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        System.out.println("MyDefaultHandler.startElement()-->"+qName);
    }

    /**
     * 结束标签时调用
     * @param qName: 结束标签的标签名称
     */
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        System.out.println("MyDefaultHandler.endElement()-->"+qName);
    }

    /**
     * 读到文本内容的时调用
     * @param ch: 表示当前读完的所有文本内容
     * @param start： 表示当前文本内容的开始位置
     * @param length: 表示当前文本内容的长度
     * char[]（                                       张三              20）   100
     *                              98 2   
     */ 
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        //得到当前文本内容
        String content = new String(ch,start,length);
        System.out.println("MyDefaultHandler.characters()-->"+content);
    }

    /**
     * 结束文档时调用
     */
    @Override
    public void endDocument() throws SAXException {
        System.out.println("MyDefaultHandler.endDocument()");
    }

}

import java.io.File;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

/**
 * 第一个SAX读取xml文件程序
 * @author APPle
 *
 */
public class Demo1 {


    public static void main(String[] args) throws Exception{
        //1.创建SAXParser对象
        SAXParser parser = SAXParserFactory.newInstance().newSAXParser();

        //2.调用parse方法
        /**
         * 参数一： xml文档
         * 参数二： DefaultHandler的子类
         */
        parser.parse(new File("./src/contact.xml"), new MyDefaultHandler());
    }

}

Demo2

import org.xml.sax.helpers.DefaultHandler;
/**
 * SAX处理器程序
 * @author APPle
 */
public class MyDefaultHandler2 extends DefaultHandler {
    //存储xml文档信息
    private StringBuffer sb = new StringBuffer();

    //获取xml信息
    public String getContent(){
        return sb.toString();
    }


    /**
     * 开始标签
     */
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        sb.append("<"+qName);
        //判断是否有属性
        if(attributes!=null){
            for(int i=0;i<attributes.getLength();i++){
                //得到属性名称
                String attrName = attributes.getQName(i);
                //得到属性值
                String attrValue = attributes.getValue(i);
                sb.append(" "+attrName+"=\""+attrValue+"\"");
            }
        }
        sb.append(">");
    }

    /**
     * 文本内容
     */
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        //得到当前读取的文本
        String content = new String(ch,start,length);
        sb.append(content);
    }

    /**
     * 结束标签
     */
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        sb.append("</"+qName+">");
    }
}

public class Demo2 {

    public static void main(String[] args)throws Exception {
        //1.创建SAXParser
        SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
        //2.读取xml文件
        MyDefaultHandler2 handler = new MyDefaultHandler2();
        parser.parse(new File("./src/contact.xml"), handler);
        String content = handler.getContent();
        System.out.println(content);
    }

}

Demo3

public class MyDefaultHandler3 extends DefaultHandler {
    //存储所有联系人对象
    private List<Contact> list = new ArrayList<Contact>();

    public List<Contact> getList(){
        return list;
    }
    //保存一个联系人信息
    private Contact contact;
    /**
     * 思路： 
     *  1）创建Contact对象
     *  2）把每个contact标签内容存入到Contact对象
     *  3）把Contact对象放入List中
     */
    //用于临时存储当前读到的标签名
    private String curTag;

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        curTag = qName;
        //读取到contact的开始标签创建Contact对象
        if("contact".equals(qName)){
            contact = new Contact();

            //设置id值
            contact.setId(attributes.getValue("id"));
        }
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        //当前文本内容
        String content = new String(ch,start,length);

        if("name".equals(curTag)){
            contact.setName(content);
        }

        if("age".equals(curTag)){
            contact.setAge(content);
        }

        if("phone".equals(curTag)){
            contact.setPhone(content);
        }

        if("email".equals(curTag)){
            contact.setEmail(content);
        }

        if("qq".equals(curTag)){
            contact.setQq(content);
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        //设置空是为了避免空格换行设置到对象的属性中
        curTag = null;
        //读到contact的结束标签放入List中
        if("contact".equals(qName)){
            list.add(contact);
        }
    }
}