Ruby 的 XML 处理

Ruby 中 XML 处理概述

在现代软件开发中，XML（可扩展标记语言）是一种广泛用于存储和传输数据的格式。它以其自描述性和灵活性而受到欢迎，常用于配置文件、数据交换等场景。Ruby 作为一种功能强大且灵活的编程语言，提供了多种处理 XML 的方式，从简单的解析到复杂的生成与操作，都有相应的库和工具支持。

常用的 XML 处理库

Nokogiri

Nokogiri 是 Ruby 中处理 XML 和 HTML 文档的强大库。它不仅支持解析 XML，还能方便地对文档进行遍历、修改和生成。Nokogiri 基于 libxml2 和 libxslt 库构建，性能出色。 安装 Nokogiri 很简单，只需在命令行中执行 gem install nokogiri。

REXML

REXML 是 Ruby 标准库的一部分，提供了用于解析和生成 XML 的类。它不需要额外安装，开箱即用，适合简单的 XML 处理任务。

使用 Nokogiri 解析 XML

基本解析

假设我们有一个简单的 XML 文件 books.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<books>
  <book>
    <title>Effective Ruby</title>
    <author>Peter Jones</author>
    <price>29.99</price>
  </book>
  <book>
    <title>Learning Ruby</title>
    <author>Jane Smith</author>
    <price>24.99</price>
  </book>
</books>

使用 Nokogiri 解析这个 XML 文件的代码如下：

require 'nokogiri'

doc = Nokogiri::XML(File.open('books.xml'))
doc.xpath('//book').each do |book|
  title = book.at_xpath('title').text
  author = book.at_xpath('author').text
  price = book.at_xpath('price').text
  puts "Title: #{title}, Author: #{author}, Price: #{price}"
end

在上述代码中，首先使用 Nokogiri::XML 方法打开并解析 XML 文件。然后通过 xpath 方法选取所有的 <book> 元素，并遍历这些元素。对于每个 <book> 元素，再通过 at_xpath 方法选取其子元素 <title>、<author> 和 <price>，并获取其文本内容。

处理 XML 命名空间

XML 命名空间用于避免元素和属性名称冲突。假设我们有一个包含命名空间的 XML 文件 books_ns.xml：

<?xml version="1.0" encoding="UTF-8"?>
<books xmlns:ns="http://example.com/books">
  <ns:book>
    <ns:title>Effective Ruby</ns:title>
    <ns:author>Peter Jones</ns:author>
    <ns:price>29.99</ns:price>
  </ns:book>
</books>

解析包含命名空间的 XML 时，需要注册命名空间，代码如下：

require 'nokogiri'

doc = Nokogiri::XML(File.open('books_ns.xml'))
ns = { 'ns' => 'http://example.com/books' }
doc.xpath('//ns:book', ns).each do |book|
  title = book.at_xpath('ns:title', ns).text
  author = book.at_xpath('ns:author', ns).text
  price = book.at_xpath('ns:price', ns).text
  puts "Title: #{title}, Author: #{author}, Price: #{price}"
end

这里通过 ns = { 'ns' => 'http://example.com/books' } 注册了命名空间，然后在 xpath 和 at_xpath 方法中传入命名空间参数来正确选取元素。

使用 Nokogiri 生成 XML

简单生成

使用 Nokogiri 生成 XML 也很方便。下面的代码生成一个简单的 XML 文档：

require 'nokogiri'

xml = Nokogiri::XML::Builder.new do |xml|
  xml.books do
    xml.book do
      xml.title 'Effective Ruby'
      xml.author 'Peter Jones'
      xml.price '29.99'
    end
  end
end.to_xml
puts xml

上述代码使用 Nokogiri::XML::Builder 类创建一个 XML 文档构建器。通过链式调用方法，按照 XML 结构添加元素和文本内容，最后通过 to_xml 方法将构建的 XML 转换为字符串输出。

生成复杂结构和属性

生成包含更复杂结构和属性的 XML 示例：

require 'nokogiri'

xml = Nokogiri::XML::Builder.new do |xml|
  xml.orders do
    xml.order(id: '12345') do
      xml.customer do
        xml.name 'John Doe'
        xml.address do
          xml.street '123 Main St'
          xml.city 'Anytown'
          xml.state 'CA'
          xml.zip '12345'
        end
      end
      xml.items do
        xml.item do
          xml.product 'Ruby Book'
          xml.quantity '2'
          xml.price '29.99'
        end
      end
    end
  end
end.to_xml
puts xml

在这个例子中，我们创建了一个 <orders> 元素，其中包含一个 <order> 子元素，并为 <order> 元素添加了 id 属性。<order> 元素又包含 <customer> 和 <items> 等子元素，展示了如何构建复杂的 XML 结构。

使用 REXML 解析 XML

基本解析

REXML 解析 XML 的方式略有不同。以下是使用 REXML 解析前面 books.xml 文件的代码：

require 'rexml/document'

file = File.new('books.xml')
doc = REXML::Document.new(file)
REXML::XPath.each(doc, '//book') do |book|
  title = book.elements['title'].text
  author = book.elements['author'].text
  price = book.elements['price'].text
  puts "Title: #{title}, Author: #{author}, Price: #{price}"
end

这里首先通过 REXML::Document.new 方法创建一个文档对象，然后使用 REXML::XPath.each 方法遍历所有的 <book> 元素，并获取其子元素的文本内容。

处理错误

在解析 XML 时，可能会遇到格式错误等问题。REXML 提供了错误处理机制。例如：

require 'rexml/document'

begin
  file = File.new('invalid_books.xml')
  doc = REXML::Document.new(file)
rescue REXML::ParseException => e
  puts "解析错误: #{e.message}"
end

如果 invalid_books.xml 文件格式不正确，就会捕获 REXML::ParseException 异常，并输出错误信息。

使用 REXML 生成 XML

简单生成

使用 REXML 生成 XML 文档如下：

require 'rexml/document'

doc = REXML::Document.new
root = REXML::Element.new('books')
doc.add_element(root)

book = REXML::Element.new('book')
root.add_element(book)

title = REXML::Element.new('title')
title.text = 'Effective Ruby'
book.add_element(title)

author = REXML::Element.new('author')
author.text = 'Peter Jones'
book.add_element(author)

price = REXML::Element.new('price')
price.text = '29.99'
book.add_element(price)

puts doc.to_s

在这段代码中，首先创建一个空的 REXML::Document 对象和根元素 <books>。然后逐步创建 <book> 及其子元素 <title>、<author> 和 <price>，并添加文本内容，最后通过 to_s 方法将文档转换为字符串输出。

生成带属性的 XML

生成包含属性的 XML 示例：

require 'rexml/document'

doc = REXML::Document.new
root = REXML::Element.new('orders')
doc.add_element(root)

order = REXML::Element.new('order')
order.attributes['id'] = '12345'
root.add_element(order)

customer = REXML::Element.new('customer')
order.add_element(customer)

name = REXML::Element.new('name')
name.text = 'John Doe'
customer.add_element(name)

address = REXML::Element.new('address')
customer.add_element(address)

street = REXML::Element.new('street')
street.text = '123 Main St'
address.add_element(street)

city = REXML::Element.new('city')
city.text = 'Anytown'
address.add_element(city)

state = REXML::Element.new('state')
state.text = 'CA'
address.add_element(state)

zip = REXML::Element.new('zip')
zip.text = '12345'
address.add_element(zip)

puts doc.to_s

此代码创建了一个 <orders> 元素，其中 <order> 元素带有 id 属性，并构建了复杂的子元素结构，展示了如何使用 REXML 生成带属性的 XML。

XML 验证

DTD 验证

文档类型定义（DTD）是一种用于定义 XML 文档结构和元素关系的机制。假设我们有一个 books.dtd 文件：

<!ELEMENT books (book+)>
<!ELEMENT book (title, author, price)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT author (#PCDATA)>
<!ELEMENT price (#PCDATA)>

使用 Nokogiri 验证 XML 文件 books.xml 是否符合该 DTD：

require 'nokogiri'

doc = Nokogiri::XML(File.open('books.xml'))
dtd = Nokogiri::XML::DTD(File.open('books.dtd'))
if doc.validate(dtd)
  puts "XML 文档有效"
else
  puts "XML 文档无效"
end

在上述代码中，首先加载 XML 文档和 DTD 文件，然后使用 validate 方法验证 XML 文档是否符合 DTD 定义。

XML Schema 验证

XML Schema 是另一种更强大的 XML 验证机制。假设我们有一个 books.xsd 文件：

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="books">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="book" maxOccurs="unbounded">
          <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:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

使用 Nokogiri 验证 XML 文件 books.xml 是否符合该 XML Schema：

require 'nokogiri'

doc = Nokogiri::XML(File.open('books.xml'))
schema = Nokogiri::XML::Schema(File.open('books.xsd'))
if schema.validate(doc)
  puts "XML 文档有效"
else
  puts "XML 文档无效"
end

这里同样先加载 XML 文档和 XML Schema 文件，然后通过 validate 方法进行验证。

XML 转换

XSLT 转换

可扩展样式表语言转换（XSLT）用于将 XML 文档转换为其他格式，如 HTML。假设我们有一个 books.xsl 文件用于将 books.xml 转换为 HTML 表格：

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/books">
    <html>
      <body>
        <h1>Books List</h1>
        <table border="1">
          <tr>
            <th>Title</th>
            <th>Author</th>
            <th>Price</th>
          </tr>
          <xsl:for-each select="book">
            <tr>
              <td><xsl:value-of select="title"/></td>
              <td><xsl:value-of select="author"/></td>
              <td><xsl:value-of select="price"/></td>
            </tr>
          </xsl:for-each>
        </table>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>

使用 Nokogiri 进行 XSLT 转换的代码如下：

require 'nokogiri'

xml_doc = Nokogiri::XML(File.open('books.xml'))
xsl_doc = Nokogiri::XML(File.open('books.xsl'))
xslt = Nokogiri::XSLT(xsl_doc)
result = xslt.transform(xml_doc)
puts result.to_html

上述代码加载 XML 文档和 XSLT 样式表，然后通过 Nokogiri::XSLT 类进行转换，并输出转换后的 HTML 内容。

性能考虑

在处理大型 XML 文件时，性能是一个重要问题。Nokogiri 由于基于高效的 C 库，通常在性能上优于 REXML。然而，对于非常大的 XML 文件，即使是 Nokogiri 也可能面临内存压力。

一种优化方法是使用 SAX（Simple API for XML）解析方式，Nokogiri 支持 SAX 解析。SAX 解析是基于事件驱动的，逐行读取 XML，不会一次性将整个文档加载到内存中。以下是一个简单的 SAX 解析示例：

require 'nokogiri'

class BookHandler < Nokogiri::XML::SAX::Document
  def start_element(name, attrs = [])
    @current_element = name
  end

  def characters(str)
    if @current_element == 'title'
      @title = str
    elsif @current_element == 'author'
      @author = str
    elsif @current_element == 'price'
      @price = str
    end
  end

  def end_element(name)
    if name == 'book'
      puts "Title: #{@title}, Author: #{@author}, Price: #{@price}"
      @title = @author = @price = nil
    end
  end
end

parser = Nokogiri::XML::SAX::Parser.new(BookHandler.new)
parser.parse(File.open('big_books.xml'))

在这个示例中，定义了一个 BookHandler 类继承自 Nokogiri::XML::SAX::Document，重写了 start_element、characters 和 end_element 方法来处理 XML 元素的开始、字符数据和结束事件。然后使用 Nokogiri::XML::SAX::Parser 进行 SAX 解析。

实际应用场景

配置文件处理

许多应用程序使用 XML 作为配置文件格式。例如，一个 Web 应用可能有一个 config.xml 文件来存储数据库连接信息、服务器设置等。使用 Ruby 处理这种配置文件可以方便地读取和修改配置内容。 假设 config.xml 如下：

<?xml version="1.0" encoding="UTF-8"?>
<config>
  <database>
    <host>localhost</host>
    <port>3306</port>
    <username>root</username>
    <password>password</password>
  </database>
  <server>
    <port>8080</port>
    <debug>true</debug>
  </server>
</config>

使用 Nokogiri 读取配置信息的代码：

require 'nokogiri'

doc = Nokogiri::XML(File.open('config.xml'))
db_host = doc.at_xpath('//database/host').text
db_port = doc.at_xpath('//database/port').text.to_i
server_port = doc.at_xpath('//server/port').text.to_i
debug_mode = doc.at_xpath('//server/debug').text == 'true'

puts "Database Host: #{db_host}, Database Port: #{db_port}"
puts "Server Port: #{server_port}, Debug Mode: #{debug_mode}"

这样可以轻松获取配置文件中的关键信息，用于应用程序的初始化。

数据交换

在不同系统之间进行数据交换时，XML 是一种常用格式。例如，一个电商系统可能与供应商系统交换产品信息。假设供应商提供一个 XML 文件 products.xml，包含产品的详细信息，电商系统可以使用 Ruby 解析这个 XML 文件，将产品信息导入到自己的数据库中。

<?xml version="1.0" encoding="UTF-8"?>
<products>
  <product>
    <id>1</id>
    <name>iPhone 14</name>
    <description>A new smartphone</description>
    <price>999.99</price>
    <stock>100</stock>
  </product>
  <product>
    <id>2</id>
    <name>MacBook Pro</name>
    <description>A powerful laptop</description>
    <price>1999.99</price>
    <stock>50</stock>
  </product>
</products>

使用 Ruby 解析并导入数据库（假设使用 SQLite3）的示例代码：

require 'nokogiri'
require 'sqlite3'

db = SQLite3::Database.new('store.db')
db.execute('CREATE TABLE IF NOT EXISTS products (id INTEGER PRIMARY KEY, name TEXT, description TEXT, price REAL, stock INTEGER)')

doc = Nokogiri::XML(File.open('products.xml'))
doc.xpath('//product').each do |product|
  id = product.at_xpath('id').text.to_i
  name = product.at_xpath('name').text
  description = product.at_xpath('description').text
  price = product.at_xpath('price').text.to_f
  stock = product.at_xpath('stock').text.to_i

  db.execute('INSERT INTO products (id, name, description, price, stock) VALUES (?,?,?,?,?)', [id, name, description, price, stock])
end

这段代码首先创建一个 SQLite 数据库表，然后解析 XML 文件，将每个产品信息插入到数据库中。

总结

Ruby 提供了丰富的工具和库来处理 XML，无论是简单的解析、复杂的生成，还是验证和转换，都能轻松应对。Nokogiri 和 REXML 各有特点，Nokogiri 功能强大且性能出色，适合复杂和高性能要求的场景；REXML 作为标准库的一部分，简单易用，适合快速开发和轻量级应用。在实际开发中，根据具体需求选择合适的工具和方法，能够高效地处理 XML 相关任务，提升软件开发的效率和质量。同时，要注意处理大型 XML 文件时的性能优化，合理使用 SAX 解析等技术来避免内存问题。在不同的应用场景，如配置文件处理和数据交换中，灵活运用 Ruby 的 XML 处理能力，可以更好地实现系统的功能和集成。