java解析xml文件的四种方式

java解析xml文件的四种方式

1、简介

XML即可扩展标记语言（EXtensible Markup Language），简单的说，XML就是一种数据的描述语言（更多关于XML的语法介绍）。目前解析XML主流的方法也就四种，即 DOM（Document Object Model）、SAX（Simple API for XML）、JDOM （Java-based Document Object Model）和 DOM4J（Document Object Model for Java）。其中前两种属于基础方法，是官方提供的平台无关的解析方式；后两种属于扩展方法，它们是在基础的方法上扩展出来的，只适用于java平台。

XML的使用场景：

XML可以作为微型数据库存储数据。
作为通信数据：最典型的就是web service，利用XML来传递数据（现在被JSON代替）。
作为一些应用程序的配置信息数据。常见的如J2EE配置Web服务器时用的web.xml。Spring、mybatis等的配置文件。
其他一些文档的XML格式。如Word、Excel等。

名词解释

Document对象：整个xml文档。
Element对象：所有标签。
Attribute对象：所有属性。
Test对象：所有文本内容。

2、解析XML文件的4种方法

books.xml文件：

<?xml version="1.0" encoding="UTF-8"?>  <!-- 文档头，定义编码格式和xml标准版本 -->
<!-- 文档类型定义，bookstore表示这个xml文档的根节点标签的元素名， 一般还会在这里定义dtd文件，可以用来检验文档格式 -->
<!DOCTYPE bookstore>
<!-- xml严格要求有开标签必须有闭标签 -->
<bookstore>
    <book id="1">
        <name>冰与火之歌</name>
        <author>乔治马丁</author>
        <year>2014</year>
        <price>89</price>
    </book>
    <book id="2">
        <name>安徒生童话</name>
        <year>2004</year>
        <price>77</price>
        <language>English</language>
    </book>
</bookstore>

2.1、DOM（Document Object Model）

DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的。因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构做出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

【优点】

形成了树结构，直观易于理解，代码更易编写。
解析过程中树结构保存在内存中，方便修改

【缺点】当XML文件较大的时候，最内存耗费比较大，容易影响解析性能并且可能会造成内存溢出。

示例代码：

import org.w3c.dom.Document;
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 java.io.IOException;

/**
 * @Author dw
 * @ClassName DOMTest
 * @Description DOM 方式解析xml
 * @Date 2023/6/20 15:15
 * @Version 1.0
 */
public class DOMTest {

    /**
     * xml文件路径
     */
    private static final String XML_PATH = "G:\\work-space\\my-project\\dw-test\\src\\main\\java\\com\\dw\\study\\dom\\books.xml";

    public static void main(String[] args) {
        // 创建一个DocumentBuilderFactory的对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try {
            // 创建DocumentBuilder对象
            DocumentBuilder db = dbf.newDocumentBuilder();
            // 通过DocumentBuilder对象的parser方法加载books.xml文件到当前项目下
            Document document = db.parse(XML_PATH);
            // 获取所有book节点的集合
            NodeList bookList = document.getElementsByTagName("book");
            System.out.println("一共有" + bookList.getLength() + "本书");
            //遍历每一个book节点
            for (int i = 0; i < bookList.getLength(); i++) {
                System.out.println("=================下面开始遍历第" + (i + 1) + "本书的内容=================");
                //通过 item(i)方法 获取一个book节点，nodelist的索引值从0开始
                Node book = bookList.item(i);
                // 获取book节点的所有属性集合
                NamedNodeMap attrs = book.getAttributes();
                System.out.println("第 " + (i + 1) + "本书共有" + attrs.getLength() + "个属性");
                // 遍历book的属性
                for (int j = 0; j < attrs.getLength(); j++) {
                    //通过item(index)方法获取book节点的某一个属性
                    Node attr = attrs.item(j);
                    //获取属性名
                    System.out.print("属性名：" + attr.getNodeName());
                    //获取属性值
                    System.out.println("--属性值" + attr.getNodeValue());
                }
                //解析book节点的子节点
                NodeList childNodes = book.getChildNodes();
                //遍历childNodes获取每个节点的节点名和节点值
                System.out.println("第" + (i + 1) + "本书共有" + childNodes.getLength() + "个子节点");
                for (int k = 0; k < childNodes.getLength(); k++) {
                    // 区分出text类型的node以及element类型的node
                    if (childNodes.item(k).getNodeType() == Node.ELEMENT_NODE) {
                        //获取了element类型节点的节点名
                        System.out.print("第" + (k + 1) + "个节点的节点名：" + childNodes.item(k).getNodeName());
                        //获取了element类型节点的节点值
                        System.out.println("--节点值是：" + childNodes.item(k).getFirstChild().getNodeValue());
                        //System.out.println("--节点值是：" + childNodes.item(k).getTextContent());
                    }
                }
                System.out.println("======================结束遍历第" + (i + 1) + "本书的内容=================");
            }
        } catch (ParserConfigurationException | SAXException | IOException e) {
            e.printStackTrace();
        }
    }
}

2.2、SAX（Simple API for XML）

SAX处理的优点非常类似于流媒体的优点，分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX比它的替代者DOM快很多。

选择DOM还是选择SAX？对于需要自己编写代码来处理XML文档的开发人员来说，选择DOM还是SAX解析模型是一个非常重要的设计决策，DOM采用建立树形结构的方式访问XML文档，而SAX采用的事件模型。 DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定索要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

【优点】

不需要等待所有数据都被处理，分析就能立即开始。
只在读取数据时检查数据，不需要保存在内存中。
可以在某个条件得到满足时停止解析，不必解析整个文档。
效率和性能较高，能解决大于系统内存的文档。

【缺点】

需要应用程序自己负责TAG的处理逻辑（例如维护父子关系等），文档越复杂程序就越复杂，即不易编码。
单向导航，很难同时访问同一个XML中的多处不同数据。

示例代码：

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

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.IOException;
import java.util.ArrayList;

/**
 * @Author dw
 * @ClassName SAXTest
 * @Description SAX 解析XML
 * @Date 2023/6/20 16:01
 * @Version 1.0
 */
public class SAXTest {
    /**
     * xml文件路径
     */
    private static final String XML_PATH = "G:\\work-space\\my-project\\dw-test\\src\\main\\java\\com\\dw\\study\\dom\\books.xml";


    public static void main(String[] args) {
        try {
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser parser = factory.newSAXParser();
            SAXParserHandler handler = new SAXParserHandler();
            parser.parse(XML_PATH, handler);
            System.out.println("~！~！~！共有" + handler.getBookList().size() + "本书");
            for (Book book : handler.getBookList()) {
                System.out.println(book.getId());
                System.out.println(book.getName());
                System.out.println(book.getAuthor());
                System.out.println(book.getYear());
                System.out.println(book.getPrice());
                System.out.println(book.getLanguage());
                System.out.println("----finish----");
            }
        } catch (ParserConfigurationException | SAXException | IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static class SAXParserHandler extends DefaultHandler {
        String value = null;
        Book book = null;
        private final ArrayList<Book> bookList = new ArrayList<>();

        public ArrayList<Book> getBookList() {
            return bookList;
        }

        int bookIndex = 0;

        /**
         * 用来标识解析开始
         */
        @Override
        public void startDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.startDocument();
            System.out.println("SAX解析开始");
        }

        /**
         * 用来标识解析结束
         */
        @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.endDocument();
            System.out.println("SAX解析结束");
        }

        /**
         * 解析xml元素
         */
        @Override
        public void startElement(String uri,
                                 String localName,
                                 String qName,
                                 Attributes attributes) throws SAXException {
            // 调用DefaultHandler类的startElement方法
            super.startElement(uri, localName, qName, attributes);
            if (qName.equals("book")) {
                bookIndex++;
                //创建一个book对象
                book = new Book();
                //开始解析book元素的属性
                System.out.println("======================开始遍历某一本书的内容=================");
                //不知道book元素下属性的名称以及个数，如何获取属性名以及属性值
                int num = attributes.getLength();
                for (int i = 0; i < num; i++) {
                    System.out.print("book元素的第" + (i + 1) + "个属性名是：" + attributes.getQName(i));
                    System.out.println("---属性值是：" + attributes.getValue(i));
                    if (attributes.getQName(i).equals("id")) {
                        book.setId(attributes.getValue(i));
                    }
                }
            } else if (!qName.equals("name") && !qName.equals("bookstore")) {
                System.out.print("节点名是：" + qName + "---");
            }
        }

        @Override
        public void endElement(String uri, String localName, String qName)
                throws SAXException {
            //调用DefaultHandler类的endElement方法
            super.endElement(uri, localName, qName);
            //判断是否针对一本书已经遍历结束
            if (qName.equals("book")) {
                bookList.add(book);
                book = null;
                System.out.println("======================结束遍历某一本书的内容=================");
            } else if (qName.equals("name")) {
                book.setName(value);
            } else if (qName.equals("author")) {
                book.setAuthor(value);
            } else if (qName.equals("year")) {
                book.setYear(value);
            } else if (qName.equals("price")) {
                book.setPrice(value);
            } else if (qName.equals("language")) {
                book.setLanguage(value);
            }
        }

        @Override
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            // TODO Auto-generated method stub
            super.characters(ch, start, length);
            value = new String(ch, start, length);
            if (!value.trim().equals("")) {
                System.out.println("节点值是：" + value);
            }
        }
    }
}

2.3、JDOM（Java-based Document Object Model）

JDOM的目的是成为java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标注扩展”。JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。 JDOM文档声明的目的是使用20%（或更少）的精力解决80%（或更多）Java/XML问题。JDOM对于大多数Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解的多。JDOM还包括对程序行为的相当广泛检查以防用户做任何在XML中无意义的事。然而，它仍需要充分理解XML以便做一些超出基本的工作。

JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档（尽管它还可以将以前构造的DOM表示作为输入）。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

【优点】

使用具体类而不是接口，简化了DOM的API。
大量使用了Java集合（Collections）类，方便了Java开发人员。

【缺点】没有较好的灵活性。性能较差。

maven 依赖

<dependency>
      <groupId>org.jdom</groupId>
       <artifactId>jdom2</artifactId>
       <version>2.0.6.1</version>
</dependency>

示例代码：

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author dw
 * @ClassName JDOMTest
 * @Description JDOM 解析XML
 * @Date 2023/6/20 16:26
 * @Version 1.0
 */
public class JDOMTest {
    /**
     * xml文件路径
     */
    private static final String XML_PATH = "G:\\work-space\\my-project\\dw-test\\src\\main\\java\\com\\dw\\study\\dom\\books.xml";

    private static final ArrayList<Book> booksList = new ArrayList<>();
    
    public static void main(String[] args) {
        // 进行对books.xml文件的JDOM解析
        // 准备工作
        // 1.创建一个SAXBuilder的对象
        SAXBuilder saxBuilder = new SAXBuilder();
        InputStream in;
        try {
            // 2.创建一个输入流，将xml文件加载到输入流中
            in = new FileInputStream(XML_PATH);
            InputStreamReader isr = new InputStreamReader(in, "UTF-8");
            // 3.通过saxBuilder的build方法，将输入流加载到saxBuilder中
            Document document = saxBuilder.build(isr);
            // 4.通过document对象获取xml文件的根节点
            Element rootElement = document.getRootElement();
            // 5.获取根节点下的子节点的List集合
            List<Element> bookList = rootElement.getChildren();
            // 继续进行解析
            for (Element book : bookList) {
                Book bookEntity = new Book();
                System.out.println("======开始解析第" + (bookList.indexOf(book) + 1) + "书======");
                // 解析book的属性集合
                List<Attribute> attrList = book.getAttributes();
                // //知道节点下属性名称时，获取节点值
                // book.getAttributeValue("id");
                // 遍历attrList(针对不清楚book节点下属性的名字及数量)
                for (Attribute attr : attrList) {
                    // 获取属性名
                    String attrName = attr.getName();
                    // 获取属性值
                    String attrValue = attr.getValue();
                    System.out.println("属性名：" + attrName + "----属性值：" + attrValue);
                    if (attrName.equals("id")) {
                        bookEntity.setId(attrValue);
                    }
                }
                // 对book节点的子节点的节点名以及节点值的遍历
                List<Element> bookChilds = book.getChildren();
                for (Element child : bookChilds) {
                    System.out.println("节点名：" + child.getName() + "----节点值："
                            + child.getValue());
                    if (child.getName().equals("name")) {
                        bookEntity.setName(child.getValue());
                    }
                    else if (child.getName().equals("author")) {
                        bookEntity.setAuthor(child.getValue());
                    }
                    else if (child.getName().equals("year")) {
                        bookEntity.setYear(child.getValue());
                    }
                    else if (child.getName().equals("price")) {
                        bookEntity.setPrice(child.getValue());
                    }
                    else if (child.getName().equals("language")) {
                        bookEntity.setLanguage(child.getValue());
                    }
                }
                System.out.println("======结束解析第" + (bookList.indexOf(book) + 1)
                        + "书======");
                booksList.add(bookEntity);
                System.out.println(booksList);
            }
        } catch (JDOMException | IOException e) {
            e.printStackTrace();
        }
    }
}

2.4、DOM4J（Document Object Model for Java）

虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能。包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。

为支持所有这些功能，DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些代替方法以允许更好的性能或更直接的编码方法。直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大很多的灵活性。在添加灵活性、XPath集成和对大文档办理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。 DOM4J是一个十分优秀的Java XML API，具有性能优异、功能强大和极端易用的特点，同时也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是Sun的JAXM也在使用DOM4J。

【优点】

大量使用了Java集合类，方便Java开发人员，同时提供一些提供性能的替代方法。
性能优异、灵活性好、功能强大和易用的特点。

【缺点】大量使用了接口，API较为复杂。

dom4j Maven 依赖

        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.1.4</version>
        </dependency>

示例代码：

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.Iterator;
import java.util.List;

/**
 * @Author dw
 * @ClassName DOM4JTest
 * @Description DOM4J 解析xml
 * @Date 2023/6/20 18:34
 * @Version 1.0
 */
public class DOM4JTest {
    /**
     * xml文件路径
     */
    private static final String XML_PATH = "G:\\work-space\\my-project\\dw-test\\src\\main\\java\\com\\dw\\study\\dom\\books.xml";
    
    public static void main(String[] args) {
        // 创建SAXReader的对象reader
        SAXReader reader = new SAXReader();
        try {
            // 通过reader对象的read方法加载books.xml文件, 获取Document对象。
            Document document = reader.read(new File(XML_PATH));
            // 通过document对象获取根节点bookstore
            Element bookStore = document.getRootElement();
            // 通过element对象的elementIterator方法获取迭代器
            Iterator it = bookStore.elementIterator();
            // 遍历迭代器，获取根节点中的信息（书籍）
            while (it.hasNext()) {
                System.out.println("=====开始遍历某一本书=====");
                Element book = (Element) it.next();
                // 获取book的属性名以及 属性值
                List<Attribute> bookAttrs = book.attributes();
                for (Attribute attr : bookAttrs) {
                    System.out.println("属性名：" + attr.getName() + "--属性值：" + attr.getValue());
                }
                Iterator itt = book.elementIterator();
                while (itt.hasNext()) {
                    Element bookChild = (Element) itt.next();
                    System.out.println("节点名：" + bookChild.getName() + "--节点值：" + bookChild.getStringValue());
                }
                System.out.println("=====结束遍历某一本书=====");
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
}

posted @ 2023-06-20 11:59 邓维-java 阅读(15567) 评论(1) 编辑收藏举报

刷新页面返回顶部

学如逆水行舟，不进则退！

当你的才华配不上你的任性时，那就努力奋斗吧！

java解析xml文件的四种方式

dom4j Maven 依赖

公告

学如逆水行舟， 不进则退！

当你的才华配不上你的任性时， 那就努力奋斗吧！

java解析xml文件的四种方式

dom4j Maven 依赖

公告

学如逆水行舟，不进则退！

当你的才华配不上你的任性时，那就努力奋斗吧！