axum处理错误

axum基于tower服务，该服务通过其关联的错误类型捆绑错误。如果您的服务产生错误并且导致该错误一直传到hyper，则连接将在不发送响应的情况下终止。这通常是不可取的，因此axum确保您始终通过依赖类型系统来生成响应

axum通过要求所有服务将Infallible作为其错误类型，Invalliable是指永远不会发生的错误的错误类型

anyhow 处理错误

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    routing::get,
    Router,
};

#[tokio::main]
async fn main() {
    let app = Router::new()
       .route("/", get(handler));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    println!("->> listening on {}", listener.local_addr().unwrap());
    axum::serve(listener, app).await.unwrap();
}
// 发生错误返回 AppError
async fn handler() -> Result<(), AppError> {
    try_thing()?;
    Ok(())
}
// 模拟一个错误
fn try_thing() -> Result<(), anyhow::Error> {
    anyhow::bail!("it failed!")
}

// 编写自定义的错误来包装Error
struct AppError(anyhow::Error);

// 告诉axum如何将AppError转换为响应体
impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            format!("Something went wrong: {}", self.0),
        )
            .into_response()
    }
}

// 允许用 ? 处理`Result<_, anyhow::Error>` 减少手动操作
impl<E> From<E> for AppError
where
    E: Into<anyhow::Error>,
{
    fn from(err: E) -> Self {
        Self(err.into())
    }
}

Serde处理响应

添加crate

# 序列化和反序列化数据
serde = { version = "1.0.127", features = ["derive"] }
# 序列化JSON
serde_json = "1.0.128"

序列化响应

use serde::Serialize;
use serde_json::json;
fn main() {

    let res_json = ResJson{
        code:200,
        data:json!({
            "name":"cci",
            "age":18,
        }).to_string(),
        message:"success".to_string(),
    };
    let json_string = json!(res_json).to_string();
    println!("{json_string}")
}
/// 响应结构体，序列化
#[derive( Debug,Serialize)]
struct ResJson{
    code:i32,
    data:String,
    message:String,
}

手动处理响应

use axum::{
    http::{header, HeaderValue}, response::IntoResponse, routing::get, Router
};
use serde::Serialize;
use serde_json::json;

/// 响应结构体
#[derive(Debug, Serialize)]
struct ResJson {
    code: i32,
    data: serde_json::Value,
    message: String,
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(hello_handler));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn hello_handler() -> impl IntoResponse {
    let data = json!({
        "name":"cci",
        "age":18,
    });
    let res_json = ResJson {
        code: 200,
        data,
        message: "success".to_string(),
    };
    let res_json = json!(res_json).to_string();
    let mut res = res_json.into_response();

    res.headers_mut().insert(
        header::CONTENT_TYPE,
        HeaderValue::from_static("application/json"),
    );
    res
}

使用IntoResponse处理响应

不需要手动添加请求头

use axum::{
response::IntoResponse, routing::get, Json, Router
};
use serde::Serialize;
use serde_json::json;

/// 响应结构体
#[derive(Debug, Serialize)]
struct ResJson {
    code: i32,
    data: serde_json::Value,
    message: String,
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(hello_handler));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn hello_handler() -> impl IntoResponse {
    let data = json!({
        "name":"cci",
        "age":18,
    });
    let res_json = ResJson {
        code: 200,
        data,
        message: "success".to_string(),
    };

    res_json
}
// 实现 `IntoResponse` trait，自动添加 `Content-Type: application/json` header
impl IntoResponse for ResJson {
    fn into_response(self) -> axum::response::Response {
        let val = json!(self);
        Json(val).into_response()
    }
}

封装错误处理响应

use axum::{
response::IntoResponse, routing::get, Json, Router
};
use serde::Serialize;
use serde_json::json;

/// 响应结构体
#[derive(Debug, Serialize)]
struct ResJson<T> {
    code: i32,
    data: Option<T>,
    message: String,
}
// 实现 `IntoResponse` trait，自动添加 `Content-Type: application/json` header
impl<T:Serialize> IntoResponse for ResJson<T> {
    fn into_response(self) -> axum::response::Response {
        let val = json!(self);
        Json(val).into_response()
    }
}
// 封装成功和错误响应
impl<T> ResJson<T>{
    pub fn success(data:T) -> Self{
        Self{
            code:200,
            data:Some(data),
            message:String::from("success"),
        }
    }
    pub fn error(){}
}
#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(hello_handler));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn hello_handler() -> impl IntoResponse {
    let data = json!({
        "name":"cci",
        "age":18,
    });
    //封装后直接调用
    ResJson::success(data)
}

还不够优雅，使用anyhow和thiserror处理错误

error.rs

use thiserror::Error;
#[derive(Error, Debug)]
pub enum CustomError {
    #[error("Request parameter error: {0}")]
    ReqParamError(String),
    #[error("Delete error: {0}")]
    ReqDeleteFail(String),
    #[error("Database error: {0}")]
    DatabaseError(String),
    #[error("IO error: {0}")]
    IOError(String),
    #[error("Network error: {0}")]
    NetworkError(String),
    #[error("Other error: {0}")]
    OtherError(String),
}

main.rs

use anyhow::Error;
use axum::{
response::IntoResponse, routing::get, Json, Router
};
use serde::Serialize;
use serde_json::json;
mod error;
use error::CustomError;
/// 响应结构体
#[derive(Debug, Serialize)]
struct ResJson<T> {
    code: i32,
    data: Option<T>,
    message: String,
}
// 实现 `IntoResponse` trait，自动添加 `Content-Type: application/json` header
impl<T:Serialize> IntoResponse for ResJson<T> {
    fn into_response(self) -> axum::response::Response {
        let val = json!(self);
        Json(val).into_response()
    }
}
// 封装成功和错误响应
impl<T> ResJson<T>{
    pub fn success(data:T) -> Self{
        Self{
            code:200,
            data:Some(data),
            message:String::from("success"),
        }
    }
    pub fn error(e:Error)->Self{
        // 向下转型为CustomError，能则属于之定义错误返回400，否则500
        let code = if e.downcast_ref::<CustomError>().is_some(){
            match e.downcast_ref::<CustomError>(){
                Some(CustomError::OtherError(_))=>400,
                _=>400,
            }
        }else{
            500
        };
        Self{
            code,
            data:None,
            message:e.to_string(),
        }
    }
}
#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(hello_handler));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn hello_handler() -> impl IntoResponse {

    let res = test_error().await;
    match res{
        Ok(data)=>ResJson::success(data),
        Err(err)=>ResJson::error(err),
    }
}
// 模拟一个错误
async fn test_error() -> Result<(), anyhow::Error> {
    // 包裹错误
    Err(CustomError::OtherError("其他错误".into()).into())
}

你应该可以请求到以下格式化信息

{
    "code": 400,
    "data": null,
    "message": "Other error: 其他错误"
}