XML
XML（可扩展标记语言，Extensible Markup Language）是一种标记语言，用于存储和传输数据。它被设计为简洁、通用、易于扩展，广泛应用于数据交换、配置文件、文档存储等领域。
查看更多相关内容
什么是 XML Schema，它与 DTD 有什么区别？XML Schema（XSD）是一种用于定义 XML 文档结构和内容的语言，它是 DTD（文档类型定义）的现代化替代方案。XML Schema 提供了更强大、更灵活的数据验证机制。
## XML Schema 的主要特点
1. **基于 XML 的语法**：Schema 本身也是 XML 文档，易于理解和处理
2. **丰富的数据类型**：支持字符串、整数、日期、布尔值等多种内置数据类型
3. **自定义类型**：可以定义复杂类型和简单类型
4. **命名空间支持**：原生支持 XML 命名空间
5. **继承和扩展**：支持类型的继承和扩展机制
6. **精确的约束**：可以定义元素的基数、取值范围、格式等约束
## XML Schema 与 DTD 的区别
| 特性 | XML Schema | DTD |
|------|------------|-----|
| 语法 | 基于 XML | 独特的 DTD 语法 |
| 数据类型 | 丰富的内置类型 | 只有字符串类型 |
| 命名空间 | 原生支持 | 不支持 |
| 继承 | 支持类型继承 | 不支持 |
| 扩展性 | 可以扩展和重用 | 难以重用 |
| 验证能力 | 强大的验证能力 | 有限的验证能力 |
## XML Schema 基本结构
```xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.com/books"
xmlns="http://www.example.com/books"
elementFormDefault="qualified">
<!-- 定义元素 -->
<xs:element name="book" type="BookType"/>
<!-- 定义复杂类型 -->
<xs:complexType name="BookType">
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="author" type="xs:string"/>
<xs:element name="price" type="xs:decimal"/>
<xs:element name="publishDate" type="xs:date"/>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required"/>
</xs:complexType>
</xs:schema>
```
## 常用的 Schema 元素
1. **element**：定义 XML 元素
2. **complexType**：定义复杂类型（包含子元素或属性）
3. **simpleType**：定义简单类型（只包含文本内容）
4. **attribute**：定义元素属性
5. **sequence**：指定子元素必须按顺序出现
6. **choice**：指定子元素中只能出现一个
7. **all**：指定子元素可以以任意顺序出现
## 约束定义
```xml
<!-- 基数约束 -->
<xs:element name="phone" minOccurs="0" maxOccurs="unbounded"/>
<!-- 取值范围约束 -->
<xs:simpleType name="AgeType">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
<!-- 模式约束 -->
<xs:simpleType name="EmailType">
<xs:restriction base="xs:string">
<xs:pattern value="[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"/>
</xs:restriction>
</xs:simpleType>
<!-- 枚举约束 -->
<xs:simpleType name="GenderType">
<xs:restriction base="xs:string">
<xs:enumeration value="male"/>
<xs:enumeration value="female"/>
</xs:restriction>
</xs:simpleType>
```
## 在 XML 文档中引用 Schema
```xml
<?xml version="1.0"?>
<book xmlns="http://www.example.com/books"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.example.com/books books.xsd">
<title>XML Programming</title>
<author>John Doe</author>
<price>49.99</price>
<publishDate>2024-01-15</publishDate>
</book>
```
## 实际应用场景
- Web 服务中的消息格式定义（如 WSDL）
- 配置文件的结构验证
- 数据交换格式的标准化
- 文档格式的定义和验证
XML Schema 提供了强大而灵活的 XML 文档验证机制，是现代 XML 应用开发中不可或缺的工具。
计算机基础 · 2月21日 14:23
XML 和 JSON 有什么区别，在什么情况下应该选择 XML 而不是 JSON？XML 与 JSON 是两种最常用的数据交换格式，它们各有优缺点，在不同的场景下有不同的适用性。
## XML 的特点
### 优点
1. **结构化强**：严格的语法和结构，适合复杂的数据结构
2. **自描述性**：标签名描述了数据的含义
3. **命名空间支持**：可以避免标签名冲突
4. **验证机制**：支持 DTD 和 Schema 验证
5. **注释支持**：可以在文档中添加注释
6. **成熟的标准**：有完善的标准和工具支持
7. **适合文档**：适合表示文档和半结构化数据
### 缺点
1. **冗余度高**：标签重复，文件体积较大
2. **解析复杂**：解析相对复杂，性能较低
3. **不够直观**：对于简单的数据结构，XML 显得过于复杂
4. **学习曲线**：需要学习 XML 相关技术（XPath、XSLT 等）
## JSON 的特点
### 优点
1. **简洁轻量**：语法简洁，文件体积小
2. **易于解析**：解析速度快，大多数语言都有内置支持
3. **易于阅读**：结构清晰，易于理解和编写
4. **与 JavaScript 兼容**：原生支持 JavaScript
5. **适合 Web**：非常适合 Web 应用和 RESTful API
6. **数据类型丰富**：支持字符串、数字、布尔值、数组、对象、null
### 缺点
1. **无注释**：不支持注释
2. **无命名空间**：不支持命名空间
3. **验证较弱**：验证机制不如 XML 完善
4. **不适合文档**：不适合表示复杂的文档结构
5. **数据类型限制**：不支持日期等特殊数据类型
## XML 与 JSON 的对比
| 特性 | XML | JSON |
|------|-----|------|
| 语法 | 标签语法 | 对象/数组语法 |
| 文件大小 | 较大 | 较小 |
| 解析速度 | 较慢 | 较快 |
| 数据类型 | 丰富 | 基本类型 |
| 注释 | 支持 | 不支持 |
| 命名空间 | 支持 | 不支持 |
| 验证 | DTD/Schema | JSON Schema |
| 可读性 | 中等 | 高 |
| 学习曲线 | 较陡 | 较平 |
| 适用场景 | 复杂数据、文档 | Web API、配置 |
## 数据示例对比
### XML 示例
```xml
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book id="1" category="web">
<title>XML Guide</title>
<author>John Doe</author>
<price>39.95</price>
<inStock>true</inStock>
<tags>
<tag>XML</tag>
<tag>Programming</tag>
</tags>
</book>
<!-- This is a comment -->
<book id="2" category="database">
<title>SQL Basics</title>
<author>Jane Smith</author>
<price>29.99</price>
<inStock>false</inStock>
<tags>
<tag>SQL</tag>
<tag>Database</tag>
</tags>
</book>
</bookstore>
```
### JSON 示例
```json
{
"bookstore": [
{
"id": 1,
"category": "web",
"title": "XML Guide",
"author": "John Doe",
"price": 39.95,
"inStock": true,
"tags": ["XML", "Programming"]
},
{
"id": 2,
"category": "database",
"title": "SQL Basics",
"author": "Jane Smith",
"price": 29.99,
"inStock": false,
"tags": ["SQL", "Database"]
}
]
}
```
## 选择建议
### 选择 XML 的场景
1. **复杂的数据结构**：需要表示复杂的嵌套结构
2. **文档表示**：需要表示文档或半结构化数据
3. **需要验证**：需要严格的数据验证
4. **需要注释**：需要在数据中添加注释
5. **遗留系统**：与遗留系统集成
6. **命名空间需求**：需要避免标签名冲突
7. **企业级应用**：企业级应用和 Web 服务
### 选择 JSON 的场景
1. **Web API**：RESTful API 和 AJAX 请求
2. **移动应用**：移动应用的数据交换
3. **配置文件**：应用程序配置
4. **简单数据**：简单的数据结构
5. **JavaScript 应用**：前端 JavaScript 应用
6. **性能要求高**：对解析性能有较高要求
7. **文件大小敏感**：对文件大小敏感的场景
## 转换工具
### XML 转 JSON
**JavaScript 示例：**
```javascript
const xml2js = require('xml2js');
const parser = new xml2js.Parser();
const xml = '<root><name>John</name><age>30</age></root>';
parser.parseString(xml, (err, result) => {
const json = JSON.stringify(result);
console.log(json);
});
```
**Python 示例：**
```python
import xmltodict
import json
xml = '<root><name>John</name><age>30</age></root>'
data = xmltodict.parse(xml)
json_data = json.dumps(data)
print(json_data)
```
### JSON 转 XML
**JavaScript 示例：**
```javascript
const js2xmlparser = require("js2xmlparser");
const obj = {
root: {
name: "John",
age: 30
}
};
const xml = js2xmlparser.parse("root", obj);
console.log(xml);
```
**Python 示例：**
```python
import xmltodict
import json
json_data = '{"root": {"name": "John", "age": 30}}'
data = json.loads(json_data)
xml = xmltodict.unparse(data)
print(xml)
```
## 性能对比
### 文件大小
- XML 通常比 JSON 大 30-50%
- 对于相同的数据，JSON 更紧凑
### 解析速度
- JSON 解析速度通常比 XML 快 2-3 倍
- JSON 解析器通常更简单、更高效
### 内存占用
- XML DOM 解析需要更多内存
- JSON 解析内存占用相对较少
## 未来趋势
1. **JSON 主导 Web**：JSON 在 Web 开发中占据主导地位
2. **XML 保留企业**：XML 在企业级应用中仍然重要
3. **混合使用**：根据场景选择合适的格式
4. **工具支持**：两种格式都有完善的工具支持
选择 XML 还是 JSON 应该根据具体的应用场景、性能要求、团队技能和生态系统来决定。在现代 Web 开发中，JSON 通常是首选，但在企业级应用和复杂文档处理中，XML 仍然具有重要价值。
计算机基础 · 2月21日 14:23
什么是 XML 中的 CDATA，它的使用场景和限制是什么？XML 中的 CDATA（Character Data）节是一种特殊的机制，用于包含不会被 XML 解析器解析的文本内容。当需要在 XML 文档中包含特殊字符（如 `<`、`>`、`&` 等）或代码片段时，CDATA 节非常有用。
## CDATA 的基本语法
CDATA 节以 `<![CDATA[` 开始，以 `]]>` 结束：
```xml
<description>
<![CDATA[
这里可以包含任何字符，包括 < > & 等特殊字符
这些字符不会被 XML 解析器解析
]]>
</description>
```
## CDATA 的使用场景
### 1. 包含代码片段
```xml
<code>
<![CDATA[
function hello() {
if (x < 10) {
return "Hello";
}
}
]]>
</code>
```
### 2. 包含数学公式
```xml
<formula>
<![CDATA[
E = mc²
x < y && y > z
]]>
</formula>
```
### 3. 包含 HTML 或 XML 片段
```xml
<content>
<![CDATA[
<div class="header">
<p>Welcome to <strong>XML</strong></p>
</div>
]]>
</content>
```
### 4. 包含特殊字符数据
```xml
<data>
<![CDATA[
Special characters: < > & " '
Comparison: 5 < 10, 20 > 15
]]>
</data>
```
## CDATA 的限制和注意事项
1. **不能嵌套**：CDATA 节不能嵌套使用
```xml
<!-- 错误：CDATA 不能嵌套 -->
<data>
<![CDATA[
Outer CDATA
<![CDATA[Inner CDATA]]>
]]>
</data>
```
2. **不能包含结束标记**：CDATA 节内部不能包含 `]]>` 字符串
```xml
<!-- 错误：包含结束标记 -->
<data>
<![CDATA[
This contains ]]> which is not allowed
]]>
</data>
```
3. **大小写敏感**：CDATA 标记必须大写
```xml
<!-- 错误：CDATA 必须大写 -->
<data>
<![cdata[This is wrong]]>
</data>
```
4. **空白字符保留**：CDATA 节内的所有空白字符都会被保留
```xml
<data>
<![CDATA[
Line 1
Line 2
Indented line
]]>
</data>
```
## CDATA 与实体引用的对比
| 特性 | CDATA | 实体引用 |
|------|-------|----------|
| 语法 | `<![CDATA[内容]]>` | `<` `>` `&` 等 |
| 可读性 | 高，直接显示原始内容 | 低，需要转换 |
| 适用范围 | 大段文本 | 单个字符 |
| 性能 | 稍好，减少解析开销 | 稍差，需要解析实体 |
| 灵活性 | 低，不能部分使用 | 高，可以精确控制 |
## 何时使用 CDATA
### 适合使用 CDATA 的情况：
1. 包含大量特殊字符的文本
2. 需要保留原始格式的代码片段
3. 包含其他标记语言（HTML、JavaScript 等）
4. 需要避免频繁的字符转义
### 不适合使用 CDATA 的情况：
1. 只包含少量特殊字符
2. 需要对内容进行部分处理
3. 内容中可能包含 `]]>` 字符串
4. 需要与其他 XML 处理工具兼容
## CDATA 的实际应用示例
### 1. Web 服务配置
```xml
<configuration>
<script>
<![CDATA[
$(document).ready(function() {
$("#button").click(function() {
if (count < 10) {
alert("Click count: " + count);
}
});
});
]]>
</script>
</configuration>
```
### 2. 数据库查询存储
```xml
<queries>
<query id="getUser">
<![CDATA[
SELECT * FROM users
WHERE age > 18 AND status = 'active'
ORDER BY name ASC
]]>
</query>
</queries>
```
### 3. 模板内容
```xml
<template>
<![CDATA[
<html>
<head><title>${title}</title></head>
<body>
<h1>Welcome, ${username}!</h1>
<p>Your balance is: $${balance}</p>
</body>
</html>
]]>
</template>
```
## CDATA 在不同语言中的处理
### Java DOM 解析
```java
Element element = document.createElement("description");
CDATASection cdata = document.createCDATASection("Text with <special> characters");
element.appendChild(cdata);
```
### Python ElementTree
```python
import xml.etree.ElementTree as ET
element = ET.Element("description")
element.text = "Text with <special> characters"
# ElementTree 会自动转义特殊字符
```
CDATA 节是 XML 中处理特殊字符和原始文本内容的重要工具，合理使用可以提高 XML 文档的可读性和维护性。
计算机基础 · 2月21日 14:23
什么是 XML 命名空间，如何声明和使用它？XML 命名空间（Namespace）是 XML 中用于解决元素和属性名称冲突的机制。当多个 XML 文档或架构合并时，可能会出现相同名称的元素代表不同含义的情况，命名空间通过为元素和属性添加唯一标识符来解决这个问题。
## 命名空间的声明
命名空间使用 xmlns 属性声明，语法格式为：
```xml
<root xmlns:prefix="namespaceURI">
<prefix:element>内容</prefix:element>
</root>
```
其中：
- `xmlns` 是保留属性，用于声明命名空间
- `prefix` 是命名空间前缀（可选，默认命名空间不需要前缀）
- `namespaceURI` 是命名空间的唯一标识符（通常是 URL）
## 命名空间的类型
### 1. 默认命名空间
```xml
<root xmlns="http://example.com/ns">
<element>内容</element>
</root>
```
默认命名空间应用于当前元素及其所有未加前缀的子元素。
### 2. 带前缀的命名空间
```xml
<root xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema>...</xs:schema>
</root>
```
带前缀的命名空间只应用于使用该前缀的元素和属性。
## 命名空间的作用域
- 命名空间声明在声明它的元素及其所有后代元素中有效
- 子元素可以覆盖父元素的命名空间声明
- 未声明命名空间的元素属于"无命名空间"
## 命名空间的最佳实践
1. **使用唯一的 URI**：命名空间 URI 应该是唯一的，通常使用 URL 格式
2. **选择有意义的前缀**：前缀应该简短且易于理解
3. **避免过度使用**：只在必要时使用命名空间
4. **保持一致性**：在整个文档中使用相同的命名空间声明
## 实际应用示例
```xml
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"
xmlns:m="http://www.example.com/stock">
<soap:Header>
<m:Authentication>
<m:Username>user</m:Username>
<m:Password>pass</m:Password>
</m:Authentication>
</soap:Header>
<soap:Body>
<m:GetStockPrice>
<m:StockSymbol>IBM</m:StockSymbol>
</m:GetStockPrice>
</soap:Body>
</soap:Envelope>
```
在这个例子中，`soap` 前缀用于 SOAP 协议的元素，`m` 前缀用于自定义的业务逻辑元素，两者互不干扰。
计算机基础 · 2月21日 14:23
什么是 XML 实体，有哪些类型以及如何使用它们？XML 实体（Entity）是一种用于定义可重用内容的机制，它允许在 XML 文档中定义一次，然后在多个地方引用。实体可以提高 XML 文档的可维护性和可读性。
## XML 实体的类型
### 1. 内部实体
内部实体在 DTD 中定义，其值直接包含在 DTD 中。
```xml
<!DOCTYPE root [
<!ENTITY company "ABC Corporation">
<!ENTITY copyright "Copyright © 2024 ABC Corporation">
]>
<root>
<name>&company;</name>
<footer>©right;</footer>
</root>
```
### 2. 外部实体
外部实体引用外部文件中的内容。
```xml
<!DOCTYPE root [
<!ENTITY header SYSTEM "header.xml">
<!ENTITY footer SYSTEM "footer.xml">
]>
<root>
&header;
<content>Main content here</content>
&footer;
</root>
```
### 3. 参数实体
参数实体主要用于 DTD 中，以 `%` 开头。
```xml
<!DOCTYPE root [
<!ENTITY % commonElements "
<!ELEMENT name (#PCDATA)>
<!ELEMENT email (#PCDATA)>
">
%commonElements;
]>
```
### 4. 预定义实体
XML 定义了 5 个预定义实体：
| 实体 | 字符 | 描述 |
|------|------|------|
| `<` | `<` | 小于号 |
| `>` | `>` | 大于号 |
| `&` | `&` | 和号 |
| `'` | `'` | 单引号 |
| `"` | `"` | 双引号 |
```xml
<data>
<comparison>5 < 10</comparison>
<quote>She said "Hello"</quote>
<ampersand>A & B</ampersand>
</data>
```
## 实体的定义和使用
### 内部实体示例
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE letter [
<!ENTITY sender "John Doe">
<!ENTITY recipient "Jane Smith">
<!ENTITY greeting "Dear">
<!ENTITY closing "Sincerely">
]>
<letter>
<salutation>&greeting; &recipient;,</salutation>
<body>
This is a sample letter from &sender; to &recipient;.
</body>
<signature>&closing;, &sender;</signature>
</letter>
```
### 外部实体示例
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE book [
<!ENTITY chapter1 SYSTEM "chapter1.xml">
<!ENTITY chapter2 SYSTEM "chapter2.xml">
<!ENTITY chapter3 SYSTEM "chapter3.xml">
]>
<book>
<title>Complete Guide</title>
&chapter1;
&chapter2;
&chapter3;
</book>
```
**chapter1.xml:**
```xml
<chapter id="1">
<title>Introduction</title>
<content>Welcome to the guide...</content>
</chapter>
```
### 参数实体示例
```xml
<!DOCTYPE book [
<!ENTITY % bookElements "
<!ELEMENT book (title, author+, chapter+)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT author (#PCDATA)>
<!ELEMENT chapter (title, content)>
<!ELEMENT content (#PCDATA)>
">
%bookElements;
]>
```
## 实体的优点
1. **代码重用**：避免重复内容
2. **易于维护**：修改一处即可更新所有引用
3. **模块化**：可以将内容分解为可管理的部分
4. **可读性**：使 XML 文档更简洁易读
5. **灵活性**：可以动态替换内容
## 实体的缺点
1. **安全性**：外部实体可能带来安全风险（XXE 攻击）
2. **复杂性**：增加 XML 文档的复杂性
3. **性能**：解析实体可能影响性能
4. **兼容性**：某些解析器可能不支持所有实体类型
## 安全考虑
### XXE 攻击风险
外部实体可能被滥用来读取服务器文件或发起攻击：
```xml
<!-- 恶意的 XXE 攻击 -->
<!DOCTYPE data [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<data>
<content>&xxe;</content>
</data>
```
### 防护措施
1. **禁用外部实体**
```java
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
```
2. **使用白名单**
```xml
<!DOCTYPE root [
<!ENTITY % safe SYSTEM "safe.dtd">
%safe;
]>
```
3. **输入验证**
```java
if (xml.contains("<!ENTITY") || xml.contains("SYSTEM")) {
throw new SecurityException("Potentially malicious content");
}
```
## 最佳实践
### 1. 合理使用实体
```xml
<!-- 好的做法：使用实体定义常用内容 -->
<!DOCTYPE config [
<!ENTITY company "My Company">
<!ENTITY version "1.0.0">
]>
<config>
<application>&company; App</application>
<version>&version;</version>
</config>
```
### 2. 避免过度使用
```xml
<!-- 不好的做法：过度使用实体 -->
<!DOCTYPE root [
<!ENTITY a "A">
<!ENTITY b "B">
<!ENTITY c "C">
<!ENTITY d "D">
]>
<root>&a;&b;&c;&d;</root>
```
### 3. 使用有意义的名称
```xml
<!-- 好的做法：使用有意义的实体名称 -->
<!DOCTYPE letter [
<!ENTITY companyName "ABC Corporation">
<!ENTITY currentYear "2024">
]>
<letter>
<footer>&companyName; ¤tYear;</footer>
</letter>
```
### 4. 文档化实体
```xml
<!-- 在 DTD 中添加注释 -->
<!DOCTYPE root [
<!-- Company name - used throughout the document -->
<!ENTITY company "ABC Corporation">
<!-- Copyright notice - appears in footer -->
<!ENTITY copyright "Copyright © 2024 ABC Corporation">
]>
```
## 实体在 Schema 中的替代方案
### 使用 XML Schema
XML Schema 不支持实体，但提供了其他机制：
```xml
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="config">
<xs:complexType>
<xs:sequence>
<xs:element name="company" type="xs:string" fixed="ABC Corporation"/>
<xs:element name="version" type="xs:string" fixed="1.0.0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
```
### 使用 XInclude
XInclude 是 XML 的包含机制，可以替代外部实体：
```xml
<book xmlns:xi="http://www.w3.org/2001/XInclude">
<title>Complete Guide</title>
<xi:include href="chapter1.xml"/>
<xi:include href="chapter2.xml"/>
<xi:include href="chapter3.xml"/>
</book>
```
## 总结
XML 实体是一个强大的功能，可以提高 XML 文档的可维护性和可读性。然而，使用实体时需要注意安全性，特别是外部实体可能带来的 XXE 攻击风险。在现代 XML 开发中，建议：
1. 优先使用内部实体而非外部实体
2. 在生产环境中禁用外部实体
3. 使用 XML Schema 或 XInclude 作为替代方案
4. 遵循最佳实践，合理使用实体
5. 进行充分的安全测试
通过正确使用 XML 实体，可以创建更清晰、更易维护的 XML 文档，同时确保应用程序的安全性。
计算机基础 · 2月21日 14:22
在什么情况下应该使用 XML 属性而不是子元素？XML 属性（Attributes）和子元素（Child Elements）都是用于存储数据的方式，但它们有不同的适用场景和最佳实践。
## XML 属性的特点
### 优点
1. **简洁性**：属性可以更简洁地表示元数据
2. **唯一性**：每个元素中属性名必须唯一
3. **适合简单数据**：适合存储简单的键值对数据
4. **减少嵌套**：可以减少 XML 的嵌套层次
### 缺点
1. **不能包含复杂结构**：属性只能包含文本，不能包含子元素
2. **不能重复**：同一元素中不能有重复的属性名
3. **难以扩展**：添加新属性可能破坏现有结构
4. **没有顺序**：属性没有顺序要求
5. **难以处理多值**：不适合存储多值数据
## XML 子元素的特点
### 优点
1. **可以包含复杂结构**：子元素可以包含其他元素和属性
2. **可以重复**：同一元素中可以有多个同名子元素
3. **易于扩展**：可以轻松添加新的子元素
4. **有顺序**：子元素有明确的顺序
5. **适合复杂数据**：适合存储复杂的数据结构
6. **支持混合内容**：可以包含文本和子元素的混合内容
### 缺点
1. **冗余度高**：需要更多的标签和嵌套
2. **文件较大**：相比属性，会增加文件大小
3. **解析稍慢**：需要更多的解析工作
## 使用属性的场景
### 1. 元数据信息
```xml
<book id="123" isbn="978-0-123456-78-9" category="programming">
<title>XML Programming</title>
<author>John Doe</author>
</book>
```
### 2. 简单的标识符
```xml
<user id="user_001" role="admin" status="active">
<name>John Doe</name>
<email>john@example.com</email>
</user>
```
### 3. 配置参数
```xml
<database driver="mysql" host="localhost" port="3306" timeout="30">
<name>mydb</name>
<user>root</user>
</database>
```
### 4. 格式化选项
```xml
<text format="bold" color="red" size="14">
This is important text
</text>
```
## 使用子元素的场景
### 1. 复杂的数据结构
```xml
<person>
<name>
<first>John</first>
<middle>William</middle>
<last>Doe</last>
</name>
<address>
<street>123 Main St</street>
<city>New York</city>
<state>NY</state>
<zip>10001</zip>
</address>
</person>
```
### 2. 多值数据
```xml
<book>
<title>XML Programming</title>
<authors>
<author>John Doe</author>
<author>Jane Smith</author>
<author>Bob Johnson</author>
</authors>
</book>
```
### 3. 长文本内容
```xml
<article>
<title>Introduction to XML</title>
<content>
XML is a markup language that defines a set of rules
for encoding documents in a format that is both human-readable
and machine-readable...
</content>
</article>
```
### 4. 需要顺序的数据
```xml
<steps>
<step>Install the software</step>
<step>Configure the settings</step>
<step>Run the application</step>
<step>Test the functionality</step>
</steps>
```
### 5. 混合内容
```xml
<paragraph>
This is <bold>important</bold> text with <italic>emphasis</italic>.
</paragraph>
```
## 对比示例
### 使用属性
```xml
<product id="P001" name="Laptop" price="999.99" stock="50" category="electronics">
<description>High-performance laptop</description>
</product>
```
### 使用子元素
```xml
<product>
<id>P001</id>
<name>Laptop</name>
<price>999.99</price>
<stock>50</stock>
<category>electronics</category>
<description>High-performance laptop</description>
</product>
```
## 最佳实践
### 1. 数据 vs 元数据
- **使用属性**：存储元数据（ID、类型、状态等）
- **使用子元素**：存储实际数据
```xml
<book id="123" category="programming">
<title>XML Programming</title>
<author>John Doe</author>
</book>
```
### 2. 简单 vs 复杂
- **使用属性**：简单数据（单个值）
- **使用子元素**：复杂数据（结构化数据）
```xml
<!-- 简单数据 -->
<user id="001" name="John"/>
<!-- 复杂数据 -->
<user>
<id>001</id>
<name>
<first>John</first>
<last>Doe</last>
</name>
</user>
```
### 3. 单值 vs 多值
- **使用属性**：单值数据
- **使用子元素**：多值数据
```xml
<!-- 单值 -->
<book category="programming"/>
<!-- 多值 -->
<book>
<categories>
<category>programming</category>
<category>reference</category>
</categories>
</book>
```
### 4. 长度考虑
- **使用属性**：短文本（通常少于 50 个字符）
- **使用子元素**：长文本
```xml
<!-- 短文本 -->
<book isbn="978-0-123456-78-9"/>
<!-- 长文本 -->
<book>
<description>This is a comprehensive guide to XML programming
that covers all the essential concepts and techniques...</description>
</book>
```
### 5. 可扩展性
- **使用属性**：相对稳定的属性
- **使用子元素**：可能变化或扩展的数据
```xml
<!-- 稳定的属性 -->
<user id="001" role="admin"/>
<!-- 可能扩展的数据 -->
<user>
<profile>
<name>John Doe</name>
<email>john@example.com</email>
<!-- 可以轻松添加更多字段 -->
</profile>
</user>
```
## Schema 设计建议
### XML Schema 示例
```xml
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="book">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="author" type="xs:string"/>
<xs:element name="description" type="xs:string" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required"/>
<xs:attribute name="isbn" type="xs:string"/>
<xs:attribute name="category" type="xs:string"/>
</xs:complexType>
</xs:element>
</xs:schema>
```
## 总结
选择使用属性还是子元素应该基于以下考虑：
1. **数据性质**：元数据用属性，实际数据用子元素
2. **数据复杂度**：简单数据用属性，复杂数据用子元素
3. **数据量**：单值用属性，多值用子元素
4. **文本长度**：短文本用属性，长文本用子元素
5. **可扩展性**：稳定数据用属性，可能变化的数据用子元素
6. **可读性**：考虑 XML 文档的可读性和维护性
在实际应用中，通常需要结合使用属性和子元素，以获得最佳的数据表示效果。
计算机基础 · 2月21日 14:22
什么是 XML 文档的有效性和格式良好性，它们有什么区别？XML 文档的有效性（Validity）和格式良好性（Well-formedness）是两个重要的概念，它们定义了 XML 文档的质量标准。
## 格式良好（Well-formed）
格式良好是指 XML 文档符合 XML 语法规则，可以被 XML 解析器正确解析。
### 格式良好的要求
1. **必须有单一的根元素**
```xml
<!-- 正确：有单一根元素 -->
<root>
<child>内容</child>
</root>
<!-- 错误：没有单一根元素 -->
<child1>内容</child1>
<child2>内容</child2>
```
2. **所有标签必须正确关闭**
```xml
<!-- 正确：所有标签都关闭 -->
<root>
<child>内容</child>
</root>
<!-- 错误：标签未关闭 -->
<root>
<child>内容
</root>
```
3. **标签必须正确嵌套**
```xml
<!-- 正确：正确嵌套 -->
<root>
<parent>
<child>内容</child>
</parent>
</root>
<!-- 错误：错误嵌套 -->
<root>
<parent>
<child>内容
</parent>
</child>
</root>
```
4. **属性值必须用引号括起来**
```xml
<!-- 正确：属性值用引号括起来 -->
<book id="1" category="web">内容</book>
<!-- 错误：属性值未用引号括起来 -->
<book id=1 category=web>内容</book>
```
5. **标签名称区分大小写**
```xml
<!-- 正确：大小写一致 -->
<root>
<Child>内容</Child>
</root>
<!-- 错误：大小写不一致 -->
<root>
<child>内容</Child>
</root>
```
6. **特殊字符必须转义**
```xml
<!-- 正确：特殊字符已转义 -->
<data>5 < 10 & 20 > 15</data>
<!-- 错误：特殊字符未转义 -->
<data>5 < 10 & 20 > 15</data>
```
7. **空元素必须正确表示**
```xml
<!-- 正确：空元素表示方式 -->
<empty/>
<empty></empty>
<!-- 错误：空元素表示不正确 -->
<empty>
```
## 有效（Valid）
有效是指 XML 文档不仅格式良好，还符合特定的文档类型定义（DTD）或 XML Schema。
### 有效的要求
1. **必须格式良好**
- 有效的文档首先必须是格式良好的
2. **必须符合 DTD 或 Schema**
```xml
<!-- XML 文档 -->
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
<to>John</to>
<from>Jane</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>
<!-- DTD 文件 (note.dtd) -->
<!ELEMENT note (to, from, heading, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
```
3. **元素和属性必须符合定义**
```xml
<!-- XML Schema -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="book">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="author" type="xs:string"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
<!-- 有效的 XML 文档 -->
<book id="1">
<title>XML Guide</title>
<author>John Doe</author>
<price>39.95</price>
</book>
<!-- 无效的 XML 文档（缺少必需的属性） -->
<book>
<title>XML Guide</title>
<author>John Doe</author>
<price>39.95</price>
</book>
```
4. **数据类型必须匹配**
```xml
<!-- 正确：数据类型匹配 -->
<price>39.95</price>
<!-- 错误：数据类型不匹配 -->
<price>thirty-nine point ninety-five</price>
```
## 格式良好 vs 有效的对比
| 特性 | 格式良好 | 有效 |
|------|---------|------|
| 语法要求 | 必须符合 XML 语法规则 | 必须符合 XML 语法规则 |
| 结构要求 | 必须有单一根元素 | 必须有单一根元素 |
| 验证要求 | 不需要 DTD 或 Schema | 需要 DTD 或 Schema |
| 约束检查 | 不检查约束 | 检查所有约束 |
| 数据类型 | 不检查数据类型 | 检查数据类型 |
| 必需元素 | 不检查必需元素 | 检查必需元素 |
| 属性约束 | 不检查属性约束 | 检查属性约束 |
## 验证 XML 文档
### 1. 验证格式良好性
**Java 示例：**
```java
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.w3c.dom.*;
public class XMLValidator {
public static boolean isWellFormed(String xml) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new InputSource(new StringReader(xml)));
return true;
} catch (Exception e) {
System.err.println("XML is not well-formed: " + e.getMessage());
return false;
}
}
}
```
### 2. 验证有效性
**使用 DTD 验证：**
```java
public class XMLValidator {
public static boolean isValidWithDTD(String xml, String dtd) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(new ErrorHandler() {
public void warning(SAXParseException e) {
System.err.println("Warning: " + e.getMessage());
}
public void error(SAXParseException e) {
System.err.println("Error: " + e.getMessage());
}
public void fatalError(SAXParseException e) {
System.err.println("Fatal Error: " + e.getMessage());
}
});
Document document = builder.parse(new InputSource(new StringReader(xml)));
return true;
} catch (Exception e) {
System.err.println("XML is not valid: " + e.getMessage());
return false;
}
}
}
```
**使用 Schema 验证：**
```java
public class XMLValidator {
public static boolean isValidWithSchema(String xml, String schemaPath) {
try {
SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = factory.newSchema(new File(schemaPath));
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
docFactory.setSchema(schema);
DocumentBuilder builder = docFactory.newDocumentBuilder();
builder.setErrorHandler(new ErrorHandler() {
public void warning(SAXParseException e) {
System.err.println("Warning: " + e.getMessage());
}
public void error(SAXParseException e) {
System.err.println("Error: " + e.getMessage());
}
public void fatalError(SAXParseException e) {
System.err.println("Fatal Error: " + e.getMessage());
}
});
Document document = builder.parse(new InputSource(new StringReader(xml)));
return true;
} catch (Exception e) {
System.err.println("XML is not valid: " + e.getMessage());
return false;
}
}
}
```
## 最佳实践
1. **始终确保格式良好**：格式良好是 XML 文档的基本要求
2. **使用 Schema 验证**：Schema 比 DTD 更强大、更灵活
3. **开发时启用验证**：在开发阶段启用验证，生产环境可根据需求调整
4. **处理验证错误**：提供清晰的错误信息，帮助调试
5. **使用标准工具**：使用成熟的 XML 解析器和验证工具
6. **文档化约束**：清楚地文档化数据结构和约束
7. **版本控制**：对 Schema 和 DTD 进行版本控制
格式良好和有效性是 XML 文档质量的两个重要维度。格式良好确保文档可以被解析，而有效性确保文档符合业务规则和数据结构要求。在实际应用中，应该根据需求选择适当的验证级别。
计算机基础 · 2月21日 14:22
什么是 XML 注入攻击，如何防止 XXE 攻击？XML 注入是一种安全漏洞，攻击者通过在 XML 输入中注入恶意内容来操纵应用程序的 XML 解析行为。这种攻击可能导致信息泄露、拒绝服务、权限提升等安全问题。
## XML 注入的类型
### 1. XML 外部实体（XXE）攻击
XXE（XML External Entity）是最常见的 XML 注入攻击类型。攻击者利用 XML 解析器处理外部实体的能力来读取服务器上的敏感文件或发起 SSRF 攻击。
**攻击示例：**
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<data>
<username>&xxe;</username>
</data>
```
**危害：**
- 读取服务器上的敏感文件
- 发起 SSRF（服务器端请求伪造）攻击
- 执行远程代码执行（在某些情况下）
- 拒绝服务攻击
### 2. XML 注入攻击
攻击者通过注入 XML 标签来修改 XML 文档的结构。
**攻击示例：**
```xml
<!-- 正常输入 -->
<user>
<name>John</name>
</user>
<!-- 恶意输入 -->
<user>
<name>John</name>
<role>admin</role>
</user>
```
### 3. XPath 注入
类似于 SQL 注入，攻击者通过操纵 XPath 查询来获取未授权的数据。
**攻击示例：**
```xml
<!-- 正常查询 -->
//user[username='john' and password='secret']
<!-- 恶意查询 -->
//user[username='john' or '1'='1']
```
## 防护措施
### 1. 禁用外部实体
**Java 示例：**
```java
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// 禁用外部实体
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
dbf.setXIncludeAware(false);
dbf.setExpandEntityReferences(false);
DocumentBuilder db = dbf.newDocumentBuilder();
```
**Python 示例：**
```python
from lxml import etree
# 禁用外部实体
parser = etree.XMLParser(resolve_entities=False, load_dtd=False)
tree = etree.parse("data.xml", parser)
```
**PHP 示例：**
```php
libxml_disable_entity_loader(true);
$xml = simplexml_load_string($xmlString);
```
### 2. 输入验证和过滤
```java
// 验证 XML 输入
public boolean isValidXML(String xml) {
try {
// 检查是否包含恶意内容
if (xml.contains("<!DOCTYPE") || xml.contains("<!ENTITY")) {
return false;
}
// 验证 XML 格式
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
DocumentBuilder db = dbf.newDocumentBuilder();
db.parse(new InputSource(new StringReader(xml)));
return true;
} catch (Exception e) {
return false;
}
}
```
### 3. 使用白名单验证
```java
// 白名单验证
public boolean isValidElement(String elementName) {
Set<String> allowedElements = new HashSet<>(Arrays.asList(
"name", "email", "age"
));
return allowedElements.contains(elementName);
}
```
### 4. 使用安全的 XML 解析器
**推荐的安全配置：**
```java
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// 安全配置
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
dbf.setXIncludeAware(false);
dbf.setExpandEntityReferences(false);
// 使用 Schema 验证
dbf.setNamespaceAware(true);
dbf.setSchema(schema);
```
### 5. XPath 注入防护
```java
// 使用参数化查询
public User getUser(String username, String password) {
try {
XPathFactory xPathFactory = XPathFactory.newInstance();
XPath xpath = xPathFactory.newXPath();
// 使用变量而不是字符串拼接
XPathExpression expr = xpath.compile(
"//user[username=$username and password=$password]"
);
XPathExpression expr = xpath.compile(
"//user[username=$username and password=$password]"
);
// 设置参数
SimpleVariableResolver resolver = new SimpleVariableResolver();
resolver.addVariable(new QName("username"), username);
resolver.addVariable(new QName("password"), password);
xpath.setXPathVariableResolver(resolver);
Node node = (Node) expr.evaluate(doc, XPathConstants.NODE);
return parseUser(node);
} catch (Exception e) {
throw new RuntimeException("XPath query failed", e);
}
}
```
### 6. 使用 XML Schema 验证
```java
// 使用 Schema 验证输入
SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = factory.newSchema(new File("schema.xsd"));
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setSchema(schema);
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new File("input.xml"));
```
## 最佳实践
1. **禁用 DTD 和外部实体**：这是防止 XXE 攻击的最有效方法
2. **使用白名单验证**：只允许预定义的元素和属性
3. **输入过滤**：过滤掉危险的 XML 结构
4. **使用安全的解析器**：配置解析器以禁用危险功能
5. **最小权限原则**：限制 XML 处理的权限
6. **定期更新**：保持 XML 解析库的最新版本
7. **安全编码**：遵循安全编码最佳实践
8. **安全测试**：定期进行安全测试和代码审查
## 检测工具
1. **OWASP ZAP**：Web 应用安全扫描器
2. **Burp Suite**：Web 应用安全测试工具
3. **XMLSec**：XML 安全库
4. **SonarQube**：代码质量和安全分析工具
XML 注入是一个严重的安全问题，必须在设计和实现阶段就考虑防护措施。通过禁用外部实体、输入验证和使用安全的解析器配置，可以有效地防止 XML 注入攻击。
计算机基础 · 2月21日 14:22
什么是 XML 解析，DOM 和 SAX 解析有什么区别？XML 解析是将 XML 文档转换为应用程序可以处理的数据结构的过程。主要有两种解析方式：DOM（文档对象模型）和 SAX（简单 API for XML）。
## DOM 解析
DOM 是一种基于树形结构的解析方式，它将整个 XML 文档加载到内存中，构建一个树形结构。
### DOM 解析的特点
1. **内存占用大**：需要将整个文档加载到内存
2. **随机访问**：可以随机访问文档的任何部分
3. **双向遍历**：可以向前和向后遍历文档
4. **修改能力**：可以修改文档的结构和内容
5. **适合小文档**：适合处理较小的 XML 文档
### DOM 解析示例（Java）
```java
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("data.xml"));
// 获取根元素
Element root = document.getDocumentElement();
// 获取所有 book 元素
NodeList books = root.getElementsByTagName("book");
for (int i = 0; i < books.getLength(); i++) {
Element book = (Element) books.item(i);
String title = book.getElementsByTagName("title")
.item(0)
.getTextContent();
System.out.println("Title: " + title);
}
```
## SAX 解析
SAX 是一种基于事件的解析方式，它逐行读取 XML 文档，在遇到特定元素时触发事件。
### SAX 解析的特点
1. **内存占用小**：不需要将整个文档加载到内存
2. **顺序访问**：只能顺序访问文档
3. **单向遍历**：只能向前遍历
4. **只读模式**：不能修改文档
5. **适合大文档**：适合处理大型 XML 文档
### SAX 解析示例（Java）
```java
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
DefaultHandler handler = new DefaultHandler() {
boolean inTitle = false;
public void startElement(String uri, String localName,
String qName, Attributes attributes) {
if (qName.equals("title")) {
inTitle = true;
}
}
public void characters(char[] ch, int start, int length) {
if (inTitle) {
System.out.println("Title: " + new String(ch, start, length));
}
}
public void endElement(String uri, String localName, String qName) {
if (qName.equals("title")) {
inTitle = false;
}
}
};
saxParser.parse(new File("data.xml"), handler);
```
## DOM 与 SAX 的对比
| 特性 | DOM | SAX |
|------|-----|-----|
| 内存占用 | 高 | 低 |
| 访问方式 | 随机访问 | 顺序访问 |
| 遍历方向 | 双向 | 单向 |
| 修改能力 | 可修改 | 只读 |
| 解析速度 | 较慢 | 较快 |
| 适用场景 | 小文档、需要修改 | 大文档、只读 |
## 其他解析方式
### 1. StAX（Streaming API for XML）
StAX 是一种拉式解析方式，结合了 DOM 和 SAX 的优点。
```java
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader reader = factory.createXMLStreamReader(new FileInputStream("data.xml"));
while (reader.hasNext()) {
int event = reader.next();
if (event == XMLStreamConstants.START_ELEMENT &&
reader.getLocalName().equals("title")) {
System.out.println("Title: " + reader.getElementText());
}
}
```
### 2. JAXB（Java Architecture for XML Binding）
JAXB 提供了 XML 与 Java 对象之间的自动绑定。
```java
JAXBContext context = JAXBContext.newInstance(Book.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
Book book = (Book) unmarshaller.unmarshal(new File("book.xml"));
```
## 选择解析方式的建议
1. **选择 DOM**：当需要随机访问、修改文档，且文档较小时
2. **选择 SAX**：当处理大型文档，且只需要顺序读取时
3. **选择 StAX**：当需要更好的性能和更灵活的控制时
4. **选择 JAXB**：当需要在 XML 和对象模型之间进行转换时
## 性能优化建议
1. **使用合适的解析器**：根据文档大小和需求选择合适的解析方式
2. **启用验证**：在开发时启用 Schema 验证，生产环境可关闭以提高性能
3. **缓存解析结果**：对于频繁访问的文档，缓存解析结果
4. **使用流式处理**：对于大型文档，使用 SAX 或 StAX 进行流式处理
XML 解析是处理 XML 数据的核心技术，选择合适的解析方式可以显著提高应用程序的性能和可维护性。
计算机基础 · 2月21日 14:22
什么是 XPath，如何在 XML 中使用它来查询数据？XPath（XML Path Language）是一种用于在 XML 文档中定位和选择节点的语言。它提供了一种简洁而强大的方式来查询 XML 文档中的数据，类似于 SQL 在关系数据库中的作用。
## XPath 的基本概念
### 节点类型
XPath 将 XML 文档视为节点树，包含以下节点类型：
1. **元素节点**：XML 元素
2. **属性节点**：元素的属性
3. **文本节点**：元素或属性中的文本内容
4. **命名空间节点**：元素的命名空间
5. **处理指令节点**：XML 处理指令
6. **注释节点**：XML 注释
7. **文档节点**：整个文档的根节点
## XPath 语法
### 1. 基本路径表达式
```xml
<!-- 示例 XML -->
<bookstore>
<book category="web">
<title lang="en">XML Guide</title>
<author>John Doe</author>
<price>39.95</price>
</book>
<book category="database">
<title lang="en">SQL Basics</title>
<author>Jane Smith</author>
<price>29.99</price>
</book>
</bookstore>
```
```xpath
/* 选择文档节点（根节点）
/bookstore 选择根元素 bookstore
/bookstore/book 选择 bookstore 下的所有 book 元素
//book 选择文档中所有的 book 元素
bookstore//book 选择 bookstore 后代中的所有 book 元素
```
### 2. 谓语（Predicates）
谓语用于查找特定的节点，放在方括号 `[]` 中：
```xpath
/bookstore/book[1] 选择第一个 book 元素
/bookstore/book[last()] 选择最后一个 book 元素
/bookstore/book[position()<3] 选择前两个 book 元素
//book[@category='web'] 选择 category 属性为 'web' 的 book 元素
//book[price>35] 选择 price 大于 35 的 book 元素
```
### 3. 通配符
```xpath
* 匹配任何元素节点
@* 匹配任何属性节点
node() 匹配任何类型的节点
//book/* 选择 book 元素的所有子元素
```
### 4. 轴（Axes）
轴定义了相对于当前节点的节点集合：
```xpath
ancestor 选择当前节点的所有祖先节点
ancestor-or-self 选择当前节点及其所有祖先节点
attribute 选择当前节点的所有属性节点
child 选择当前节点的所有子节点
descendant 选择当前节点的所有后代节点
descendant-or-self 选择当前节点及其所有后代节点
following 选择文档中当前节点之后的所有节点
following-sibling 选择当前节点之后的所有同级节点
namespace 选择当前节点的所有命名空间节点
parent 选择当前节点的父节点
preceding 选择文档中当前节点之前的所有节点
preceding-sibling 选择当前节点之前的所有同级节点
self 选择当前节点本身
```
### 5. 运算符
```xpath
算术运算符：+ - * div mod
比较运算符：= != < > <= >=
布尔运算符：and or not()
```
## XPath 函数
### 节点集函数
```xpath
count(//book) 统计 book 元素的数量
id('b1') 选择 ID 为 'b1' 的元素
local-name() 返回节点的本地名称
namespace-uri() 返回节点的命名空间 URI
name() 返回节点的名称
```
### 字符串函数
```xpath
string() 将节点转换为字符串
concat('Hello', ' ', 'World') 连接字符串
starts-with(text, 'XML') 检查是否以指定字符串开头
contains(text, 'XML') 检查是否包含指定字符串
substring(text, 1, 3) 提取子字符串
string-length(text) 返回字符串长度
normalize-space(text) 规范化空白字符
translate(text, 'abc', 'XYZ') 字符替换
```
### 布尔函数
```xpath
boolean() 转换为布尔值
not() 逻辑非
true() 返回 true
false() 返回 false
lang() 检查语言设置
```
### 数字函数
```xpath
number() 转换为数字
sum(//price) 计算总和
floor(3.7) 向下取整
ceiling(3.2) 向上取整
round(3.7) 四舍五入
```
## XPath 实际应用示例
### 1. Java 中使用 XPath
```java
import javax.xml.xpath.*;
import org.w3c.dom.*;
XPathFactory factory = XPathFactory.newInstance();
XPath xpath = factory.newXPath();
// 解析 XML 文档
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = docFactory.newDocumentBuilder();
Document doc = builder.parse(new File("books.xml"));
// 执行 XPath 查询
String expression = "//book[@category='web']/title/text()";
String title = xpath.evaluate(expression, doc, XPathConstants.STRING);
System.out.println("Title: " + title);
// 获取节点列表
NodeList books = (NodeList) xpath.evaluate("//book", doc, XPathConstants.NODESET);
for (int i = 0; i < books.getLength(); i++) {
Element book = (Element) books.item(i);
System.out.println(book.getAttribute("category"));
}
```
### 2. Python 中使用 XPath（lxml）
```python
from lxml import etree
# 解析 XML 文档
tree = etree.parse("books.xml")
# 执行 XPath 查询
titles = tree.xpath("//book[@category='web']/title/text()")
for title in titles:
print(f"Title: {title}")
# 获取属性
categories = tree.xpath("//book/@category")
for category in categories:
print(f"Category: {category}")
# 使用函数
total_price = sum(tree.xpath("//book/price/text()"))
print(f"Total price: {total_price}")
```
### 3. JavaScript 中使用 XPath
```javascript
// 解析 XML
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
// 执行 XPath 查询
const result = xmlDoc.evaluate(
"//book[@category='web']/title",
xmlDoc,
null,
XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
null
);
for (let i = 0; i < result.snapshotLength; i++) {
const node = result.snapshotItem(i);
console.log(node.textContent);
}
```
## XPath 与 XQuery 的关系
XQuery 是基于 XPath 构建的查询语言，扩展了 XPath 的功能：
- XPath：用于定位和选择节点
- XQuery：用于查询、转换和构造 XML 数据
## XPath 最佳实践
1. **使用绝对路径**：当文档结构固定时，使用绝对路径提高性能
2. **避免使用 `//`**：`//` 会搜索整个文档，影响性能
3. **使用谓词过滤**：尽早过滤节点，减少处理的数据量
4. **利用索引**：在大型文档中，考虑使用索引优化查询
5. **缓存查询结果**：对于频繁执行的查询，缓存结果
XPath 是处理 XML 数据的强大工具，掌握 XPath 可以大大提高 XML 数据处理的效率和灵活性。
计算机基础 · 2月21日 14:22