活动公告

系统通知
通知：2026夏日主题满意度调查
06-22 18:10
系统通知
通知：微软邮箱更换提醒
06-14 00:00
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

XPath XML命名空间处理完全指南从基础到高级掌握实用技巧解决XML查询中的命名空间问题提升开发效率

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

3079

科技点

3万

积分

执行版主

碾压王

积分
32876

塔罗立华奏
执行版主 发表于 2025-9-21 23:50:03 | 显示全部楼层 |阅读模式

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

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

x
引言

XML（可扩展标记语言）作为一种广泛使用的数据交换格式，在众多应用场景中扮演着重要角色。而XPath则是XML文档查询和导航的强大工具，它提供了一种简洁的方式来定位XML文档中的元素和属性。然而，当XML文档使用命名空间（Namespaces）时，XPath查询变得复杂起来，许多开发者在这一环节遇到困难。

XML命名空间的设计初衷是为了避免元素和属性名称的冲突，但它确实给XPath查询带来了额外的复杂性。本指南将从基础概念出发，逐步深入到高级技巧，全面介绍如何在XPath中有效处理XML命名空间问题，帮助开发者提升处理XML文档的效率和能力。

XML命名空间基础

什么是XML命名空间？

XML命名空间是一种避免元素和属性命名冲突的机制。在XML文档中，不同的词汇表（vocabularies）可能会使用相同的元素名称，命名空间通过将这些名称与唯一的URI（统一资源标识符）关联起来，确保了名称的唯一性。

命名空间的声明语法

XML命名空间通过特殊的属性声明，通常以”xmlns:“开头：
  2. <root xmlns:book="http://www.example.com/books">
  3.     <book:title>XML Guide</book:title>
  4. </root>
复制代码

在这个例子中：

• xmlns:book声明了一个前缀为”book”的命名空间
• http://www.example.com/books是命名空间的URI
• book:title使用了这个命名空间

默认命名空间

XML还支持默认命名空间，即不使用前缀的命名空间：
  2. <root xmlns="http://www.example.com/default">
  3.     <title>Default Namespace</title>
  4. </root>
复制代码

在这个例子中，<root>元素及其所有没有前缀的子元素都属于默认命名空间http://www.example.com/default。

命名空间的作用域

命名空间声明的作用域从声明元素开始，到其对应的结束元素为止。子元素可以继承父元素的命名空间声明，也可以覆盖或声明新的命名空间。
  2. <root xmlns:book="http://www.example.com/books">
  3.     <book:library>
  4.         <book:book xmlns:book="http://www.example.com/new-books">
  5.             <book:title>New Book</book:title>
  6.         </book:book>
  7.     </book:library>
  8. </root>
复制代码

在这个例子中，内部的<book:book>元素重新定义了book前缀，覆盖了外部定义。

XPath基础

XPath表达式的基本语法

XPath使用路径表达式来选取XML文档中的节点或节点集。这些路径表达式类似于文件系统中的路径。
  2. <!-- 示例XML文档 -->
  3. <bookstore>
  4.     <book category="cooking">
  5.         <title lang="en">Everyday Italian</title>
  6.         <author>Giada De Laurentiis</author>
  7.         <year>2005</year>
  8.         <price>30.00</price>
  9.     </book>
  10.     <book category="children">
  11.         <title lang="en">Harry Potter</title>
  12.         <author>J.K. Rowling</author>
  13.         <year>2005</year>
  14.         <price>29.99</price>
  15.     </book>
  16. </bookstore>
复制代码

基本的XPath表达式示例：
  2. /bookstore/book/title  <!-- 选取所有book元素下的title子元素 -->
  3. //title               <!-- 选取文档中所有的title元素 -->
  4. //@category           <!-- 选取所有名为category的属性 -->
  5. /bookstore/book[1]    <!-- 选取bookstore下的第一个book元素 -->
  6. //title[@lang='en']   <!-- 选取所有具有lang属性且值为en的title元素 -->
复制代码

轴（Axes）

XPath轴定义了相对于当前节点的节点集。常用的轴包括：

• child：选取当前节点的所有子元素（默认轴）
• attribute：选取当前节点的所有属性
• descendant：选取当前节点的所有后代元素（子、孙等）
• ancestor：选取当前节点的所有祖先元素（父、祖父等）
• following-sibling：选取当前节点之后的所有同级节点
• preceding-sibling：选取当前节点之前的所有同级节点
  2. child::book      <!-- 选取当前节点的所有book子元素 -->
  3. attribute::lang  <!-- 选取当前节点的lang属性 -->
  4. descendant::title <!-- 选取当前节点的所有title后代元素 -->
复制代码

节点测试

节点测试用于筛选轴中的节点。常见的节点测试包括：

• 节点名称（如book、title）
• node()：任何类型的节点
• text()：文本节点
• comment()：注释节点
• processing-instruction()：处理指令
  2. child::text()    <!-- 选取当前节点的所有文本子节点 -->
  3. child::node()    <!-- 选取当前节点的所有类型的子节点 -->
复制代码

谓语（Predicates）

谓语用于查找某个特定的节点或者包含某个指定值的节点，被嵌在方括号[]中。
  2. /bookstore/book[1]          <!-- 选取bookstore下的第一个book元素 -->
  3. //book[price>35.00]         <!-- 选取所有price元素值大于35的book元素 -->
  4. //book[category='cooking']  <!-- 选取所有category属性为cooking的book元素 -->
  5. //book[position()<3]        <!-- 选取前两个book元素 -->
复制代码

函数和运算符

XPath提供了丰富的函数库和运算符，用于处理和筛选数据。

常用函数：

• count(node-set)：计算节点集中的节点数
• string(value)：将值转换为字符串
• concat(string, string, ...)：连接字符串
• starts-with(string, string)：检查字符串是否以指定字符串开头
• contains(string, string)：检查字符串是否包含指定字符串
• substring(string, start, length)：提取子字符串
• number(value)：将值转换为数字
• sum(node-set)：计算节点集中所有数值节点的和
  2. count(//book)                          <!-- 计算文档中book元素的数量 -->
  3. string(//book[1]/price)                <!-- 将第一个book的price转换为字符串 -->
  4. concat(//book[1]/title, ' by ', //book[1]/author) <!-- 连接字符串 -->
  5. //book[starts-with(title, 'Everyday')] <!-- 选取title以Everyday开头的book -->
  6. //book[contains(title, 'Potter')]      <!-- 选取title包含Potter的book -->
  7. sum(//book/price)                      <!-- 计算所有book的price总和 -->
复制代码

XPath中的命名空间问题

当XML文档使用命名空间时，简单的XPath表达式往往无法正确匹配元素，这是开发者经常遇到的问题。让我们通过一个例子来说明这个问题：
  2. <!-- 带有命名空间的XML文档 -->
  3. <bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">
  4.     <book:book category="cooking">
  5.         <book:title lang="en">Everyday Italian</book:title>
  6.         <auth:author>Giada De Laurentiis</auth:author>
  7.         <book:year>2005</book:year>
  8.         <book:price>30.00</book:price>
  9.     </book:book>
  10.     <book:book category="children">
  11.         <book:title lang="en">Harry Potter</book:title>
  12.         <auth:author>J.K. Rowling</auth:author>
  13.         <book:year>2005</book:year>
  14.         <book:price>29.99</book:price>
  15.     </book:book>
  16. </bookstore>
复制代码

为什么简单的XPath表达式无法匹配带有命名空间的元素？

对于上面的XML文档，如果我们尝试使用简单的XPath表达式：
  2. //book
复制代码

这个表达式将无法匹配任何元素，因为XML文档中的book元素实际上属于http://www.example.com/books命名空间，而XPath表达式中的book没有指定命名空间。

默认命名空间的影响

默认命名空间也会带来问题。考虑以下XML文档：
  2. <bookstore xmlns="http://www.example.com/bookstore">
  3.     <book category="cooking">
  4.         <title lang="en">Everyday Italian</title>
  5.         <author>Giada De Laurentiis</author>
  6.         <year>2005</year>
  7.         <price>30.00</price>
  8.     </book>
  9.     <book category="children">
  10.         <title lang="en">Harry Potter</title>
  11.         <author>J.K. Rowling</author>
  12.         <year>2005</year>
  13.         <price>29.99</price>
  14.     </book>
  15. </bookstore>
复制代码

在这个例子中，所有元素都属于默认命名空间http://www.example.com/bookstore。如果我们尝试使用XPath表达式：
  2. //book
复制代码

同样无法匹配任何元素，因为XPath表达式中的book没有命名空间，而XML文档中的book元素属于默认命名空间。

命名空间冲突问题

当不同的命名空间使用相同的元素名称时，可能会导致命名空间冲突：
  2. <document xmlns:doc="http://www.example.com/document" xmlns:meta="http://www.example.com/metadata">
  3.     <doc:title>Document Title</doc:title>
  4.     <meta:title>Metadata Title</meta:title>
  5. </document>
复制代码

在这个例子中，有两个不同的title元素，分别属于不同的命名空间。如果我们想要选择特定的title元素，必须指定正确的命名空间。

解决命名空间问题的基本方法

使用命名空间前缀

最直接的方法是在XPath表达式中使用命名空间前缀。但是，这需要我们在执行XPath查询之前，将命名空间URI与前缀关联起来。
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import javax.xml.namespace.NamespaceContext;
  9. import org.w3c.dom.Document;
  10. import org.w3c.dom.NodeList;
  11. import java.io.StringReader;
  12. import org.xml.sax.InputSource;
  14. public class XPathNamespaceExample {
  15.     public static void main(String[] args) throws Exception {
  16.         String xml = "<bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">" +
  17.                      "    <book:book category="cooking">" +
  18.                      "        <book:title lang="en">Everyday Italian</book:title>" +
  19.                      "        <auth:author>Giada De Laurentiis</auth:author>" +
  20.                      "        <book:year>2005</book:year>" +
  21.                      "        <book:price>30.00</book:price>" +
  22.                      "    </book:book>" +
  23.                      "    <book:book category="children">" +
  24.                      "        <book:title lang="en">Harry Potter</book:title>" +
  25.                      "        <auth:author>J.K. Rowling</auth:author>" +
  26.                      "        <book:year>2005</book:year>" +
  27.                      "        <book:price>29.99</book:price>" +
  28.                      "    </book:book>" +
  29.                      "</bookstore>";
  31.         // 创建DOM文档
  32.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  33.         factory.setNamespaceAware(true); // 重要：启用命名空间支持
  34.         DocumentBuilder builder = factory.newDocumentBuilder();
  35.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  37.         // 创建XPath对象
  38.         XPathFactory xPathFactory = XPathFactory.newInstance();
  39.         XPath xpath = xPathFactory.newXPath();
  41.         // 设置命名空间上下文
  42.         NamespaceContext ctx = new SimpleNamespaceContext();
  43.         xpath.setNamespaceContext(ctx);
  45.         // 使用命名空间前缀的XPath表达式
  46.         XPathExpression expr = xpath.compile("//book:book");
  47.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  49.         // 输出结果
  50.         for (int i = 0; i < nodes.getLength(); i++) {
  51.             System.out.println(nodes.item(i).getTextContent());
  52.         }
  53.     }
  54. }
  56. // 简单的命名空间上下文实现
  57. class SimpleNamespaceContext implements NamespaceContext {
  58.     @Override
  59.     public String getNamespaceURI(String prefix) {
  60.         if ("book".equals(prefix)) {
  61.             return "http://www.example.com/books";
  62.         } else if ("auth".equals(prefix)) {
  63.             return "http://www.example.com/authors";
  64.         }
  65.         return null;
  66.     }
  68.     @Override
  69.     public String getPrefix(String namespaceURI) {
  70.         if ("http://www.example.com/books".equals(namespaceURI)) {
  71.             return "book";
  72.         } else if ("http://www.example.com/authors".equals(namespaceURI)) {
  73.             return "auth";
  74.         }
  75.         return null;
  76.     }
  78.     @Override
  79.     public java.util.Iterator<String> getPrefixes(String namespaceURI) {
  80.         java.util.Set<String> prefixes = new java.util.HashSet<String>();
  81.         if ("http://www.example.com/books".equals(namespaceURI)) {
  82.             prefixes.add("book");
  83.         } else if ("http://www.example.com/authors".equals(namespaceURI)) {
  84.             prefixes.add("auth");
  85.         }
  86.         return prefixes.iterator();
  87.     }
  88. }
复制代码
  2. from lxml import etree
  4. xml = """
  5. <bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">
  6.     <book:book category="cooking">
  7.         <book:title lang="en">Everyday Italian</book:title>
  8.         <auth:author>Giada De Laurentiis</auth:author>
  9.         <book:year>2005</book:year>
  10.         <book:price>30.00</book:price>
  11.     </book:book>
  12.     <book:book category="children">
  13.         <book:title lang="en">Harry Potter</book:title>
  14.         <auth:author>J.K. Rowling</auth:author>
  15.         <book:year>2005</book:year>
  16.         <book:price>29.99</book:price>
  17.     </book:book>
  18. </bookstore>
  19. """
  21. # 解析XML
  22. doc = etree.fromstring(xml)
  24. # 定义命名空间映射
  25. ns = {
  26.     'book': 'http://www.example.com/books',
  27.     'auth': 'http://www.example.com/authors'
  28. }
  30. # 使用命名空间前缀的XPath表达式
  31. books = doc.xpath('//book:book', namespaces=ns)
  33. # 输出结果
  34. for book in books:
  35.     print(etree.tostring(book, encoding='unicode'))
复制代码

处理默认命名空间

处理默认命名空间时，我们需要为其分配一个前缀，然后在XPath表达式中使用这个前缀。
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import javax.xml.namespace.NamespaceContext;
  9. import org.w3c.dom.Document;
  10. import org.w3c.dom.NodeList;
  11. import java.io.StringReader;
  12. import org.xml.sax.InputSource;
  14. public class XPathDefaultNamespaceExample {
  15.     public static void main(String[] args) throws Exception {
  16.         String xml = "<bookstore xmlns="http://www.example.com/bookstore">" +
  17.                      "    <book category="cooking">" +
  18.                      "        <title lang="en">Everyday Italian</title>" +
  19.                      "        <author>Giada De Laurentiis</author>" +
  20.                      "        <year>2005</year>" +
  21.                      "        <price>30.00</price>" +
  22.                      "    </book>" +
  23.                      "    <book category="children">" +
  24.                      "        <title lang="en">Harry Potter</title>" +
  25.                      "        <author>J.K. Rowling</author>" +
  26.                      "        <year>2005</year>" +
  27.                      "        <price>29.99</price>" +
  28.                      "    </book>" +
  29.                      "</bookstore>";
  31.         // 创建DOM文档
  32.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  33.         factory.setNamespaceAware(true); // 重要：启用命名空间支持
  34.         DocumentBuilder builder = factory.newDocumentBuilder();
  35.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  37.         // 创建XPath对象
  38.         XPathFactory xPathFactory = XPathFactory.newInstance();
  39.         XPath xpath = xPathFactory.newXPath();
  41.         // 设置命名空间上下文，为默认命名空间分配前缀
  42.         NamespaceContext ctx = new DefaultNamespaceContext();
  43.         xpath.setNamespaceContext(ctx);
  45.         // 使用命名空间前缀的XPath表达式
  46.         XPathExpression expr = xpath.compile("//ns:book");
  47.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  49.         // 输出结果
  50.         for (int i = 0; i < nodes.getLength(); i++) {
  51.             System.out.println(nodes.item(i).getTextContent());
  52.         }
  53.     }
  54. }
  56. // 处理默认命名空间的上下文实现
  57. class DefaultNamespaceContext implements NamespaceContext {
  58.     @Override
  59.     public String getNamespaceURI(String prefix) {
  60.         if ("ns".equals(prefix)) {
  61.             return "http://www.example.com/bookstore";
  62.         }
  63.         return null;
  64.     }
  66.     @Override
  67.     public String getPrefix(String namespaceURI) {
  68.         if ("http://www.example.com/bookstore".equals(namespaceURI)) {
  69.             return "ns";
  70.         }
  71.         return null;
  72.     }
  74.     @Override
  75.     public java.util.Iterator<String> getPrefixes(String namespaceURI) {
  76.         java.util.Set<String> prefixes = new java.util.HashSet<String>();
  77.         if ("http://www.example.com/bookstore".equals(namespaceURI)) {
  78.             prefixes.add("ns");
  79.         }
  80.         return prefixes.iterator();
  81.     }
  82. }
复制代码
  2. from lxml import etree
  4. xml = """
  5. <bookstore xmlns="http://www.example.com/bookstore">
  6.     <book category="cooking">
  7.         <title lang="en">Everyday Italian</title>
  8.         <author>Giada De Laurentiis</author>
  9.         <year>2005</year>
  10.         <price>30.00</price>
  11.     </book>
  12.     <book category="children">
  13.         <title lang="en">Harry Potter</title>
  14.         <author>J.K. Rowling</author>
  15.         <year>2005</year>
  16.         <price>29.99</price>
  17.     </book>
  18. </bookstore>
  19. """
  21. # 解析XML
  22. doc = etree.fromstring(xml)
  24. # 定义命名空间映射，为默认命名空间分配前缀
  25. ns = {
  26.     'ns': 'http://www.example.com/bookstore'
  27. }
  29. # 使用命名空间前缀的XPath表达式
  30. books = doc.xpath('//ns:book', namespaces=ns)
  32. # 输出结果
  33. for book in books:
  34.     print(etree.tostring(book, encoding='unicode'))
复制代码

高级命名空间处理技巧

处理动态命名空间

有时，XML文档中的命名空间URI可能是动态生成的，或者在不同文档中有所不同。在这种情况下，我们可以使用XPath函数来处理命名空间。

local-name()函数返回节点的本地名称（不带命名空间前缀），这使我们可以忽略命名空间进行匹配。
  2. <!-- 动态命名空间示例 -->
  3. <bookstore xmlns:ns1="http://www.example.com/12345">
  4.     <ns1:book category="cooking">
  5.         <ns1:title lang="en">Everyday Italian</ns1:title>
  6.     </ns1:book>
  7. </bookstore>
复制代码
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import org.w3c.dom.Document;
  9. import org.w3c.dom.NodeList;
  10. import java.io.StringReader;
  11. import org.xml.sax.InputSource;
  13. public class XPathDynamicNamespaceExample {
  14.     public static void main(String[] args) throws Exception {
  15.         String xml = "<bookstore xmlns:ns1="http://www.example.com/12345">" +
  16.                      "    <ns1:book category="cooking">" +
  17.                      "        <ns1:title lang="en">Everyday Italian</ns1:title>" +
  18.                      "    </ns1:book>" +
  19.                      "</bookstore>";
  21.         // 创建DOM文档
  22.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  23.         factory.setNamespaceAware(true);
  24.         DocumentBuilder builder = factory.newDocumentBuilder();
  25.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  27.         // 创建XPath对象
  28.         XPathFactory xPathFactory = XPathFactory.newInstance();
  29.         XPath xpath = xPathFactory.newXPath();
  31.         // 使用local-name()函数忽略命名空间
  32.         XPathExpression expr = xpath.compile("//*[local-name()='book']");
  33.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  35.         // 输出结果
  36.         for (int i = 0; i < nodes.getLength(); i++) {
  37.             System.out.println(nodes.item(i).getTextContent());
  38.         }
  39.     }
  40. }
复制代码
  2. from lxml import etree
  4. xml = """
  5. <bookstore xmlns:ns1="http://www.example.com/12345">
  6.     <ns1:book category="cooking">
  7.         <ns1:title lang="en">Everyday Italian</ns1:title>
  8.     </ns1:book>
  9. </bookstore>
  10. """
  12. # 解析XML
  13. doc = etree.fromstring(xml)
  15. # 使用local-name()函数忽略命名空间
  16. books = doc.xpath("//*[local-name()='book']")
  18. # 输出结果
  19. for book in books:
  20.     print(etree.tostring(book, encoding='unicode'))
复制代码

namespace-uri()函数返回节点的命名空间URI，这使我们可以根据命名空间URI进行匹配。
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import org.w3c.dom.Document;
  9. import org.w3c.dom.NodeList;
  10. import java.io.StringReader;
  11. import org.xml.sax.InputSource;
  13. public class XPathNamespaceURIExample {
  14.     public static void main(String[] args) throws Exception {
  15.         String xml = "<bookstore xmlns:ns1="http://www.example.com/12345">" +
  16.                      "    <ns1:book category="cooking">" +
  17.                      "        <ns1:title lang="en">Everyday Italian</ns1:title>" +
  18.                      "    </ns1:book>" +
  19.                      "</bookstore>";
  21.         // 创建DOM文档
  22.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  23.         factory.setNamespaceAware(true);
  24.         DocumentBuilder builder = factory.newDocumentBuilder();
  25.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  27.         // 创建XPath对象
  28.         XPathFactory xPathFactory = XPathFactory.newInstance();
  29.         XPath xpath = xPathFactory.newXPath();
  31.         // 使用namespace-uri()函数匹配命名空间
  32.         XPathExpression expr = xpath.compile("//*[namespace-uri()='http://www.example.com/12345']");
  33.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  35.         // 输出结果
  36.         for (int i = 0; i < nodes.getLength(); i++) {
  37.             System.out.println(nodes.item(i).getTextContent());
  38.         }
  39.     }
  40. }
复制代码
  2. from lxml import etree
  4. xml = """
  5. <bookstore xmlns:ns1="http://www.example.com/12345">
  6.     <ns1:book category="cooking">
  7.         <ns1:title lang="en">Everyday Italian</ns1:title>
  8.     </ns1:book>
  9. </bookstore>
  10. """
  12. # 解析XML
  13. doc = etree.fromstring(xml)
  15. # 使用namespace-uri()函数匹配命名空间
  16. books = doc.xpath("//*[namespace-uri()='http://www.example.com/12345']")
  18. # 输出结果
  19. for book in books:
  20.     print(etree.tostring(book, encoding='unicode'))
复制代码

处理嵌套命名空间

当XML文档中包含嵌套的命名空间声明时，我们需要特别注意命名空间的作用域。
  2. <root xmlns="http://www.example.com/root">
  3.     <child xmlns="http://www.example.com/child">
  4.         <grandchild xmlns="http://www.example.com/grandchild">
  5.             Content
  6.         </grandchild>
  7.     </child>
  8. </root>
复制代码

在这种情况下，每个元素都属于不同的命名空间，即使它们使用了相同的本地名称。
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import javax.xml.namespace.NamespaceContext;
  9. import org.w3c.dom.Document;
  10. import org.w3c.dom.NodeList;
  11. import java.io.StringReader;
  12. import org.xml.sax.InputSource;
  14. public class XPathNestedNamespaceExample {
  15.     public static void main(String[] args) throws Exception {
  16.         String xml = "<root xmlns="http://www.example.com/root">" +
  17.                      "    <child xmlns="http://www.example.com/child">" +
  18.                      "        <grandchild xmlns="http://www.example.com/grandchild">" +
  19.                      "            Content" +
  20.                      "        </grandchild>" +
  21.                      "    </child>" +
  22.                      "</root>";
  24.         // 创建DOM文档
  25.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  26.         factory.setNamespaceAware(true);
  27.         DocumentBuilder builder = factory.newDocumentBuilder();
  28.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  30.         // 创建XPath对象
  31.         XPathFactory xPathFactory = XPathFactory.newInstance();
  32.         XPath xpath = xPathFactory.newXPath();
  34.         // 设置命名空间上下文
  35.         NamespaceContext ctx = new NestedNamespaceContext();
  36.         xpath.setNamespaceContext(ctx);
  38.         // 使用命名空间前缀的XPath表达式
  39.         XPathExpression expr = xpath.compile("//root:child/child:grandchild");
  40.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  42.         // 输出结果
  43.         for (int i = 0; i < nodes.getLength(); i++) {
  44.             System.out.println(nodes.item(i).getTextContent());
  45.         }
  46.     }
  47. }
  49. // 处理嵌套命名空间的上下文实现
  50. class NestedNamespaceContext implements NamespaceContext {
  51.     @Override
  52.     public String getNamespaceURI(String prefix) {
  53.         if ("root".equals(prefix)) {
  54.             return "http://www.example.com/root";
  55.         } else if ("child".equals(prefix)) {
  56.             return "http://www.example.com/child";
  57.         } else if ("grandchild".equals(prefix)) {
  58.             return "http://www.example.com/grandchild";
  59.         }
  60.         return null;
  61.     }
  63.     @Override
  64.     public String getPrefix(String namespaceURI) {
  65.         if ("http://www.example.com/root".equals(namespaceURI)) {
  66.             return "root";
  67.         } else if ("http://www.example.com/child".equals(namespaceURI)) {
  68.             return "child";
  69.         } else if ("http://www.example.com/grandchild".equals(namespaceURI)) {
  70.             return "grandchild";
  71.         }
  72.         return null;
  73.     }
  75.     @Override
  76.     public java.util.Iterator<String> getPrefixes(String namespaceURI) {
  77.         java.util.Set<String> prefixes = new java.util.HashSet<String>();
  78.         if ("http://www.example.com/root".equals(namespaceURI)) {
  79.             prefixes.add("root");
  80.         } else if ("http://www.example.com/child".equals(namespaceURI)) {
  81.             prefixes.add("child");
  82.         } else if ("http://www.example.com/grandchild".equals(namespaceURI)) {
  83.             prefixes.add("grandchild");
  84.         }
  85.         return prefixes.iterator();
  86.     }
  87. }
复制代码
  2. from lxml import etree
  4. xml = """
  5. <root xmlns="http://www.example.com/root">
  6.     <child xmlns="http://www.example.com/child">
  7.         <grandchild xmlns="http://www.example.com/grandchild">
  8.             Content
  9.         </grandchild>
  10.     </child>
  11. </root>
  12. """
  14. # 解析XML
  15. doc = etree.fromstring(xml)
  17. # 定义命名空间映射
  18. ns = {
  19.     'root': 'http://www.example.com/root',
  20.     'child': 'http://www.example.com/child',
  21.     'grandchild': 'http://www.example.com/grandchild'
  22. }
  24. # 使用命名空间前缀的XPath表达式
  25. grandchildren = doc.xpath("//root:child/child:grandchild", namespaces=ns)
  27. # 输出结果
  28. for grandchild in grandchildren:
  29.     print(grandchild.text)
复制代码

忽略命名空间的技巧

在某些情况下，我们可能希望完全忽略命名空间，直接根据本地名称匹配元素。虽然这不是最佳实践，但在某些特定场景下可能会很有用。
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import org.w3c.dom.Document;
  9. import org.w3c.dom.NodeList;
  10. import java.io.StringReader;
  11. import org.xml.sax.InputSource;
  13. public class XPathIgnoreNamespaceExample {
  14.     public static void main(String[] args) throws Exception {
  15.         String xml = "<bookstore xmlns:book="http://www.example.com/books">" +
  16.                      "    <book:book category="cooking">" +
  17.                      "        <book:title lang="en">Everyday Italian</book:title>" +
  18.                      "    </book:book>" +
  19.                      "</bookstore>";
  21.         // 创建DOM文档
  22.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  23.         factory.setNamespaceAware(true);
  24.         DocumentBuilder builder = factory.newDocumentBuilder();
  25.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  27.         // 创建XPath对象
  28.         XPathFactory xPathFactory = XPathFactory.newInstance();
  29.         XPath xpath = xPathFactory.newXPath();
  31.         // 使用local-name()函数忽略命名空间
  32.         XPathExpression expr = xpath.compile("//*[local-name()='book']");
  33.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  35.         // 输出结果
  36.         for (int i = 0; i < nodes.getLength(); i++) {
  37.             System.out.println(nodes.item(i).getTextContent());
  38.         }
  39.     }
  40. }
复制代码
  2. from lxml import etree
  4. xml = """
  5. <bookstore xmlns:book="http://www.example.com/books">
  6.     <book:book category="cooking">
  7.         <book:title lang="en">Everyday Italian</book:title>
  8.     </book:book>
  9. </bookstore>
  10. """
  12. # 解析XML
  13. doc = etree.fromstring(xml)
  15. # 使用local-name()函数忽略命名空间
  16. books = doc.xpath("//*[local-name()='book']")
  18. # 输出结果
  19. for book in books:
  20.     print(etree.tostring(book, encoding='unicode'))
复制代码

不同编程语言中的实现

Java中的实现

Java提供了多种处理XML和XPath的API，包括DOM、JDOM、DOM4J等。下面展示几种常见的实现方式。
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import javax.xml.namespace.NamespaceContext;
  9. import org.w3c.dom.Document;
  10. import org.w3c.dom.NodeList;
  11. import java.io.StringReader;
  12. import org.xml.sax.InputSource;
  14. public class JavaDomXPathExample {
  15.     public static void main(String[] args) throws Exception {
  16.         String xml = "<bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">" +
  17.                      "    <book:book category="cooking">" +
  18.                      "        <book:title lang="en">Everyday Italian</book:title>" +
  19.                      "        <auth:author>Giada De Laurentiis</auth:author>" +
  20.                      "        <book:year>2005</book:year>" +
  21.                      "        <book:price>30.00</book:price>" +
  22.                      "    </book:book>" +
  23.                      "    <book:book category="children">" +
  24.                      "        <book:title lang="en">Harry Potter</book:title>" +
  25.                      "        <auth:author>J.K. Rowling</auth:author>" +
  26.                      "        <book:year>2005</book:year>" +
  27.                      "        <book:price>29.99</book:price>" +
  28.                      "    </book:book>" +
  29.                      "</bookstore>";
  31.         // 创建DOM文档
  32.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  33.         factory.setNamespaceAware(true);
  34.         DocumentBuilder builder = factory.newDocumentBuilder();
  35.         Document doc = builder.parse(new InputSource(new StringReader(xml)));
  37.         // 创建XPath对象
  38.         XPathFactory xPathFactory = XPathFactory.newInstance();
  39.         XPath xpath = xPathFactory.newXPath();
  41.         // 设置命名空间上下文
  42.         NamespaceContext ctx = new BookNamespaceContext();
  43.         xpath.setNamespaceContext(ctx);
  45.         // 查询所有书籍
  46.         XPathExpression expr = xpath.compile("//book:book");
  47.         NodeList books = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  49.         // 输出结果
  50.         for (int i = 0; i < books.getLength(); i++) {
  51.             System.out.println("Book " + (i + 1) + ":");
  52.             
  53.             // 获取标题
  54.             expr = xpath.compile("book:title", books.item(i));
  55.             String title = (String) expr.evaluate(books.item(i), XPathConstants.STRING);
  56.             System.out.println("  Title: " + title);
  57.             
  58.             // 获取作者
  59.             expr = xpath.compile("auth:author", books.item(i));
  60.             String author = (String) expr.evaluate(books.item(i), XPathConstants.STRING);
  61.             System.out.println("  Author: " + author);
  62.             
  63.             // 获取价格
  64.             expr = xpath.compile("book:price", books.item(i));
  65.             String price = (String) expr.evaluate(books.item(i), XPathConstants.STRING);
  66.             System.out.println("  Price: " + price);
  67.             
  68.             System.out.println();
  69.         }
  70.     }
  71. }
  73. class BookNamespaceContext implements NamespaceContext {
  74.     @Override
  75.     public String getNamespaceURI(String prefix) {
  76.         if ("book".equals(prefix)) {
  77.             return "http://www.example.com/books";
  78.         } else if ("auth".equals(prefix)) {
  79.             return "http://www.example.com/authors";
  80.         }
  81.         return null;
  82.     }
  84.     @Override
  85.     public String getPrefix(String namespaceURI) {
  86.         if ("http://www.example.com/books".equals(namespaceURI)) {
  87.             return "book";
  88.         } else if ("http://www.example.com/authors".equals(namespaceURI)) {
  89.             return "auth";
  90.         }
  91.         return null;
  92.     }
  94.     @Override
  95.     public java.util.Iterator<String> getPrefixes(String namespaceURI) {
  96.         java.util.Set<String> prefixes = new java.util.HashSet<String>();
  97.         if ("http://www.example.com/books".equals(namespaceURI)) {
  98.             prefixes.add("book");
  99.         } else if ("http://www.example.com/authors".equals(namespaceURI)) {
  100.             prefixes.add("auth");
  101.         }
  102.         return prefixes.iterator();
  103.     }
  104. }
复制代码
  2. import org.jdom2.Document;
  3. import org.jdom2.Element;
  4. import org.jdom2.Namespace;
  5. import org.jdom2.input.SAXBuilder;
  6. import org.jdom2.xpath.XPathFactory;
  7. import org.jdom2.xpath.XPathExpression;
  8. import java.io.StringReader;
  9. import java.util.List;
  11. public class JavaJdomXPathExample {
  12.     public static void main(String[] args) throws Exception {
  13.         String xml = "<bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">" +
  14.                      "    <book:book category="cooking">" +
  15.                      "        <book:title lang="en">Everyday Italian</book:title>" +
  16.                      "        <auth:author>Giada De Laurentiis</auth:author>" +
  17.                      "        <book:year>2005</book:year>" +
  18.                      "        <book:price>30.00</book:price>" +
  19.                      "    </book:book>" +
  20.                      "    <book:book category="children">" +
  21.                      "        <book:title lang="en">Harry Potter</book:title>" +
  22.                      "        <auth:author>J.K. Rowling</auth:author>" +
  23.                      "        <book:year>2005</book:year>" +
  24.                      "        <book:price>29.99</book:price>" +
  25.                      "    </book:book>" +
  26.                      "</bookstore>";
  28.         // 解析XML
  29.         SAXBuilder builder = new SAXBuilder();
  30.         Document doc = builder.build(new StringReader(xml));
  32.         // 定义命名空间
  33.         Namespace bookNs = Namespace.getNamespace("book", "http://www.example.com/books");
  34.         Namespace authNs = Namespace.getNamespace("auth", "http://www.example.com/authors");
  36.         // 创建XPath表达式
  37.         XPathExpression<Element> expr = XPathFactory.instance().compile("//book:book",
  38.             new org.jdom2.filter.ElementFilter(), null, bookNs);
  40.         // 执行查询
  41.         List<Element> books = expr.evaluate(doc);
  43.         // 输出结果
  44.         for (int i = 0; i < books.size(); i++) {
  45.             Element book = books.get(i);
  46.             System.out.println("Book " + (i + 1) + ":");
  47.             
  48.             // 获取标题
  49.             Element title = book.getChild("title", bookNs);
  50.             System.out.println("  Title: " + title.getText());
  51.             
  52.             // 获取作者
  53.             Element author = book.getChild("author", authNs);
  54.             System.out.println("  Author: " + author.getText());
  55.             
  56.             // 获取价格
  57.             Element price = book.getChild("price", bookNs);
  58.             System.out.println("  Price: " + price.getText());
  59.             
  60.             System.out.println();
  61.         }
  62.     }
  63. }
复制代码

Python中的实现

Python提供了多种处理XML的库，包括lxml、ElementTree、minidom等。下面展示几种常见的实现方式。
  2. from lxml import etree
  4. xml = """
  5. <bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">
  6.     <book:book category="cooking">
  7.         <book:title lang="en">Everyday Italian</book:title>
  8.         <auth:author>Giada De Laurentiis</auth:author>
  9.         <book:year>2005</book:year>
  10.         <book:price>30.00</book:price>
  11.     </book:book>
  12.     <book:book category="children">
  13.         <book:title lang="en">Harry Potter</book:title>
  14.         <auth:author>J.K. Rowling</auth:author>
  15.         <book:year>2005</book:year>
  16.         <book:price>29.99</book:price>
  17.     </book:book>
  18. </bookstore>
  19. """
  21. # 解析XML
  22. doc = etree.fromstring(xml)
  24. # 定义命名空间映射
  25. ns = {
  26.     'book': 'http://www.example.com/books',
  27.     'auth': 'http://www.example.com/authors'
  28. }
  30. # 查询所有书籍
  31. books = doc.xpath('//book:book', namespaces=ns)
  33. # 输出结果
  34. for i, book in enumerate(books, 1):
  35.     print(f"Book {i}:")
  36.    
  37.     # 获取标题
  38.     title = book.xpath('book:title/text()', namespaces=ns)[0]
  39.     print(f"  Title: {title}")
  40.    
  41.     # 获取作者
  42.     author = book.xpath('auth:author/text()', namespaces=ns)[0]
  43.     print(f"  Author: {author}")
  44.    
  45.     # 获取价格
  46.     price = book.xpath('book:price/text()', namespaces=ns)[0]
  47.     print(f"  Price: {price}")
  48.    
  49.     print()
复制代码
  2. import xml.etree.ElementTree as ET
  4. xml = """
  5. <bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">
  6.     <book:book category="cooking">
  7.         <book:title lang="en">Everyday Italian</book:title>
  8.         <auth:author>Giada De Laurentiis</auth:author>
  9.         <book:year>2005</book:year>
  10.         <book:price>30.00</book:price>
  11.     </book:book>
  12.     <book:book category="children">
  13.         <book:title lang="en">Harry Potter</book:title>
  14.         <auth:author>J.K. Rowling</auth:author>
  15.         <book:year>2005</book:year>
  16.         <book:price>29.99</book:price>
  17.     </book:book>
  18. </bookstore>
  19. """
  21. # 解析XML
  22. root = ET.fromstring(xml)
  24. # 定义命名空间映射
  25. ns = {
  26.     'book': 'http://www.example.com/books',
  27.     'auth': 'http://www.example.com/authors'
  28. }
  30. # 查询所有书籍
  31. books = root.findall('.//book:book', ns)
  33. # 输出结果
  34. for i, book in enumerate(books, 1):
  35.     print(f"Book {i}:")
  36.    
  37.     # 获取标题
  38.     title = book.find('book:title', ns).text
  39.     print(f"  Title: {title}")
  40.    
  41.     # 获取作者
  42.     author = book.find('auth:author', ns).text
  43.     print(f"  Author: {author}")
  44.    
  45.     # 获取价格
  46.     price = book.find('book:price', ns).text
  47.     print(f"  Price: {price}")
  48.    
  49.     print()
复制代码

C#中的实现

C#提供了System.Xml命名空间来处理XML和XPath。
  2. using System;
  3. using System.Xml;
  4. using System.Xml.XPath;
  6. class CSharpXPathExample
  7. {
  8.     static void Main(string[] args)
  9.     {
  10.         string xml = @"<bookstore xmlns:book=""http://www.example.com/books"" xmlns:auth=""http://www.example.com/authors"">
  11.                         <book:book category=""cooking"">
  12.                             <book:title lang=""en"">Everyday Italian</book:title>
  13.                             <auth:author>Giada De Laurentiis</auth:author>
  14.                             <book:year>2005</book:year>
  15.                             <book:price>30.00</book:price>
  16.                         </book:book>
  17.                         <book:book category=""children"">
  18.                             <book:title lang=""en"">Harry Potter</book:title>
  19.                             <auth:author>J.K. Rowling</auth:author>
  20.                             <book:year>2005</book:year>
  21.                             <book:price>29.99</book:price>
  22.                         </book:book>
  23.                       </bookstore>";
  25.         // 创建XmlDocument
  26.         XmlDocument doc = new XmlDocument();
  27.         doc.LoadXml(xml);
  29.         // 创建XmlNamespaceManager
  30.         XmlNamespaceManager nsMgr = new XmlNamespaceManager(doc.NameTable);
  31.         nsMgr.AddNamespace("book", "http://www.example.com/books");
  32.         nsMgr.AddNamespace("auth", "http://www.example.com/authors");
  34.         // 查询所有书籍
  35.         XmlNodeList books = doc.SelectNodes("//book:book", nsMgr);
  37.         // 输出结果
  38.         for (int i = 0; i < books.Count; i++)
  39.         {
  40.             Console.WriteLine($"Book {i + 1}:");
  41.             
  42.             // 获取标题
  43.             XmlNode title = books[i].SelectSingleNode("book:title", nsMgr);
  44.             Console.WriteLine($"  Title: {title.InnerText}");
  45.             
  46.             // 获取作者
  47.             XmlNode author = books[i].SelectSingleNode("auth:author", nsMgr);
  48.             Console.WriteLine($"  Author: {author.InnerText}");
  49.             
  50.             // 获取价格
  51.             XmlNode price = books[i].SelectSingleNode("book:price", nsMgr);
  52.             Console.WriteLine($"  Price: {price.InnerText}");
  53.             
  54.             Console.WriteLine();
  55.         }
  56.     }
  57. }
复制代码

JavaScript中的实现

JavaScript可以在浏览器环境中使用DOM API，或者在Node.js环境中使用第三方库如xmldom来处理XML。
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.     <title>XPath XML Namespace Example</title>
  6. </head>
  7. <body>
  8.     <script>
  9.         // XML字符串
  10.         const xml = `<bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">
  11.                         <book:book category="cooking">
  12.                             <book:title lang="en">Everyday Italian</book:title>
  13.                             <auth:author>Giada De Laurentiis</auth:author>
  14.                             <book:year>2005</book:year>
  15.                             <book:price>30.00</book:price>
  16.                         </book:book>
  17.                         <book:book category="children">
  18.                             <book:title lang="en">Harry Potter</book:title>
  19.                             <auth:author>J.K. Rowling</auth:author>
  20.                             <book:year>2005</book:year>
  21.                             <book:price>29.99</book:price>
  22.                         </book:book>
  23.                      </bookstore>`;
  25.         // 解析XML
  26.         const parser = new DOMParser();
  27.         const doc = parser.parseFromString(xml, "application/xml");
  29.         // 创建XPath解析器
  30.         const resolver = {
  31.             lookupNamespaceURI: function(prefix) {
  32.                 const namespaces = {
  33.                     'book': 'http://www.example.com/books',
  34.                     'auth': 'http://www.example.com/authors'
  35.                 };
  36.                 return namespaces[prefix] || null;
  37.             }
  38.         };
  40.         // 查询所有书籍
  41.         const books = doc.evaluate('//book:book', doc, resolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
  43.         // 输出结果
  44.         for (let i = 0; i < books.snapshotLength; i++) {
  45.             const book = books.snapshotItem(i);
  46.             console.log(`Book ${i + 1}:`);
  47.             
  48.             // 获取标题
  49.             const title = doc.evaluate('book:title', book, resolver, XPathResult.STRING_TYPE, null).stringValue;
  50.             console.log(`  Title: ${title}`);
  51.             
  52.             // 获取作者
  53.             const author = doc.evaluate('auth:author', book, resolver, XPathResult.STRING_TYPE, null).stringValue;
  54.             console.log(`  Author: ${author}`);
  55.             
  56.             // 获取价格
  57.             const price = doc.evaluate('book:price', book, resolver, XPathResult.STRING_TYPE, null).stringValue;
  58.             console.log(`  Price: ${price}`);
  59.             
  60.             console.log('');
  61.         }
  62.     </script>
  63. </body>
  64. </html>
复制代码
  2. const { DOMParser, XPathEvaluator } = require('xmldom');
  4. // XML字符串
  5. const xml = `<bookstore xmlns:book="http://www.example.com/books" xmlns:auth="http://www.example.com/authors">
  6.                 <book:book category="cooking">
  7.                     <book:title lang="en">Everyday Italian</book:title>
  8.                     <auth:author>Giada De Laurentiis</auth:author>
  9.                     <book:year>2005</book:year>
  10.                     <book:price>30.00</book:price>
  11.                 </book:book>
  12.                 <book:book category="children">
  13.                     <book:title lang="en">Harry Potter</book:title>
  14.                     <auth:author>J.K. Rowling</auth:author>
  15.                     <book:year>2005</book:year>
  16.                     <book:price>29.99</book:price>
  17.                 </book:book>
  18.              </bookstore>`;
  20. // 解析XML
  21. const doc = new DOMParser().parseFromString(xml);
  23. // 创建命名空间解析器
  24. const resolver = {
  25.     lookupNamespaceURI: function(prefix) {
  26.         const namespaces = {
  27.             'book': 'http://www.example.com/books',
  28.             'auth': 'http://www.example.com/authors'
  29.         };
  30.         return namespaces[prefix] || null;
  31.     }
  32. };
  34. // 创建XPath评估器
  35. const evaluator = new XPathEvaluator();
  37. // 查询所有书籍
  38. const books = evaluator.evaluate('//book:book', doc, resolver, XPathEvaluator.ORDERED_NODE_SNAPSHOT_TYPE, null);
  40. // 输出结果
  41. for (let i = 0; i < books.snapshotLength; i++) {
  42.     const book = books.snapshotItem(i);
  43.     console.log(`Book ${i + 1}:`);
  44.    
  45.     // 获取标题
  46.     const title = evaluator.evaluate('book:title', book, resolver, XPathEvaluator.STRING_TYPE, null).stringValue;
  47.     console.log(`  Title: ${title}`);
  48.    
  49.     // 获取作者
  50.     const author = evaluator.evaluate('auth:author', book, resolver, XPathEvaluator.STRING_TYPE, null).stringValue;
  51.     console.log(`  Author: ${author}`);
  52.    
  53.     // 获取价格
  54.     const price = evaluator.evaluate('book:price', book, resolver, XPathEvaluator.STRING_TYPE, null).stringValue;
  55.     console.log(`  Price: ${price}`);
  56.    
  57.     console.log('');
  58. }
复制代码

实际应用场景和案例

Web服务响应处理

Web服务（特别是SOAP服务）经常使用带有命名空间的XML作为响应格式。处理这些响应时，正确处理命名空间至关重要。
  2. <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"
  3.                xmlns:m="http://www.example.com/bookstore">
  4.     <soap:Body>
  5.         <m:GetBookResponse>
  6.             <m:Book>
  7.                 <m:Title>XML Guide</m:Title>
  8.                 <m:Author>John Doe</m:Author>
  9.                 <m:Price>29.99</m:Price>
  10.             </m:Book>
  11.         </m:GetBookResponse>
  12.     </soap:Body>
  13. </soap:Envelope>
复制代码
  2. import javax.xml.parsers.DocumentBuilder;
  3. import javax.xml.parsers.DocumentBuilderFactory;
  4. import javax.xml.xpath.XPath;
  5. import javax.xml.xpath.XPathConstants;
  6. import javax.xml.xpath.XPathExpression;
  7. import javax.xml.xpath.XPathFactory;
  8. import javax.xml.namespace.NamespaceContext;
  9. import org.w3c.dom.Document;
  10. import java.io.StringReader;
  11. import org.xml.sax.InputSource;
  13. public class SoapResponseExample {
  14.     public static void main(String[] args) throws Exception {
  15.         String soapResponse = "<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"\n" +
  16.                               "               xmlns:m="http://www.example.com/bookstore">\n" +
  17.                               "    <soap:Body>\n" +
  18.                               "        <m:GetBookResponse>\n" +
  19.                               "            <m:Book>\n" +
  20.                               "                <m:Title>XML Guide</m:Title>\n" +
  21.                               "                <m:Author>John Doe</m:Author>\n" +
  22.                               "                <m:Price>29.99</m:Price>\n" +
  23.                               "            </m:Book>\n" +
  24.                               "        </m:GetBookResponse>\n" +
  25.                               "    </soap:Body>\n" +
  26.                               "</soap:Envelope>";
  28.         // 创建DOM文档
  29.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  30.         factory.setNamespaceAware(true);
  31.         DocumentBuilder builder = factory.newDocumentBuilder();
  32.         Document doc = builder.parse(new InputSource(new StringReader(soapResponse)));
  34.         // 创建XPath对象
  35.         XPathFactory xPathFactory = XPathFactory.newInstance();
  36.         XPath xpath = xPathFactory.newXPath();
  38.         // 设置命名空间上下文
  39.         NamespaceContext ctx = new SoapNamespaceContext();
  40.         xpath.setNamespaceContext(ctx);
  42.         // 提取书名
  43.         XPathExpression expr = xpath.compile("//m:Title");
  44.         String title = (String) expr.evaluate(doc, XPathConstants.STRING);
  45.         System.out.println("Title: " + title);
  47.         // 提取作者
  48.         expr = xpath.compile("//m:Author");
  49.         String author = (String) expr.evaluate(doc, XPathConstants.STRING);
  50.         System.out.println("Author: " + author);
  52.         // 提取价格
  53.         expr = xpath.compile("//m:Price");
  54.         String price = (String) expr.evaluate(doc, XPathConstants.STRING);
  55.         System.out.println("Price: " + price);
  56.     }
  57. }
  59. class SoapNamespaceContext implements NamespaceContext {
  60.     @Override
  61.     public String getNamespaceURI(String prefix) {
  62.         if ("soap".equals(prefix)) {
  63.             return "http://www.w3.org/2003/05/soap-envelope";
  64.         } else if ("m".equals(prefix)) {
  65.             return "http://www.example.com/bookstore";
  66.         }
  67.         return null;
  68.     }
  70.     @Override
  71.     public String getPrefix(String namespaceURI) {
  72.         if ("http://www.w3.org/2003/05/soap-envelope".equals(namespaceURI)) {
  73.             return "soap";
  74.         } else if ("http://www.example.com/bookstore".equals(namespaceURI)) {
  75.             return "m";
  76.         }
  77.         return null;
  78.     }
  80.     @Override
  81.     public java.util.Iterator<String> getPrefixes(String namespaceURI) {
  82.         java.util.Set<String> prefixes = new java.util.HashSet<String>();
  83.         if ("http://www.w3.org/2003/05/soap-envelope".equals(namespaceURI)) {
  84.             prefixes.add("soap");
  85.         } else if ("http://www.example.com/bookstore".equals(namespaceURI)) {
  86.             prefixes.add("m");
  87.         }
  88.         return prefixes.iterator();
  89.     }
  90. }
复制代码

配置文件解析

许多应用程序使用XML作为配置文件格式，这些文件通常使用命名空间来组织和区分不同模块的配置。
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.                            http://www.springframework.org/schema/beans/spring-beans.xsd
  7.                            http://www.springframework.org/schema/context
  8.                            http://www.springframework.org/schema/context/spring-context.xsd">
  9.    
  10.     <context:component-scan base-package="com.example"/>
  11.    
  12.     <bean id="userService" class="com.example.UserService"/>
  13.    
  14.     <bean id="dataSource" class="com.example.DataSource">
  15.         <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
  16.         <property name="username" value="root"/>
  17.         <property name="password" value="password"/>
  18.     </bean>
  19. </beans>
复制代码
  2. from lxml import etree
  4. # Spring配置文件
  5. spring_config = """
  6. <beans xmlns="http://www.springframework.org/schema/beans"
  7.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  8.        xmlns:context="http://www.springframework.org/schema/context"
  9.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  10.                            http://www.springframework.org/schema/beans/spring-beans.xsd
  11.                            http://www.springframework.org/schema/context
  12.                            http://www.springframework.org/schema/context/spring-context.xsd">
  13.    
  14.     <context:component-scan base-package="com.example"/>
  15.    
  16.     <bean id="userService" class="com.example.UserService"/>
  17.    
  18.     <bean id="dataSource" class="com.example.DataSource">
  19.         <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
  20.         <property name="username" value="root"/>
  21.         <property name="password" value="password"/>
  22.     </bean>
  23. </beans>
  24. """
  26. # 解析XML
  27. doc = etree.fromstring(spring_config)
  29. # 定义命名空间映射
  30. ns = {
  31.     'beans': 'http://www.springframework.org/schema/beans',
  32.     'context': 'http://www.springframework.org/schema/context',
  33.     'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
  34. }
  36. # 获取组件扫描的包
  37. component_scan = doc.xpath('//context:component-scan', namespaces=ns)[0]
  38. base_package = component_scan.get('base-package')
  39. print(f"Component scan base package: {base_package}")
  41. # 获取所有bean定义
  42. beans = doc.xpath('//beans:bean', namespaces=ns)
  43. print("\nBean definitions:")
  44. for bean in beans:
  45.     bean_id = bean.get('id')
  46.     bean_class = bean.get('class')
  47.     print(f"  ID: {bean_id}, Class: {bean_class}")
  48.    
  49.     # 获取bean属性
  50.     properties = bean.xpath('./beans:property', namespaces=ns)
  51.     for prop in properties:
  52.         prop_name = prop.get('name')
  53.         prop_value = prop.get('value')
  54.         print(f"    Property: {prop_name} = {prop_value}")
复制代码

数据转换

在数据转换和集成场景中，我们经常需要从源XML文档中提取数据，并将其转换为目标格式。正确处理命名空间是确保数据准确转换的关键。
  2. <orders xmlns="http://www.example.com/orders"
  3.         xmlns:cust="http://www.example.com/customers"
  4.         xmlns:prod="http://www.example.com/products">
  5.     <order id="1001">
  6.         <cust:customer id="C001">
  7.             <cust:name>John Doe</cust:name>
  8.             <cust:email>john@example.com</cust:email>
  9.         </cust:customer>
  10.         <items>
  11.             <item>
  12.                 <prod:product id="P001">
  13.                     <prod:name>XML Guide</prod:name>
  14.                     <prod:price>29.99</prod:price>
  15.                 </prod:product>
  16.                 <quantity>2</quantity>
  17.             </item>
  18.             <item>
  19.                 <prod:product id="P002">
  20.                     <prod:name>XPath Tutorial</prod:name>
  21.                     <prod:price>19.99</prod:price>
  22.                 </prod:product>
  23.                 <quantity>1</quantity>
  24.             </item>
  25.         </items>
  26.     </order>
  27.     <order id="1002">
  28.         <cust:customer id="C002">
  29.             <cust:name>Jane Smith</cust:name>
  30.             <cust:email>jane@example.com</cust:email>
  31.         </cust:customer>
  32.         <items>
  33.             <item>
  34.                 <prod:product id="P003">
  35.                     <prod:name>Web Services</prod:name>
  36.                     <prod:price>39.99</prod:price>
  37.                 </prod:product>
  38.                 <quantity>1</quantity>
  39.             </item>
  40.         </items>
  41.     </order>
  42. </orders>
复制代码
  2. from lxml import etree
  3. import json
  5. # XML订单数据
  6. orders_xml = """
  7. <orders xmlns="http://www.example.com/orders"
  8.         xmlns:cust="http://www.example.com/customers"
  9.         xmlns:prod="http://www.example.com/products">
  10.     <order id="1001">
  11.         <cust:customer id="C001">
  12.             <cust:name>John Doe</cust:name>
  13.             <cust:email>john@example.com</cust:email>
  14.         </cust:customer>
  15.         <items>
  16.             <item>
  17.                 <prod:product id="P001">
  18.                     <prod:name>XML Guide</prod:name>
  19.                     <prod:price>29.99</prod:price>
  20.                 </prod:product>
  21.                 <quantity>2</quantity>
  22.             </item>
  23.             <item>
  24.                 <prod:product id="P002">
  25.                     <prod:name>XPath Tutorial</prod:name>
  26.                     <prod:price>19.99</prod:price>
  27.                 </prod:product>
  28.                 <quantity>1</quantity>
  29.             </item>
  30.         </items>
  31.     </order>
  32.     <order id="1002">
  33.         <cust:customer id="C002">
  34.             <cust:name>Jane Smith</cust:name>
  35.             <cust:email>jane@example.com</cust:email>
  36.         </cust:customer>
  37.         <items>
  38.             <item>
  39.                 <prod:product id="P003">
  40.                     <prod:name>Web Services</prod:name>
  41.                     <prod:price>39.99</prod:price>
  42.                 </prod:product>
  43.                 <quantity>1</quantity>
  44.             </item>
  45.         </items>
  46.     </order>
  47. </orders>
  48. """
  50. # 解析XML
  51. doc = etree.fromstring(orders_xml)
  53. # 定义命名空间映射
  54. ns = {
  55.     'orders': 'http://www.example.com/orders',
  56.     'cust': 'http://www.example.com/customers',
  57.     'prod': 'http://www.example.com/products'
  58. }
  60. # 转换函数
  61. def xml_orders_to_json(xml_doc, namespaces):
  62.     orders = []
  63.    
  64.     # 获取所有订单
  65.     order_elements = xml_doc.xpath('//orders:order', namespaces=namespaces)
  66.    
  67.     for order_elem in order_elements:
  68.         order_id = order_elem.get('id')
  69.         
  70.         # 获取客户信息
  71.         customer_elem = order_elem.xpath('./cust:customer', namespaces=namespaces)[0]
  72.         customer_id = customer_elem.get('id')
  73.         customer_name = customer_elem.xpath('./cust:name/text()', namespaces=namespaces)[0]
  74.         customer_email = customer_elem.xpath('./cust:email/text()', namespaces=namespaces)[0]
  75.         
  76.         # 获取订单项
  77.         items = []
  78.         item_elements = order_elem.xpath('./items/item', namespaces=namespaces)
  79.         
  80.         for item_elem in item_elements:
  81.             product_elem = item_elem.xpath('./prod:product', namespaces=namespaces)[0]
  82.             product_id = product_elem.get('id')
  83.             product_name = product_elem.xpath('./prod:name/text()', namespaces=namespaces)[0]
  84.             product_price = float(product_elem.xpath('./prod:price/text()', namespaces=namespaces)[0])
  85.             quantity = int(item_elem.xpath('./quantity/text()', namespaces=namespaces)[0])
  86.             
  87.             items.append({
  88.                 'product': {
  89.                     'id': product_id,
  90.                     'name': product_name,
  91.                     'price': product_price
  92.                 },
  93.                 'quantity': quantity
  94.             })
  95.         
  96.         # 构建订单对象
  97.         order = {
  98.             'id': order_id,
  99.             'customer': {
  100.                 'id': customer_id,
  101.                 'name': customer_name,
  102.                 'email': customer_email
  103.             },
  104.             'items': items
  105.         }
  106.         
  107.         orders.append(order)
  108.    
  109.     return orders
  111. # 执行转换
  112. orders_data = xml_orders_to_json(doc, ns)
  114. # 输出JSON
  115. print(json.dumps(orders_data, indent=2))
复制代码

大型XML文档处理

处理大型XML文档时，内存使用和性能成为关键考虑因素。使用SAX（Simple API for XML）或StAX（Streaming API for XML）等流式处理技术可以有效地处理大型文档。
  2. import javax.xml.stream.XMLInputFactory;
  3. import javax.xml.stream.XMLStreamConstants;
  4. import javax.xml.stream.XMLStreamReader;
  5. import java.io.StringReader;
  7. public class LargeXmlProcessingExample {
  8.     public static void main(String[] args) throws Exception {
  9.         String xml = "<orders xmlns="http://www.example.com/orders" xmlns:cust="http://www.example.com/customers">" +
  10.                      "    <order id="1001">" +
  11.                      "        <cust:customer id="C001">" +
  12.                      "            <cust:name>John Doe</cust:name>" +
  13.                      "        </cust:customer>" +
  14.                      "        <items>" +
  15.                      "            <item>" +
  16.                      "                <product>XML Guide</product>" +
  17.                      "                <quantity>2</quantity>" +
  18.                      "            </item>" +
  19.                      "        </items>" +
  20.                      "    </order>" +
  21.                      "    <order id="1002">" +
  22.                      "        <cust:customer id="C002">" +
  23.                      "            <cust:name>Jane Smith</cust:name>" +
  24.                      "        </cust:customer>" +
  25.                      "        <items>" +
  26.                      "            <item>" +
  27.                      "                <product>Web Services</product>" +
  28.                      "                <quantity>1</quantity>" +
  29.                      "            </item>" +
  30.                      "        </items>" +
  31.                      "    </order>" +
  32.                      "</orders>";
  34.         // 创建StAX解析器
  35.         XMLInputFactory factory = XMLInputFactory.newInstance();
  36.         XMLStreamReader reader = factory.createXMLStreamReader(new StringReader(xml));
  38.         // 处理XML文档
  39.         processXml(reader);
  41.         // 关闭解析器
  42.         reader.close();
  43.     }
  45.     private static void processXml(XMLStreamReader reader) throws Exception {
  46.         String currentOrderId = null;
  47.         String currentCustomerId = null;
  48.         String currentCustomerName = null;
  49.         String currentProduct = null;
  50.         String currentQuantity = null;
  52.         while (reader.hasNext()) {
  53.             int event = reader.next();
  55.             switch (event) {
  56.                 case XMLStreamConstants.START_ELEMENT:
  57.                     String elementName = reader.getLocalName();
  58.                     String namespaceUri = reader.getNamespaceURI();
  60.                     // 处理订单开始
  61.                     if ("order".equals(elementName) && "http://www.example.com/orders".equals(namespaceUri)) {
  62.                         currentOrderId = reader.getAttributeValue(null, "id");
  63.                     }
  64.                     // 处理客户开始
  65.                     else if ("customer".equals(elementName) && "http://www.example.com/customers".equals(namespaceUri)) {
  66.                         currentCustomerId = reader.getAttributeValue(null, "id");
  67.                     }
  68.                     break;
  70.                 case XMLStreamConstants.CHARACTERS:
  71.                     String text = reader.getText().trim();
  72.                     if (!text.isEmpty()) {
  73.                         String parentElement = getParentElement(reader);
  74.                         String parentNamespace = getParentNamespace(reader);
  76.                         // 处理客户名称
  77.                         if ("name".equals(parentElement) && "http://www.example.com/customers".equals(parentNamespace)) {
  78.                             currentCustomerName = text;
  79.                         }
  80.                         // 处理产品名称
  81.                         else if ("product".equals(parentElement) && "http://www.example.com/orders".equals(parentNamespace)) {
  82.                             currentProduct = text;
  83.                         }
  84.                         // 处理数量
  85.                         else if ("quantity".equals(parentElement) && "http://www.example.com/orders".equals(parentNamespace)) {
  86.                             currentQuantity = text;
  87.                         }
  88.                     }
  89.                     break;
  91.                 case XMLStreamConstants.END_ELEMENT:
  92.                     String endElementName = reader.getLocalName();
  93.                     String endNamespaceUri = reader.getNamespaceURI();
  95.                     // 处理订单结束
  96.                     if ("order".equals(endElementName) && "http://www.example.com/orders".equals(endNamespaceUri)) {
  97.                         System.out.println("Order ID: " + currentOrderId);
  98.                         System.out.println("Customer ID: " + currentCustomerId);
  99.                         System.out.println("Customer Name: " + currentCustomerName);
  100.                         System.out.println("Product: " + currentProduct);
  101.                         System.out.println("Quantity: " + currentQuantity);
  102.                         System.out.println("----------------------");
  103.                         
  104.                         // 重置变量
  105.                         currentOrderId = null;
  106.                         currentCustomerId = null;
  107.                         currentCustomerName = null;
  108.                         currentProduct = null;
  109.                         currentQuantity = null;
  110.                     }
  111.                     break;
  112.             }
  113.         }
  114.     }
  116.     private static String getParentElement(XMLStreamReader reader) {
  117.         // 简化实现，实际应用中需要维护元素栈
  118.         return null;
  119.     }
  121.     private static String getParentNamespace(XMLStreamReader reader) {
  122.         // 简化实现，实际应用中需要维护命名空间栈
  123.         return null;
  124.     }
  125. }
复制代码

最佳实践和性能优化

命名空间处理的性能考虑

处理XML命名空间时，性能是一个重要的考虑因素，特别是在处理大型XML文档时。以下是一些性能优化的建议：

1. 缓存命名空间上下文：如果多次使用相同的命名空间，应该缓存命名空间上下文对象，避免重复创建。
  2. // Java示例：缓存命名空间上下文
  3. public class NamespaceCache {
  4.     private static final Map<String, NamespaceContext> cache = new HashMap<>();
  5.    
  6.     public static NamespaceContext getNamespaceContext(String key) {
  7.         return cache.get(key);
  8.     }
  9.    
  10.     public static void putNamespaceContext(String key, NamespaceContext ctx) {
  11.         cache.put(key, ctx);
  12.     }
  13. }
  15. // 使用缓存
  16. NamespaceContext ctx = NamespaceCache.getNamespaceContext("bookstore");
  17. if (ctx == null) {
  18.     ctx = new BookNamespaceContext();
  19.     NamespaceCache.putNamespaceContext("bookstore", ctx);
  20. }
  21. xpath.setNamespaceContext(ctx);
复制代码

1. 使用特定的XPath表达式：避免使用过于通用的XPath表达式（如//*），这会导致解析器遍历整个文档树。
  2. // 不好的做法：遍历整个文档
  3. XPathExpression expr = xpath.compile("//*[local-name()='book']");
  5. // 好的做法：使用特定路径
  6. XPathExpression expr = xpath.compile("/bookstore/book");
复制代码

1. 预编译XPath表达式：如果多次使用相同的XPath表达式，应该预编译并缓存这些表达式。
  2. // Java示例：预编译XPath表达式
  3. public class XPathExpressionCache {
  4.     private static final Map<String, XPathExpression> cache = new HashMap<>();
  5.    
  6.     public static XPathExpression getXPathExpression(XPath xpath, String expression) throws Exception {
  7.         XPathExpression expr = cache.get(expression);
  8.         if (expr == null) {
  9.             expr = xpath.compile(expression);
  10.             cache.put(expression, expr);
  11.         }
  12.         return expr;
  13.     }
  14. }
  16. // 使用缓存
  17. XPathExpression expr = XPathExpressionCache.getXPathExpression(xpath, "//book:book");
  18. NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
复制代码

1. 使用适当的XML解析器：根据文档大小和复杂度选择合适的解析器。对于大型文档，考虑使用SAX或StAX等流式解析器。
  2. // 使用DOM解析器（适合小型文档）
  3. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  4. factory.setNamespaceAware(true);
  5. DocumentBuilder builder = factory.newDocumentBuilder();
  6. Document doc = builder.parse(new File("small.xml"));
  8. // 使用StAX解析器（适合大型文档）
  9. XMLInputFactory factory = XMLInputFactory.newInstance();
  10. XMLStreamReader reader = factory.createXMLStreamReader(new FileInputStream("large.xml"));
复制代码

代码组织和可维护性

良好的代码组织和可维护性对于长期维护XPath和XML处理代码至关重要。

1. 封装命名空间处理：创建专门的类来处理命名空间，提高代码的可重用性。
  2. // Java示例：封装命名空间处理
  3. public class NamespaceHandler {
  4.     private final Map<String, String> prefixToUri = new HashMap<>();
  5.     private final Map<String, String> uriToPrefix = new HashMap<>();
  6.    
  7.     public void addNamespace(String prefix, String uri) {
  8.         prefixToUri.put(prefix, uri);
  9.         uriToPrefix.put(uri, prefix);
  10.     }
  11.    
  12.     public NamespaceContext createNamespaceContext() {
  13.         return new SimpleNamespaceContext(prefixToUri, uriToPrefix);
  14.     }
  15.    
  16.     public String getPrefixForUri(String uri) {
  17.         return uriToPrefix.get(uri);
  18.     }
  19.    
  20.     public String getUriForPrefix(String prefix) {
  21.         return prefixToUri.get(prefix);
  22.     }
  23. }
  25. // 使用封装的命名空间处理器
  26. NamespaceHandler nsHandler = new NamespaceHandler();
  27. nsHandler.addNamespace("book", "http://www.example.com/books");
  28. nsHandler.addNamespace("auth", "http://www.example.com/authors");
  30. xpath.setNamespaceContext(nsHandler.createNamespaceContext());
复制代码

1. 使用常量定义XPath表达式：将常用的XPath表达式定义为常量，便于维护和修改。
  2. // Java示例：使用常量定义XPath表达式
  3. public class BookXPathExpressions {
  4.     public static final String ALL_BOOKS = "//book:book";
  5.     public static final String BOOK_BY_ID = "//book:book[@id='%s']";
  6.     public static final String BOOK_TITLE = "book:title/text()";
  7.     public static final String BOOK_AUTHOR = "auth:author/text()";
  8.     public static final String BOOK_PRICE = "book:price/text()";
  9. }
  11. // 使用常量
  12. XPathExpression expr = xpath.compile(BookXPathExpressions.ALL_BOOKS);
  13. NodeList books = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
复制代码

1. 创建专门的查询方法：为常用的查询操作创建专门的方法，提高代码的可读性和可维护性。
  2. // Java示例：创建专门的查询方法
  3. public class BookRepository {
  4.     private final XPath xpath;
  5.     private final NamespaceContext nsContext;
  6.    
  7.     public BookRepository(XPath xpath, NamespaceContext nsContext) {
  8.         this.xpath = xpath;
  9.         this.nsContext = nsContext;
  10.         this.xpath.setNamespaceContext(nsContext);
  11.     }
  12.    
  13.     public List<Book> findAllBooks(Document doc) throws Exception {
  14.         XPathExpression expr = xpath.compile("//book:book");
  15.         NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  16.         
  17.         List<Book> books = new ArrayList<>();
  18.         for (int i = 0; i < nodes.getLength(); i++) {
  19.             books.add(extractBook(nodes.item(i)));
  20.         }
  21.         
  22.         return books;
  23.     }
  24.    
  25.     public Book findBookById(Document doc, String id) throws Exception {
  26.         XPathExpression expr = xpath.compile(String.format("//book:book[@id='%s']", id));
  27.         Node node = (Node) expr.evaluate(doc, XPathConstants.NODE);
  28.         
  29.         return node != null ? extractBook(node) : null;
  30.     }
  31.    
  32.     private Book extractBook(Node node) throws Exception {
  33.         Book book = new Book();
  34.         
  35.         // 提取ID
  36.         Element elem = (Element) node;
  37.         book.setId(elem.getAttribute("id"));
  38.         
  39.         // 提取标题
  40.         XPathExpression expr = xpath.compile("book:title/text()");
  41.         String title = (String) expr.evaluate(node, XPathConstants.STRING);
  42.         book.setTitle(title);
  43.         
  44.         // 提取作者
  45.         expr = xpath.compile("auth:author/text()");
  46.         String author = (String) expr.evaluate(node, XPathConstants.STRING);
  47.         book.setAuthor(author);
  48.         
  49.         // 提取价格
  50.         expr = xpath.compile("book:price/text()");
  51.         String priceStr = (String) expr.evaluate(node, XPathConstants.STRING);
  52.         book.setPrice(Double.parseDouble(priceStr));
  53.         
  54.         return book;
  55.     }
  56. }
  58. // 使用专门的查询方法
  59. BookRepository repo = new BookRepository(xpath, nsContext);
  60. List<Book> books = repo.findAllBooks(doc);
  61. Book book = repo.findBookById(doc, "1001");
复制代码

错误处理和调试技巧

处理XML和XPath时，良好的错误处理和调试技巧可以帮助快速定位和解决问题。

1. 验证XML文档：在处理XML文档之前，先验证其格式是否正确。
  2. // Java示例：验证XML文档
  3. public class XmlValidator {
  4.     public static boolean isValid(String xml) {
  5.         try {
  6.             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  7.             factory.setNamespaceAware(true);
  8.             DocumentBuilder builder = factory.newDocumentBuilder();
  9.             builder.parse(new InputSource(new StringReader(xml)));
  10.             return true;
  11.         } catch (Exception e) {
  12.             e.printStackTrace();
  13.             return false;
  14.         }
  15.     }
  16. }
  18. // 使用验证器
  19. if (XmlValidator.isValid(xml)) {
  20.     // 处理XML
  21. } else {
  22.     System.err.println("Invalid XML document");
  23. }
复制代码

1. 记录XPath表达式和结果：在调试时，记录执行的XPath表达式和结果，便于分析问题。
  2. // Java示例：记录XPath表达式和结果
  3. public class XPathLogger {
  4.     private static final Logger logger = Logger.getLogger(XPathLogger.class.getName());
  5.    
  6.     public static Object evaluate(XPath xpath, String expression, Object item, QName returnType) throws Exception {
  7.         logger.info("Evaluating XPath expression: " + expression);
  8.         
  9.         XPathExpression expr = xpath.compile(expression);
  10.         Object result = expr.evaluate(item, returnType);
  11.         
  12.         logger.info("XPath result: " + result);
  13.         
  14.         return result;
  15.     }
  16. }
  18. // 使用日志记录器
  19. NodeList nodes = (NodeList) XPathLogger.evaluate(xpath, "//book:book", doc, XPathConstants.NODESET);
复制代码

1. 使用命名空间感知的XML查看器：使用支持命名空间的XML查看器（如XMLSpy、Oxygen XML Editor等）来检查XML文档和测试XPath表达式。
2. 分解复杂的XPath表达式：如果复杂的XPath表达式出现问题，可以将其分解为多个简单的表达式，逐步调试。

使用命名空间感知的XML查看器：使用支持命名空间的XML查看器（如XMLSpy、Oxygen XML Editor等）来检查XML文档和测试XPath表达式。

分解复杂的XPath表达式：如果复杂的XPath表达式出现问题，可以将其分解为多个简单的表达式，逐步调试。
  2. // Java示例：分解复杂的XPath表达式
  3. // 复杂的表达式
  4. String complexExpr = "//book:book[book:price > 20 and auth:author='John Doe']";
  6. // 分解为简单的表达式
  7. String allBooksExpr = "//book:book";
  8. XPathExpression expr = xpath.compile(allBooksExpr);
  9. NodeList books = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  11. for (int i = 0; i < books.getLength(); i++) {
  12.     Node book = books.item(i);
  13.    
  14.     // 检查价格
  15.     expr = xpath.compile("book:price/text()");
  16.     String priceStr = (String) expr.evaluate(book, XPathConstants.STRING);
  17.     double price = Double.parseDouble(priceStr);
  18.    
  19.     // 检查作者
  20.     expr = xpath.compile("auth:author/text()");
  21.     String author = (String) expr.evaluate(book, XPathConstants.STRING);
  22.    
  23.     if (price > 20 && "John Doe".equals(author)) {
  24.         // 处理符合条件的书籍
  25.     }
  26. }
复制代码

性能优化策略

在处理大型XML文档或执行大量XPath查询时，性能优化尤为重要。

1. 使用索引：如果频繁查询特定元素，可以考虑创建索引来加速查询。
  2. // Java示例：使用Map索引元素
  3. public class BookIndex {
  4.     private final Map<String, Element> bookById = new HashMap<>();
  5.    
  6.     public void indexBooks(Document doc) throws Exception {
  7.         XPathFactory xPathFactory = XPathFactory.newInstance();
  8.         XPath xpath = xPathFactory.newXPath();
  9.         
  10.         // 设置命名空间上下文
  11.         NamespaceContext ctx = new BookNamespaceContext();
  12.         xpath.setNamespaceContext(ctx);
  13.         
  14.         // 获取所有书籍
  15.         XPathExpression expr = xpath.compile("//book:book");
  16.         NodeList books = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  17.         
  18.         // 创建索引
  19.         for (int i = 0; i < books.getLength(); i++) {
  20.             Element book = (Element) books.item(i);
  21.             String id = book.getAttribute("id");
  22.             bookById.put(id, book);
  23.         }
  24.     }
  25.    
  26.     public Element getBookById(String id) {
  27.         return bookById.get(id);
  28.     }
  29. }
  31. // 使用索引
  32. BookIndex index = new BookIndex();
  33. index.indexBooks(doc);
  35. Element book = index.getBookById("1001");
复制代码

1. 批量处理：如果需要对多个元素执行相同的操作，考虑批量处理以减少解析开销。
  2. // Java示例：批量处理
  3. public class BookBatchProcessor {
  4.     public void processBooks(Document doc, Consumer<Element> processor) throws Exception {
  5.         XPathFactory xPathFactory = XPathFactory.newInstance();
  6.         XPath xpath = xPathFactory.newXPath();
  7.         
  8.         // 设置命名空间上下文
  9.         NamespaceContext ctx = new BookNamespaceContext();
  10.         xpath.setNamespaceContext(ctx);
  11.         
  12.         // 获取所有书籍
  13.         XPathExpression expr = xpath.compile("//book:book");
  14.         NodeList books = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  15.         
  16.         // 批量处理
  17.         for (int i = 0; i < books.getLength(); i++) {
  18.             processor.accept((Element) books.item(i));
  19.         }
  20.     }
  21. }
  23. // 使用批量处理器
  24. BookBatchProcessor batchProcessor = new BookBatchProcessor();
  25. batchProcessor.processBooks(doc, book -> {
  26.     // 处理每个书籍元素
  27.     String id = book.getAttribute("id");
  28.     System.out.println("Processing book: " + id);
  29. });
复制代码

1. 使用适当的集合类型：根据查询需求选择合适的集合类型，如使用HashSet进行快速查找，使用ArrayList进行顺序访问。
  2. // Java示例：使用适当的集合类型
  3. public class BookCollection {
  4.     private final List<Element> books = new ArrayList<>();
  5.     private final Map<String, Element> bookById = new HashMap<>();
  6.     private final Map<String, List<Element>> booksByAuthor = new HashMap<>();
  7.    
  8.     public void addBook(Element book) {
  9.         String id = book.getAttribute("id");
  10.         books.add(book);
  11.         bookById.put(id, book);
  12.         
  13.         // 按作者索引
  14.         try {
  15.             XPathFactory xPathFactory = XPathFactory.newInstance();
  16.             XPath xpath = xPathFactory.newXPath();
  17.             
  18.             // 设置命名空间上下文
  19.             NamespaceContext ctx = new BookNamespaceContext();
  20.             xpath.setNamespaceContext(ctx);
  21.             
  22.             // 获取作者
  23.             XPathExpression expr = xpath.compile("auth:author/text()");
  24.             String author = (String) expr.evaluate(book, XPathConstants.STRING);
  25.             
  26.             // 添加到作者索引
  27.             booksByAuthor.computeIfAbsent(author, k -> new ArrayList<>()).add(book);
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32.    
  33.     public List<Element> getAllBooks() {
  34.         return new ArrayList<>(books);
  35.     }
  36.    
  37.     public Element getBookById(String id) {
  38.         return bookById.get(id);
  39.     }
  40.    
  41.     public List<Element> getBooksByAuthor(String author) {
  42.         return booksByAuthor.getOrDefault(author, Collections.emptyList());
  43.     }
  44. }
  46. // 使用适当的集合类型
  47. BookCollection collection = new BookCollection();
  49. // 添加书籍
  50. collection.addBook(book1);
  51. collection.addBook(book2);
  53. // 查询
  54. List<Element> allBooks = collection.getAllBooks();
  55. Element book = collection.getBookById("1001");
  56. List<Element> booksByAuthor = collection.getBooksByAuthor("John Doe");
复制代码

总结

XPath和XML命名空间是XML处理中的两个重要概念，正确理解和处理它们对于高效、准确地处理XML文档至关重要。本指南从基础概念出发，逐步深入到高级技巧，全面介绍了XPath中处理XML命名空间的方法和策略。

我们首先了解了XML命名空间的基本概念，包括命名空间的声明语法、默认命名空间和命名空间的作用域。然后，我们介绍了XPath的基础知识，包括路径表达式、轴、节点测试、谓语以及函数和运算符。

接着，我们详细讨论了XPath中常见的命名空间问题，包括为什么简单的XPath表达式无法匹配带有命名空间的元素、默认命名空间的影响以及命名空间冲突问题。针对这些问题，我们提供了一系列解决方案，从基本的方法如使用命名空间前缀和处理默认命名空间，到高级技巧如处理动态命名空间、处理嵌套命名空间以及忽略命名空间的技巧。

我们还展示了在不同编程语言中实现XPath命名空间处理的方法，包括Java、Python、C#和JavaScript，为不同背景的开发者提供了实用的参考。

在实际应用场景部分，我们探讨了Web服务响应处理、配置文件解析、数据转换以及大型XML文档处理等常见场景，并提供了详细的示例代码。

最后，我们分享了一系列最佳实践和性能优化策略，包括命名空间处理的性能考虑、代码组织和可维护性、错误处理和调试技巧以及性能优化策略，帮助开发者编写更高效、更可维护的代码。

通过掌握本指南中介绍的知识和技巧，开发者将能够更加自信地处理带有命名空间的XML文档，编写更高效、更准确的XPath查询，从而提升开发效率，减少调试时间，提高代码质量。

XPath和XML命名空间处理是XML开发中的核心技能，希望本指南能够帮助开发者从基础到高级全面掌握这一技能，在实际项目中游刃有余地处理各种XML命名空间问题。
扮演着
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则