Actix-web中Redis缓存中间件异步逻辑的生命周期问题

问题背景 #

尝试基于Redis和Actix-web开发缓存中间件，预期实现以下逻辑：

• 拼接请求路径与query_string生成Redis键
• 从Redis数据库获取对应值
• 若值非空，直接返回该内容
• 若值为空，调用后续服务，完成后将响应存入Redis缓存

但在wrap_fn函数中添加异步Redis操作后，将srv.call(req)移入async块时出现生命周期错误：

error: lifetime may not live long enough
--> src/main.rs:90:4
|
74 | .wrap_fn(|req, srv| {
| ---- return type of closure impl futures::Future<Output = Result<ServiceResponse, actix_web::Error>> contains a lifetime '2
| |
| has type &'1 actix_web::app_service::AppRouting
...
90 | / async {
91 | | let res = srv.call(req).await?;
92 | | Ok(res)
93 | | }
| |_____________^ returning this value requires that '1 must outlive '2

解决方案 #

这个错误的核心是Rust编译器无法推断出srv的生命周期能覆盖async块返回的Future。可以通过以下方式修复：

关键修复点 #

1. 用async move捕获变量：将闭包中的srv、Redis连接等变量转移到async块中，让编译器明确生命周期关联。
2. 通过Data注入Redis连接：使用Actix-web的web::Data管理全局共享的Redis连接，避免持有短生命周期引用。
3. 提前复制请求数据：在进入async块前，将请求的路径、查询字符串复制为独立的String，避免持有请求对象的引用引发生命周期冲突。

修正后的完整代码示例 #

use actix_web::{web, App, HttpResponse, HttpServer, middleware::wrap_fn, Error, ServiceResponse};
use redis::{AsyncCommands, Client};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // 初始化Redis客户端与连接
    let redis_client = Client::open("redis://127.0.0.1/").unwrap();
    let redis_conn = redis_client.get_async_connection().await.unwrap();

    HttpServer::new(move || {
        App::new()
            // 将Redis连接注入应用全局数据
            .app_data(web::Data::new(redis_conn.clone()))
            .wrap_fn(|req, srv| {
                // 提前获取并复制请求的路径、查询字符串
                let path = req.path().to_string();
                let query = req.query_string().to_string();
                // 获取全局的Redis连接引用
                let redis = req.app_data::<web::Data<redis::aio::Connection>>().unwrap().clone();

                // 使用async move转移变量所有权，解决生命周期问题
                async move {
                    // 生成缓存键
                    let cache_key = format!("{}?{}", path, query);

                    // 尝试从Redis读取缓存
                    let cached_value: Option<String> = redis.get(&cache_key).await.map_err(Error::from)?;

                    if let Some(value) = cached_value {
                        // 直接返回缓存内容
                        Ok(ServiceResponse::new(
                            req.into_parts().0,
                            HttpResponse::Ok().body(value),
                        ))
                    } else {
                        // 调用后续服务获取响应
                        let mut res = srv.call(req).await?;

                        // 提取响应体并存入Redis
                        let body = res.response().body().as_str().unwrap_or_default().to_string();
                        redis.set(&cache_key, body).await.map_err(Error::from)?;

                        Ok(res)
                    }
                }
            })
            .route("/", web::get().to(|| async { HttpResponse::Ok().body("Hello World!") }))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

内容的提问来源于stack exchange，提问作者Victor D