lifetime may not live long enoug hreturning this value requires that '1 must outlive 'static

[WyntersN]

use std::future::{ready, Ready};

use actix_session::{Session, SessionExt};
use actix_web::{
    body::EitherBody,
    dev::{self, Service, ServiceRequest, ServiceResponse, Transform},
    Error, HttpResponse,
};
use futures_util::future::LocalBoxFuture;
use jsonwebtoken::{decode, DecodingKey, Validation};

use crate::server::global::CONF;

pub struct Auth;

impl<S, B> Transform<S, ServiceRequest> for Auth
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<EitherBody<B>>;
    type Error = Error;
    type InitError = ();
    type Transform = AuthMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(AuthMiddleware { service }))
    }
}
pub struct AuthMiddleware<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for AuthMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<EitherBody<B>>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    dev::forward_ready!(service);

    fn call(&self, request: ServiceRequest) -> Self::Future {
        let fut = async move {
            let path = request.path();

            // 允许特定路径无需认证
            if !path.starts_with("/api") || path == "/api/v1/login" || path == CONF.app.security_dir.as_str() {
                let res = self.service.call(request).await?;
                return Ok(ServiceResponse::map_into_left_body(res));
            }

            // 检查请求的 Cookies 或 Headers 中是否有 token
            let token = request.headers().get("Authorization").and_then(|header| {
                header.to_str().ok().map(|token| token.trim_start_matches("Bearer "))
            });

            match token {
                Some(token) => {
                    let secret = "your_secret"; // 确保这是从配置中安全获取的
                    let key = DecodingKey::from_secret(secret.as_bytes());
                    let validation = Validation::default();

                    match decode::<String>(&token, &key, &validation) {
                        Ok(_) => {
                            // Token is valid
                            Session::insert(&request.get_session(), "666", "9999999").unwrap();
                            //request.session().set("token", token).await?;
                            let res = self.service.call(request).await?;
                            Ok(ServiceResponse::map_into_left_body(res))
                        }
                        Err(_) => {
                            // Token is invalid
                            let response = HttpResponse::Unauthorized().json(serde_json::json!({"code": 401, "message": "Unauthorized"}));
                            let (request, _payload) = request.into_parts();
                            Ok(ServiceResponse::new(request, response.map_into_right_body()))
                        }
                    }
                }
                None => {
                    // No token found
                    let response = HttpResponse::Unauthorized().json(serde_json::json!({"code": 401, "message": "Unauthorized"}));
                    let (request, _payload) = request.into_parts();
                    Ok(ServiceResponse::new(request, response.map_into_right_body()))
                }
            }
        };

        Box::pin(fut) //Error：lifetime may not live long enoug hreturning this value requires that `'1` must outlive `'static`
    }
}

tokio = { version = "1", features = ["full"] }
rusqlite = { version="0.31",features = ["bundled"] }
chrono = { version = "0", features = ["serde"] }
actix-session = { version = "0", features = ["cookie-session"] }
jsonwebtoken = "9.3.0"
r2d2 = "0.8"
actix-web = "4"

What should I do？