如何在不消耗hyper::Request的情况下使用其请求体？

尝试使用req.into_body()读取请求体，基于请求的URI和请求体生成哈希键，但req.into_body()会消耗整个Request实例，导致后续无法复用；同时请求体Body没有提供clone方法，无法直接复制。请问如何在不消耗Request变量的前提下复用它？

示例代码 #

async fn readKey(req: Request<Body>) -> (String, Request<Body>) {
    let mut key: String;
    if (!req.method().as_str().eq("GET")) {
        let body_bytes = hyper::body::to_bytes(req.into_body()).await.unwrap();
        let body_string = String::from_utf8(body_bytes.to_vec()).unwrap();
        key = format!(
            "{}{}{}",
            req.uri().host().unwrap(),
            req.uri().path(),
            body_string
        );
    } else {
        key = format!("{}{}", req.uri().host().unwrap(), req.uri().path());
    }
    return (key, req);
}

编译错误 #

error[E0382]: borrow of moved value: `req`
   --> src/main.rs:72:33
    |
65  | async fn readKey(req: Request<Body>) -> (String , Request<Body>) {
    |                  --- move occurs because `req` has type `Request<Body>`, which does not implement the `Copy` trait
...
70  |         let body_bytes = hyper::body::to_bytes(req.into_body()).await.unwrap();
    |                                                    ----------- `req` moved due to this method call
71  |         let body_string = String::from_utf8(body_bytes.to_vec()).unwrap();
72  |         key = format!("{}{}{}", req.uri().host().unwrap(), req.uri().path(),body_string);
    |                                 ^^^^^^^^^ value borrowed here after move
    |
note: `Request::<T>::into_body` takes ownership of the receiver `self`, which moves `req`
   --> /Users/sunilsingh/.cargo/registry/src/github.com-1ecc6299db9ec823/http-0.2.9/src/request.rs:653:22
    |
653 |     pub fn into_body(self) -> T {
    |                      ^^^^

核心思路是：先提取Request中不需要消耗所有权的信息（比如method、host、path），再处理请求体，最后用处理后的字节重新构建Body，并结合原Request的其他部分生成新的Request实例，这样既拿到了请求体内容，又能返回可用的Request。

修改后的代码如下：

use hyper::{Request, Body};

async fn read_key(req: Request<Body>) -> (String, Request<Body>) {
    // 提前提取可克隆的请求信息，避免后续移动Request后无法访问
    let method = req.method().clone();
    let uri = req.uri().clone();
    let headers = req.headers().clone();
    let host = uri.host().unwrap().to_string();
    let path = uri.path().to_string();

    let (key, new_req) = if !method.as_str().eq("GET") {
        // 取出原请求的body
        let body = req.into_body();
        // 将body转为字节数组
        let body_bytes = hyper::body::to_bytes(body).await.unwrap();
        let body_string = String::from_utf8(body_bytes.to_vec()).unwrap();
        // 生成目标哈希键
        let key = format!("{}{}{}", host, path, body_string);
        // 用字节重新构建可复用的Body
        let new_body = Body::from(body_bytes);
        // 组装新的Request实例
        let new_req = Request::builder()
            .method(method)
            .uri(uri)
            .headers(headers)
            .body(new_body)
            .unwrap();
        (key, new_req)
    } else {
        // GET请求无需处理body，直接返回原请求和生成的键
        let key = format!("{}{}", host, path);
        (key, req)
    };

    (key, new_req)
}

关键步骤说明 #

• 提前提取静态信息：先把method、uri、headers这些支持克隆的信息复制出来，避免调用into_body移动Request后无法访问这些字段。
• 重构Request实例：处理完body字节后，用Body::from(body_bytes)重新创建可复用的Body，再结合之前提取的请求元数据组装成完整的Request，确保返回的实例可以正常后续使用。
• 错误处理提示：示例中用unwrap()简化逻辑，实际项目中建议替换为符合业务需求的错误捕获（比如返回Result类型）。

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