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

Rust研习社2026-04-30 8:22

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

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

添加库依赖

在 Cargo.toml 中配置依赖：

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 命令：

rust 复制代码 
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 与同步模式高度一致：

rust 复制代码 
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 特性提供了内置连接池，能自动管理连接的创建、复用、销毁和重连，无需手动处理连接生命周期：

rust 复制代码 
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() 执行：

rust 复制代码 
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() 方法进行事务操作：

rust 复制代码 
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 可快速调用脚本：

rust 复制代码 
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 应该已经有足够的了解了，接下来就能实际开发中使用它了。

相关推荐
deviant-ART1 小时前
HttpServletResponse 中 Header 与 OutputStream 的正确使用顺序（避坑指南）
java·后端·servlet
编码者卢布1 小时前
【App Service】查看Application Insights自身SDK日志的方法示例
后端·python·flask
Wmenghu1 小时前
Ubuntu 安装 MySQL 8.0 + Redis 并开启远程访问
redis·mysql·ubuntu
xyq20241 小时前
Memcached stats items 命令详解
开发语言
Evand J1 小时前
【MATLAB例程】多传感器协同DOA目标跟踪与EKF滤波，输出动态目标轨迹、轨迹误差对比分析
开发语言·matlab·目标跟踪·滤波·定位·导航
csbysj20201 小时前
《jEasyUI 自定义分页》
开发语言
初心未改HD1 小时前
Go语言Context深度解析与工程实践
开发语言·golang
土豆12501 小时前
Rust 生命周期开发实战：从"编译不过"到"一次过编"的实用指南
前端·rust
Victor3561 小时前
MongoDB（111）如何使用MongoDB Atlas进行管理？
后端
热门推荐
01GitHub 镜像站点022026年4月AI大事件深度解读：大模型竞争进入“深水区“03近期有什么ai的新消息，新动态？ 2026.4月04Codex 接入 DeepSeek API 完整配置文档05【AI】2026 年具身智能模型和世界模型总结062026年AI编程工具终极横评：Cursor vs Claude Code vs Copilot07实测可用｜小米 MiMo 百万亿 Token 免费领，开发者速冲08在Windows 11上安装Docker的踩坑记录09裂开！ChatGPT 居然开始要手机号验证，附详细解决方法102026年AI前瞻：量子AI、具身智能与科学发现的新纪元