《Java核心技术卷II》笔记——（8）XML解析

曾经终败给现在 2023-09-30 10:08 13阅读 0赞

**XML？**

XML（EXtensible Markup Language）,可扩展标记语言;

区别于java.util.Properties，将配置信息保存在“属性文件”中，以便读取和修改；（Properties文件下的属性-描述难以解析，与文本长度/格式有关）

**XML的特点？**

1.  XML与操作系统、编程语言的开发平台都无关【通用的数据交换格式】
2.  实现不同系统之间的数据交换【包括系统的配置文件】
3.  是一种标记语言，没有固定的标记，可以随便发明也可以自己创建
4.  【整个XML是一种树形文件】

**XML有什么用？**

1.  数据交互
2.  配置应用程序和网站
3.  Ajax基石

**XML怎么写（结构是什么样）？**

*  开头 - <?xml version="1.0"?> 【声明部分（位于第一行）；这个是满足xml 1.0标准的】
 *  文档类型定义 - <!DOCTYPE web-app PUBLIC ...>
 *  正文（包括 根元素/其他元素/文本） - <A0> <A1>...</A1> <A0>  
    【底下的都是：文档元素描述信息（文档结构），所有带尖括号的都叫标签，也叫元素，都是用树形文件写出来的】

eg：

<?xml version="1.0" encoding="UTF-8"?>    
    <books>    【根元素，每个XML文件的根元素有且仅有一个】
               【XML中的注释语法：】
        <book id="bk101">     【books的子元素，包含关系的元素要用缩进来体现】
            <author>王珊</author>     【book的子元素】
            <title>.NET高级编程</title>   【就像以前的类和属性】
            <description>包含C#框架和网络编程等</description>
        </book>
        <book id="bk102">    【books的子元素】
            <author>李明明</author>
            <title>XML基础编程</title>
            <description>包含XML基础概念和基本作用</description>
        </book>
    </books>    【根元素</……>是结束的符号】

**XML的语法**：

1.  属性值用双引号包裹，eg:<book id="bk101">
2.  一个元素可以有多个属性（或者叫子元素），eg:book元素下的<author><title><description>
3.  属性值中不能直接包含<、“、&（不建议：‘、>）【最好都不要写】

**XML写法小结**：

1.  XML文档内容由一系列标签元素组成，XML必须正确的嵌套，所有XML元素都必须有结束标签（</……>）;
2.  根元素有且仅有一个;
3.  <元素名 属性名=“属性值”>元素内容</元素名>，同级标签以缩进对齐;
4.  XML标签对大小写敏感;
5.  空元素的方法：  
    <name>（这里是一个空格）</name>  
    <name></name>  
    <name/>
6.  当元素中出现很多特殊字符时，可以使用CDATA节，如：<description><!\[CDATA\[讲解了元素<title>以及</title>的使用\]\]> 等同于：<description><讲解了元素<title>以及</title>的使用> </description>
7.  为解决命名冲突，采取了类似Java包 (com.myStudy.test) 的方式，即“命名空间 namespace”，eg:

<element xmlns:="namespace_URL01" >
        <child xmlns:="namespace_URL02">
        grand_children
        </child>
        more_children ...
    </element>

**元素命名习惯？**

1.  编写的元素名称要有描述性，元素名称可以包含字母、数字或其他的字符，元素名称不能以数字或者标点符号开始(<5name>是错误的)；
2.  名字尽量简短些，可以用下划线“\_”，但是不要用中横线“-”、点“.”或者冒号“:”（<book\_title>）；
3.  数据库怎么命名，XML文件就怎么命名，要保持一致；

**XML解析？**

要处理XML文档，先得要解析(parse)它；解析器：读入一个文件，确认这个文件有正确的格式，然后将其分解成各种元素，然后可以访问这些元素；

Java库提供了两种解析器：**DOM**和**SAX**；

**解析XML的相关技术？**

*  **DOM**

基于XML文档树结构的解析（DOM把XML文档映射成一个倒挂的树，解析成DOM树放内存里）  
适用于多次访问的XML文档  
特点：**比较消耗资源**

**DOM解析XML文件步骤？**

1.  创建解析器工厂对象
2.  解析器工厂对象创建解析器对象
3.  解析器对象指定XML文件创建Document对象
4.  以Document对象为起点操作DOM树

eg：下面的“(读)写XML文件？”中给出了Document对象的使用示例；

*  **SAX**

基于事件的解析,适用于大数据量的XML文档  
特点：*占用资源少，内存消耗小*

*  **DOM4J**（把DOM解析进行了一次封装，应用更多）

非常优秀的Java XML API；  
性能优异、功能强大；  
开放源代码；

**XML与反射？**

eg：web.xml的Servlet配置，读取xml文件，根据名称获取server下的子元素，通过ClassForName反射获取类信息，newInstance得到对象，invoke()调用对象方法；

定义一个接口，有a() b() c()3个方法；将其实现类放在xml的Servlet配置里面（类名、路径）

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://www.example.org/web-app_2_5"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
    version="2.5">
    <servlet>
        <servlet-name>MyServer</servlet-name>
        <servlet-class>com.oracle.demo04.PersonS</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>MyServer</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    </web-app>

//test
    
    @Test
    public void fuc_02() throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, DocumentException {
        //创建解析器
     SAXReader sa = new SAXReader();
     //此处写要读取xml文件的路径
     Document doc = (Document) sa.read("testXML\\xml_01.xml");
     //获取根元素<web-app>
     Element el = doc.getRootElement();
     //获取根元素下的指定的子元素
     Element em = el.element("servlet");
     //获取server下的子元素
     String servletclass = em.elementText("servlet-class");
     //获取后再根据获取到的xml元素来获取字节码对象
     Class c = Class.forName(servletclass);
     //创建一个对象，然后通过字节码对象来过去该类的方法
     Object obj = c.newInstance();
     Method a = c.getMethod("a");
     Method b = c.getMethod("b");
     Method c = c.getMethod("c");
     //调用方法
     a.invoke(obj);
     b.invoke(obj);
     c.invoke(obj);
     //要注意，xml的路径一定要写对，创建doc对象读取的路径也要写对
    }

**(读)写XML文件？**

对XML文件的元素“增删改查”；

eg：XML源文件
    <?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <exam>
        <student examid="111" idcard="123">
        <name>张三</name>
        <location>广州</location>
        <grade>100</grade>
    </student>
    <student examid="444" idcard="333">
        <name>李四</name>
        <location>大连</location>
        <grade>97</grade>
    </student>
    <student examid="1111111" idcard="22222">
        <name>小毛</name>
        <location>广州</location>
        <grade>23.0</grade>
    </student>
    
    <student examid="199" idcard="300">
        <grade>80.0</grade>
        <location>广州</location>
        <name>钟源茂</name>
    </student>
    </exam>

// test 用到getDocument()方法；删除和新增会用到writeXml(Document document)，将内存数据保存至XML；如下所示：

// 获得操作xml文件的Document 对象
    
    private static Document getDocument() throws ParserConfigurationException,
     IOException, org.xml.sax.SAXException {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(new File("testXML\\xml_03.xml"));
        Element e = document.getDocumentElement();
        return document;
    }
    // 将内存中的数据保存到XML文件中
    private static void writeXml(Document document) throws TransformerException {
        DOMSource source = new DOMSource(document);
        StreamResult result = new StreamResult(new File("testXML\\xml_03.xml"));
        TransformerFactory factory = TransformerFactory.newInstance();
        Transformer trans = factory.newTransformer();
        trans.transform(source, result);
    }

1.读XML-查找：获取Doucument对象（绑定XML文件），根据TagName查找获得List元素列表，遍历列表获取各个元素属性来一一匹配目标值，找到后封装属性于返回对象；
    
    public Student fuc_03(String Find_examid) throws IOException, SAXException, ParserConfigurationException {
        Document document = getDocument();
     NodeList list = document.getElementsByTagName("student");
     for (int i = 0; i < list.getLength(); i++) {
            Element element = (Element) list.item(i);
            String value = element.getAttribute("examid");
            if (Find_examid.equals(value)) {//遍历所有节点找到索引examid元素，如果其值value匹配Find_examid，则封装属性到Student对象返回
            Student student = new Student();
            student.setExamid(Find_examid);
            student.setIdcart(element.getAttribute("idcard"));
            student.setName(element.getElementsByTagName("name").item(0).getTextContent());
            student.setLocation(element.getElementsByTagName("location").item(0).getTextContent());
            student.setGrade(element.getElementsByTagName("grade").item(0).getTextContent());
            return student;
            }
        }
        return null;
    }

2.新增：获取Doucument对象（绑定XML文件），document.createElement创建元素与其子元素，setAttribute和setTextContent添加元素属性，appendChild将子元素与父元素"绑定"-将父元素与根元素绑定，writeXml写入XML；
    
    @Test
    public void fuc_04() throws ParserConfigurationException,
     IOException, org.xml.sax.SAXException, TransformerException {
        Student student = new Student("明凯", "4396", "666", "武汉", "99");//test
        Document document = getDocument();//获得document对象
        Element studentNode = document.createElement("student");//新建Element元素对象
        studentNode.setAttribute("idcard", student.getIdcart());//设置“属性”值
        studentNode.setAttribute("examid", student.getExamid());
        Node name = document.createElement("name");//创建3个子Node并赋值
        name.setTextContent(student.getName());
        Node location = document.createElement("location");
        location.setTextContent(student.getLocation());
        Node grade = document.createElement("grade");
        grade.setTextContent(student.getGrade());
        // 将3个子元素添加到当前元素（绑定）
        studentNode.appendChild(name);
        studentNode.appendChild(location);
        studentNode.appendChild(grade);
        // 获取XML文档的根元素，将当前元素添加到其子元素列表中
        Element root = document.getDocumentElement();
        root.appendChild(studentNode);
        writeXml(document); // 将Document写入XML
    }

3.删除，获取Doucument对象（绑定XML文件），查找目标元素node(根1.查找一样)，removeChild()从 “根元素”/其父元素的“父元素” 删除其父元素，writeXml写入XML；
    
    // 如：根据name删除整个元素，即从name找到其“父元素”，从 “根元素”/其父元素的“父元素” 删除其父元素
    
    @Test
    public void fuc_05() throws ParserConfigurationException, IOException, TransformerException, org.xml.sax.SAXException {
        String name = "钟源茂0";
        Document document = getDocument();
        NodeList list = document.getElementsByTagName("name");
        for (int i = 0; i < list.getLength(); i++) {
            Node node = list.item(i);
            if (node.getTextContent().equals(name)) {
                node.getParentNode().getParentNode().removeChild(node.getParentNode());//从当前name元素的父元素的“父元素” 删除其父元素
            }
        }
        writeXml(document);
    }

**XPath定位？**

通过遍历DOM树需要从根节点开始查找节点，XPath可以指定“路径”，让元素/属性的访问变得容易；使用方法类似打开文件的目录一样；可以指定元素/exam/student、元素下的属性/exam/student/name（子元素）、元素列表下的某一个/exam/student\[7\]/name（按照索引）

eg：

// 测试XPath
    @Test
    public void fuc_06() throws ParserConfigurationException, IOException, TransformerException, org.xml.sax.SAXException, XPathExpressionException { 
      XPathFactory xPathFactory = XPathFactory.newInstance();
      XPath path = xPathFactory.newXPath();
      Document document = getDocument();//获得document对象
      NodeList list = (NodeList) (path.evaluate("/exam/student/name", document, XPathConstants.NODESET));//满足指定路径Path的整个列表
      for (int i = 0; i < list.getLength(); i++) {
        System.out.println(list.item(i).getTextContent());
      }
      Node node_01 = (Node) (path.evaluate("/exam/student[1]/name", document, XPathConstants.NODE));//满足指定路径Path的第1个元素（从1开始）
      System.out.println("node_01:"+node_01.getTextContent());
      String node_02 = (String) (path.evaluate("/exam/student[2]/name", document, XPathConstants.STRING));//ke==可以直接转成String/int/boolean...
      System.out.println("node_02:"+node_02);
    }

**流机制解析器？**

DOM会完整的读入XML文档形成一个树形结构；如果文档太大，DOM的效率就不高，这种情况下就可以使用“流机制解析器”在运行时解析节点，如SAX解析器；

得到SAX解析器：  
`SAXParserFactory factory = SAXParserFactory.newInstance();`  
`SAXParser saxParser = factory.newSAXParser();`

处理文档：saxParser.parse(source, handler); source是数据源（文件、URL、输入流）；handler是处理器，为DefaultHandler类的对象（实现startElement方法）；