Rust 操作 Redis 从入门到生产级应用

Rust 操作 Redis 从入门到生产级应用

在现代后端开发中，Redis 作为高性能的内存数据库，广泛用于缓存、会话管理、消息队列等场景。本文将基于主流的 redis-rs 库，带你全面掌握 Rust 操作 Redis 的技巧，覆盖同步/异步双模式、连接池、序列化等内容。

添加库依赖

在 Cargo.toml 中配置依赖：

[dependencies]
redis = { version = "1.2", features = [
    "tokio-comp",            # 异步支持
    "connection-manager",    # 内置连接池
    "tokio-native-tls-comp",
] }
tokio = { version = "1", features = ["full"] }
anyhow = "1.0"

基础操作

redis-rs 对 Redis 原生命令做了优雅封装，API 与 Redis 命令高度一致，学习成本极低，同时依托 Rust 的编译期检查，能从根源规避类型错误、命令误用等问题。以下示例分别展示同步与异步模式下的基础操作。

同步模式：简单场景快速上手

同步模式适合简单脚本、单线程工具等场景，核心是通过 Client 创建连接，再通过 Commands 特征调用 Redis 命令：

use anyhow::Result;
use redis::{Client, Commands};

fn main() -> Result<()> {
    // 创建 Redis 客户端
    let client = Client::open("redis://127.0.0.1:6379")?;
    // 获取连接（同步连接）
    let mut conn = client.get_connection()?;

    // 字符串操作：SET / GET
    let _: () = conn.set("username", "rust_dev")?; // SET 命令，返回空元组
    let username: Option<String> = conn.get("username")?; // GET 命令，返回 Option（避免空值 panic）
    println!("获取 username: {:?}", username); // 输出：Some("rust_dev")

    // 哈希操作：HSET / HGET / HGETALL
    let _: () = conn.hset("user:1", "id", 1)?;
    let _: () = conn.hset("user:1", "name", "Alice")?;
    let user_name: Option<String> = conn.hget("user:1", "name")?;
    let user: Option<redis::Value> = conn.hgetall("user:1")?; // 获取整个哈希
    println!("获取用户名称: {:?}", user_name); // 输出：Some("Alice")
    println!("获取用户全部信息: {:?}", user);

    // 列表操作：LPUSH / LRANGE
    let _: () = conn.lpush("tasks", "learn redis")?;
    let _: () = conn.lpush("tasks", "learn rust")?;
    let tasks: Vec<String> = conn.lrange("tasks", 0, -1)?; // 获取所有列表元素
    println!("任务列表: {:?}", tasks); // 输出：["learn rust", "learn redis"]

    // 删除操作：DEL
    let _: () = conn.del("username")?;

    Ok(())
}

异步模式：高并发场景首选

异步模式基于 Tokio 实现，非阻塞 IO，其 API 与同步模式高度一致：

use anyhow::Result;
use redis::{AsyncCommands, Client};

#[tokio::main]
async fn main() -> Result<()> {
    // 创建 Redis 客户端
    let client = Client::open("redis://127.0.0.1:6379")?;
    // 获取异步连接
    let mut conn = client.get_multiplexed_async_connection().await?;

    // 异步操作：与同步模式 API 一致
    let _: () = conn.set("async_key", "async_value").await?;
    let async_value: Option<String> = conn.get("async_key").await?;
    println!("异步获取值: {:?}", async_value); // 输出：Some("async_value")

    // 哈希操作（异步）
    let _: () = conn.hset("async_user:1", "age", 25).await?;
    let age: Option<i32> = conn.hget("async_user:1", "age").await?;
    println!("异步获取用户年龄: {:?}", age); // 输出：Some(25)

    Ok(())
}

进阶特性

在实际生产环境中，仅基础操作远远不够，redis-rs 提供还提供了连接池、管道、事务、序列化等特性，能帮助我们构建更稳定、高效的服务。

连接池：高并发下的连接管理

频繁创建/销毁 Redis 连接会严重影响性能，connection-manager 特性提供了内置连接池，能自动管理连接的创建、复用、销毁和重连，无需手动处理连接生命周期：

use anyhow::Result;
use redis::{AsyncCommands, Client};

#[tokio::main]
async fn main() -> Result<()> {
    // 创建 Redis 客户端
    let client = Client::open("redis://127.0.0.1:6379")?;
    // 创建连接池，默认配置
    // 另外可提供 get_connection_manager_with_config 自定义最大连接数、超时时间等
    let mut conn_manager = client.get_connection_manager().await?;

    // 从连接池获取连接并执行操作（自动复用连接）
    for i in 0..5 {
        let key = format!("pool_key:{}", i);

        let _: () = conn_manager.set(&key, i).await?;
        let value: Option<i32> = conn_manager.get(&key).await?;

        println!("连接池操作 {}: {:?}", key, value);
    }

    Ok(())
}

管道（Pipeline）：批量操作提升性能

Redis 管道允许将多个命令批量发送到服务器，减少网络往返次数，显著提升批量操作的性能。redis-rs 支持管道的链式调用，通过 pipe() 创建管道，添加命令后通过 exec() 或 query() 执行：

use anyhow::Result;
use redis::{Client, pipe};

#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::open("redis://127.0.0.1:6379")?;
    let mut conn = client.get_connection()?;

    // 创建管道，批量执行 SET 命令（无返回值）
    pipe()
        .set("pipe_key1", "value1")
        .set("pipe_key2", "value2")
        .set("pipe_key3", "value3")
        .exec(&mut conn)?;
    println!("管道批量 SET 执行完成");

    // 批量执行 GET 命令（获取返回值）
    let (val1, val2, val3): (Option<String>, Option<String>, Option<String>) = pipe()
        .get("pipe_key1")
        .get("pipe_key2")
        .get("pipe_key3")
        .query(&mut conn)?;
    println!("管道批量 GET 结果: {:?}, {:?}, {:?}", val1, val2, val3);

    Ok(())
}

事务（Transaction）：保证操作原子性

Redis 事务通过 MULTI、EXEC 命令实现，确保多个命令原子性执行（要么全部成功，要么全部失败）。redis-rs 通过管道提供的 atomic() 方法进行事务操作：

use anyhow::Result;
use redis::{Client, pipe};

#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::open("redis://127.0.0.1:6379")?;
    let mut conn = client.get_connection()?;

    // 开启事务
    let mut pipe = pipe();
    pipe.atomic();

    // 向事务中添加命令
    pipe.set("tx_key1", "tx_val1")
        .hset("tx_user:1", "name", "Bob")
        .lpush("tx_tasks", "finish transaction");

    // 执行事务（通过 query 发送所有命令）
    let results: Vec<redis::Value> = pipe.query(&mut conn)?;
    println!("事务执行结果: {:?}", results);

    Ok(())
}

Lua 脚本：扩展 Redis 功能与原子操作

Redis 支持通过 Lua 脚本执行简单原子操作，redis-rs 提供简洁的 API 可快速调用脚本：

use anyhow::Result;
use redis::{Client, Script};

// 定义结构体
#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::open("redis://127.0.0.1:6379")?;
    let mut conn = client.get_multiplexed_async_connection().await?;

    // 定义 Lua 脚本：自增指定 key，返回自增后的值
    let lua_script = Script::new(
        r#"
        local key = KEYS[1]
        -- 调用 Redis 原生命令 INCR，实现自增
        return redis.call('INCR', key)
    "#,
    );

    // 执行脚本：通过 .key() 传递 KEYS 参数
    let new_val: i32 = lua_script
        .key("simple_lua_counter") // 添加 KEY
        .invoke_async(&mut conn) // 执行脚本
        .await?;
    println!("Lua 脚本执行结果（自增后）: {}", new_val); // 首次执行输出 1

    // 传递参数的简单示例，设置 key 值并返回
    let set_and_get_script = Script::new(
        r#"
        local key = KEYS[1]
        local val = ARGV[1]
        redis.call('SET', key, val)
        return val
    "#,
    );

    let result: String = set_and_get_script
        .key("lua_test_key") // 添加 KEY
        .arg("test_value") // 添加 ARG
        .invoke_async(&mut conn)
        .await?;
    println!("设置并返回值: {}", result); // 输出 test_value

    Ok(())
}

注意事项与最佳实践

错误处理

Rust 强调错误处理的严谨性，redis-rs 的所有操作都会返回 RedisResult，实际开发中应避免使用 unwrap()，建议通过 ? 关键字传播错误，或者使用 thiserror 自定义错误类型，提升代码可维护性。

连接池配置

生产环境中，需根据并发量合理配置连接池的最大连接数（默认 10），避免连接数过多导致 Redis 服务压力过大，或连接数过少导致请求阻塞。同时可设置连接超时时间，防止连接泄露。

数据类型匹配

redis-rs 是强类型客户端，Redis 数据类型与 Rust 类型需严格匹配（如 Redis 字符串对应 Rust 的 String，Redis 数字对应 Rust i32/u64 等），否则会导致编译错误或运行时错误。

性能优化

• 批量操作优先使用管道，减少网络往返；
• 高并发场景使用异步模式 + 连接池，充分利用系统资源；
• 避免存储过大的数据（Redis 适合存储轻量数据），如需存储大对象，可考虑分块存储或使用其他存储方案。

总结

看完这篇文章，你对 redis-rs 应该已经有足够的了解了，接下来就能实际开发中使用它了。