Rust高效数据路由库zenoh-keyexpr使用指南

zenoh-keyexpr是Zenoh网络中间件中用于处理主题表达式的核心库，提供了高效灵活的主题表达式解析与操作功能。

基本概念

Zenoh使用key expression（键表达式）来标识和路由数据，类似于MQTT中的主题但功能更强大。

安装

在Cargo.toml中添加依赖：

[dependencies]
zenoh-keyexpr = "0.7"

基本使用

创建键表达式

use zenoh_keyexpr::keyexpr;

// 创建静态键表达式（编译时检查）
let static_key = keyexpr!("demo/example");
println!("Static keyexpr: {}", static_key);

// 动态创建键表达式（运行时检查）
let dynamic_key = "demo/example".try_into().unwrap();
println!("Dynamic keyexpr: {}", dynamic_key);

键表达式操作

use zenoh_keyexpr::keyexpr;

let base = keyexpr!("demo/example");

// 连接键表达式
let joined = base.join("subtopic").unwrap();
println!("Joined: {}", joined); // 输出: demo/example/subtopic

// 检查包含关系
let parent = keyexpr!("demo/*");
println!("Does {} include {}? {}", parent, base, parent.includes(&base));

高级功能

通配符和模式匹配

use zenoh_keyexpr::keyexpr;

let pattern = keyexpr!("demo/**/sensor?");
let candidate1 = keyexpr!("demo/room1/sensor1");
let candidate2 = keyexpr!("demo/building/floor2/sensor3");

println!("Does {} match {}? {}", candidate1, pattern, pattern.matches(&candidate1));
println!("Does {} match {}? {}", candidate2, pattern, pattern.matches(&candidate2));

表达式规范化

use zenoh_keyexpr::keyexpr;

let unnormalized = keyexpr!("demo///a//b/");
let normalized = unnormalized.normalize();
println!("Normalized: {}", normalized); // 输出: demo/a/b

表达式切分

use zenoh_keyexpr::keyexpr;

let key = keyexpr!("a/b/c/d");
for chunk in key.chunks() {
    println!("Chunk: {}", chunk);
}
// 输出:
// Chunk: a
// Chunk: b
// Chunk: c
// Chunk: d

与Zenoh集成

use zenoh::prelude::*;
use zenoh::config::Config;

#[async_std::main]
async fn main() {
    let session = zenoh::open(Config::default()).await.unwrap();
    
    // 发布数据
    let publisher = session.publisher("demo/example").await.unwrap();
    publisher.put("Hello from Rust!").await.unwrap();
    
    // 订阅数据
    let subscriber = session.subscribe("demo/*").await.unwrap();
    while let Ok(sample) = subscriber.recv_async().await {
        println!("Received: {} => {}", sample.key_expr, sample.value);
    }
}

性能提示

1. 尽可能使用keyexpr!宏创建静态键表达式，它在编译时完成验证
2. 重用键表达式对象而不是重复创建
3. 对频繁匹配的操作考虑预编译匹配模式

zenoh-keyexpr为Zenoh提供了强大而灵活的主题表达式处理能力，是构建高效数据路由系统的关键组件。

完整示例DEMO

use zenoh::prelude::*;
use zenoh::config::Config;
use zenoh_keyexpr::keyexpr;

#[async_std::main]
async fn main() {
    // 初始化Zenoh会话
    let session = zenoh::open(Config::default()).await.unwrap();
    
    // 创建静态键表达式
    let pub_key = keyexpr!("demo/example");
    let sub_key = keyexpr!("demo/*");
    
    // 异步任务 - 订阅数据
    let sub_task = async_std::task::spawn({
        let session = session.clone();
        async move {
            let subscriber = session.subscribe(sub_key).await.unwrap();
            println!("Subscribed to: {}", sub_key);
            
            while let Ok(sample) = subscriber.recv_async().await {
                println!("Received on {}: {}", sample.key_expr, sample.value);
            }
        }
    });
    
    // 发布数据
    let publisher = session.publisher(pub_key).await.unwrap();
    for i in 0..3 {
        let msg = format!("Message {}", i);
        publisher.put(msg).await.unwrap();
        println!("Published to: {}", pub_key);
        async_std::task::sleep(std::time::Duration::from_secs(1)).await;
    }
    
    // 等待订阅任务完成
    sub_task.await;
    
    // 关闭会话
    session.close().await.unwrap();
}

这个完整示例展示了：

1. 创建Zenoh会话
2. 使用keyexpr!宏创建静态键表达式
3. 异步订阅和发布消息
4. 键表达式在实际通信中的应用
5. 资源的正确清理

运行这个示例需要同时安装zenoh和zenoh-keyexpr依赖：

[dependencies]
zenoh = "0.7"
zenoh-keyexpr = "0.7"
async-std = { version = "1.9", features = ["attributes"] }