如何在Axum同一处理器中同时返回成功与错误响应？

问题场景 #

你编写的Axum处理器代码如下：

#[debug_handler]
async fn handler(
    State(server_state): State<Arc<Server>>,
    Query(query_params): Query<Query>,
) -> impl IntoResponse {
    match server_state.store.handle(query_params).await {
        Ok(res) => (StatusCode::OK, Json(res)),
        Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, Json(err))
    }
}

编译时触发类型不兼容错误：

|
42 | /     match server_state.store.handle(query_params).await {
43 | |         Ok(res) => (StatusCode::OK, Json(res)),
   | |                   -------------------------- this is found to be of type `(StatusCode, axum::Json<Vec<Data>>)`
44 | |         Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, Json(err))
   | |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Vec`, found enum `sqlx::Error`
45 | |     }
   | |_____- `match` arms have incompatible types
   |
   = note: expected tuple `(StatusCode, axum::Json<Vec<Data>>)`
              found tuple `(StatusCode, axum::Json<sqlx::Error>)`

你想过定义包含可选body和error字段的响应结构体，但不确定这是否是Axum的通用处理方式。

修复方案 #

不推荐统一结构体的思路 #

你设想的Response结构体（同时包含Option<Data>和Option<sqlx::Error>）并不是Axum的通用做法，原因很直接：

• HTTP协议本身通过状态码区分成功/错误场景，没必要把错误信息塞进成功响应的Body里
• 这种结构会增加前端的处理复杂度，需要额外判断两个可选字段的状态

两种通用的正确处理方式 #

方案1：用Result结合自定义错误类型

先定义一个实现IntoResponse trait的自定义错误枚举，把sqlx错误包装进去：

use axum::{http::StatusCode, Json, response::IntoResponse};
use sqlx::Error as SqlxError;

enum HandlerError {
    DatabaseError(SqlxError),
}

impl IntoResponse for HandlerError {
    fn into_response(self) -> axum::response::Response {
        match self {
            HandlerError::DatabaseError(err) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(format!("数据库错误: {}", err)),
            ).into_response(),
        }
    }
}

// 修改处理器返回Result类型
#[debug_handler]
async fn handler(
    State(server_state): State<Arc<Server>>,
    Query(query_params): Query<Query>,
) -> Result<impl IntoResponse, HandlerError> {
    let res = server_state.store.handle(query_params).await.map_err(HandlerError::DatabaseError)?;
    Ok((StatusCode::OK, Json(res)))
}

方案2：分支返回不同的IntoResponse实现

Axum允许match分支返回不同类型，只要它们都实现了IntoResponse。你可以给错误分支定义专门的错误响应结构体：

use axum::{http::StatusCode, Json};

#[derive(serde::Serialize)]
struct ErrorResponse {
    message: String,
}

#[debug_handler]
async fn handler(
    State(server_state): State<Arc<Server>>,
    Query(query_params): Query<Query>,
) -> impl IntoResponse {
    match server_state.store.handle(query_params).await {
        Ok(res) => (StatusCode::OK, Json(res)).into_response(),
        Err(err) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                message: format!("数据库操作失败: {}", err),
            }),
        ).into_response(),
    }
}

为什么初始写法报错？ #

Rust要求match所有分支必须返回同一种类型，而(StatusCode, Json<Vec<Data>>)和(StatusCode, Json<sqlx::Error>)是完全不同的元组类型，自然会触发类型不兼容错误。上面的两种方案要么把错误包装成统一的IntoResponse类型，要么通过.into_response()把不同分支的结果转换成Axum标准的Response类型，解决了类型不匹配问题。

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