Java读取XML文件

使用Java读取XML文件有四种方式：

1. DOM
2. SAX
3. JDOM
4. DOM4j

book.xml文件内容： 

<?xml version="1.0" encoding="UTF-8"?>
<书架>
    <书>
        <书名 编号="a_1">JavaWeb程序开发入门</书名>
        <作者 分类="AA">传智播客</作者>
        <售价 单位="元">60</售价>
    </书>
    <书>
        <书名 编号="a_2">JavaWeb从入门到精通</书名>
        <作者 分类="BB">明日科技</作者>
        <售价>80</售价>
    </书>
    <书>
        <书名 编号="a_3">计算机文化基础</书名>
        <作者 分类="CC">山东商务</作者>
        <售价>40</售价>
    </书>
</书架>

1.DOM

DOM 解析 XML 的步骤：

1) 创建一个 DocumentBuilderFactory 的对象。

2) 创建一个 DocumentBuilder 对象。

3) 通过DocumentBuilder的parse(...)方法得到Document对象。

4) 通过 getElementsByTagName(...)方法获取到节点的列表。

5) 通过 for 循环遍历每一个节点。

6) 得到每个节点的属性和属性值。

7) 得到每个节点的节点名和节点值。  

　　NodeType解释：

　　Node（节点）是DOM层次结构中的任何类型的对象的通用名称，Node有很多类型，如元素节点，属性节点，文本节点，注释节点等，通过NodeType区分，常见的有：

节点类型	NodeType
元素element	1
属性attribute	2
文本text	3
注释comment	8
文档document	9

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


public class DomXmlDemo {

    // 用Element方式
    public static void element(NodeList list) {
        for (int i = 0; i < list.getLength(); i++) {
            Element element = (Element) list.item(i);
            NodeList childNodes = element.getChildNodes();
            for (int j = 0; j < childNodes.getLength(); j++) {
                if (childNodes.item(j).getNodeType() == Node.ELEMENT_NODE) {
                    // 获取节点
                    System.out.print(childNodes.item(j).getNodeName() + ":");
                    // 获取节点值
                    System.out.println(childNodes.item(j).getFirstChild().getNodeValue());
                }
            }
        }
    }

    // 用Node方式
    public static void node(NodeList list) {
        for (int i = 0; i < list.getLength(); i++) {
            Node node = list.item(i);
            NodeList childNodes = node.getChildNodes();
            for (int j = 0; j < childNodes.getLength(); j++) {
                if (childNodes.item(j).getNodeType() == Node.ELEMENT_NODE) {
                    System.out.print(childNodes.item(j).getNodeName() + ":");
                    System.out.println(childNodes.item(j).getFirstChild().getNodeValue());
                }
            }
        }
    }

    public static void main(String[] args) {
        // 1.创建DocumentBuilderFactory对象
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        // 2.创建DocumentBuilder对象
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document d = builder.parse("src/book.xml");
            NodeList sList = d.getElementsByTagName("书");
            element(sList);// Element方式
            // node(sList);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

 2.SAX 

SAX 方式解析：以事件驱动的XML API，边扫描边解析，解析速度快占用内存少（逐行解析）。

SAX 解析 XML 的步骤：

1) 创建 SAXParserFactory 的对象。

2) 创建 SAXParser 对象（解析器）。

3) 创建一个 DefaultHandler 的子类，并且重写里面的方法。

4) 调用 parse 方法，传入DefaultHandler的子类对象。

DefaultHandler类解释：

在DefaultHandler中有几个比较重要的方法。

1. public void startDocument() throws SAXException

第一个执行方法。

2. public void startElement(String uri, String localName, String qName,   Attributes attributes) throws SAXException

该方法是继第一个方法后第二个执行方法。

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

这个是继startElement方法后的执行方法。

该方法中的ch把所解析的xml的所有数据都保存进来，且ch初始化为2K数据。start是一个节点">"的位置。length就是">"到下一个"<"的长度。

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

若一个节点，比如<name>michael</name>，在执行完characters后会执行该方法。如果节点，比如<names><name>michael</name></names>在执行names节点时，不会执行到该方法。

5. public void endDocument() throws SAXException

最后一个执行方法。

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

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SaxXmlDemo {

    public static void main(String[] args) throws Exception {
        // 1.获取SAXParserFactory实例
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 2.获取SAXparser实例
        SAXParser saxParser = factory.newSAXParser();
        // 3.创建DefaultHandler的子类对象
        SAXDemoHandler handler = new SAXDemoHandler();
        // 4.调用parse()方法，传入DefaultHandler的子类对象
        saxParser.parse("src/book.xml", handler);
    }
}

class SAXDemoHandler extends DefaultHandler {
    // 遍历xml文件开始标签
    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
        System.out.println("sax解析开始");
    }

    // 遍历xml文件结束标签
    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
        System.out.println("sax解析结束");
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        super.startElement(uri, localName, qName, attributes);
        if (qName.equals("书")) {
            System.out.println("============开始遍历=============");
        } else if (!qName.equals("书") && !qName.equals("书架")) {
            System.out.print("节点名称:" + qName); // 输出节点名称
            for (int i = 0; i < attributes.getLength(); i++) {
                System.out.print("， 属性：" + attributes.getQName(i) + "=" + attributes.getValue(i));
            }
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
        if (qName.equals("书")) {
            System.out.println(qName + "：遍历结束");
            System.out.println("============结束遍历============");
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
        String value = new String(ch, start, length).trim();
        if (!value.equals("")) {
            System.out.println("， 节点内容:" + value); // 输出节点内容
        }
    }
}

运行结果：

 

3.JDOM

JDOM 解析：是一种解析XML的JAVA工具包，是基于树形结构，利用纯JAVA技术对XML文档实现解析，只适用于JAVA语言。

JDOM解析XML的步骤：

1) 创建一个 SAXBuilder 对象。

2) 调用 build 方法，得到 Document 对象（通过 IO 流）。

3) 获取根节点。

4) 获取根节点的直接子节点的集合。

5) 遍历集合。

 到 http://www.jdom.org/downloads/index.html 下载jar包，有1.1.3和2.0.6两个，我们下载，复制到项目的lib目录中，右键添加的Build Path中。

 

  

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.List;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;

public class JdomXmlDemo {

    public static void main(String[] args) throws Exception {
        // 1.创建SAXBuilder对象
        SAXBuilder saxBuilder = new SAXBuilder();
        // 2.创建输入流
        InputStream is = new FileInputStream(new File("src/book.xml"));
        // 3.将输入流加载到build中
        Document document = saxBuilder.build(is);
        // 4.获取根节点
        Element rootElement = document.getRootElement();
        // 5.获取子节点
        List<Element> children = rootElement.getChildren();
        for (Element child : children) {
            List<Attribute> attributes = child.getAttributes();
            // 打印属性
            for (Attribute attr : attributes) {
                System.out.println(attr.getName() + ":" + attr.getValue());
            }
            List<Element> childrenList = child.getChildren();
            System.out.println("======获取子节点-start======");
            for (Element e : childrenList) {
                System.out.println("节点名：" + e.getName() + "， 节点值：" + e.getValue());
                List<Attribute> childAttributes = e.getAttributes();
                for (Attribute attr : childAttributes) {
                    System.out.println(attr.getName() + "=" + attr.getValue());
                }
            }
            System.out.println("======获取子节点-end======");
        }
    }

}

运行结果：

 

4.DOM4j

DOM4J ：DOM4J是一个JAVA的XML API，JDOM的升级版。

DOM4J 解析 XML 的步骤：

1) 创建 SAXReader 对象。

2) 调用 read 方法。

3) 获取根元素。

4) 通过迭代器遍历直接节点。

通常使用Dom4j工具进行XML的DOM解析，首先要到Dom4j的官网https://dom4j.github.io/下载包并加载到IDE开发工具中（例如eclipse）。

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.io.SAXReader;

public class Dom4jXmlDemo {

    public static void main(String[] args) throws Exception {
        // 1.创建Reader对象
        SAXReader reader = new SAXReader();
        // 2.加载xml
        Document document = reader.read(new File("src/book.xml"));
        // 3.获取根节点
        Element rootElement = document.getRootElement();
        Iterator<Element> iterator = rootElement.elementIterator();
        while (iterator.hasNext()) {
            Element child = (Element) iterator.next();
            List<Attribute> attributes = child.attributes();
            System.out.println("======获取属性值-start======");
            for (Attribute attribute : attributes) {
                System.out.println(attribute.getName() + "=" + attribute.getValue());
            }
            System.out.println("======获取属性值-end======");
            System.out.println("======遍历子节点-start======");
            Iterator<Element> childIterator = child.elementIterator();
            while (childIterator.hasNext()) {
                Element e = (Element) childIterator.next();
                System.out.println("节点名：" + e.getName() + "，节点值：" + e.getStringValue());
                List<Attribute> childAttributes = e.attributes();
                for (Attribute attr : childAttributes) {
                    System.out.println(attr.getName() + "=" + attr.getValue());
                }
            }
            System.out.println("======遍历子节点-end======");
        }
    }
}

运行结果：

 

---

四种解析 XML 的特点

1.DOM 解析:

形成了树结构，有助于更好的理解、掌握，且代码容易编写。解析过程中，树结构保存在内存中，方便修改。

2.SAX 解析:

采用事件驱动模式，对内存耗费比较小。适用于只处理 XML 文件中的数据时。

3.JDOM 解析:

仅使用具体类，而不使用接口。API 大量使用了 Collections 类。

4.DOM4J解析：

使用接口和抽象基本类方法。性能优异，灵活性好，功能强大和易于使用。