(StatusCode, Json) 序列化失败仍返回你给的状态码

axum = "=0.8.9"
serde_json = "1"
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt"] }

use std::collections::BTreeMap;

use axum::body::Body;
use axum::extract::Request;
use axum::http::{header, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::get;
use axum::{Json, Router};
use tower::ServiceExt;

// A map with tuple keys: serde_json refuses to serialize it.
fn bad() -> BTreeMap<(u8, u8), u8> {
  BTreeMap::from([((1, 2), 3)])
}

async fn plain() -> Json<BTreeMap<(u8, u8), u8>> {
  Json(bad())
}

async fn created() -> (StatusCode, Json<BTreeMap<(u8, u8), u8>>) {
  (StatusCode::CREATED, Json(bad()))
}

async fn created_with_parts() -> impl IntoResponse {
  (
    StatusCode::CREATED,
    [(header::LOCATION, "/items/7"), (header::SET_COOKIE, "seen=1")],
    Json(bad()),
  )
}

// Workaround: serialize first, so the error is yours to map.
async fn to_value_first() -> Result<(StatusCode, Json<serde_json::Value>), (StatusCode, String)> {
  let value = serde_json::to_value(bad())
    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("serialize: {e}")))?;
  Ok((StatusCode::CREATED, Json(value)))
}

// Workaround: only override a status that is not already a server error.
fn status_unless_failed(status: StatusCode, body: impl IntoResponse) -> Response {
  let mut res = body.into_response();
  if !res.status().is_server_error() {
    *res.status_mut() = status;
  }
  res
}

async fn guarded() -> Response {
  status_unless_failed(StatusCode::CREATED, Json(bad()))
}

async fn show(app: &Router, uri: &str) {
  let res: Response = app.clone().oneshot(Request::get(uri).body(Body::empty()).unwrap()).await.unwrap();
  let status = res.status();
  let h = |name| res.headers().get(name).map(|v: &header::HeaderValue| v.to_str().unwrap().to_owned());
  let (ct, loc, cookie) = (h(header::CONTENT_TYPE), h(header::LOCATION), h(header::SET_COOKIE));
  let body = axum::body::to_bytes(res.into_body(), 1024).await.unwrap();
  println!("{uri:<20} {status}");
  println!("{:<20} content-type={ct:?} location={loc:?} set-cookie={cookie:?}", "");
  println!("{:<20} body={:?}", "", String::from_utf8_lossy(&body));
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let app = Router::new()
    .route("/plain", get(plain))
    .route("/created", get(created))
    .route("/created_with_parts", get(created_with_parts))
    .route("/to_value_first", get(to_value_first))
    .route("/guarded", get(guarded));
  for uri in ["/plain", "/created", "/created_with_parts", "/to_value_first", "/guarded"] {
    show(&app, uri).await;
  }
}

/plain               500 Internal Server Error
                     content-type=Some("text/plain; charset=utf-8") location=None set-cookie=None
                     body="key must be a string"
/created             201 Created
                     content-type=Some("text/plain; charset=utf-8") location=None set-cookie=None
                     body="key must be a string"
/created_with_parts  201 Created
                     content-type=Some("text/plain; charset=utf-8") location=Some("/items/7") set-cookie=Some("seen=1")
                     body="key must be a string"
/to_value_first      500 Internal Server Error
                     content-type=Some("text/plain; charset=utf-8") location=None set-cookie=None
                     body="serialize: key must be a string"
/guarded             500 Internal Server Error
                     content-type=Some("text/plain; charset=utf-8") location=None set-cookie=None
                     body="key must be a string"

                Err(err) => (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    [(
                        header::CONTENT_TYPE,
                        HeaderValue::from_static(mime::TEXT_PLAIN_UTF_8.as_ref()),
                    )],
                    err.to_string(),
                )
                    .into_response(),

impl<R> IntoResponse for (StatusCode, R)
where
    R: IntoResponse,
{
    fn into_response(self) -> Response {
        let mut res = self.1.into_response();
        *res.status_mut() = self.0;
        res
    }
}

            fn into_response(self) -> Response {
                let (status, $($ty),*, res) = self;

                let res = res.into_response();
                let parts = ResponseParts { res };

                $(
                    let parts = match $ty.into_response_parts(parts) {
                        Ok(parts) => parts,
                        Err(err) => {
                            return err.into_response();
                        }
                    };
                )*

                (status, parts.res).into_response()
            }

                Err(err) => (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    [(
                        header::CONTENT_TYPE,
                        HeaderValue::from_static(mime::TEXT_PLAIN_UTF_8.as_ref()),
                    )],
                    IntoResponseFailed,
                    err.to_string(),
                )
                    .into_response(),

impl<R> IntoResponse for (StatusCode, R)
where
    R: IntoResponse,
{
    fn into_response(self) -> Response {
        let mut res = self.1.into_response();
        if res.extensions().get::<IntoResponseFailed>().is_none() {
            *res.status_mut() = self.0;
        }
        res
    }
}