XML DOM遍历XML树从基础概念到实际应用的完整指南帮助开发者轻松解析和操作XML文档数据

威震华夏关云长 · 发表于 2025-9-3 20:30:05

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

引言

XML（可扩展标记语言）作为一种重要的数据交换格式，在Web开发、企业应用集成和配置文件管理等领域有着广泛的应用。而XML DOM（文档对象模型）则提供了一种标准的方式来访问和操作XML文档。本文将深入探讨XML DOM遍历XML树的各个方面，从基础概念到实际应用，帮助开发者全面理解和掌握XML文档的解析与操作技术。

1. XML DOM基础概念

1.1 什么是XML DOM

XML DOM（Document Object Model）是XML文档的编程接口，它将XML文档表示为一个树结构，其中每个节点都是文档中的一个部分（如元素、属性、文本等）。通过DOM，开发者可以动态地访问、修改、添加或删除XML文档中的任何元素。

1.2 DOM树结构

DOM将XML文档表示为一个层次化的树结构，其中包含以下几种主要节点类型：

• 文档节点（Document）：整个XML文档的根节点
• 元素节点（Element）：XML中的元素
• 属性节点（Attribute）：元素的属性
• 文本节点（Text）：元素中的文本内容
• 注释节点（Comment）：XML中的注释
• 处理指令节点（Processing Instruction）：XML处理指令

例如，对于以下简单的XML文档：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="fiction">
<title lang="en">Harry Potter</title>
<author>J.K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="children">
<title lang="en">The Wonderful Wizard of Oz</title>
<author>L. Frank Baum</author>
<year>1900</year>
<price>15.99</price>
</book>
</bookstore>

复制代码

其DOM树结构如下：

Document
└── Element: bookstore
├── Element: book (attribute: category="fiction")
│ ├── Element: title (attribute: lang="en")
│ │ └── Text: Harry Potter
│ ├── Element: author
│ │ └── Text: J.K. Rowling
│ ├── Element: year
│ │ └── Text: 2005
│ └── Element: price
│ └── Text: 29.99
└── Element: book (attribute: category="children")
├── Element: title (attribute: lang="en")
│ └── Text: The Wonderful Wizard of Oz
├── Element: author
│ └── Text: L. Frank Baum
├── Element: year
│ └── Text: 1900
└── Element: price
└── Text: 15.99

复制代码

2. 解析XML文档

在遍历XML DOM树之前，首先需要将XML文档解析为DOM对象。不同的编程语言提供了不同的解析器，下面以JavaScript、Java和Python为例展示如何解析XML文档。

2.1 JavaScript中的XML解析

在浏览器环境中，可以使用DOMParser对象解析XML字符串：

// XML字符串
const xmlString = `
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="fiction">
<title lang="en">Harry Potter</title>
<author>J.K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="children">
<title lang="en">The Wonderful Wizard of Oz</title>
<author>L. Frank Baum</author>
<year>1900</year>
<price>15.99</price>
</book>
</bookstore>
`;
// 创建DOM解析器
const parser = new DOMParser();
// 解析XML字符串
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
// 检查解析错误
const parserError = xmlDoc.getElementsByTagName("parsererror")[0];
if (parserError) {
console.error("XML解析错误:", parserError.textContent);
} else {
console.log("XML解析成功");
}

复制代码

在Node.js环境中，可以使用xmldom或libxmljs等第三方库：

// 安装xmldom: npm install xmldom
const { DOMParser } = require('xmldom');
// XML字符串
const xmlString = `...`; // 同上
// 创建DOM解析器
const parser = new DOMParser();
// 解析XML字符串
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
// 检查解析错误
if (xmlDoc.documentElement.nodeName === "parsererror") {
console.error("XML解析错误:", xmlDoc.documentElement.textContent);
} else {
console.log("XML解析成功");
}

复制代码

2.2 Java中的XML解析

Java提供了多种XML解析API，其中最常用的是DOM解析器：

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
public class XMLParser {
public static void main(String[] args) {
try {
// 创建DocumentBuilderFactory
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 创建DocumentBuilder
DocumentBuilder builder = factory.newDocumentBuilder();
// 解析XML文件
Document document = builder.parse(new File("books.xml"));
// 可选：规范化XML文档
document.getDocumentElement().normalize();
System.out.println("XML解析成功");
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

2.3 Python中的XML解析

Python提供了xml.dom.minidom模块来解析XML文档：

from xml.dom.minidom import parse, parseString
# 从字符串解析XML
xml_string = """
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="fiction">
<title lang="en">Harry Potter</title>
<author>J.K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="children">
<title lang="en">The Wonderful Wizard of Oz</title>
<author>L. Frank Baum</author>
<year>1900</year>
<price>15.99</price>
</book>
</bookstore>
"""
# 解析XML字符串
dom = parseString(xml_string)
print("XML解析成功")
# 从文件解析XML
# dom = parse("books.xml")

复制代码

3. 遍历XML DOM树

一旦将XML文档解析为DOM对象，就可以开始遍历DOM树来访问和操作XML数据。下面介绍几种常见的遍历方法。

3.1 基本遍历方法

遍历DOM树通常从根元素开始：

// JavaScript
const rootElement = xmlDoc.documentElement;
console.log("根元素:", rootElement.nodeName);

复制代码

// Java
Element rootElement = document.getDocumentElement();
System.out.println("根元素: " + rootElement.getNodeName());

复制代码

# Python
root_element = dom.documentElement
print("根元素:", root_element.nodeName)

复制代码

可以使用childNodes属性获取元素的所有子节点：

// JavaScript
const childNodes = rootElement.childNodes;
console.log("子节点数量:", childNodes.length);
for (let i = 0; i < childNodes.length; i++) {
const node = childNodes[i];
if (node.nodeType === Node.ELEMENT_NODE) { // 只处理元素节点
console.log("子元素:", node.nodeName);
}
}

复制代码

// Java
NodeList childNodes = rootElement.getChildNodes();
System.out.println("子节点数量: " + childNodes.getLength());
for (int i = 0; i < childNodes.getLength(); i++) {
Node node = childNodes.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) { // 只处理元素节点
System.out.println("子元素: " + node.getNodeName());
}
}

复制代码

# Python
child_nodes = root_element.childNodes
print("子节点数量:", child_nodes.length)
for i in range(child_nodes.length):
node = child_nodes.item(i)
if node.nodeType == node.ELEMENT_NODE: # 只处理元素节点
print("子元素:", node.nodeName)

复制代码

可以使用getElementsByTagName方法获取特定标签名的所有元素：

// JavaScript
const books = xmlDoc.getElementsByTagName("book");
console.log("找到的book元素数量:", books.length);
for (let i = 0; i < books.length; i++) {
const book = books[i];
const category = book.getAttribute("category");
console.log("Book #" + (i + 1) + ", Category: " + category);
}

复制代码

// Java
NodeList books = document.getElementsByTagName("book");
System.out.println("找到的book元素数量: " + books.getLength());
for (int i = 0; i < books.getLength(); i++) {
Element book = (Element) books.item(i);
String category = book.getAttribute("category");
System.out.println("Book #" + (i + 1) + ", Category: " + category);
}

复制代码

# Python
books = dom.getElementsByTagName("book")
print("找到的book元素数量:", books.length)
for i in range(books.length):
book = books.item(i)
category = book.getAttribute("category")
print(f"Book #{i + 1}, Category: {category}")

复制代码

3.2 深度优先遍历

深度优先遍历是一种常见的DOM树遍历方法，可以使用递归实现：

// JavaScript
function traverseNode(node, depth = 0) {
const indent = " ".repeat(depth);
if (node.nodeType === Node.TEXT_NODE && node.textContent.trim() === "") {
// 跳过空白文本节点
return;
}
if (node.nodeType === Node.ELEMENT_NODE) {
console.log(`${indent}Element: ${node.nodeName}`);
// 输出属性
if (node.attributes.length > 0) {
console.log(`${indent} Attributes:`);
for (let i = 0; i < node.attributes.length; i++) {
const attr = node.attributes[i];
console.log(`${indent} ${attr.nodeName}="${attr.nodeValue}"`);
}
}
} else if (node.nodeType === Node.TEXT_NODE) {
console.log(`${indent}Text: "${node.textContent.trim()}"`);
} else if (node.nodeType === Node.COMMENT_NODE) {
console.log(`${indent}Comment: "${node.textContent.trim()}"`);
}
// 递归遍历子节点
for (let i = 0; i < node.childNodes.length; i++) {
traverseNode(node.childNodes[i], depth + 1);
}
}
// 从根元素开始遍历
traverseNode(xmlDoc.documentElement);

复制代码

// Java
public static void traverseNode(Node node, int depth) {
String indent = " ".repeat(Math.max(0, depth));
if (node.getNodeType() == Node.TEXT_NODE && node.getTextContent().trim().isEmpty()) {
// 跳过空白文本节点
return;
}
if (node.getNodeType() == Node.ELEMENT_NODE) {
System.out.println(indent + "Element: " + node.getNodeName());
// 输出属性
NamedNodeMap attributes = node.getAttributes();
if (attributes != null && attributes.getLength() > 0) {
System.out.println(indent + " Attributes:");
for (int i = 0; i < attributes.getLength(); i++) {
Node attr = attributes.item(i);
System.out.println(indent + " " + attr.getNodeName() + "="" + attr.getNodeValue() + """);
}
}
} else if (node.getNodeType() == Node.TEXT_NODE) {
System.out.println(indent + "Text: "" + node.getTextContent().trim() + """);
} else if (node.getNodeType() == Node.COMMENT_NODE) {
System.out.println(indent + "Comment: "" + node.getTextContent().trim() + """);
}
// 递归遍历子节点
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
traverseNode(children.item(i), depth + 1);
}
}
// 从根元素开始遍历
traverseNode(document.getDocumentElement(), 0);

复制代码

# Python
def traverse_node(node, depth=0):
indent = " " * depth
if node.nodeType == node.TEXT_NODE and node.data.strip() == "":
# 跳过空白文本节点
return
if node.nodeType == node.ELEMENT_NODE:
print(f"{indent}Element: {node.nodeName}")
# 输出属性
if node.hasAttributes():
print(f"{indent} Attributes:")
for i in range(node.attributes.length):
attr = node.attributes.item(i)
print(f"{indent} {attr.name}="{attr.value}"")
elif node.nodeType == node.TEXT_NODE:
print(f"{indent}Text: "{node.data.strip()}"")
elif node.nodeType == node.COMMENT_NODE:
print(f"{indent}Comment: "{node.data.strip()}"")
# 递归遍历子节点
for i in range(node.childNodes.length):
traverse_node(node.childNodes.item(i), depth + 1)
# 从根元素开始遍历
traverse_node(dom.documentElement)

复制代码

3.3 广度优先遍历

广度优先遍历是另一种遍历DOM树的方法，通常使用队列实现：

// JavaScript
function breadthFirstTraverse(root) {
const queue = [root];
while (queue.length > 0) {
const node = queue.shift();
if (node.nodeType === Node.TEXT_NODE && node.textContent.trim() === "") {
// 跳过空白文本节点
continue;
}
if (node.nodeType === Node.ELEMENT_NODE) {
console.log(`Element: ${node.nodeName}`);
// 输出属性
if (node.attributes.length > 0) {
console.log(" Attributes:");
for (let i = 0; i < node.attributes.length; i++) {
const attr = node.attributes[i];
console.log(` ${attr.nodeName}="${attr.nodeValue}"`);
}
}
} else if (node.nodeType === Node.TEXT_NODE) {
console.log(`Text: "${node.textContent.trim()}"`);
} else if (node.nodeType === Node.COMMENT_NODE) {
console.log(`Comment: "${node.textContent.trim()}"`);
}
// 将子节点加入队列
for (let i = 0; i < node.childNodes.length; i++) {
queue.push(node.childNodes[i]);
}
}
}
// 从根元素开始遍历
breadthFirstTraverse(xmlDoc.documentElement);

复制代码

// Java
import java.util.LinkedList;
import java.util.Queue;
public static void breadthFirstTraverse(Node root) {
Queue<Node> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
Node node = queue.poll();
if (node.getNodeType() == Node.TEXT_NODE && node.getTextContent().trim().isEmpty()) {
// 跳过空白文本节点
continue;
}
if (node.getNodeType() == Node.ELEMENT_NODE) {
System.out.println("Element: " + node.getNodeName());
// 输出属性
NamedNodeMap attributes = node.getAttributes();
if (attributes != null && attributes.getLength() > 0) {
System.out.println(" Attributes:");
for (int i = 0; i < attributes.getLength(); i++) {
Node attr = attributes.item(i);
System.out.println(" " + attr.getNodeName() + "="" + attr.getNodeValue() + """);
}
}
} else if (node.getNodeType() == Node.TEXT_NODE) {
System.out.println("Text: "" + node.getTextContent().trim() + """);
} else if (node.getNodeType() == Node.COMMENT_NODE) {
System.out.println("Comment: "" + node.getTextContent().trim() + """);
}
// 将子节点加入队列
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
queue.add(children.item(i));
}
}
}
// 从根元素开始遍历
breadthFirstTraverse(document.getDocumentElement());

复制代码

# Python
from collections import deque
def breadth_first_traverse(root):
queue = deque([root])
while queue:
node = queue.popleft()
if node.nodeType == node.TEXT_NODE and node.data.strip() == "":
# 跳过空白文本节点
continue
if node.nodeType == node.ELEMENT_NODE:
print(f"Element: {node.nodeName}")
# 输出属性
if node.hasAttributes():
print(" Attributes:")
for i in range(node.attributes.length):
attr = node.attributes.item(i)
print(f" {attr.name}="{attr.value}"")
elif node.nodeType == node.TEXT_NODE:
print(f"Text: "{node.data.strip()}"")
elif node.nodeType == node.COMMENT_NODE:
print(f"Comment: "{node.data.strip()}"")
# 将子节点加入队列
for i in range(node.childNodes.length):
queue.append(node.childNodes.item(i))
# 从根元素开始遍历
breadth_first_traverse(dom.documentElement)

复制代码

4. 查询和选择XML节点

除了基本的遍历方法外，DOM还提供了一些更高级的查询方法，使开发者能够更方便地选择特定的节点。

4.1 getElementById方法

getElementById方法可以通过元素的ID属性快速获取元素。需要注意的是，XML文档中必须有一个DTD（文档类型定义）或Schema声明某个属性为ID类型，此方法才能正常工作。

// JavaScript
// 假设XML文档中有一个元素的id属性被声明为ID类型
const element = xmlDoc.getElementById("uniqueId");
if (element) {
console.log("找到ID为uniqueId的元素:", element.nodeName);
} else {
console.log("未找到ID为uniqueId的元素");
}

复制代码

// Java
// 假设XML文档中有一个元素的id属性被声明为ID类型
Element element = document.getElementById("uniqueId");
if (element != null) {
System.out.println("找到ID为uniqueId的元素: " + element.getNodeName());
} else {
System.out.println("未找到ID为uniqueId的元素");
}

复制代码

# Python
# 假设XML文档中有一个元素的id属性被声明为ID类型
element = dom.getElementById("uniqueId")
if element:
print(f"找到ID为uniqueId的元素: {element.nodeName}")
else:
print("未找到ID为uniqueId的元素")

复制代码

4.2 getElementsByTagName方法

getElementsByTagName方法可以获取指定标签名的所有元素，返回一个NodeList对象。

// JavaScript
const titles = xmlDoc.getElementsByTagName("title");
console.log("找到的title元素数量:", titles.length);
for (let i = 0; i < titles.length; i++) {
const title = titles[i];
const lang = title.getAttribute("lang");
const text = title.textContent.trim();
console.log(`Title #${i + 1}: "${text}" (lang: ${lang})`);
}

复制代码

// Java
NodeList titles = document.getElementsByTagName("title");
System.out.println("找到的title元素数量: " + titles.getLength());
for (int i = 0; i < titles.getLength(); i++) {
Element title = (Element) titles.item(i);
String lang = title.getAttribute("lang");
String text = title.getTextContent().trim();
System.out.println("Title #" + (i + 1) + ": "" + text + "" (lang: " + lang + ")");
}

复制代码

# Python
titles = dom.getElementsByTagName("title")
print("找到的title元素数量:", titles.length)
for i in range(titles.length):
title = titles.item(i)
lang = title.getAttribute("lang")
text = title.firstChild.data.strip()
print(f"Title #{i + 1}: "{text}" (lang: {lang})")

复制代码

4.3 XPath查询

XPath是一种在XML文档中查找信息的语言，它提供了更强大和灵活的节点选择能力。

在浏览器环境中，可以使用document.evaluate方法执行XPath查询：

// JavaScript
// 查询所有category属性为"fiction"的book元素
const xpath = "//book[@category='fiction']";
const result = xmlDoc.evaluate(xpath, xmlDoc, null, XPathResult.ANY_TYPE, null);
let node = result.iterateNext();
while (node) {
console.log("找到匹配的book元素");
// 获取book元素的子元素
const title = node.getElementsByTagName("title")[0].textContent.trim();
const author = node.getElementsByTagName("author")[0].textContent.trim();
const year = node.getElementsByTagName("year")[0].textContent.trim();
const price = node.getElementsByTagName("price")[0].textContent.trim();
console.log(`Title: ${title}`);
console.log(`Author: ${author}`);
console.log(`Year: ${year}`);
console.log(`Price: ${price}`);
console.log("-------------------");
node = result.iterateNext();
}

复制代码

在Node.js环境中，可以使用xpath库：

// 安装xpath: npm install xpath
const xpath = require('xpath');
const { DOMParser } = require('xmldom');
// 解析XML文档
const xmlDoc = new DOMParser().parseFromString(xmlString, "text/xml");
// 查询所有category属性为"fiction"的book元素
const nodes = xpath.select("//book[@category='fiction']", xmlDoc);
nodes.forEach(node => {
console.log("找到匹配的book元素");
// 获取book元素的子元素
const title = xpath.select("title/text()", node)[0].data.trim();
const author = xpath.select("author/text()", node)[0].data.trim();
const year = xpath.select("year/text()", node)[0].data.trim();
const price = xpath.select("price/text()", node)[0].data.trim();
console.log(`Title: ${title}`);
console.log(`Author: ${author}`);
console.log(`Year: ${year}`);
console.log(`Price: ${price}`);
console.log("-------------------");
});

复制代码

Java提供了javax.xml.xpath包来支持XPath查询：

import javax.xml.xpath.*;
import org.w3c.dom.*;
public class XPathExample {
public static void main(String[] args) {
try {
// 创建DocumentBuilder
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
// 解析XML文件
Document document = builder.parse(new File("books.xml"));
// 创建XPath对象
XPathFactory xPathFactory = XPathFactory.newInstance();
XPath xpath = xPathFactory.newXPath();
// 查询所有category属性为"fiction"的book元素
XPathExpression expr = xpath.compile("//book[@category='fiction']");
NodeList nodes = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
for (int i = 0; i < nodes.getLength(); i++) {
Node node = nodes.item(i);
System.out.println("找到匹配的book元素");
// 获取book元素的子元素
Element bookElement = (Element) node;
String title = bookElement.getElementsByTagName("title").item(0).getTextContent().trim();
String author = bookElement.getElementsByTagName("author").item(0).getTextContent().trim();
String year = bookElement.getElementsByTagName("year").item(0).getTextContent().trim();
String price = bookElement.getElementsByTagName("price").item(0).getTextContent().trim();
System.out.println("Title: " + title);
System.out.println("Author: " + author);
System.out.println("Year: " + year);
System.out.println("Price: " + price);
System.out.println("-------------------");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

Python的xml.dom模块本身不直接支持XPath，但可以使用lxml库：

# 安装lxml: pip install lxml
from lxml import etree
# 解析XML文档
root = etree.fromstring(xml_string)
# 查询所有category属性为"fiction"的book元素
books = root.xpath("//book[@category='fiction']")
for book in books:
print("找到匹配的book元素")
# 获取book元素的子元素
title = book.find("title").text.strip()
author = book.find("author").text.strip()
year = book.find("year").text.strip()
price = book.find("price").text.strip()
print(f"Title: {title}")
print(f"Author: {author}")
print(f"Year: {year}")
print(f"Price: {price}")
print("-------------------")

复制代码

5. 修改XML文档

除了遍历和查询XML文档外，DOM还提供了修改XML文档的方法，包括添加、删除和修改节点。

5.1 修改元素和属性

// JavaScript
// 获取第一个book元素的title元素
const firstBook = xmlDoc.getElementsByTagName("book")[0];
const titleElement = firstBook.getElementsByTagName("title")[0];
// 修改title元素的文本内容
titleElement.textContent = "Harry Potter and the Philosopher's Stone";
console.log("修改后的title:", titleElement.textContent);

复制代码

// Java
// 获取第一个book元素的title元素
NodeList books = document.getElementsByTagName("book");
Element firstBook = (Element) books.item(0);
Element titleElement = (Element) firstBook.getElementsByTagName("title").item(0);
// 修改title元素的文本内容
titleElement.setTextContent("Harry Potter and the Philosopher's Stone");
System.out.println("修改后的title: " + titleElement.getTextContent());

复制代码

# Python
# 获取第一个book元素的title元素
books = dom.getElementsByTagName("book")
first_book = books.item(0)
title_element = first_book.getElementsByTagName("title").item(0)
# 修改title元素的文本内容
title_element.firstChild.data = "Harry Potter and the Philosopher's Stone"
print("修改后的title:", title_element.firstChild.data.strip())

复制代码

// JavaScript
// 获取第一个book元素
const firstBook = xmlDoc.getElementsByTagName("book")[0];
// 修改category属性值
firstBook.setAttribute("category", "fantasy");
console.log("修改后的category属性:", firstBook.getAttribute("category"));

复制代码

// Java
// 获取第一个book元素
NodeList books = document.getElementsByTagName("book");
Element firstBook = (Element) books.item(0);
// 修改category属性值
firstBook.setAttribute("category", "fantasy");
System.out.println("修改后的category属性: " + firstBook.getAttribute("category"));

复制代码

# Python
# 获取第一个book元素
books = dom.getElementsByTagName("book")
first_book = books.item(0)
# 修改category属性值
first_book.setAttribute("category", "fantasy")
print("修改后的category属性:", first_book.getAttribute("category"))

复制代码

5.2 添加新元素和属性

// JavaScript
// 创建新的book元素
const newBook = xmlDoc.createElement("book");
newBook.setAttribute("category", "mystery");
// 创建子元素
const title = xmlDoc.createElement("title");
title.setAttribute("lang", "en");
title.textContent = "The Da Vinci Code";
newBook.appendChild(title);
const author = xmlDoc.createElement("author");
author.textContent = "Dan Brown";
newBook.appendChild(author);
const year = xmlDoc.createElement("year");
year.textContent = "2003";
newBook.appendChild(year);
const price = xmlDoc.createElement("price");
price.textContent = "24.99";
newBook.appendChild(price);
// 将新book元素添加到bookstore元素
xmlDoc.documentElement.appendChild(newBook);
console.log("添加了新的book元素");

复制代码

// Java
// 创建新的book元素
Element newBook = document.createElement("book");
newBook.setAttribute("category", "mystery");
// 创建子元素
Element title = document.createElement("title");
title.setAttribute("lang", "en");
title.setTextContent("The Da Vinci Code");
newBook.appendChild(title);
Element author = document.createElement("author");
author.setTextContent("Dan Brown");
newBook.appendChild(author);
Element year = document.createElement("year");
year.setTextContent("2003");
newBook.appendChild(year);
Element price = document.createElement("price");
price.setTextContent("24.99");
newBook.appendChild(price);
// 将新book元素添加到bookstore元素
document.getDocumentElement().appendChild(newBook);
System.out.println("添加了新的book元素");

复制代码

# Python
# 创建新的book元素
new_book = dom.createElement("book")
new_book.setAttribute("category", "mystery")
# 创建子元素
title = dom.createElement("title")
title.setAttribute("lang", "en")
title_text = dom.createTextNode("The Da Vinci Code")
title.appendChild(title_text)
new_book.appendChild(title)
author = dom.createElement("author")
author_text = dom.createTextNode("Dan Brown")
author.appendChild(author_text)
new_book.appendChild(author)
year = dom.createElement("year")
year_text = dom.createTextNode("2003")
year.appendChild(year_text)
new_book.appendChild(year)
price = dom.createElement("price")
price_text = dom.createTextNode("24.99")
price.appendChild(price_text)
new_book.appendChild(price)
# 将新book元素添加到bookstore元素
dom.documentElement.appendChild(new_book)
print("添加了新的book元素")

复制代码

// JavaScript
// 获取第一个book元素
const firstBook = xmlDoc.getElementsByTagName("book")[0];
// 添加新属性
firstBook.setAttribute("id", "book001");
console.log("添加了id属性:", firstBook.getAttribute("id"));

复制代码

// Java
// 获取第一个book元素
NodeList books = document.getElementsByTagName("book");
Element firstBook = (Element) books.item(0);
// 添加新属性
firstBook.setAttribute("id", "book001");
System.out.println("添加了id属性: " + firstBook.getAttribute("id"));

复制代码

# Python
# 获取第一个book元素
books = dom.getElementsByTagName("book")
first_book = books.item(0)
# 添加新属性
first_book.setAttribute("id", "book001")
print("添加了id属性:", first_book.getAttribute("id"))

复制代码

5.3 删除元素和属性

// JavaScript
// 获取最后一个book元素
const books = xmlDoc.getElementsByTagName("book");
const lastBook = books[books.length - 1];
// 获取父元素
const parent = lastBook.parentNode;
// 删除元素
parent.removeChild(lastBook);
console.log("删除了最后一个book元素");

复制代码

// Java
// 获取最后一个book元素
NodeList books = document.getElementsByTagName("book");
Element lastBook = (Element) books.item(books.getLength() - 1);
// 获取父元素
Node parent = lastBook.getParentNode();
// 删除元素
parent.removeChild(lastBook);
System.out.println("删除了最后一个book元素");

复制代码

# Python
# 获取最后一个book元素
books = dom.getElementsByTagName("book")
last_book = books.item(books.length - 1)
# 获取父元素
parent = last_book.parentNode
# 删除元素
parent.removeChild(last_book)
print("删除了最后一个book元素")

复制代码

// JavaScript
// 获取第一个book元素
const firstBook = xmlDoc.getElementsByTagName("book")[0];
// 删除category属性
firstBook.removeAttribute("category");
console.log("删除了category属性");

复制代码

// Java
// 获取第一个book元素
NodeList books = document.getElementsByTagName("book");
Element firstBook = (Element) books.item(0);
// 删除category属性
firstBook.removeAttribute("category");
System.out.println("删除了category属性");

复制代码

# Python
# 获取第一个book元素
books = dom.getElementsByTagName("book")
first_book = books.item(0)
# 删除category属性
first_book.removeAttribute("category")
print("删除了category属性")

复制代码

6. 保存和序列化XML文档

在对XML文档进行修改后，通常需要将修改后的DOM对象保存回XML文件或序列化为XML字符串。

6.1 JavaScript中的序列化

在浏览器环境中，可以使用XMLSerializer对象将DOM对象序列化为XML字符串：

// JavaScript
// 创建XMLSerializer对象
const serializer = new XMLSerializer();
// 将DOM对象序列化为XML字符串
const xmlString = serializer.serializeToString(xmlDoc);
console.log("序列化后的XML:");
console.log(xmlString);

复制代码

在Node.js环境中，可以使用xmldom的XMLSerializer：

// Node.js
const { XMLSerializer } = require('xmldom');
// 创建XMLSerializer对象
const serializer = new XMLSerializer();
// 将DOM对象序列化为XML字符串
const xmlString = serializer.serializeToString(xmlDoc);
console.log("序列化后的XML:");
console.log(xmlString);

复制代码

6.2 Java中的序列化

Java提供了Transformer类来将DOM对象转换为XML字符串或写入文件：

import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringWriter;
public class XMLSerializer {
public static void main(String[] args) {
try {
// ... 前面的代码用于创建和修改DOM对象 ...
// 创建TransformerFactory
TransformerFactory transformerFactory = TransformerFactory.newInstance();
// 创建Transformer
Transformer transformer = transformerFactory.newTransformer();
// 设置输出属性（可选）
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
// 创建DOMSource
DOMSource source = new DOMSource(document);
// 创建StringWriter用于存储XML字符串
StringWriter writer = new StringWriter();
// 创建StreamResult
StreamResult result = new StreamResult(writer);
// 转换DOM对象为XML字符串
transformer.transform(source, result);
// 获取XML字符串
String xmlString = writer.toString();
System.out.println("序列化后的XML:");
System.out.println(xmlString);
// 也可以直接写入文件
// StreamResult fileResult = new StreamResult(new File("output.xml"));
// transformer.transform(source, fileResult);
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

6.3 Python中的序列化

Python的xml.dom.minidom模块提供了toxml()方法来将DOM对象序列化为XML字符串：

# Python
# 将DOM对象序列化为XML字符串
xml_string = dom.toxml()
print("序列化后的XML:")
print(xml_string)
# 也可以使用toprettyxml()方法获取格式化的XML字符串
pretty_xml_string = dom.toprettyxml(indent=" ")
print("\n格式化后的XML:")
print(pretty_xml_string)
# 写入文件
with open("output.xml", "w", encoding="utf-8") as f:
f.write(pretty_xml_string)

复制代码

7. 实际应用案例

下面通过几个实际应用案例来展示XML DOM遍历的实际应用。

7.1 配置文件解析

假设有一个应用程序配置文件config.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<config>
<database>
<host>localhost</host>
<port>3306</port>
<username>admin</username>
<password>secret</password>
<dbname>myapp</dbname>
</database>
<server>
<port>8080</port>
<threads>10</threads>
<timeout>30</timeout>
</server>
<logging>
<level>INFO</level>
<file>logs/app.log</file>
<maxsize>10MB</maxsize>
<backupCount>5</backupCount>
</logging>
</config>

复制代码

下面是使用JavaScript解析这个配置文件的代码：

// JavaScript
function parseConfig(xmlString) {
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
const config = {
database: {},
server: {},
logging: {}
};
// 解析数据库配置
const database = xmlDoc.getElementsByTagName("database")[0];
config.database.host = database.getElementsByTagName("host")[0].textContent;
config.database.port = parseInt(database.getElementsByTagName("port")[0].textContent);
config.database.username = database.getElementsByTagName("username")[0].textContent;
config.database.password = database.getElementsByTagName("password")[0].textContent;
config.database.dbname = database.getElementsByTagName("dbname")[0].textContent;
// 解析服务器配置
const server = xmlDoc.getElementsByTagName("server")[0];
config.server.port = parseInt(server.getElementsByTagName("port")[0].textContent);
config.server.threads = parseInt(server.getElementsByTagName("threads")[0].textContent);
config.server.timeout = parseInt(server.getElementsByTagName("timeout")[0].textContent);
// 解析日志配置
const logging = xmlDoc.getElementsByTagName("logging")[0];
config.logging.level = logging.getElementsByTagName("level")[0].textContent;
config.logging.file = logging.getElementsByTagName("file")[0].textContent;
config.logging.maxsize = logging.getElementsByTagName("maxsize")[0].textContent;
config.logging.backupCount = parseInt(logging.getElementsByTagName("backupCount")[0].textContent);
return config;
}
// 使用示例
const configXml = `...`; // 上面的config.xml内容
const config = parseConfig(configXml);
console.log("数据库配置:", config.database);
console.log("服务器配置:", config.server);
console.log("日志配置:", config.logging);

复制代码

7.2 RSS订阅解析

RSS是一种常见的XML格式，用于发布经常更新的内容，如博客文章、新闻标题等。下面是一个RSS订阅的示例：

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
<channel>
<title>示例博客</title>
<link>https://example.com/blog</link>
<description>这是一个示例博客的RSS订阅</description>
<language>zh-cn</language>
<pubDate>Mon, 06 Sep 2021 10:00:00 +0000</pubDate>
<lastBuildDate>Mon, 06 Sep 2021 10:00:00 +0000</lastBuildDate>
<item>
<title>第一篇博客文章</title>
<link>https://example.com/blog/post1</link>
<description>这是第一篇博客文章的摘要。</description>
<pubDate>Mon, 06 Sep 2021 10:00:00 +0000</pubDate>
<guid>https://example.com/blog/post1</guid>
</item>
<item>
<title>第二篇博客文章</title>
<link>https://example.com/blog/post2</link>
<description>这是第二篇博客文章的摘要。</description>
<pubDate>Sun, 05 Sep 2021 15:30:00 +0000</pubDate>
<guid>https://example.com/blog/post2</guid>
</item>
<item>
<title>第三篇博客文章</title>
<link>https://example.com/blog/post3</link>
<description>这是第三篇博客文章的摘要。</description>
<pubDate>Sat, 04 Sep 2021 09:15:00 +0000</pubDate>
<guid>https://example.com/blog/post3</guid>
</item>
</channel>
</rss>

复制代码

下面是使用Java解析这个RSS订阅的代码：

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
public class RSSParser {
public static void main(String[] args) {
try {
// 创建DocumentBuilder
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
// 解析XML文件
Document document = builder.parse(new File("rss.xml"));
// 获取channel元素
Element channel = (Element) document.getElementsByTagName("channel").item(0);
// 解析频道信息
String title = channel.getElementsByTagName("title").item(0).getTextContent();
String link = channel.getElementsByTagName("link").item(0).getTextContent();
String description = channel.getElementsByTagName("description").item(0).getTextContent();
String language = channel.getElementsByTagName("language").item(0).getTextContent();
String pubDate = channel.getElementsByTagName("pubDate").item(0).getTextContent();
System.out.println("频道标题: " + title);
System.out.println("频道链接: " + link);
System.out.println("频道描述: " + description);
System.out.println("频道语言: " + language);
System.out.println("发布日期: " + pubDate);
System.out.println("---------------------------------");
// 解析文章列表
NodeList items = channel.getElementsByTagName("item");
List<Map<String, String>> articles = new ArrayList<>();
SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z", Locale.ENGLISH);
for (int i = 0; i < items.getLength(); i++) {
Element item = (Element) items.item(i);
Map<String, String> article = new HashMap<>();
article.put("title", item.getElementsByTagName("title").item(0).getTextContent());
article.put("link", item.getElementsByTagName("link").item(0).getTextContent());
article.put("description", item.getElementsByTagName("description").item(0).getTextContent());
article.put("pubDate", item.getElementsByTagName("pubDate").item(0).getTextContent());
article.put("guid", item.getElementsByTagName("guid").item(0).getTextContent());
articles.add(article);
System.out.println("文章标题: " + article.get("title"));
System.out.println("文章链接: " + article.get("link"));
System.out.println("文章摘要: " + article.get("description"));
System.out.println("发布日期: " + article.get("pubDate"));
System.out.println("文章ID: " + article.get("guid"));
System.out.println("---------------------------------");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

7.3 数据转换

XML DOM遍历的另一个常见应用是将XML数据转换为其他格式，如JSON。下面是一个将XML数据转换为JSON的Python示例：

import json
from xml.dom.minidom import parseString
def element_to_dict(element):
"""将XML元素转换为字典"""
result = {}
# 添加属性
if element.hasAttributes():
for i in range(element.attributes.length):
attr = element.attributes.item(i)
result[f"@{attr.name}"] = attr.value
# 添加子元素和文本内容
children = element.childNodes
if children.length == 1 and children.item(0).nodeType == children.item(0).TEXT_NODE:
# 只有文本内容
result["#text"] = children.item(0).data.strip()
else:
# 有子元素
for i in range(children.length):
child = children.item(i)
if child.nodeType == child.ELEMENT_NODE:
child_data = element_to_dict(child)
if child.nodeName in result:
# 处理同名元素
if not isinstance(result[child.nodeName], list):
result[child.nodeName] = [result[child.nodeName]]
result[child.nodeName].append(child_data)
else:
result[child.nodeName] = child_data
return result
def xml_to_json(xml_string):
"""将XML字符串转换为JSON字符串"""
dom = parseString(xml_string)
root = dom.documentElement
# 将根元素转换为字典
result = element_to_dict(root)
# 添加XML声明信息
result["@version"] = dom.xmlVersion
result["@encoding"] = dom.xmlEncoding
# 转换为JSON字符串
return json.dumps(result, indent=2, ensure_ascii=False)
# 使用示例
xml_string = """
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="fiction">
<title lang="en">Harry Potter</title>
<author>J.K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="children">
<title lang="en">The Wonderful Wizard of Oz</title>
<author>L. Frank Baum</author>
<year>1900</year>
<price>15.99</price>
</book>
</bookstore>
"""
json_string = xml_to_json(xml_string)
print(json_string)

复制代码

输出结果：

{
"@version": "1.0",
"@encoding": "UTF-8",
"book": [
{
"@category": "fiction",
"title": {
"@lang": "en",
"#text": "Harry Potter"
},
"author": "J.K. Rowling",
"year": "2005",
"price": "29.99"
},
{
"@category": "children",
"title": {
"@lang": "en",
"#text": "The Wonderful Wizard of Oz"
},
"author": "L. Frank Baum",
"year": "1900",
"price": "15.99"
}
]
}

复制代码

8. 最佳实践和性能考虑

在使用XML DOM遍历时，有一些最佳实践和性能考虑需要注意。

8.1 最佳实践

根据具体需求选择合适的遍历方法：

• 如果需要查找特定元素，使用getElementsByTagName或XPath查询通常比手动遍历更高效。
• 如果需要处理整个文档的结构，深度优先遍历或广度优先遍历可能更合适。
• 如果只需要处理文档的一部分，尽量限制遍历的范围，避免不必要的处理。

XML文档中的空白字符（如换行符和缩进）可能会被解析为文本节点。在遍历时，应该检查并跳过这些空白文本节点：

// JavaScript
function isWhitespaceTextNode(node) {
return node.nodeType === Node.TEXT_NODE && node.textContent.trim() === "";
}
// 使用示例
for (let i = 0; i < node.childNodes.length; i++) {
const child = node.childNodes[i];
if (!isWhitespaceTextNode(child)) {
// 处理非空白节点
}
}

复制代码

如果XML文档使用了命名空间，应该使用支持命名空间的方法来处理：

// JavaScript
// 使用getElementsByTagNameNS处理命名空间
const items = xmlDoc.getElementsByTagNameNS("http://example.com/namespace", "item");
// 使用XPath处理命名空间
const xpath = "//ns:item";
const resolver = {
lookupNamespaceURI: function(prefix) {
if (prefix === "ns") {
return "http://example.com/namespace";
}
return null;
}
};
const result = xmlDoc.evaluate(xpath, xmlDoc, resolver, XPathResult.ANY_TYPE, null);

复制代码

8.2 性能考虑

DOM操作通常是昂贵的，特别是在处理大型XML文档时。尽量减少DOM操作的次数，例如：

• 批量处理节点，而不是逐个处理。
• 在内存中构建数据结构，然后一次性更新DOM。
• 避免在循环中修改DOM结构。

对于复杂的查询，使用XPath通常比手动遍历DOM更高效：

// JavaScript
// 手动遍历（低效）
const books = xmlDoc.getElementsByTagName("book");
let result = [];
for (let i = 0; i < books.length; i++) {
const book = books[i];
const category = book.getAttribute("category");
const price = parseFloat(book.getElementsByTagName("price")[0].textContent);
if (category === "fiction" && price < 30) {
result.push(book);
}
}
// 使用XPath（高效）
const xpath = "//book[@category='fiction' and number(price) < 30]";
const xpathResult = xmlDoc.evaluate(xpath, xmlDoc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
result = [];
for (let i = 0; i < xpathResult.snapshotLength; i++) {
result.push(xpathResult.snapshotItem(i));
}

复制代码

对于非常大的XML文件，DOM解析器可能会消耗大量内存，因为它需要将整个文档加载到内存中。在这种情况下，可以考虑使用SAX（Simple API for XML）解析器，它采用事件驱动的方式处理XML文档，不需要将整个文档加载到内存中。

以下是使用Python的xml.sax模块处理大型XML文件的示例：

import xml.sax
class BookHandler(xml.sax.ContentHandler):
def __init__(self):
self.current_data = ""
self.current_book = {}
self.books = []
def startElement(self, tag, attrs):
self.current_data = tag
if tag == "book":
self.current_book = {"category": attrs["category"]}
def endElement(self, tag):
if tag == "book":
self.books.append(self.current_book)
self.current_book = {}
elif self.current_data:
self.current_book[self.current_data] = self.current_data_value
self.current_data = ""
def characters(self, content):
if self.current_data:
self.current_data_value = content.strip()
# 使用示例
parser = xml.sax.make_parser()
parser.setFeature(xml.sax.handler.feature_namespaces, 0)
handler = BookHandler()
parser.setContentHandler(handler)
parser.parse("large_books.xml")
print(f"解析了 {len(handler.books)} 本书")

复制代码

9. 常见问题和解决方案

9.1 XML解析错误

XML文档必须符合严格的格式要求，否则会导致解析错误。常见的格式错误包括：

• 标签未正确关闭
• 属性值未用引号括起来
• 特殊字符未正确转义
• 文档编码问题

在解析XML文档之前，应该验证其格式是否正确。可以使用在线XML验证工具或编程语言的内置验证功能：

// JavaScript
function validateXML(xmlString) {
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
const parserError = xmlDoc.getElementsByTagName("parsererror")[0];
if (parserError) {
console.error("XML解析错误:", parserError.textContent);
return false;
}
return true;
}
// 使用示例
const xmlString = "<root><child>Content</child></root>";
if (validateXML(xmlString)) {
console.log("XML格式正确");
// 继续处理XML文档
} else {
console.log("XML格式错误");
}

复制代码

9.2 性能问题

当处理大型XML文档时，DOM解析器可能会消耗大量内存和处理时间，导致性能问题。

根据XML文档的大小和复杂度，选择合适的解析方法：

• 对于小型XML文档，使用DOM解析器。
• 对于大型XML文档，考虑使用SAX解析器或StAX解析器。
• 对于需要随机访问的大型XML文档，可以考虑使用VTD-XML（Virtual Token Descriptor）等高效的XML处理库。

以下是使用Java的StAX解析器处理大型XML文件的示例：

import javax.xml.stream.*;
import javax.xml.stream.events.*;
import java.io.*;
public class StAXParser {
public static void main(String[] args) {
try {
// 创建XML输入工厂
XMLInputFactory factory = XMLInputFactory.newInstance();
// 创建XML读取器
XMLEventReader eventReader = factory.createXMLEventReader(new FileReader("large_books.xml"));
// 遍历XML事件
while (eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
if (event.isStartElement()) {
StartElement startElement = event.asStartElement();
if (startElement.getName().getLocalPart().equals("book")) {
// 处理book元素
String category = startElement.getAttributeByName(new QName("category")).getValue();
System.out.println("找到book元素，category: " + category);
}
} else if (event.isCharacters()) {
Characters characters = event.asCharacters();
if (!characters.isWhiteSpace()) {
// 处理非空白文本内容
System.out.println("文本内容: " + characters.getData());
}
} else if (event.isEndElement()) {
EndElement endElement = event.asEndElement();
if (endElement.getName().getLocalPart().equals("book")) {
// book元素结束
System.out.println("book元素处理完成");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

9.3 命名空间问题

当XML文档使用命名空间时，标准的DOM方法可能无法正确处理元素和属性。

处理带命名空间的XML文档时，应该使用命名空间感知的方法：

// JavaScript
// 带命名空间的XML文档
const xmlString = `
<?xml version="1.0" encoding="UTF-8"?>
<root xmlns:ns="http://example.com/namespace">
<ns:child ns:attr="value">Content</ns:child>
</root>
`;
// 解析XML文档
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
// 使用getElementsByTagNameNS获取元素
const children = xmlDoc.getElementsByTagNameNS("http://example.com/namespace", "child");
console.log("找到的child元素数量:", children.length);
// 使用getAttributeNS获取属性
if (children.length > 0) {
const attrValue = children[0].getAttributeNS("http://example.com/namespace", "attr");
console.log("属性值:", attrValue);
}
// 使用XPath处理命名空间
const xpath = "//ns:child";
const resolver = {
lookupNamespaceURI: function(prefix) {
if (prefix === "ns") {
return "http://example.com/namespace";
}
return null;
}
};
const result = xmlDoc.evaluate(xpath, xmlDoc, resolver, XPathResult.ANY_TYPE, null);
let node = result.iterateNext();
while (node) {
console.log("找到child元素:", node.textContent);
node = result.iterateNext();
}

复制代码

10. 总结

本文详细介绍了XML DOM遍历XML树的各个方面，从基础概念到实际应用。我们学习了：

1. XML DOM的基础概念，包括DOM树结构和节点类型。
2. 如何解析XML文档，包括在JavaScript、Java和Python中的实现。
3. 遍历XML DOM树的各种方法，包括基本遍历、深度优先遍历和广度优先遍历。
4. 查询和选择XML节点的方法，包括getElementById、getElementsByTagName和XPath。
5. 修改XML文档的方法，包括修改元素和属性、添加新元素和属性、删除元素和属性。
6. 保存和序列化XML文档的方法。
7. 实际应用案例，包括配置文件解析、RSS订阅解析和数据转换。
8. 最佳实践和性能考虑，包括使用适当的遍历方法、处理空白文本节点、使用命名空间等。
9. 常见问题和解决方案，包括XML解析错误、性能问题和命名空间问题。

通过掌握这些知识，开发者可以轻松地解析和操作XML文档数据，满足各种应用场景的需求。无论是处理配置文件、解析RSS订阅，还是进行数据转换，XML DOM遍历都是一项重要的技能。

希望本文能够帮助读者全面理解和掌握XML DOM遍历技术，在实际开发中更加高效地处理XML数据。

活动公告

XML DOM遍历XML树从基础概念到实际应用的完整指南帮助开发者轻松解析和操作XML文档数据

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

塔罗

立华奏

站长推荐 /1

友情链接

Tencent QQ