Java 的XML 解析器--详细说明

迷南。 2022-12-10 03:50 294阅读 0赞

### 1. XML 是什么 ###

**XML:extensiable markup language 被称作可扩展标记语言，是**一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。它被认为是传输标准装置和存储数据，在数据交互还有配置问题方面会比较常用到。

**用途：**

> ①：**配置文件(例子：Tomcat的web.xml,server.xml......)，XML能够非常清晰描述出程序之间的关系**
> 
> ②：**程序间数据的传输，XML的格式是通用的，能够减少交换数据时的复杂性！**
> 
> ③：**充当小型数据库，如果我们的数据有时候需要人工配置的，那么XML充当小型的数据库是个不错的选择，程序直接读取XML文件显然要比读取数据库要快呢！**

**XML的常用解析方式分大致为四种：**

1、DOM解析；2、SAX解析；3、JDOM解析；4、DOM4J解析。前两种属于基础方法，是官方提供的解析方式；后两种是在基础的方法上扩展出来的。

### 2. 两种XML 解析方式 ###

在XML文件中由于更多的是描述信息的内容，所以在得到一个XML文档后用该利用程序按照其中元素的定义名称取出对应的内容，这样的操作就称为XML解析。在XML解析中W3C定义了SAX和DOM两种解析方式，这两种解析方式的程序操作如下：

![a99b1b9b53f1512b3ad8e8ae4989dbd7.png][]

### 1）DOM解析方式 ###

> DOM解析是一个基于对象的API，它把XML的内容加载到内存中，生成与XML文档内容对应的模型！当解析完成，内存中会生成与XML文档的结构与之对应的DOM对象树，这样就能够根据树的结构，以节点的形式对文档进行操作！

简单来说：**DOM解析会把XML文档加载到内存中，生成DOM树的元素都是以对象的形式存在的！我们操作这些对象就能够操作XML文档了！**

**优点：**

> 整个文档树在内存中，便于操作；
> 
> 支持删除、修改、重新排列等多种功能；

**缺点：**

> 将整个文档调入内存（包括无用的节点），浪费时间和空间；【不适合大型文件】

**使用场合：**

> 一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。

**XML文档内容对应的DOM树**

![4d78895cd2c3ac08de84cb7d97d56bfa.png][]

**在DOM解析中有几个核心的操作接口：**

>  *  **Document【代表整个XML文档，通过Document节点可以访问XML文件中所有的元素内容！】**
>  *  **Node【Node节点几乎在XML操作接口中几乎相当于普通Java类的Object，很多核心接口都实现了它，在下面的关系图可以看出！】**
>  *  **NodeList【代表着一个节点的集合，通常是一个节点的子节点的集合！】**
>  *  NameNodeMap【表示一组节点和其唯一名称对应的一一对应关系，主要用于属性节点的表示

DOM 解析树

![Center][]

> 1）Element类：是Node类最主要的子对象，被广泛使用，在元素中可以包含属性，因而Element中有存取其属性的方法。
> 
> 2）Node类：Node对象是DOM中最基本的对象，代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象，而是使用Node对象的子对象Element,Attr,Text等。
> 
> 3）NodeList类：代表了一个包含一个或者多个Node的列表，根据操作可以将其简化的看做为数组。

DOM解析器在解析XML文档时，**会把文档中的所有元素，按照其出现的层次关系，解析成一个个Node对象(节点)** ，节点之间关系可以用DOM树描述

![2022aec14fea98b7d6bf6c54748ced46.png][]

**dom树的节点接口：**

![1ab59e2392fe5353edb85184c58ce911.png][]

**DOM解析步骤：**

> **（1）建立DocumentBuilderFactory：**DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
> **（2）建立DocumentBuilder：**DocumentBuilder builder = factory.newDocumentBuilder();  
> **（3）建立Document：**Document doc= builder.parse("要读取的文件路径");  
> **（4）建立NodeList：**NodeList nl = doc.getElementsByTagName("读取节点");  
> （5）进行XML信息读取。

**使用Dom 获取XML 中的元素：**

**1. 这个方法用来获取XML中节点的数据**。这个方法会返回一个NodeList类型的值 的 节点集合。

NodeList nl=Document.getElementsByTagName("TagName");

**2. 获取到了XML中的节点集合之后**，可以**通过n1.getLength()方法** 来获取集合中的节点个数。

同时可以**用item(index);方法来获取集合当中的节点**，这个方法会返回一个Node类型的值。

Node n=nl.item(index);

**3. 获取到了节点之后**，我们可以通过getAttributes();方法来获取节点的属性值,它会返回一个NameNodeMap类型的集合，里面有节点所有的属性。

NamedNodeMap attrs=book.getAttributes();

4. 然后通过item方法来获取attr中的属性，这个方法会返回一个Node类型的值，我们接收之后就可以通过调用 getNodeName以及getNodeValue两个方法来分别获取属性名以及属性值了。

除了获取节点的的属性之外，我们还可以获取节点的子节点。通过节点的getChildNodes函数，可以返回一个NodeList集合，里面有所有的子节点。

需要注意的是子节点指的是节点中包含的所有数据，包括换行符。**换行符会返回Test的值\#test。**

在实际操作中，可以**使用getNodeType函数来返回子节点的类型，从而来跳过换行符**。

if(getNodeType()==Node.ELEMENT_NODE)

最后使用getNodeName函数可以获取到子节点的名字。

第一种方法. 如果还**需要获得子节点的值，可以使用getTextContent函数**，

第二种方法. 或者是使用**getFirstChild先获取子节点的子节点，再使用getNodeValue函数来获取值**。

**例子：**

<?xml version="1.0" encoding="utf-8"?>
    <books> 
       <book id="001"> 
          <title>Harry Potter</title> 
          <author>J K. Rowling</author> 
       </book> 
       <book id="002"> 
          <title>Learning XML</title> 
          <author>Erik T. Ray</author> 
       </book> 
    </books>

**获取指定 title 里面的属性值：**

**item(i) 是返回到当前的节点**

String value = doc.getElementsByTagName("title").item(i).getFirstChild().getNodeValue();

**获取title 的名：**

String value = doc.getElementsByTagName("title").item(i).getNodeName();

**获取book下的所有的title 和 autor 的 值：**

/**
     * DOM生成与解析XML文档
     */
    public class DomDemo implements XmlDocument {
        private Document document;
        private String fileName;
    
        public void init() {
            try {
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = factory.newDocumentBuilder();
                this.document = builder.newDocument();
            } catch (ParserConfigurationException e) {
                System.out.println(e.getMessage());
            }
        }
    
        public void createXml(String fileName) {
            Element root = this.document.createElement("employees");
            this.document.appendChild(root);
            Element employee = this.document.createElement("employee");
            Element name = this.document.createElement("name");
            name.appendChild(this.document.createTextNode("活这么大就没饱过"));
            employee.appendChild(name);
            Element sex = this.document.createElement("sex");
            sex.appendChild(this.document.createTextNode("m"));
            employee.appendChild(sex);
            Element age = this.document.createElement("age");
            age.appendChild(this.document.createTextNode("24"));
            employee.appendChild(age);
            root.appendChild(employee);
            TransformerFactory tf = TransformerFactory.newInstance();
            try {
                Transformer transformer = tf.newTransformer();
                DOMSource source = new DOMSource(document);
                transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312");
                transformer.setOutputProperty(OutputKeys.INDENT, "yes");
                PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
                StreamResult result = new StreamResult(pw);
                transformer.transform(source, result);
                System.out.println("生成XML文件成功!");
            } catch (TransformerConfigurationException e) {
                System.out.println(e.getMessage());
            } catch (IllegalArgumentException e) {
                System.out.println(e.getMessage());
            } catch (FileNotFoundException e) {
                System.out.println(e.getMessage());
            } catch (TransformerException e) {
                System.out.println(e.getMessage());
            }
        }
    
        public void parserXml(String fileName) {
            try {
                DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                DocumentBuilder db = dbf.newDocumentBuilder();
                Document document = db.parse(fileName);
                NodeList employees = document.getChildNodes();
                for (int i = 0; i < employees.getLength(); i++) {
                    Node employee = employees.item(i);
                    NodeList employeeInfo = employee.getChildNodes();
                    for (int j = 0; j < employeeInfo.getLength(); j++) {
                        Node node = employeeInfo.item(j);
                        NodeList employeeMeta = node.getChildNodes();
                        for (int k = 0; k < employeeMeta.getLength(); k++) {
                            System.out.println(employeeMeta.item(k).getNodeName() + ":" + employeeMeta.item(k).getTextContent());
                        }
                    }
                }
                System.out.println("解析完毕");
            } catch (FileNotFoundException e) {
                System.out.println(e.getMessage());
            } catch (ParserConfigurationException e) {
                System.out.println(e.getMessage());
            } catch (SAXException e) {
                System.out.println(e.getMessage());
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }

如果现在需要将XML文件保存在硬盘上，则需要使用TransformerFactory、Transformer、DOMSource、StreamResult 4个类完成。

TransformerFactory类：取得一个Transformer类的实例对象。DOMSource类：接收Document对象。StreamResult 类：指定要使用的输出流对象（可以向文件输出，也可以向指定的输出流输出）。Transformer类：通过该类完成内容的输出。

**----依据根部节点root，使用递归的方法解析XML下的所有的节点名字和属性----**

package com.java.xlmdemo;
    
    
    
    import org.junit.runners.parameterized.ParametersRunnerFactory;
    import org.w3c.dom.Attr;
    import org.w3c.dom.DOMConfiguration;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.NamedNodeMap;
    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 javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    import org.w3c.dom.Comment;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class DomXmlTest {
    
        public static final String path = "D:\\android\\my_project\\app\\src\\test\\java\\com\\java\\xlmdemo\\test.xml";
    
        //  使用 sax 解析器工厂模式，建立一个对象
    //    SAXParserFactory factory = SAXParserFactory.newInstance();
    //
    //    // 创建一个 sax 解析器
    //    SAXParser saxParser = factory.newSAXParser();
    
    
        // 获取 dom 的根部节点
        private Element getDomRoot(String filePath) throws Exception{
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
    
            Document doc = db.parse(filePath);
            Element root = doc.getDocumentElement();
            System.out.println(root.getNodeName());
            return root;
        }
    
        // 利用 递归方法 打印出所有的节点， 即将所有的xml 读取到内存打印出来
        private static void parseByRecursion(Element root){
            // 获取元素名字
            String tagName = root.getNodeName();
            System.out.print("< " + tagName);
    
            // 获取root 子节点元素列表，可能是 文本
            NodeList children = root.getChildNodes();
    
            // 获取 当前的 root 的全部的元素对象
            NamedNodeMap map = root.getAttributes();
            if (map != null){
                for(int i = 0; i < map.getLength(); i++){
                    // 获取当前元素的每一个属性的 name 和 value值
                    Attr attr = (Attr)map.item(i);
                    String attrName = attr.getName();
                    String attrValue = attr.getValue();
    
    //                System.out.println("-----");
    //                System.out.println(attrName);
    //                System.out.println("------");
    
                    System.out.print(" "+ attrName + " = \"" + attrValue + "\""); // 增加 " " 的表示
                }
            }
            System.out.print(" >");
    
            // 解析 root 的子节点
            for(int i =0; i < children.getLength(); i++){
                Node node = children.item(i);
    
                //获取节点类型
                short nodeType = node.getNodeType();
    
                // 如果节点是元素，则递归
                if (nodeType == Node.ELEMENT_NODE){
                    parseByRecursion((Element)node); // 递归遍历元素
                }
                // 如果是文本文件，则直接打印出来
                else if (nodeType == Node.TEXT_NODE){
                    System.out.print(node.getNodeValue());
                }
                // 如果是注释文件的话
                else if (nodeType == Node.COMMENT_NODE){
                    System.out.print(" ");
                }
            }
            System.out.print(" </ " + tagName + ">");
        }
    
    
        public static void main(String[] args) throws Exception{
            System.out.println("haha -----");
            System.out.println("this is a test");
            DomXmlTest xt = new DomXmlTest();
    //        xt.loopDomXml(path);
    
            Element root = xt.getDomRoot(path);
            parseByRecursion(root);
        }
    }

### 2）SAX解析方式 ###

SAX采用的是一种顺序的模式进行访问，是一种快速读取XML数据的方式。当时候SAX解析器进行操作时，会触发一系列事件SAX。采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分：**解析器和事件处理器**

**sax是一种推式的机制,你创建一个sax 解析器,解析器在发现xml文档中的内容时就告诉你(把事件推给你). 如何处理这些内容，由程序员自己决定。**

当解析器解析到`<?xml version="1.0" encoding="UTF-8" standalone="no"?>`声明头时，会触发事件。解析到`<china>`元素头时也会触发事件！也就是说：**当使用SAX解析器扫描XML文档(也就是Document对象)开始、结束，以及元素的开始、结束时都会触发事件，根据不同事件调用相对应的方法!**

![c5ca464579daab004c75b785a3a04628.png][]

**优点：**

> 不用事先调入整个文档，占用资源少；
> 
> SAX解析器代码比DOM解析器代码小，适于Applet，下载。

**缺点：**

> 不是持久的；事件过后，若没保存数据，那么数据就丢了；
> 
> 无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；

**使用场合：**

> Applet;只需XML文档的少量内容，很少回头访问；机器内存少。

**SAX解析步骤：**

>     使用SAXParserFactory创建SAX解析工厂
>     SAXParserFactory spf = SAXParserFactory.newInstance();
>     通过SAX解析工厂得到解析器对象        
>     SAXParser sp = spf.newSAXParser();
>     通过解析器对象得到一个XML的读取器
>     XMLReader xmlReader = sp.getXMLReader();
>     设置读取器的事件处理器     
>     xmlReader.setContentHandler(new BookParserHandler());
>     解析xml文件 
>     xmlReader.parse("book.xml");

代码：

/**
     * SAX文档解析
     */
    public class SaxDemo implements XmlDocument {
        public void createXml(String fileName) {
            System.out.println("<<" + filename + ">>");
        }
    
        public void parserXml(String fileName) {
            SAXParserFactory saxfac = SAXParserFactory.newInstance();
            try {
                SAXParser saxparser = saxfac.newSAXParser();
                InputStream is = new FileInputStream(fileName);
                saxparser.parse(is, new MySAXHandler());
            } catch (ParserConfigurationException e) {
                e.printStackTrace();
            } catch (SAXException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    class MySAXHandler extends DefaultHandler {
        boolean hasAttribute = false;
        Attributes attributes = null;
    
        public void startDocument() throws SAXException {
            System.out.println("文档开始打印了");
        }
    
        public void endDocument() throws SAXException {
            System.out.println("文档打印结束了");
        }
    
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            if (qName.equals("employees")) {
                return;
            }
            if (qName.equals("employee")) {
                System.out.println(qName);
            }
            if (attributes.getLength() > 0) {
                this.attributes = attributes;
                this.hasAttribute = true;
            }
        }
    
        public void endElement(String uri, String localName, String qName) throws SAXException {
            if (hasAttribute && (attributes != null)) {
                for (int i = 0; i < attributes.getLength(); i++) {
                    System.out.println(attributes.getQName(0) + attributes.getValue(0));
                }
            }
        }
    
        public void characters(char[] ch, int start, int length) throws SAXException {
            System.out.println(new String(ch, start, length));
        }
    }

**DOM解析和SAX解析的区别：**

DOM解析适合于对文件进行修改和随机存取的操作，但是不适合于大型文件的操作。

SAX采用部分读取的方式，所以可以处理大型文件，而且只需要从文件中读取特定内容。SAX解析可以由用户自己建立自己的对象模型。

![a4b09c47a652f09afd2e503fc6b24eb2.png][]

### 3. 存在的解析包 ###

XML解析的好帮手：jdom  
jdom是使用Java编写的，用于读、写、操作XML的一套组件。  
**jdom = dom 修改文件的有点 + SAX读取快速的优点**

JDOM生成和解析XML 为减少DOM、SAX的编码量，出现了JDOM；优点：20-80原则，极大减少了代码量。使用场合：要实现的功能简单，如解析、创建等，但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。

![aecebb5907149e8dcbb94f3773659334.png][]

/**
     * JDOM 生成与解析XML文档  *
     */
    public class JDomDemo implements XmlDocument {
        public void createXml(String fileName) {
            Document document;
            Element root;
            root = new Element("employees");
            document = new Document(root);
            Element employee = new Element("employee");
            root.addContent(employee);
            Element name = new Element("name");
            name.setText("活这么大就没饱过");
            employee.addContent(name);
            Element sex = new Element("sex");
            sex.setText("m");
            employee.addContent(sex);
            Element age = new Element("age");
            age.setText("24");
            employee.addContent(age);
            XMLOutputter XMLOut = new XMLOutputter();
            try {
                XMLOut.output(document, new FileOutputStream(fileName));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public void parserXml(String fileName) {
            SAXBuilder builder = new SAXBuilder(false);
            try {
                Document document = builder.build(fileName);
                Element employees = document.getRootElement();
                List employeeList = employees.getChildren("employee");
                for (int i = 0; Element employee = (Element) employeeList.get(i);
                List employeeInfo = employee.getChildren();
                for (int j = 0; System.out.println(((Element) employeeInfo.get(j)).getName() + ":" + ((Element) employeeInfo.get(j)).getValue());
            } catch (JDOMException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

**2.4、解析工具：dom4j**  
dom4j也是一组XML操作组件包，主要用来读写XML文件，由于dom4j性能优异、功能强大，且具有易用性，所以现在已经被广泛地应用开来。如，Hibernate、Spring框架中都使用了dom4j进行XML的解析操作。开发时需要引入的jar包：dom4j-1.6.1.jar、lib/jaxen-1.1-beta-6.jar

DOM4J生成和解析XML文档DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

![89532c29319b2fd1d3ec1a582a986f0b.png][]

/**
     * Dom4j 生成XML文档与解析XML文档
     */
    public class Dom4jDemo implements XmlDocument {
        public void createXml(String fileName) {
            Document document = DocumentHelper.createDocument();
            Element employees = document.addElement("employees");
            Element employee = employees.addElement("employee");
            Element name = employee.addElement("name");
            name.setText("活这么大就没饱过");
            Element sex = employee.addElement("sex");
            sex.setText("m");
            Element age = employee.addElement("age");
            age.setText("24");
            try {
                Writer fileWriter = new FileWriter(fileName);
                XMLWriter xmlWriter = new XMLWriter(fileWriter);
                xmlWriter.write(document);
                xmlWriter.close();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    
        public void parserXml(String fileName) {
            File inputXml = new File(fileName);
            SAXReader saxReader = new SAXReader();
            try {
                Document document = saxReader.read(inputXml);
                Element employees = document.getRootElement();
                for (Iterator i = employees.elementIterator(); i.hasNext(); ) {
                    Element employee = (Element) i.next();
                    for (Iterator j = employee.elementIterator(); j.hasNext(); ) {
                        Element node = (Element) j.next();
                        System.out.println(node.getName() + ":" + node.getText());
                    }
                }
            } catch (DocumentException e) {
                System.out.println(e.getMessage());
            }
            System.out.println("dom4j parserXml");
        }
    }

[a99b1b9b53f1512b3ad8e8ae4989dbd7.png]: /images/20221123/8e4a6868412740f982c2ac37cfe7624d.png
[4d78895cd2c3ac08de84cb7d97d56bfa.png]: /images/20221123/1ea5a26d37bc4fd491ede01c01be3489.png
[Center]: /images/20221123/09b22c1fbd104ed2acb61b7d66352e99.png
[2022aec14fea98b7d6bf6c54748ced46.png]: /images/20221123/6c49fe08dd994a42b53b200a8bf073e2.png
[1ab59e2392fe5353edb85184c58ce911.png]: /images/20221123/5d2a7858f1034d168c9ab55e13df2124.png
[c5ca464579daab004c75b785a3a04628.png]: /images/20221123/a300543c25fb4633be391e14bb20880c.png
[a4b09c47a652f09afd2e503fc6b24eb2.png]: /images/20221123/0248bbdfafa34e048672edf76c7ec307.png
[aecebb5907149e8dcbb94f3773659334.png]: /images/20221123/2928054367b44f7faf860bd085a605da.png
[89532c29319b2fd1d3ec1a582a986f0b.png]: /images/20221123/59ddcb1af2264b36b703eed208cf455f.png