Axum中包含多自定义提取器的请求处理函数编译失败问题求助

大家好，我在使用Axum开发后端接口时遇到了一个编译问题：当请求处理函数中同时使用多个自定义提取器时，编译器提示Handler trait绑定不满足的错误，但只要移除任意一个提取器，代码就能正常编译。以下是我的代码、错误信息和排查思路，希望能得到大家的帮助：

我的代码片段 #

1. DTO定义 #

use serde::{Deserialize, Serialize};
use validator::Validate;

#[derive(Debug, Serialize, Deserialize, Validate)]
pub struct RevokeUser {
    #[validate(length(min = 6, message = "username id must be at least 6 characters"))]
    pub user_id: String, // 修正了原代码的笔误：string → String
}

2. 自定义提取器实现 #

use crate::api::error::APIError;
use axum::extract::Json;
use serde::de::DeserializeOwned;
use validator::Validate;
use axum::http::request::Parts;
use axum::extract::{FromRequestParts, State};
use axum::http::StatusCode;
use axum::async_trait;
use std::convert::FromRef;

pub struct ValidatedJson<T>(pub T);

impl<T> ValidatedJson<T>
where
    T: DeserializeOwned + Validate,
{
    pub fn new(json: Json<T>) -> Result<Self, APIError> {
        let payload = json.0;
        payload
            .validate()
            .map_err(|e| APIError::invalid_input(&e.to_string()))?;
        Ok(ValidatedJson(payload))
    }
}

// 注意：Axum异步提取器必须添加#[axum::async_trait]宏
#[async_trait]
impl<S, T> FromRequestParts<S> for ValidatedJson<T>
where
    T: DeserializeOwned + Validate,
    S: Send + Sync,
{
    type Rejection = APIError;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let json = Json::<T>::from_request_parts(parts, state).await?;
        Self::new(json)
    }
}

// 假设的自定义类型
pub struct AccessClaims {
    pub sub: String,
}
pub struct SharedState;
pub enum APIVersion { V1, V2 }
pub struct APIErrorEntry;

// AccessClaims的提取器实现
#[async_trait]
impl<S> FromRequestParts<S> for AccessClaims
where
    SharedState: FromRef<S>,
    S: Send + Sync,
{
    type Rejection = APIError;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        decode_token_from_request_part(parts, state).await
    }
}

pub struct ApiVersionHeader(pub APIVersion);

#[async_trait]
impl<S> FromRequestParts<S> for ApiVersionHeader
where
    S: Send + Sync,
{
    type Rejection = APIError;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        use axum::http::header::HeaderName;
        let name = HeaderName::from_static("x-api-version");
        let value = parts.headers.get(&name).ok_or_else(|| {
            APIError::from((
                StatusCode::BAD_REQUEST,
                APIErrorEntry::new("missing X-Api-Version header"),
            ))
        })?;
        let s = value.to_str().map_err(|_| {
            APIError::from((
                StatusCode::BAD_REQUEST,
                APIErrorEntry::new("invalid X-Api-Version header"),
            ))
        })?;
        let version: APIVersion = s.parse().map_err(|err: String| {
            APIError::from((StatusCode::BAD_REQUEST, APIErrorEntry::new(&err)))
        })?;
        Ok(ApiVersionHeader(version))
    }
}

// 辅助类型和函数的简化实现
impl AccessClaims {
    pub fn validate_role_admin(&self) -> Result<(), APIError> { Ok(()) }
}
impl APIErrorEntry {
    pub fn new(_msg: &str) -> Self { APIErrorEntry }
}
impl APIError {
    pub fn invalid_input(_msg: &str) -> Self { APIError }
}
impl From<(StatusCode, APIErrorEntry)> for APIError {
    fn from(_: (StatusCode, APIErrorEntry)) -> Self { APIError }
}
async fn decode_token_from_request_part<S>(_parts: &mut Parts, _state: &S) -> Result<AccessClaims, APIError> {
    Ok(AccessClaims { sub: "test_user".to_string() })
}
impl std::fmt::Display for APIVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}
impl std::str::FromStr for APIVersion {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "v1" => Ok(APIVersion::V1),
            "v2" => Ok(APIVersion::V2),
            _ => Err("invalid api version".to_string()),
        }
    }
}
// 确保APIError实现IntoResponse，Axum要求Rejection类型必须实现该 trait
impl axum::response::IntoResponse for APIError {
    fn into_response(self) -> axum::response::Response {
        (StatusCode::BAD_REQUEST, "invalid input").into_response()
    }
}

3. 请求处理函数 #

use tracing::trace;
use axum::response::IntoResponse;

pub async fn revoke_user_handler(
    ApiVersionHeader(api_version): ApiVersionHeader,
    State(state): State<SharedState>,
    access_claims: AccessClaims,
    ValidatedJson(revoke_user): ValidatedJson<RevokeUser>,
) -> Result<impl IntoResponse, APIError> {
    trace!("api version: {}", api_version);

    if access_claims.sub != revoke_user.user_id {
        access_claims.validate_role_admin()?;
    }

    trace!("revoke_user: {:?}", revoke_user);
    // caching::revoke_user_tokens(&revoke_user.user_id, &state).await?;

    Ok(())
}

4. 路由定义 #

use axum::Router;
use std::sync::Arc;
use axum::middleware;

pub async fn start(state: SharedState) {
    let mut router = Router::new()
        .nest("/{version}/auth", auth_routes::routes())
        .fallback(error_404_handler)
        .with_state(Arc::clone(&state))
        .layer(middleware::from_fn(logging_middleware));
    // ... 启动服务逻辑
}

pub fn routes() -> Router<SharedState> {
    Router::new()
        .route("/revoke-user", post(revoke_user_handler))
}

async fn error_404_handler() -> impl IntoResponse {
    (StatusCode::NOT_FOUND, "Not Found")
}
async fn logging_middleware<B>(
    req: axum::http::Request<B>,
    next: axum::middleware::Next<B>,
) -> Result<axum::http::Response<B>, APIError> {
    Ok(next.run(req).await)
}

编译错误信息 #

the trait bound `fn(ApiVersionHeader, State<SharedState>, AccessClaims, ValidatedJson<RevokeUser>) -> impl Future<Output = Result<impl IntoResponse, APIError>> {revoke_user_handler}: Handler<_, _>` is not satisfied
Consider using `#[axum::debug_handler]` to improve the error message
the following other types implement trait `Handler<T, S>`:
  `IntoHandler<H, T, S>` implements `Handler<T, S>`
  `Layered<L, H, T, S>` implements `Handler<T, S>`
  `MethodRouter<S>` implements `Handler<(), S>`
  `axum_extra::handler::Or<L, R, Lt, Rt, S>` implements `Handler<(M, Lt, Rt), S>`
the full name for the type has been written to '/Users/j3d/Projects/agamura/kippis-backend/target/debug/deps/kippis_backend-47c8643d69cc81b0.long-type-12359894106709628904.txt'
consider using `--verbose` to print the full type name to the console

排查与解决方案建议 #

我在整理代码时已经修复了几个明显的问题：

1. 修正了DTO中user_id: string的笔误为String
2. 给所有自定义提取器的FromRequestParts实现添加了必须的#[axum::async_trait]宏（Axum异步 trait 实现的强制要求）
3. 确保APIError实现了IntoResponse trait（Axum要求Handler的Rejection类型必须实现该 trait）

如果问题仍然存在，建议按以下步骤进一步排查：

• 给处理函数添加#[axum::debug_handler]宏，然后运行cargo build --verbose查看完整的类型错误信息，这能精准定位哪个类型不匹配
• 检查SharedState的FromRef实现是否满足AccessClaims的泛型约束
• 确认所有自定义提取器的Rejection类型完全统一为APIError，且没有隐式的类型转换问题
• 验证ValidatedJson的FromRequestParts实现是否正确依赖了Json提取器的逻辑

内容来源于stack exchange