下面是我的简单Axum服务器代码：

...
use std::sync::Mutex;
...

type Cache = Arc<Mutex<LruCache<u64, Bytes>>>;
...

#[tokio::main]
async fn main() {
    let cache: Cache = Arc::new(Mutex::new(LruCache::new(NonZeroUsize::new(100).unwrap())));

    let app = Router::new()
        .route("/image/:spec/:url", get(generate))
        .layer(ServiceBuilder::new().layer(Extension(cache)));

    ...

}

字符串
generate函数的代码：

async fn generate(Path(Params { spec, url }): Path<Params>, Extension(cache): Extension<Cache>) 
    -> Result<(HeaderMap, Vec<u8>), StatusCode> {

    let mut hasher = DefaultHasher::new();
    url.hash(&mut hasher);
    let key = hasher.finish();

    let mut g = cache.lock().unwrap();
    let data = match g.get(&key) {
        Some(v) => {
            info!("Match cache {}", key);
            v.to_owned()
        }
        None => {
            info!("Retrieve url");
            match reqwest::get("https://www.rust-lang.org/").await {
                Ok(response) => {
                    match response.bytes().await {
                        Ok(body) => {
                            g.put(key, body.clone());
                            body
                        }
                        Err(_) => {
                            Bytes::new()
                        }
                    }
                },
                Err(_) => {
                    Bytes::new()
                }
            }
        }
    };

    let mut headers = HeaderMap::new();
    headers.insert("content-type", HeaderValue::from_static("image/jpeg"));
    Ok((headers, data.to_vec()))
}

型
但我得到了这个错误：

the trait bound `fn(axum::extract::Path<Params>, Extension<Arc<std::sync::Mutex<LruCache<u64, bytes::Bytes>>>>) -> impl Future<Output = Result<(HeaderMap, Vec<u8>), StatusCode>> {generate}: Handler<_, _, _>` is not satisfied
Consider using `#[axum::debug_handler]` to improve the error message
the following other types implement trait `Handler<T, S, B>`:
  <axum::handler::Layered<L, H, T, S, B, B2> as Handler<T, S, B2>>
  <MethodRouter<S, B> as Handler<(), S, B>>

型
我花了很长时间，但没有弄清楚，我认为问题是这个声明：let mut g = cache.lock().unwrap();，因为如果我将其更改为let mut g: HashMap<u64, Bytes> = HashMap::new();，错误将消失。

更新：我把std::sync::Mutex改为tokio::sync::Mutex，现在它可以工作了，我不知道这两者之间的区别，为什么tokio::sync::Mutex可以通过编译，而std::sync::Mutex不能。