【Rust】路由匹配与参数提取：从 match 语句到 axum 的类型魔法

# 一个典型的 Python Flask 示例
@app.route('/user/<id>')
def get_user(id):
    try:
        user_id = int(id) # 1. 手动类型转换
        # ... 业务逻辑
    except ValueError:
        return "Invalid ID format", 400 # 2. 手动错误处理

use axum::{routing::get, Router};

// 一个最简单的 Handler
async fn hello_world() -> &'static str {
    "Hello, world!"
}

async fn get_root() -> &'static str {
    "This is the root page."
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(get_root)) // GET / -> get_root
        .route("/hello", get(hello_world)); // GET /hello -> hello_world

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("Listening on http://0.0.0.0:3000");
    axum::serve(listener, app).await.unwrap();
}

use axum::{routing::get, Router};

// 定义用户相关的路由
fn user_routes() -> Router {
    Router::new()
        .route("/users", get(get_users_list))
        .route("/users/:id", get(get_user_by_id))
}

// 定义商品相关的路由
fn product_routes() -> Router {
    Router::new().route("/products", get(get_products_list))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .nest("/api/v1", user_routes()) // 嵌套用户路由
        .nest("/api/v1", product_routes()); // 合并商品路由

    // ... 启动服务 ...
}

// -- Handler stubs --
async fn get_users_list() {}
async fn get_user_by_id() {}
async fn get_products_list() {}

use axum::{extract::Path, routing::get, Router};

// 路由定义为 /users/:id
async fn profile(Path(user_id): Path<u32>) -> String {
    format!("Fetching profile for user ID: {}", user_id)
}

// 路由定义为 /teams/:team_id/users/:user_id
async fn team_member_details(Path((team_id, user_id)): Path<(String, u32)>) -> String {
    format!("Details for user {} in team {}", user_id, team_id)
}

// main 函数中配置路由
let app = Router::new()
    .route("/users/:id", get(profile))
    .route("/teams/:team_id/users/:user_id", get(team_member_details));

use axum::{extract::Query, routing::get, Router};
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Pagination {
    page: Option<u32>,
    per_page: Option<u32>,
}

// 路由匹配 /search?q=rust&page=1
async fn search(Query(params): Query<HashMap<String, String>>, Query(pagination): Query<Pagination>) -> String {
    format!("Searching for: {:?}. Pagination: {:?}", params, pagination)
}

// main 函数中配置路由
let app = Router::new().route("/search", get(search));

use axum::{extract::Json, routing::post, Router};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Debug)]
struct CreateUser {
    username: String,
    email: String,
}

#[derive(Serialize)]
struct User {
    id: u64,
    username: String,
    email: String,
}

// 路由匹配 POST /users
async fn create_user(Json(payload): Json<CreateUser>) -> Json<User> {
    println!("Creating user: {:?}", payload);
    let user = User {
        id: 1337,
        username: payload.username,
        email: payload.email,
    };
    Json(user) // 使用 Json 包装器返回 JSON 响应
}

// main 函数中配置路由
let app = Router::new().route("/users", post(create_user));

// POST /articles/:id/comments?notify=true
// Body: { "content": "Great article!" }
async fn post_comment(
    Path(article_id): Path<u32>,
    Query(notify): Query<HashMap<String, bool>>,
    Json(payload): Json<CommentPayload>,
) {
    // ...
}

// axum 源码中的简化版定义
pub trait FromRequestParts<S>: Sized {
    type Rejection: IntoResponse; // 如果提取失败，返回的错误类型
    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection>;
}

pub trait FromRequest<S>: Sized {
    type Rejection: IntoResponse;
    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection>;
}

use axum::{async_trait, extract::FromRequestParts, http::{request::Parts, StatusCode}};

struct ApiKey(String);

#[async_trait]
impl<S> FromRequestParts<S> for ApiKey
where
    S: Send + Sync,
{
    type Rejection = (StatusCode, &'static str);

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        if let Some(key) = parts.headers.get("X-Api-Key").and_then(|v| v.to_str().ok()) {
            Ok(ApiKey(key.to_string()))
        } else {
            Err((StatusCode::UNAUTHORIZED, "X-Api-Key header is missing"))
        }
    }
}

// 在 Handler 中直接使用
async fn protected_route(api_key: ApiKey) {
    // ...
}

let db_pool = create_db_pool().await;
let app = Router::new()
    .route("/users", get(get_users))
    .with_state(db_pool); // 注入状态

async fn get_users(State(pool): State<MyDbPool>) {
    // ... 使用数据库连接池
}