将reqwest::Response逻辑移至异步方法时的生命周期错误解决问询

问题背景 #

需要改进生成并返回reqwest::Response的Future逻辑，添加捕获401响应、重新认证并重试的功能。但将请求逻辑移至结构体的异步方法时，出现生命周期错误。

原可正常运行的代码 #

结构体中的非异步方法，返回boxed future，self.client为reqwest::Client，使用tokio运行时：

pub fn demo_good(
    &mut self,
    url: Url,
) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send>> {
    let mut map = HashMap::new();
    map.insert("fake_key".to_string(), "fake_value".to_string());
    let response = self.client.post(url).json(&map).send();
    Box::pin(response)
}

修改后报错的代码 #

将请求逻辑移至异步方法demo_post后，编译报错：

// POST to the execute_url, handling reauthentication
async fn demo_post(
    &mut self,
    url: Url,
    body: HashMap<String, String>,
) -> Result<Response, Error> {
    // Run first request
    let response = self.client.post(url).json(&body).send().await;
    // Todo: catch 401s, reauth, and repeat
    dbg!(&response);
    // Return
    response
}

pub fn demo_bad(
    &mut self,
    url: Url,
) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send>> {
    let mut map = HashMap::new();
    map.insert("fake_key".to_string(), "fake_value".to_string());
    let response = self.demo_post(url, map);
    Box::pin(response)
}

编译错误信息 #

Compiling playground v0.0.1 (/playground)
error: lifetime may not live long enough
  --> src/lib.rs:41:9
   |
35 |         &mut self,
   |         - let's call the lifetime of this reference `'1`
...
41 |         Box::pin(response)
   |         ^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'static`
   |
help: to declare that the trait object captures data from argument `self`, you can add an explicit `'_` lifetime bound
   |
37 |     ) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send + '_>> {
   |                                                                   

疑问 #

可以按照提示添加生命周期约束，但该方法并未比原demo_good方法捕获更多self的数据。此外，需要返回该Future供代码库其他部分使用，担心新的生命周期约束会引发如error[E0515]: cannot return value referencing temporary value的新错误。

请问是否有替代方案实现该策略，比如在方法签名中指定生命周期参数？或者由于原reqwest方法（非异步返回Future）与新增包装异步方法的差异，该方案不可行，需要采用其他设计？

解决方案 #

1. 按提示添加生命周期约束（最直接修复） #

编译提示的+ '_生命周期约束是合理的，核心原因：

• 原demo_good返回的Future来自reqwest::RequestBuilder::send()，仅捕获Client的引用（而Client是结构体成员，本身满足'static生命周期要求）。
• 而demo_post是异步方法，其返回的Future会捕获&mut self的引用，必须显式标注该Future的生命周期与self的引用绑定。

修改后的demo_bad签名：

pub fn demo_bad(
    &mut self,
    url: Url,
) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send + '_>> {
    let mut map = HashMap::new();
    map.insert("fake_key".to_string(), "fake_value".to_string());
    let response = self.demo_post(url, map);
    Box::pin(response)
}

这种约束不会引发额外错误，只要调用方持有self的引用直到Future完成即可——这与原demo_good的使用逻辑完全一致，原方法同样要求self在Future执行期间保持有效。

2. 使用async_trait crate简化异步方法签名 #

如果不想手动处理生命周期，可以借助async_trait crate自动生成正确的生命周期绑定：

首先在Cargo.toml添加依赖：

async-trait = "0.1"

修改代码示例：

use async_trait::async_trait;

#[async_trait]
impl YourStruct {
    async fn demo_post(
        &mut self,
        url: Url,
        body: HashMap<String, String>,
    ) -> Result<Response, Error> {
        let mut response = self.client.post(url.clone()).json(&body).send().await;
        // 实现401重试逻辑
        if let Ok(resp) = &response {
            if resp.status() == StatusCode::UNAUTHORIZED {
                self.reauthenticate().await?;
                response = self.client.post(url).json(&body).send().await;
            }
        }
        response
    }

    pub fn demo_bad(
        &mut self,
        url: Url,
    ) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send + '_>> {
        let mut map = HashMap::new();
        map.insert("fake_key".to_string(), "fake_value".to_string());
        Box::pin(self.demo_post(url, map))
    }
}

3. 直接在返回Future的方法中实现重试逻辑（避免拆分方法） #

如果不想拆分异步方法，可以将重试逻辑直接写在demo_good风格的方法里，通过async {}块构建Future：

pub fn demo_with_retry(
    &mut self,
    url: Url,
) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send + '_>> {
    let mut map = HashMap::new();
    map.insert("fake_key".to_string(), "fake_value".to_string());
    let body = map;
    let url_clone = url.clone();

    Box::pin(async move {
        let mut response = self.client.post(url_clone).json(&body).send().await?;
        if response.status() == StatusCode::UNAUTHORIZED {
            // 执行重新认证逻辑
            self.reauthenticate().await?;
            // 重试请求
            response = self.client.post(url).json(&body).send().await?;
        }
        Ok(response)
    })
}

这种方式无需额外异步方法，直接在返回的Future中处理重试，生命周期由编译器自动推导。

4. 将Client改为Arc<Client>（缓解可变引用限制） #

如果后续遇到可变引用导致的并发调用限制，可以将结构体中的client: reqwest::Client改为client: Arc<reqwest::Client>，使用共享引用替代可变引用：

use std::sync::Arc;

struct YourStruct {
    client: Arc<reqwest::Client>,
    // 其他字段（如token可搭配Mutex/RwLock实现线程安全修改）
}

impl YourStruct {
    async fn demo_post(
        &self,
        url: Url,
        body: HashMap<String, String>,
    ) -> Result<Response, Error> {
        let mut response = self.client.post(url.clone()).json(&body).send().await?;
        if response.status() == StatusCode::UNAUTHORIZED {
            self.reauthenticate().await?;
            response = self.client.post(url).json(&body).send().await?;
        }
        Ok(response)
    }

    pub fn demo(
        &self,
        url: Url,
    ) -> Pin<Box<dyn futures::Future<Output = Result<Response, Error>> + Send + '_>> {
        let mut map = HashMap::new();
        map.insert("fake_key".to_string(), "fake_value".to_string());
        Box::pin(self.demo_post(url, map))
    }
}

这种设计可以减少可变引用带来的生命周期问题，同时支持并发请求。

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