Rust中Tokio+Hyper服务器async函数生命周期不匹配问题

依赖配置 #

[dependencies]
hyper = { version = "1", features = ["full"] }
tokio = { version = "1", features = ["full"] }
http-body-util = "0.1"
hyper-util = { version = "0.1", features = ["full"] }

程序代码 #

use std::convert::Infallible;
use std::net::SocketAddr;

use http_body_util::Full;
use hyper::body::Bytes;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;

use std::future::Future;
#[derive(Debug,Clone)]
struct TestStruct {
    a : i32,
}

async fn query_dispatcher_test(_req: Request<hyper::body::Incoming>, _pool : &TestStruct) -> Result<Response<Full<Bytes>>, Infallible>
{
    Ok(Response::new(Full::new(Bytes::from("default API"))))
}

async fn build_service<F, S>(pool : &TestStruct, listener : &TcpListener, f: F)
where
    F: 'static + Fn(Request<hyper::body::Incoming>, &TestStruct) -> S,
    F: Sync + Send + Copy,
    S: Future<Output = Result<Response<Full<Bytes>>, Infallible>> + Send 
{
    let (stream, _) = listener.accept().await.unwrap();
    // Use an adapter to access something implementing `tokio::io` traits as if they implement
    // `hyper::rt` IO traits.
    let io: TokioIo<_> = TokioIo::new(stream);
    let pool_clone = pool.clone();
    let service = service_fn(move |_req : Request<hyper::body::Incoming>| {
        let inner = pool_clone.clone();
        async move {
            f(_req, &inner).await
        }
    });

    // Spawn a tokio task to serve multiple connections concurrently
    tokio::task::spawn(async move {
        // Finally, we bind the incoming connection to our service
        if let Err(err) = http1::Builder::new()
            .serve_connection(io, service)
            .await
        {
            eprintln!("Error serving connection: {:?}", err);
        }
    });
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    let listener = TcpListener::bind(addr).await?;
    let pool = TestStruct{
        a : 1,
    };
    // We start a loop to continuously accept incoming connections
    loop {
        build_service(&pool, &listener,query_dispatcher_test);   
    }
}

编译错误 #

error[E0308]: mismatched types
   --> src/main.rs:64:9
    |
64  |         build_service(&pool, &listener,query_dispatcher_test);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
    |
    = note: expected opaque type `impl for<'a> Future<Output = Result<Response<http_body_util::Full<hyper::body::Bytes>>, Infallible>>`
               found opaque type `impl Future<Output = Result<Response<http_body_util::Full<hyper::body::Bytes>>, Infallible>>`
    = help: consider `await`ing on both `Future`s
    = note: distinct uses of `impl Trait` result in different opaque types
note: the lifetime requirement is introduced here
   --> src/main.rs:25:69
    |
25  |     F: 'static + Fn(Request<hyper::body::Incoming>, &TestStruct) -> S,
    |                                                                     ^

已知信息 #

• 移除query_dispatcher_test中的TestStruct引用后，程序可正常编译
• 将build_service的逻辑直接移入main的loop中，替换f为query_dispatcher_test，程序也能编译
• 已克隆pool以保证与service_fn闭包生命周期一致，但仍不理解编译器所需的生命周期要求，推测与tokio::task::spawn相关

根源 #

编译器报错的核心是生命周期约束不匹配：build_service中对闭包F的返回值S（即Future）没有绑定正确的生命周期。query_dispatcher_test返回的Future依赖于传入的&TestStruct的生命周期，但当前的泛型约束没有明确这一点，导致编译器无法确认Future的生命周期是否满足spawn要求（spawn要求任务必须是'static）。另外，build_service的泛型参数S缺少生命周期绑定，需要明确S的生命周期与闭包参数中&TestStruct的生命周期关联。

修正方案 #

1. 为build_service的泛型添加生命周期参数，明确闭包F返回的FutureS依赖于传入的TestStruct引用的生命周期
2. 调整service_fn的闭包逻辑，确保克隆后的TestStruct完全独立（因为已经实现Clone，直接持有所有权而非引用，避免生命周期纠缠）

修正后的代码 #

use std::convert::Infallible;
use std::net::SocketAddr;

use http_body_util::Full;
use hyper::body::Bytes;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;

use std::future::Future;
#[derive(Debug, Clone)]
struct TestStruct {
    a: i32,
}

async fn query_dispatcher_test(
    _req: Request<hyper::body::Incoming>,
    _pool: &TestStruct,
) -> Result<Response<Full<Bytes>>, Infallible> {
    Ok(Response::new(Full::new(Bytes::from("default API"))))
}

// 添加生命周期参数'a，明确S的生命周期与闭包中TestStruct引用的关联
async fn build_service<'a, F, S>(pool: &TestStruct, listener: &TcpListener, f: F)
where
    F: 'static + Fn(Request<hyper::body::Incoming>, &'a TestStruct) -> S + Sync + Send + Copy,
    S: Future<Output = Result<Response<Full<Bytes>>, Infallible>> + Send + 'a,
{
    let (stream, _) = listener.accept().await.unwrap();
    let io: TokioIo<_> = TokioIo::new(stream);
    let pool_clone = pool.clone();
    
    // 直接持有pool_clone的所有权，在闭包中使用其引用，避免生命周期问题
    let service = service_fn(move |req: Request<hyper::body::Incoming>| {
        let inner_pool = pool_clone.clone();
        async move {
            f(req, &inner_pool).await
        }
    });

    tokio::task::spawn(async move {
        if let Err(err) = http1::Builder::new()
            .serve_connection(io, service)
            .await
        {
            eprintln!("Error serving connection: {:?}", err);
        }
    });
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    let listener = TcpListener::bind(addr).await?;
    let pool = TestStruct { a: 1 };

    loop {
        build_service(&pool, &listener, query_dispatcher_test);
    }
}

关键调整说明 #

• 添加了生命周期参数'a，并将闭包F的参数&TestStruct绑定到'a，同时要求S（Future）的生命周期至少为'a，这样编译器能明确Future的生命周期依赖
• 虽然已经克隆了pool，但通过在service_fn闭包中再次克隆inner_pool，确保每个请求处理都持有独立的TestStruct实例，完全避免了引用生命周期的问题，同时满足tokio::spawn对'static的要求（因为克隆后的实例是所有权类型，生命周期为'static）

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