• XML 的解析方式有两种方式: DOM 解析和 SAX 解析.
• DOM 解析: 根据 XML 的层级结构, 在内存中分配一个树形结构, 把 XML 的标签, 属性和文本都封装成对象.
  • 优点: 可以实现增删改查操作
  • 弊端: 如果文件过大, 容易造成内存溢出
• SAX 解析: 采用事件驱动, 边读边解析. 从上到下, 一行一行的解析, 解析到某一个对象, 把对象返回.
  • 优点: 可以方便的实现查询
  • 不能实现增删改操作
• XML 解析器
  • jaxp 解析器, 由 SUN 公司提供的针对 dom 和 sax 的解析器
  • dom4j 解析器, 由 dom4j 组织提供的针对 dom 和 sax 的解析器

jaxp 解析器

• jaxp 解析器在 JDK 的 javax.xml.parsers 包里面
• DOM 解析使用到的类:
  • DocumentBuilder : 解析器类
  • DocumentBuildreFactory : 解析器工厂类
• SAX 解析使用到的类:
  • SAXParser : 解析器类
  • SAXParserFactory : 解析器工厂

jaxp 解析器的 DOM 方式解析 xml 文件

1. DocumentBuilder 解析器类
   • 该解析器类是一个抽象类, 不能 new. 此类的实例可以从 DocumentBuilderFactory.newDocumentBuilder() 方法获取.
   • 解析 xml 文档, 使用解析器类中的 parse("xml 路径");方法, 返回的是 Document 对象, 其父接口为 Node
   • Document 对象中的方法:
     • getElementsByTagName(String tagname); : 获取标签, 返回的是 NodeList 集合
     • createElement(String tagName); : 创建标签
     • createTextNode(String data); : 创建文本
     • appendChild(Node newChild); : 将文本添加到标签下面
2. DocumentBuilderFactory 解析器工厂
   • 该解析器工厂也是一个抽象类, 不能直接 new. 以 DocumentBuilderFactory.newInstance() 获取对应的实例.
3. 使用 jaxp 解析器实现对 xml 文档的增删改查

// 示例:

// xml 文件

<?xml version="1.0" encoding="gbk"?>

<person>

    <p1>

        <name>zhangsan</name>

        <age>20</age>

    </p1>

    <p1>

        <name>lisi</name>

        <age>32</age>

    </p1>

</person>

// 查询: 查询 xml 文件中所有的 name 元素的值

    /*

     * 思路:

     *    1. 创建解析器工厂

     *    2. 根据解析器工厂创建解析器

     *    3. 解析 xml 返回 document, 需要导包, org.w3c.dom.Document

     *    4. 使用 document 对象中的 getElementsByTagName() 方法, 获取 NodeList 集合

     *    5. 遍历集合, 获取每一个 name 对应的值

     */

    public class TestJaxp {

        public static void main(String[] args){

            // 1. 创建解析器工厂

            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();

            // 2. 根据解析器工厂创建解析器

            DocumentBuilder builder = builderFactory.newDocumentBuilder();

            // 3. 解析 xml 文档

            Document document = builder.parser("src/person.xml");

            // 4. 得到 name 元素

            NodeList list = document.getElementsByTagName("name");

            // 5. 遍历集合, 得到每一个 name 元素, NodeList 接口位于 org.w3c.dom 包下

            for(int i=0; i<list.getLength(); i++){

                Node name1 = list.item(i);

                // 得到 name 元素里面的值

                String s = name1.getTextContent();

                System.out.println("name:"+s);

            }

        }

    }

// 添加: 在第一个 p1 下面添加 <sex>male</sex>

    /*

     * 思路:

     *    1. 创建解析器工厂

     *    2. 根据解析器工厂创建解析器

     *    3. 解析 xml 文档返回 document

     *    4. 获取第一个 p1 元素

     *    5. 创建 sex 标签, createElement

     *    6. 创建文本 "male", createTextNode

     *    7. 把文本添加到 sex 下面, appendChild()

     *    8. 把 sex 添加到第一个 p1 下面

     *

     *

     *    9. 回写 xml 文档(将内存中的数据写入到硬盘中)

     *        9.1 创建 TransformerFactory 工厂

     *        9.2 创建 Transformer 类

     *        9.3 回写

     */

     public class TestJaxp{

        public static void main(String[] args){

            // 1. 创建解析器工厂

            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();

            // 2. 创建解析器

            DocumentBuilder builder = builderFactory.newDocumentBuilder();

            // 3. 解析 xml 文档

            Document document = builder.parse("src/person.xml");

            // 4. 获取所有 p1 元素

            NodeList list = document.getElementsByTagName("p1");

            // 5. 获取第一个 p1 元素

            Node p1 = list.item(0);

            // 6. 创建 sex 标签

            Element sex1 = document.createElement("sex");

            // 7. 创建 "male" 文本

            TextNode text1 = document.createTextNode("male");

            // 8. 将文本添加到 sex 标签下, 没有返回值

            sex1.appendChild(text1);

            // 9. 将 sex 标签添加到 p1 下面

            p1.appendChild(sex1);

            // 10. 回写 xml

            // 创建 TransformerFactory 工厂

            TransformerFactory transformerFactory = TransformerFactory.newInstance();

            // 得到 Transformer 类

            Transformer transformer = transformerFactory.newTransformer();

            // 回写

            //  transform(Source xmlSource, Result outputTarget);

            // Source 是接口, DOMSource 是其中的一个实现类.

            // Result 也是接口, StreamResult 是其中的一个实现类

            transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));

        }

    }

// 升级版, 把获取 document 对象封装成方法,

// 只要对 xml 文档进行增删改操作, 都需要回写 xml , 因此回写 xml 也封装成一个方法

public class JaxpUtils{

    // 返回 document 对象

    public static Document getDocument(String path){

        // 有异常需要 try/catch

        try{

            // 1. 创建解析器工厂

            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();

            // 2. 根据解析器工厂创建解析器

            DocumentBuilder builder = builderFactory.newDocumentBuilder();

            // 3. 解析 xml 文档,获取 document 对象

            Document document = builder.parser(path);

            // 4. 将结果返回

            return document;

        } catch (Exception e){

            e.printStackTrace();

        }

        // 如果出现异常, 返回 null

        return null;

    }

    // 回写 xml 操作

    public static void xmlTransform(Document document, String path){

        try{

            // 1. 创建 TransformerFactory 工厂

            TransformerFactory transformerFactory = TransformerFactor.newInstance();

            // 2. 得到 Transformer 类

            Transformer transformer = transformerFactory.newTransformer();

            // 3. 使用 transform 方法进行回写

            transformer.transform(new DOMSource(document), new StreamResult(path));

        } catch(Exception e){

            e.printStackTrace();

        }

    }

}

// 删除: 删除 p1 下面的 <sex>male</sex>

public void remSex(){

    // 1. 获取 document 对象

    Document document = JaxpUtils.getDocument("src/person.xml");

    // 2. 获取 sex 标签

    NodeList list = document.getElementsByTagName("sex")

    Node sex1 = list.item(0);

    // 3. 使用 sex 的父节点并删除 sex,

    //    获取父节点, 使用 getParentNode 方法

    sex1.getParentNode.removeChild(sex1);

    // 4. 回写 xml

    JaxpUtils.xmlTransform(document,"src/person.xml");

}

// 使用 jaxp 遍历节点, 也就是把 xml 中的所有元素名称打印出来

    /*

     * 思路: 使用递归实现遍历

     *    1. 得到根节点

     *    2. 得到根节点的子节点

     *    3. 得到根节点的子节点的子节点

     */

     public static void listElement(String path) throws Exception{

        // 1. 获取 document 对象

        Document document = JaxpUtils.getDocument("src/person.xml");

        // 2. 编写一个方法实现遍历

        list2(document);

    }

    // 因为 Node 是 Document 的父接口

    // list(Document document) 升级为 list(Node node)

    public static void list2(Node node){

        // 判断是否是元素, 如果是, 就输出

        // 如果不判断, 会把空格和换行当成内容也打印出来

        if(node.getNodeType() == Node.ELEMENT_NODE){

            System.out.println(node.getNodeName);

        }

        // 得到第一层子节点

        NodeList list = node.getChildNodes();

        // 遍历 list

        for(int i=0; i<list.getLength(); i++){

            // 得到每一个节点

            Node node2 = list.item(i);

            // 递归

            list2(node2);

        }

    }

jaxp 解析器的 SAX 方式解析 xml 文件

1. SAX 方式解析 xml 文档, 只能实现对文档的查询操作,不能实现增删改操作.
2. SAXParser 解析器
   • 该解析器的实例通过 SAXParserFactory.newSAXParser() 方法获得
   • 解析 xml 文档, 使用解析器类中的 parse(String uri, DefaultHandler dh);方法, 返回值为 void
   • String uri : xml 文档的路径
   • DefaultHandler dh: 事件处理器, 相当于在 parse() 方法上绑定了一个事件
3. SAXParserFactory 解析器工厂
   • 通过 newInstance() 方法获得
4. 使用 jaxp 的 SAX 方式解析 xml 文档

// DefaultHandler 说明

    // 1. DefaultHandler 中有三个方法: startElement, characters, endElement

    // 2. 当解析到开始标签时, 自动执行 startElement 方法,

    // 3. 当解析到文本内容时, 自动执行 characters 方法

    // 4. 当解析到标签结束时, 自动执行 endElement 方法

// 示例:

// xml 文件

<?xml version="1.0" encoding="gbk"?>

<person>

    <p1>

        <name>zhangsan</name>

        <age>20</age>

    </p1>

    <p1>

        <name>lisi</name>

        <age>32</age>

    </p1>

</person>

// 需求一: 打印 xml 文档中所有元素

    /*

     * 思路:

     *    1. 创建解析器工厂

     *    2. 创建解析器

     *    3. 执行 parse 方法

     *

     *    4. 自己创建一个类, 继承 DefaultHandler

     *    5. 重写类里面的三个方法

     * /

    public class TestJaxp{

         public static void main(String[] args){

            // 1. 创建解析器工厂

            SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();

            // 2. 创建解析器

            SAXParser saxParser = saxParserFactory.newSAXParser();

            // 3. 执行 parse 方法, 并传入自定义的事件处理器

            saxParser.parse("src/person.xml", new MyDefault2());

        }

    }

    // 打印整个文档的事件处理器

    class MyDefault2 extends DefaultHandler{

        // 重写 startElement

        public void startElement(String uri, String localName, String qname,

                Attributes attributes) throws SAXException{

                System.out.print("<"+qName+"/>");  // qName 表示的是标签名, 此处输出的是开始标签

            }

        // 重写 characters 方法

        public void characters(char[] ch, int start, int length) throws SAXException{

            System.out.print(new String(ch,start,length));  // 打印元素中的文本

        }

        // 重写 endElement 方法

        public void endElement(String uri, String localName, String qName) throws SAXException{

            System.out.print("</"+qName+">");   // qName 表示的是标签名, 此处输出的是结束标签

        }

    }

    // 获取所有的 name 元素的值, 事件处理器

    class MyDefault3 extends DefaultHandler{

        // 定义变量

        boolean flag = false;

        // 重写 startElement

        public void startElement(String uri, String localName, String qname,

                Attributes attributes) throws SAXException{

                // 判断 qName 是否是 name 元素

                if("name".equals(qName)){

                    flag = true;

                }

            }

        // 重写 characters 方法

        public void characters(char[] ch, int start, int length) throws SAXException{

            // 如果 flag 值是 true 的时候, 表示解析到的是 name 元素

            if(flag){

                System.out.println(new String(ch,start,length));

            }

        }

        // 重写 endElement 方法

        public void endElement(String uri, String localName, String qName) throws SAXException{

            // 重置 flag 标记, 表示 name 元素读取结束

            if("name".equals(qName)){

                flag = false;

            }

        }

    }

    // 获取第一个 name 元素中的值

    class MyDefault3 extends DefaultHandler{

        // 定义变量

        boolean flag = false;

        int count=1;

        // 重写 startElement

        public void startElement(String uri, String localName, String qname,

                Attributes attributes) throws SAXException{

                // 判断 qName 是否是 name 元素

                if("name".equals(qName)){

                    flag = true;

                }

            }

        // 重写 characters 方法

        public void characters(char[] ch, int start, int length) throws SAXException{

            // 如果 flag 值是 true 的时候, 表示解析到的是 name 元素

            if(flag && count == 1){

                System.out.println(new String(ch,start,length));

            }

        }

        // 重写 endElement 方法

        public void endElement(String uri, String localName, String qName) throws SAXException{

            // 重置 flag 标记, 表示 name 元素读取结束

            if("name".equals(qName)){

                flag = false;

                count++;

            }

        }

    }

参考资料:

• JavaWeb 视频教程
• jaxp API 文档

最新文章

1. selenium ide脚本回放出现element not found
2. android editText 监听事件
3. [转]使用Sencha Ext JS 6打造通用应用程序
4. iOS学习笔记---C语言第三天
5. C标签
6. [转]PHP100视频教程（2012-2013版）下载地址及密码
7. 通过Unity依赖注入
8. [拾 得] 一枚迷人的贝壳 SHELL / Linux | shell 脚本初步入门
9. R语言常用函数：交集intersect、并集union、找不同setdiff、判断相同setequal
10. PLSQL安装教程，无需oracle客户端（解决本地需要安装oracle客户端的烦恼）
11. zeromq学习记录(六)C语言示例
12. LeetCode--371--两整数之和
13. 使用SpringBoot集成ActiveMQ
14. SQLServer中利用NTILE函数对数据进行分组的一点使用
15. 8K - 圆桌会议
16. C语言复习---迭代法，牛顿迭代法，二分法求根
17. 丑女贝蒂第一至四季/全集Ugly Betty迅雷下载
18. Curl操作Elasticsearch的常用方法
19. 01: Centos7 常用命令
20. asp.net core 发布到docker 极简步骤

热门文章

1. apache与和mysql重启命令
2. c#动态类型
3. PCIe to AXI Translation——PCIe 内存空间到AXI内存空间的转换
4. [elk]elasticsearch5.0及head插件安装
5. 关于Qt半自动内存管理的思考及实验
6. HDU 1978 How many ways DP问题
7. JS根据时间内容分组代码
8. 您的位置：首页 » IOS » iOS中全局悬浮按钮，类似IPhone中的AssistiveTouch iOS中全局悬浮按钮，类似IPhone中的AssistiveTouch
9. CC1101 433无线模块,STM8串口透传
10. SPI_FLASH时序描述及驱动编程