先聊聊啥是 Axum，干嘛用的

说实话，Axum 就是 Rust 里那颗新星，专门干异步 Web 的。

它靠 Tokio 打底，靠 Tower-HTTP 搞中间件，听起来高大上。

但其实上手也不难，跟写普通函数差不多。

哈哈，你别怕，这玩意儿比 Actix 那套宏要清爽得多。

先装好 Rust，建议用 nightly。

然后在 Cargo.toml 加几行：

axum = { version = "0.7", features =  }
tokio = { version = "1", features =  }
tower-http = { version = "0.4", features =  }
serde = { version = "1", features =  }
serde_json = "1"
tracing-subscriber = { version = "0.3", features =  }

别忘了运行 cargo build 把依赖拉下来。

下面这段代码就是Zui基础的例子，我把它塞进 src/main.rs。

use anyhow::Result;
use axum::{Router, routing::get};
use tokio::net::TcpListener;
// 根路由处理函数：异步函数，返回字符串
async fn root_handler -> &'static str {
    "Hello, Axum!"
}
#
async fn main -> Result<> {
    tracing_subscriber::fmt::init;
    // 构建路由：将 GET 请求 / 映射到 root_handler
    let app = Router::new.route);
    // 启动服务器
    let listener = TcpListener::bind.await?;
    axum::serve.await?;
    Ok)
}

保存后 cargo run，打开浏览器敲 http://127.0.0.1:3000/，kan到 “Hello, Axum!” 就算成功啦。

Axum Zui大的亮点之一，就是各种提取器。比如想拿 Query 参数：

use axum::{extract::Query, routing::get, Json, Router};
use serde::Deserialize;
#
struct Pagination {
    page: u64,
    limit: u64,
}
// 提取查询参数
async fn user_list: Query) -> String {
    let offset =  * pagination.limit;
    format!
}
#
async fn main -> anyhow::Result<> {
    tracing_subscriber::fmt::init;
    let app = Router::new.route);
    let listener = tokio::net::TcpListener::bind.await?;
    axum::serve.await?;
    Ok)
}

再说 JSON 请求体：

use axum::{extract::Json, routing::post, Router};
use serde::Deserialize;
#
struct CreateUserRequest {
    username: String,
    email: String,
    age: Option,
}
// 自动把 JSON 反序列化成结构体
async fn create_user: Json) -> String {
    format! 年龄{:?}", payload.username, payload.email, payload.age)
}
#
async fn main -> anyhow::Result<> {
    tracing_subscriber::fmt.init;
    let app = Router::<_>::new.route);
    let listener = tokio::net::TcpListener::bind.await?;
    axum::serve.await?;
    Ok)
}

项目里常常要共享资源，这时候就用 State 提取器。

use std::{sync::{Arc, Mutex}, net::SocketAddr};
use axum::{Router, routing::get, extract::State};
#
struct AppState {
    counter: Arc,
}
// 每次请求dou把计数器+1
async fn incr_counter: State) -> String {
    let mut cnt = state.counter.lock.unwrap;
    *cnt += 1;
     format!
}
#
async fn main -> anyhow::Result<> {
   tracing_subscriber::fmt.init;
   let shared_state = AppState { counter: Arc:new) };
   let app = Router::<_>::new
        .route)
        .with_state;
   let listener= tokio::net::
       TcpListener::
       bind.
       await?;
   axum::
       serve(listener,
             app).
       await?;
   Ok)
}

Axum 本身不写中间件，它直接借 Tower 的生态。

CORS、日志、压缩，douNeng一层层叠加。

use tower_http::{
   cors::{CorsLayer},
   trace::{TraceLayer}
};
let cors_layer= CorsLayer::
      permissive; // 开发阶段直接放行
let trace_layer= TraceLayer::
      new_for_http;
let app= Router::<_>::new
     .route)
     .layer
     .layer;

use std::{
   future::{Future},
   pin::
Pin,
   task::{
      Context,Poll
   },
   time::
Instant
};
use tower::{Service, Layer};
#
struct TimingLayer;
impl Layer for TimingLayer{
   type Service=S;
   fn layer->Self::
      Service{
      TimingService{inner}
}} 
#
struct TimingService{
   inner:S,
}
implS:
Service<&Req>
for TimingServicewhe
re S:
Service,
S:
Future+Send+'static{
type Response=S::
Response;
type Error=S::
Error;
type Future=Pin+Send>;
fn poll_ready
->Poll{
self.inner.poll_ready
}
fn call(&mut self,
req:Req)->Self::
Future{
let start=
Instant::
now;
let fut=self.inner.
call;
Box:::pin(async move{
let res=fut.await;
println!);
res})
}
}

let user_router=
Router::<_>::new
 .route)
 .route);
let article_router=
Router::<_>::new
 .route);
let app=Router::<_>::new
 .nest
 .nest("/article",
article_router);

async fn book_detail(
 Path:
 Path) 
-> String{
 format!
}