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: 其他错误"
}