在 Rust Web 服务中使用 Redis：同步与异步连接池实战

结果与目标

最终目标是建立一个基于 Rust 的 Web 服务，能够通过 HTTP 接口向本地运行的 Redis 实例写入键值对并读取返回。我们将对比同步模型（r2d2）与异步模型（mobc）在代码结构和性能上的差异。

准备条件

1. 开发环境：已安装 Rust 编译器 (cargo)。
2. 运行环境：需确保本地或服务器已启动 Redis 服务。推荐命令：docker run -p 6379:6379 redis，默认连接字符串为 redis://127.0.0.1/。

真实操作顺序

第1步：初始化项目并配置依赖

目的：创建基础工程并引入必要的网络请求、异步运行时及 Redis 连接池库。

操作：

1. 新建项目：在终端执行 cargo new rust-redis-web-example。
2. 配置 Cargo.toml：在 [dependencies] 区域添加以下版本依赖（版本号可根据实际情况调整，但需保持兼容）：

   tokio = { version = "1", features = ["full"] }
   warp = "0.3"
   redis = "0.21"
   r2d2_redis = "0.14"
   mobc-redis = "0.7"
   mobc = "0.7"
   thiserror = "1.0"
   

第2步：定义共享类型与错误处理

目的：统一错误返回格式，区分内部业务错误（Result）与外部 HTTP 拒绝错误（WebResult），以便 warp 框架正确处理。

操作：在 src/main.rs 顶部定义通用类型与枚举错误：

use std::result::Result;
use thiserror::Error;
use warp::{Rejection, Reply};

// Result 用于业务逻辑内部，WebResult 用于 warp 路由返回
pub type WebResult = std::result::Result<impl Reply, Rejection>;
pub type Result<T> = std::result::Result<T, Error>;

const REDIS_CON_STRING: &str = "redis://127.0.0.1/";

#[derive(Error, Debug)]
pub enum Error {
    #[error("Mobc error: {0}")]
    MobcError(#[from] MobcError),
    #[error("R2d2 error: {0}")]
    R2D2Error(#[from] R2D2Error),
}

// 省略具体的 MobcError 和 R2D2Error 定义...
// 需实现 warp::reject::Reject trait
impl warp::reject::Reject for Error {}

第3步：实现同步连接池 (r2d2)

目的：创建模块处理同步模式的 Redis 连接获取与 CRUD 操作。

入口：新建 src/r2d2_pool.rs。

动作：

1. 配置常量：设置最大连接数、最小空闲数、超时及生命周期。
2. 创建连接池：使用 r2d2::Pool 结合 RedisConnectionManager。
3. 实现 API：编写 get_con（获取连接）、set_str（设置键值与过期时间）、get_str（获取键值）函数。

use crate::{R2D2Error, Result, REDIS_CON_STRING};
use r2d2_redis::redis::{Commands, FromRedisValue};
use r2d2_redis::{r2d2, RedisConnectionManager};
use std::time::Duration;

pub type R2D2Pool = r2d2::Pool<RedisConnectionManager>;
pub type R2D2Con = r2d2::PooledConnection<RedisConnectionManager>;

// 配置常量示例
const CACHE_POOL_MAX_OPEN: u32 = 16;
const CACHE_POOL_TIMEOUT_SECONDS: u64 = 1;

pub fn connect() -> Result<R2D2Pool> {
    let manager = RedisConnectionManager::new(REDIS_CON_STRING).map_err(R2D2Error::RedisClientError)?;
    r2d2::Pool::builder()
        .max_size(CACHE_POOL_MAX_OPEN)
        .build(manager)
        .map_err(|e| R2D2Error::RedisPoolError(e).into())
}

pub fn get_con(pool: &R2D2Pool) -> Result<R2D2Con> {
    pool.get_timeout(Duration::from_secs(CACHE_POOL_TIMEOUT_SECONDS))
        .map_err(|e| R2D2Error::RedisPoolError(e).into())
}

pub fn set_str(pool: &R2D2Pool, key: &str, value: &str, ttl_seconds: usize) -> Result<()> {
    let mut con = get_con(pool)?;
    con.set(key, value).map_err(R2D2Error::RedisCMDError)?;
    if ttl_seconds > 0 {
        con.expire(key, ttl_seconds).map_err(R2D2Error::RedisCMDError)?;
    }
    Ok(())
}

pub fn get_str(pool: &R2D2Pool, key: &str) -> Result<String> {
    let mut con = get_con(pool)?;
    let value: String = con.get(key).map_err(R2D2Error::RedisCMDError)?;
    Ok(value)
}

第4步：实现异步连接池 (mobc)

目的：创建模块处理异步模式的 Redis 连接。由于 Warp 是异步框架，此方案更贴合现代高性能 Web 架构。

入口：新建 src/mobc_pool.rs。

动作：

1. 创建连接池：类似 r2d2，使用 mobc::Pool，但构建器方法名略有不同（如 max_open 对应 max_size）。
2. 实现 API：所有涉及 IO 的操作需标记 async/await。

use crate::{MobcError, Result, REDIS_CON_STRING};
use mobc::{Connection, Pool};
use mobc_redis::redis::{AsyncCommands, FromRedisValue};
use mobc_redis::{redis, RedisConnectionManager};
use std::time::Duration;

pub type MobcPool = Pool<redis::Client>;
pub type MobcCon = Connection<redis::Client>;

const CACHE_POOL_MAX_OPEN: u64 = 16;
const CACHE_POOL_TIMEOUT_SECONDS: u64 = 1;

pub async fn connect() -> Result<MobcPool> {
    let client = redis::Client::open(REDIS_CON_STRING).map_err(MobcError::RedisClientError)?;
    let manager = RedisConnectionManager::new(client);
    Ok(Pool::builder()
        .get_timeout(Some(Duration::from_secs(CACHE_POOL_TIMEOUT_SECONDS)))
        .max_open(CACHE_POOL_MAX_OPEN)
        .build(manager))
}

pub async fn get_con(pool: &MobcPool) -> Result<MobcCon> {
    pool.get().await.map_err(|e| MobcError::RedisPoolError(e).into())
}

pub async fn set_str(pool: &MobcPool, key: &str, value: &str, ttl_seconds: usize) -> Result<()> {
    let mut con = get_con(pool).await?;
    con.set(key, value).await.map_err(MobcError::RedisCMDError)?;
    if ttl_seconds > 0 {
        con.expire(key, ttl_seconds).await.map_err(MobcError::RedisCMDError)?;
    }
    Ok(())
}

pub async fn get_str(pool: &MobcPool, key: &str) -> Result<String> {
    let mut con = get_con(pool).await?;
    let value: String = con.get(key).await.map_err(MobcError::RedisCMDError)?;
    Ok(value)
}

第5步：集成 Warp 路由

目的：将两个连接池接入 Web 服务器，监听不同路径测试功能。

入口：修改 src/main.rs。

重要参数：端口 8080，路径分别为 /mobc 和 /r2d2。

// 在 main.rs 头部声明模块
mod r2d2_pool;
mod mobc_pool;

#[tokio::main]
async fn main() {
    // 1. 初始化池
    let mobc_pool = mobc_pool::connect().await.expect("mobc init failed");
    let r2d2_pool = r2d2_pool::connect().expect("r2d2 init failed");

    // 2. 定义 Filter
    let mobc_route = warp::path!("mobc")
        .and(warp::any().map(move || mobc_pool.clone()))
        .and_then(mobc_handler);

    let r2d2_route = warp::path!("r2d2")
        .and(warp::any().map(move || r2d2_pool.clone()))
        .and_then(r2d2_handler);

    let routes = mobc_route.or(r2d2_route);

    // 3. 运行服务
    println!("Server running on http://localhost:8080");
    warp::serve(routes).run(([0, 0, 0, 0], 8080)).await;
}

// Handler 实现参考前文 API 调用部分，注意区分 async 与非 async 语法

完成判断

1. 执行 cargo run --release 启动服务。
2. 打开浏览器或使用 curl 访问：
   
   • curl http://localhost:8080/r2d2：应返回 r2d2_world 字样。
   • curl http://localhost:8080/mobc：应返回 mobc_world 字样。
3. 若无报错且返回值正确，说明同步与异步两种集成模式均部署成功。

简要总结

Rust 生态提供了成熟的连接池解决方案。r2d2`适合传统的阻塞式 IO 场景或与旧有代码兼容；而在追求高并发性能的现代 Web 服务中，mobc` 配合异步运行时（Tokio）能提供更优的资源利用率。关键在于根据项目的 I/O 模型选择对应的客户端驱动和连接池库。

以上就是在 Rust Web 服务中使用 Redis 的详细教程，更多关于 Rust 性能优化与 Web 开发资料请关注本站其它相关文章！