XML解析四种方式代码示例详解-FinClip官网

XML解析四种方式代码示例详解

网友投稿 757 2023-03-03

XML解析四种方式代码示例详解

XML是一种通用的数据交换格式,它的平台无关性、语言无关性、系统无关性、给数据集成与交互带来了极大的方便。XML在不同的语言环境中解析方式都是一样的,只不过实现的语法不同而已。

XML的解析方式分为四种：1、DOM解析；2、SAX解析；3、JDOM解析；4、DOM4J解析。其中前两种属于基础方法，是官方提供的平台无关的解析方式；后两种属于扩展方法，它们是在基础的方法上扩展出来的，只适用于java平台。

针对以下XML文件，会对四种方式进行详细描述：

冰与火之歌

乔治马丁

2014

安徒生童话

2004

English

一、DOM解析

DOM的全称是Document Object Model，也即文档对象模型。在应用程序中，基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称作随机访问机制。

DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式，这些分层对象模型依据XML的文档结构形成了一棵节点树。无论XML文档中所描述的是什么类型的信息，即便是制表数据、项目列表或一个文档，利用DOM所生成的模型都是节点树的形式。也就是说，DOM强制使用树模型来访问XML文档中的信息。由于XML本质上就是一种分层结构，所以这种描述方法是相当有效的。

DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性，它可以任意地控制整个XML文档中的内容。然而，由于DOM分析器把整个XML文档转化成DOM树放在了内存中，因此，当文档比较大或者结构比较复杂时，对内存的需求就比较高。而且，对于结构复杂的树的遍历也是一项耗时的操作。所以，DOM分析器对机器性能的要求比较高，实现效率不十分理想。不过，由于DOM分析器所采用的树结构的思想与XML文档的结构相吻合，同时鉴于随机访问所带来的方便，因此，DOM分析器还是有很广泛的使用价值的。

优点：

形成了树结构，有助于更好的理解、掌握，且代码容易编写。

解析过程中，树结构保存在内存中，方便修改。

缺点：

由于文件是一次性读取，所以对内存的耗费比较大。

如果XML文件比较大，容易影响解析性能且可能会造成内存溢出。

以下是解决代码：

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.springframework.core.io.Resource;

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;

public final class DomParseHelper {

private DomParseHelper(){}

public static void domParseXml() {

//创建一个DocumentBuilderFactory的对象

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

try {

//创建一个DocumentBuilder的对象

DocumentBuilder db = dbf.newDocumentBuilder();

//通过DocumentBuilder对象的parser方法加载books.xml文件到当前项目下

Resource resource = new org.springframework.core.io.ClassPathResource("books.xml");

Document document = db.parse(resource.getURI().toString());

//获取所有book节点的集合

NodeList bookList = document.getElementsByTagName("book");

//通过nodelist的getLength()方法可以获取bookList的长度

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 e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

}

二、SAX解析

SAX的全称是Simple APIs for XML，也即XML简单应用程序接口。与DOM不同，SAX提供的访问模式是一种顺序模式，这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时，会触发一系列事件，并激活相应的事件处理函数，应用程序通过这些事件处理函数实现对XML文档的访问，因而SAX接口也被称作事件驱动接口。

优点：

采用事件驱动模式，对内存耗费比较小。

适用于只处理XML文件中的数据时。

缺点：

编码比较麻烦

很难同时访问XML文件中的多处不同数据。

以下是解析代码

Book.java

public class Book {

private String id;

private String name;

private String author;

private String year;

private String price;

private String language;

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getAuthor() {

return author;

}

public void setAuthor(String author) {

this.author = author;

}

public String getYear() {

return year;

}

public void setYear(String year) {

this.year = year;

}

public String getPrice() {

return price;

}

public void setPrice(String price) {

this.price = price;

}

public String getLanguage() {

return language;

}

public void setLanguage(String language) {

this.language = language;

}

SAXParserHandler.java

import java.util.ArrayList;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class SAXParserHandler extends DefaultHandler {

String value = null;

Book book = null;

private ArrayList bookList = new ArrayList();

public ArrayList getBookList() {

return bookList;

}

int bookIndex = 0;

/**

* 用来标识解析开始

@Override

public void startDocument() throws SAXException {

super.startDocument();

System.out.println("SAX解析开始");

}

/**

* 用来标识解析结束

@Override

public void endDocument() throws SAXException {

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 {

super.characters(ch, start, length);

value = new String(ch, start, length);

if (!value.trim().equals("")) {

System.out.println("节点值是：" + value);

}

SAXParseHelper.java

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import org.xml.sax.SAXException;

phttp://ublic final class SAXParseHelper {

private SAXParseHelper() {

}

public static void saxParseXml() {

//创建一个SAXParserFactory工厂对象

SAXParserFactory factory = SAXParserFactory.newInstance();

try {

//通过工厂对象获取SAXParser解析器

SAXParser parser = factory.newSAXParser();

//使用SAXParserHandler解析xml

Resource resource = new ClassPathResource("books.xml");

SAXParserHandler handler = new SAXParserHandler();

parser.parse(resource.getURI().toString(), 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 e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

三、JDOM解析

特征：

仅使用具体类，而不使用接口。

API大量使用了Collections类。

添加Maven依赖

jdom

1.1

以下是解析的具体代码：

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

import org.jdom.Attribute;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.JDOMException;

import org.jdom.input.SAXBuilder;

import org.springframework.core.io.ClassPathResource;

public final class JDOMParseHelper {

private JDOMParseHelper(){}

public static void jDOMParseXml(){

List booksList = new ArrayList();

// 进行对books.xml文件的JDOM解析

// 准备工作

// 1.创建一个SAXBuilder的对象

SAXBuilder saxBuilder = new SAXBuilder();

InputStream in;

try {

// 2.创建一个输入流，将xml文件加载到输入流中

ClassPathResource resource = new ClassPathResource("books.xml");

in = resource.getInputStream();

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 bookList = rootElement.getChildren();

// 继续进行解析

for (Element book : bookList) {

Book bookEntity = new Book();

System.out.println("======开始解析第" + (bookList.indexOf(book) + 1) + "书======");

// 解析book的属性集合

List 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 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.size());

System.out.println(booksList.get(0).getId());

System.out.println(booksList.get(0).getName());

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (JDOMException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

四、DOM4J解析

特征：

DOM的一种智能分支，它合并了许多超出基本XML文档表示的功能。

它使用接口和抽象基本类方法。

具有性能优异、灵活性好、功能强大和极端易用的特点。

是一个开放源码的文件

添加Maven依赖

org.dom4j

dom4j

2.1.3

以下是解析的代码：

import java.io.IOException;

import java.util.Iterator;

import java.util.List;

import org.dom4j.Attribute;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

public final class DOM4JParseHelper {

private DOM4JParseHelper() {

}

public static void dom4jParseXml() {

// 解析books.xml文件

// 创建SAXReader的对象reader

SAXReader reader = new SAXReader();

try {

// 通过reader对象的read方法加载books.xml文件,获取docuemnt对象。

Resource resource = new ClassPathResource("books.xml");

Document document = reader.read(resource.getFile());

// 通过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 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 | IOException e) {

e.printStackTrace();

}

五、总结

DOM4J性能最好，连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J。

JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM。虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在javascript中使用DOM）。

SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

微前端架构如何改变企业的开发模式与效率提升

757 2023-03-03

XML解析四种方式代码 示例详解

微前端架构如何改变企业的开发模式与效率提升

轻量级前端框架助力开发者提升项目效率与性能

大屏前端框架如何推动企业数据可视化与用户体验的革新

最近发表

更多内容

小程序SDK

Finclip技术文档

小程序开发

小程序容器

小程序框架

Finclip小程序平台

Finclip用户投稿

车联网

推荐文章

小程序SDK是什么意思？小程序sdk和插件有什么区别？

小程序支付功能怎么实现？

企业app开发流程是什么？

app运营模式有哪些？

小程序多端引流怎么做？

小程序生态分析的机会和威胁

Flutter入门这一篇效率文章就够了

原生与跨平台解决方案分析,跨平台软件开发技术方案

热更新技术：让软件更新变得更加轻松快速

解决方案

银行解决方案

证券解决方案

互联网解决方案

政企OA解决方案

科技解决方案

loT解决方案

信任解决方案

热评文章

AppCan:基于混合模式的移动应用开发,移动混合模

Hybrid App混合模式开发的了解

小程序容器技术助力券商数字营销突围，小程序容器化的意

用mpvue开发微信小程序基础知识（vue.js开发

小程序多端框架全面测评对比，强烈推荐！

券商app架构 - 解析券商应用程序的构建与设计