Rust XML处理库libxml的使用，提供高效解析、序列化及操作XML文档功能

Rust的libxml库是对libxml2的封装包装器。该项目的主要目标是利用libxml2的成熟性和稳定性，同时等待原生Rust XML库发展成熟成为近乎可以直接替代的方案。

特性

从0.2.0版本开始，该crate提供了一些基本的安全保证：

可变性和所有权 - 使用Rc<RefCell<T>>包装器来确保在Rust层已经实现libxml2操作的运行时安全性
内存安全保证 - 特别是Node和Document对象具有自动簿记和释放功能，确保无内存泄漏
无线程安全 - libxml2的全局内存管理难以以线程安全的方式适配

覆盖范围：目前仅支持libxml2的一个子集，欢迎贡献。我们尝试在每个版本中增加支持。

安装

在您的项目目录中运行以下Cargo命令：

cargo add libxml

或者在您的Cargo.toml中添加以下行：

libxml = "0.3.6"

系统要求

在使用前，您需要安装libxml2的相关组件：

Linux/Debian

在Linux系统上，您需要libxml2的开发头文件(例如Debian中的libxml2-dev)，以及pkg-config。

从0.3.4开始，构建需要bindgen，因此您需要安装CLang 9.0或更高版本：

Alpine: apk add clang-dev
Arch Linux: pacman -S clang
Debian/Ubuntu: apt install libclang-dev
Fedora: dnf install clang-devel

示例代码

以下是一个完整的示例，展示如何使用libxml进行XML文档的解析、修改和序列化：

use libxml::parser::Parser;
use libxml::tree::Node;

fn main() {
    // 1. 解析XML文档
    let parser = Parser::default();
    let xml = r#"<?xml version="1.0"?>
<root>
    <child attr="value">Text content</child>
</root>"#;
    
    let doc = parser.parse_string(xml).expect("Failed to parse XML");
    
    // 2. 获取根节点
    let root = doc.get_root_element().expect("No root element found");
    
    // 3. 查找子节点
    let children = root.get_child_nodes();
    for child in children {
        if child.get_name() == "child" {
            // 4. 获取属性
            let attr_value = child.get_attribute("attr").unwrap();
            println!("Attribute value: {}", attr_value);
            
            // 5. 获取文本内容
            let text_content = child.get_content();
            println!("Text content: {}", text_content);
            
            // 6. 修改节点
            child.set_content("New content");
            
            // 7. 添加新节点
            let new_child = Node::new("new_child", None, &doc).unwrap();
            new_child.set_content("Another child");
            root.add_child(new_child);
        }
    }
    
    // 8. 序列化为字符串
    let modified_xml = doc.to_string();
    println!("Modified XML:\n{}", modified_xml);
}

完整示例代码

以下是一个更完整的示例，展示libxml库的更多功能：

use libxml::parser::Parser;
use libxml::tree::{Document, Node};
use libxml::xpath::Context;

fn main() {
    // 1. 创建新文档
    let doc = Document::new().expect("Failed to create new document");
    
    // 2. 创建根节点
    let root = Node::new("catalog", None, &doc).unwrap();
    doc.set_root_element(&root);
    
    // 3. 添加子节点
    let book1 = Node::new("book", None, &doc).unwrap();
    book1.set_attribute("id", "bk101").unwrap();
    root.add_child(book1.clone());
    
    // 4. 添加嵌套节点
    let author = Node::new("author", None, &doc).unwrap();
    author.set_content("Gambardella, Matthew");
    book1.add_child(author);
    
    let title = Node::new("title", None, &doc).unwrap();
    title.set_content("XML Developer's Guide");
    book1.add_child(title);
    
    // 5. 添加第二个book节点
    let book2 = Node::new("book", None, &doc).unwrap();
    book2.set_attribute("id", "bk102").unwrap();
    root.add_child(book2.clone());
    
    // 6. 使用XPath查询
    let context = Context::new(&doc).unwrap();
    let results = context.evaluate("//book[@id='bk101']/title").unwrap();
    for node in results.get_nodes_as_vec() {
        println!("Found title: {}", node.get_content());
    }
    
    // 7. 保存到文件
    doc.save_file("output.xml").expect("Failed to save file");
    
    // 8. 从文件读取
    let parser = Parser::default();
    let loaded_doc = parser.parse_file("output.xml").expect("Failed to parse file");
    println!("Loaded document:\n{}", loaded_doc.to_string());
}

主要功能

文档解析：支持从文件、字符串或流中解析XML文档
节点操作：可以遍历、查询、修改和删除XML节点
属性操作：可以获取、设置和删除节点属性
文本内容处理：可以获取和设置节点的文本内容
文档序列化：可以将修改后的文档序列化为字符串或写入文件
XPath支持：可以使用XPath表达式查询节点

注意事项

该库不是线程安全的
目前仅支持libxml2功能的一个子集
内存管理由Rust的RAII机制自动处理

itying888 1楼

Rust XML处理库libxml的使用指南

介绍

libxml是一个Rust语言的XML处理库，提供了高效的XML文档解析、序列化和操作功能。它是基于libxml2 C库的Rust绑定，具有以下特点：

高性能的XML解析和序列化
支持XPath查询
完整的DOM操作API
支持XML命名空间
验证和模式支持

安装

在Cargo.toml中添加依赖：

[dependencies]
libxml = "0.3.0"

基本使用方法

1. 解析XML文档

use libxml::parser::Parser;

fn main() {
    let xml = r#"<?xml version="1.0"?>
<root>
    <element attribute="value">Content</element>
</root>"#;

    let parser = Parser::default();
    let doc = parser.parse_string(xml).expect("Failed to parse XML");
    
    println!("Successfully parsed XML document");
}

2. 创建新XML文档

use libxml::tree::Document;
use libxml::tree::Node;

fn create_xml() -> Document {
    let doc = Document::new().unwrap();
    let root = Node::new("root", None, &doc).unwrap();
    doc.set_root_element(&root);
    
    let child = Node::new("child", None, &doc).unwrap();
    child.set_content("Child content");
    root.add_child(&child);
    
    doc
}

fn main() {
    let doc = create_xml();
    println!("{}", doc.to_string());
}

3. 使用XPath查询

use libxml::parser::Parser;
use libxml::xpath::Context;

fn main() {
    let xml = r#"<?xml version="1.0"?>
<books>
    <book category="fiction">
        <title>The Great Gatsby</title>
        <author>F. Scott Fitzgerald</author>
    </book>
    <book category="non-fiction">
        <title>Rust in Action</title>
        <author>Tim McNamara</author>
    </book>
</books>"#;

    let parser = Parser::default();
    let doc = parser.parse_string(xml).expect("Failed to parse XML");
    
    let context = Context::new(&doc).unwrap();
    let results = context.evaluate("//book[@category='fiction']/title").unwrap();
    
    for node in results.get_nodes_as_vec() {
        println!("Fiction book title: {}", node.get_content());
    }
}

4. 修改XML文档

use libxml::parser::Parser;

fn main() {
    let xml = r#"<?xml version="1.0"?>
<root>
    <element>Old content</element>
</root>"#;

    let parser = Parser::default();
    let mut doc = parser.parse_string(xml).expect("Failed to parse XML");
    
    let root = doc.get_root_element().unwrap();
    let element = root.get_first_child().unwrap();
    element.set_content("New content");
    
    println!("Modified XML:\n{}", doc.to_string());
}

高级功能

1. 使用命名空间

use libxml::tree::Document;
use libxml::tree::Node;

fn create_xml_with_namespace() -> Document {
    let doc = Document::new().unwrap();
    let root = Node::new("root", None, &doc).unwrap();
    doc.set_root_element(&root);
    
    let ns = root.add_namespace("ns", "http://example.com/ns").unwrap();
    let child = Node::new("child", Some(&ns), &doc).unwrap();
    child.set_content("Namespaced content");
    root.add_child(&child);
    
    doc
}

fn main() {
    let doc = create_xml_with_namespace();
    println!("{}", doc.to_string());
}

2. 验证XML文档

use libxml::parser::Parser;
use libxml::schemas::SchemaParserContext;

fn validate_xml() {
    let xml = r#"<?xml version="1.0"?>
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="schema.xsd">
    <element>Content</element>
</root>"#;

    let xsd = r#"<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="root">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="element" type="xs:string"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>"#;

    let parser = Parser::default();
    let doc = parser.parse_string(xml).expect("Failed to parse XML");
    
    let schema_parser = SchemaParserContext::from_buffer(xsd);
    let schema = schema_parser.parse().expect("Failed to parse schema");
    
    match doc.validate_schema(&schema) {
        Ok(_) => println!("XML is valid"),
        Err(errors) => {
            println!("Validation errors:");
            for error in errors {
                println!("- {}", error.message);
            }
        }
    }
}

fn main() {
    validate_xml();
}

性能提示

对于大型XML文件，考虑使用流式解析器而不是DOM解析器
重用Document和Context对象以提高性能
对于频繁的XPath查询，考虑预编译XPath表达式

错误处理

libxml提供了详细的错误信息，建议正确处理可能出现的错误：

use libxml::parser::Parser;
use libxml::error::Error as XmlError;

fn safe_parse(xml: &str) -> Result<(), XmlError> {
    let parser = Parser::default();
    let doc = parser.parse_string(xml)?;
    // 处理文档...
    Ok(())
}

fn main() {
    let xml = "<malformed><xml>";
    match safe_parse(xml) {
        Ok(_) => println!("Success"),
        Err(e) => println!("Error: {}", e),
    }
}

libxml库为Rust开发者提供了强大的XML处理能力，适合需要高性能XML处理的场景。

完整示例

下面是一个综合使用libxml库的完整示例，展示了XML文档的创建、修改、查询和验证：

use libxml::parser::Parser;
use libxml::tree::{Document, Node};
use libxml::xpath::Context;
use libxml::schemas::SchemaParserContext;
use libxml::error::Error as XmlError;

fn main() -> Result<(), XmlError> {
    // 1. 创建新XML文档
    let doc = create_xml_document()?;
    println!("Created XML:\n{}", doc.to_string());

    // 2. 修改XML文档
    modify_xml_document(&doc)?;
    println!("Modified XML:\n{}", doc.to_string());

    // 3. 使用XPath查询
    query_xml_with_xpath(&doc)?;

    // 4. 验证XML文档
    validate_xml_document(&doc)?;

    Ok(())
}

fn create_xml_document() -> Result<Document, XmlError> {
    let doc = Document::new()?;
    let root = Node::new("library", None, &doc)?;
    doc.set_root_element(&root);

    // 添加命名空间
    let ns = root.add_namespace("lib", "http://example.com/library")?;

    // 添加书籍节点
    let book1 = Node::new("book", Some(&ns), &doc)?;
    book1.set_attribute("category", "fiction")?;
    
    let title1 = Node::new("title", Some(&ns), &doc)?;
    title1.set_content("The Great Gatsby")?;
    book1.add_child(&title1)?;
    
    let author1 = Node::new("author", Some(&ns), &doc)?;
    author1.set_content("F. Scott Fitzgerald")?;
    book1.add_child(&author1)?;
    
    root.add_child(&book1)?;

    Ok(doc)
}

fn modify_xml_document(doc: &Document) -> Result<(), XmlError> {
    let root = doc.get_root_element()?;
    
    // 添加第二本书
    let ns = root.get_namespace("lib")?;
    let book2 = Node::new("book", ns.as_ref(), doc)?;
    book2.set_attribute("category", "non-fiction")?;
    
    let title2 = Node::new("title", ns.as_ref(), doc)?;
    title2.set_content("Rust in Action")?;
    book2.add_child(&title2)?;
    
    let author2 = Node::new("author", ns.as_ref(), doc)?;
    author2.set_content("Tim McNamara")?;
    book2.add_child(&author2)?;
    
    root.add_child(&book2)?;

    Ok(())
}

fn query_xml_with_xpath(doc: &Document) -> Result<(), XmlError> {
    let context = Context::new(doc)?;
    
    // 注册命名空间
    context.register_namespace("lib", "http://example.com/library")?;
    
    // 查询所有小说书籍
    let results = context.evaluate("//lib:book[@category='fiction']/lib:title")?;
    
    println!("\nXPath查询结果:");
    for node in results.get_nodes_as_vec() {
        println!("- {}", node.get_content());
    }

    Ok(())
}

fn validate_xml_document(doc: &Document) -> Result<(), XmlError> {
    let xsd = r#"<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://example.com/library"
           xmlns:lib="http://example.com/library"
           elementFormDefault="qualified">
    <xs:element name="library">
        <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:sequence>
                        <xs:attribute name="category" type="xs:string"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>"#;

    let schema_parser = SchemaParserContext::from_buffer(xsd);
    let schema = schema_parser.parse()?;
    
    println!("\nXML验证结果:");
    match doc.validate_schema(&schema) {
        Ok(_) => println!("文档验证通过"),
        Err(errors) => {
            println!("验证错误:");
            for error in errors {
                println!("- {}", error.message);
            }
        }
    }

    Ok(())
}

这个完整示例演示了：

创建带有命名空间的XML文档
动态添加新的XML节点
使用XPath查询带有命名空间的元素
使用XML Schema验证文档结构

注意在实际使用时，应该更完善地处理错误，这里为了示例简洁使用了?操作符简化错误处理。