XML的解析和基本操作

1、xml的解析的简介
        * xml是标记型文档
        * js使用dom解析标记型文档？
        - 根据html的层级结构，在内存中分配一个树形结构，把html的标签，属性和文本都封装成对象
        - document对象、element对象、属性对象、文本对象、Node节点对象

        * xml的解析方式（技术）：dom 和 sax
        *** dom解析和sax解析区别：
        ** dom方式解析
            * 根据xml的层级结构在内存中分配一个树形结构，把xml的标签，属性和文本都封装成对象
            * 缺点：如果文件过大，造成内存溢出
            * 优点：很方便实现增删改操作

    ** sax方式解析
        * 采用事件驱动，边读边解析
            - 从上到下，一行一行的解析，解析到某一个对象，返回对象名称
        * 缺点：不能实现增删改操作
        * 优点：如果文件过大，不会造成内存溢出，方便实现查询操作

    * 想要解析xml，首先需要解析器
        ** 不同的公司和组织提供了 针对dom和sax方式的解析器，通过api方式提供
        *** sun公司提供了针对dom和sax解析器  jaxp
        *** dom4j组织，针对dom和sax解析器    dom4j（*** 实际开发中****）
        *** jdom组织，针对dom和sax解析器     jdom

2、jaxp的api的查看
    ** jaxp是javase的一部分

    ** jaxp解析器在jdk的javax.xml.parsers包里面
        ** 四个类：分别是针对dom和sax解析使用的类
        *** dom： 
            DocumentBuilder  : 解析器类
                - 这个类是一个抽象类，不能new，
                    此类的实例可以从DocumentBuilderFactory.newDocumentBuilder() 方法获取

                - 一个方法，可以解析xml  parse("xml路径") 返回是 Document 整个文档
                - 返回的document是一个接口，父节点是Node，如果在document里面找不到想要的方法，到Node里面去找

                - 在document里面方法 
                    getElementsByTagName(String tagname) 
                    -- 这个方法可以得到标签
                    -- 返回集合 NodeList

                    createElement(String tagName)
                    -- 创建标签

                    Element getElementById(String elementId) 
                    --返回具有带给定值的 ID 属性的 Element。 

                    createTextNode(String data) 
                    -- 创建文本

                    appendChild(Node newChild) 
                    -- 把文本添加到标签下面

                    removeChild(Node oldChild) 
                    -- 删除节点

                    getParentNode() 
                    -- 获取父节点

                    NodeList list
                    - getLength() 得到集合的长度
                    - item(int index)下标取到具体的值
                    for(int i=0;i<list.getLength();i++) {
                        list.item(i)
                    }

                    getTextContent()
                    - 得到标签里面的内容

            DocumentBuilderFactory： 解析器工厂
                - 这个类也是一个抽象类，不能new
                newInstance() 获取 DocumentBuilderFactory 的实例。

        *** sax：
            SAXParser：解析器类
            SAXParserFactory: 解析器工厂

3、使用jaxp实现查询操作
    *** 查询xml中所有的name元素的值
    * 步骤
    //查询所有name元素的值
/*
 * 1、创建解析器工厂
    DocumentBuilderFactory.newInstance();
 * 2、根据解析器工厂创建解析器
    builderFactory.newDocumentBuilder();
 * 3、解析xml返回document
 *  Document document = builder.parse("src/person.xml");
 * 4、得到所有的name元素
    使用document.getElementsByTagName("name");
 * 5、返回集合，遍历集合，得到每一个name元素
    - 遍历 getLength() item()
    - 得到元素里面值 使用 getTextContent()
 * */

 *** 查询xml中第一个name元素的值
 * 步骤
 /*
     * 1、创建解析器工厂
     * 2、根据解析器工厂创建解析器
     * 3、解析xml，返回document
     * 
     * 4、得到所有name元素
     * 5、使用返回集合，里面方法 item，下标获取具体的元素
        NodeList.item(下标)： 集合下标从0开始
     * 6、得到具体的值，使用 getTextContent方法
     * 
     * */

3、使用jaxp添加节点
    *** 在第一个p1下面（末尾）添加 <sex>nv</sex>
    **步骤
    /*
     * 1、创建解析器工厂
     * 2、根据解析器工厂创建解析器
     * 3、解析xml，返回document
     * 
     * 4、得到第一个p1
     *  - 得到所有p1，使用item方法下标得到

     * 5、创建sex标签 createElement
     * 6、创建文本 createTextNode
     * 7、把文本添加到sex下面 appendChild

     * 8、把sex添加到第一个p1下面　appendChild
     * 
     * 9、回写xml
     * */

4、使用jaxp修改节点
    *** 修改第一个p1下面的sex内容是nan
    ** 步骤
    /*
     * 1、创建解析器工厂
     * 2、根据解析器工厂创建解析器
     * 3、解析xml，返回document 
     * 
     * 4、得到sex item方法
     * 5、修改sex里面的值  
        *** setTextContent方法
     * 
     * 6、回写xml
     * */

5、使用jaxp删除节点
    *** 删除<sex>nan</sex>节点
    ** 步骤
    /*
     * 1、创建解析器工厂
     * 2、根据解析器工厂创建解析器
     * 3、解析xml，返回document 
     * 
     * 4、获取sex元素
     * 5、获取sex的父节点  使用getParentNode方法
     * 6、删除使用父节点删除  removeChild方法
     * 
     * 7、回写xml
     * */

package cn.itcast.jaxptest;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;

/**
 * 实现jaxp操作xml
 * @author asus
 *
 */
public class TestJaxp {

    public static void main(String[] args) throws Exception {
        //selectAll();
        //selectSin();
        //addSex();
        //modifySex();
        //delSex();
        listElement();
    }

    //遍历节点，把所有元素名称打印出来
    public static void listElement() throws Exception {
        /*
         * 1、创建解析器工厂
         * 2、根据解析器工厂创建解析器
         * 3、解析xml，返回document
         * 
         * ====使用递归实现=====
         * 4、得到根节点
         * 5、得到根节点子节点
         * 6、得到根节点子节点的子节点
         * */
        //创建解析器工厂
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //得到document
        Document document = builder.parse("src/person.xml");

        //编写一个方法实现遍历操作
        list1(document);
    }

    //递归遍历的方法
    private static void list1(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 node1 = list.item(i);
            //继续得到node1的子节点
            //node1.getChildNodes()
            list1(node1);
        }
    }

    //删除<sex>nan</sex>节点
    public static void delSex() throws Exception {
        /*
         * 1、创建解析器工厂
         * 2、根据解析器工厂创建解析器
         * 3、解析xml，返回document 
         * 
         * 4、获取sex元素
         * 5、获取sex的父节点 
         * 6、删除使用父节点删除 removeChild方法
         * 
         * 7、回写xml
         * */
        //创建解析器工厂
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //得到document
        Document document = builder.parse("src/person.xml");
        //得到sex元素
        Node sex1 = document.getElementsByTagName("sex").item(0);
        //得到sex1父节点
        Node p1 = sex1.getParentNode();
        //删除操作
        p1.removeChild(sex1);
        //回写xml
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
    }

    //修改第一个p1下面的sex内容是nan
    public static void modifySex() throws Exception {
        /*
         * 1、创建解析器工厂
         * 2、根据解析器工厂创建解析器
         * 3、解析xml，返回document 
         * 
         * 4、得到sex item方法
         * 5、修改sex里面的值  setTextContent方法
         * 
         * 6、回写xml
         * */
        //创建解析器工厂
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //得到document
        Document document = builder.parse("src/person.xml");

        //得到sex
        Node sex1 = document.getElementsByTagName("sex").item(0);
        //修改sex值
        sex1.setTextContent("nan");
        //回写xml
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
    }

    //在第一个p1下面（末尾）添加 <sex>nv</sex>
    public static void addSex() throws Exception {
        /*
         * 1、创建解析器工厂
         * 2、根据解析器工厂创建解析器
         * 3、解析xml，返回document
         * 
         * 4、得到第一个p1
         *  - 得到所有p1，使用item方法下标得到
         * 5、创建sex标签 createElement
         * 6、创建文本 createTextNode
         * 7、把文本添加到sex下面 appendChild
         * 8、把sex添加到第一个p1下面
         * 
         * 9、回写xml
         * */
        //创建解析器工厂
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //得到document
        Document document = builder.parse("src/person.xml");

        //得到所有的p1
        NodeList list = document.getElementsByTagName("p1");
        //得到第一个p1
        Node p1 = list.item(0);
        //创建标签
        Element sex1 = document.createElement("sex");
        //创建文本
        Text text1 = document.createTextNode("nv");
        //把文本添加到sex1下面
        sex1.appendChild(text1);
        //把sex1添加到p1下面
        p1.appendChild(sex1);
        //回写xml
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.transform(new DOMSource(document), new StreamResult("src/person.xml")); 
    }

    //查询xml中第一个name元素的值
    public static void selectSin() throws Exception {
        /*
         * 1、创建解析器工厂
         * 2、根据解析器工厂创建解析器
         * 3、解析xml，返回document
         * 
         * 4、得到所有name元素
         * 5、使用返回集合，里面方法 item，下标获取具体的元素
         * 6、得到具体的值，使用 getTextContent方法
         * 
         * */
        //创建解析器工厂
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //解析xml，得到document
        Document document = builder.parse("src/person.xml");
        //得到所有的name元素
        NodeList list = document.getElementsByTagName("name");
        //使用下标 得到第一个元素
        Node name1 = list.item(1);
        //得到name里面的具体的值
        String s1 = name1.getTextContent();
        System.out.println(s1);
    }

    //查询所有name元素的值
    private static void selectAll() throws Exception {
        //查询所有name元素的值
        /*
         * 1、创建解析器工厂
         * 2、根据解析器工厂创建解析器
         * 3、解析xml返回document
         *  
         * 4、得到所有的name元素
         * 5、返回集合，遍历集合，得到每一个name元素
         * */
        //创建解析器工厂    atl / : 代码提示
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //解析xml返回document
        Document document = builder.parse("src/person.xml");
        //得到name元素
        NodeList list = document.getElementsByTagName("name");
        //遍历集合
        for(int i=0;i<list.getLength();i++) {
            Node name1 = list.item(i); //得到每一个name元素
            //得到name元素里面的值
            String s = name1.getTextContent();
            System.out.println(s);
        }
    }

}

6、使用jaxp遍历节点
    ** 把xml中的所有元素名称打印出来
    ** 步骤
    /*
     * 1、创建解析器工厂
     * 2、根据解析器工厂创建解析器
     * 3、解析xml，返回document
     * 
     * ====使用递归实现=====
     * 4、得到根节点
     * 5、得到根节点子节点
     * 6、得到根节点子节点的子节点
     * */
** 遍历的方法

//递归遍历的方法
    private static void list1(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 node1 = list.item(i);
            //继续得到node1的子节点
            //node1.getChildNodes()
            list1(node1);
        }
    }