Axum Web 开发¶

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

#[tokio::main]
async fn main() {
    // 初始化日志
    tracing_subscriber::fmt::init();

    // 构建路由
    let app = Router::new()
        .route("/", get(root))
        .route("/hello/{name}", get(hello));

    // 启动服务器
    // ⚠️ 教学示例使用 unwrap()；生产代码应使用 ? 或 expect() 并配合优雅的错误处理
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    tracing::info!("服务器启动在 http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

async fn root() -> &'static str {
    "Hello, Axum!"
}

async fn hello(axum::extract::Path(name): axum::extract::Path<String>) -> String {
    format!("Hello, {}!", name)
}

use axum::{
    routing::{get, post, put, delete, patch},
    Router,
};

fn app() -> Router {
    Router::new()
        // HTTP 方法路由
        .route("/users", get(list_users).post(create_user))
        .route("/users/{id}", get(get_user).put(update_user).delete(delete_user))

        // 单方法路由
        .route("/health", get(health_check))
        .route("/upload", post(upload_file))
}

async fn list_users() -> &'static str { "列出所有用户" }
async fn create_user() -> &'static str { "创建用户" }
async fn get_user() -> &'static str { "获取用户" }
async fn update_user() -> &'static str { "更新用户" }
async fn delete_user() -> &'static str { "删除用户" }
async fn health_check() -> &'static str { "OK" }
async fn upload_file() -> &'static str { "上传成功" }

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

fn app() -> Router {
    Router::new()
        .nest("/api", api_routes())
        .nest("/admin", admin_routes())
        .route("/", get(index))
}

fn api_routes() -> Router {
    Router::new()
        .nest("/v1", v1_routes())
        .nest("/v2", v2_routes())
}

fn v1_routes() -> Router {
    Router::new()
        .route("/users", get(list_users_v1))
        .route("/posts", get(list_posts_v1))
}

fn v2_routes() -> Router {
    Router::new()
        .route("/users", get(list_users_v2))
        .route("/posts", get(list_posts_v2))
}

fn admin_routes() -> Router {
    Router::new()
        .route("/dashboard", get(dashboard))
        .route("/settings", get(settings).post(update_settings))
}

// 最终路由结构：
// GET /           -> index
// GET /api/v1/users -> list_users_v1
// GET /api/v1/posts -> list_posts_v1
// GET /api/v2/users -> list_users_v2
// GET /api/v2/posts -> list_posts_v2
// GET /admin/dashboard -> dashboard
// GET /admin/settings  -> settings

async fn index() -> &'static str { "首页" }
async fn list_users_v1() -> &'static str { "v1 users" }
async fn list_posts_v1() -> &'static str { "v1 posts" }
async fn list_users_v2() -> &'static str { "v2 users" }
async fn list_posts_v2() -> &'static str { "v2 posts" }
async fn dashboard() -> &'static str { "管理面板" }
async fn settings() -> &'static str { "设置" }
async fn update_settings() -> &'static str { "更新设置" }

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

fn app() -> Router {
    Router::new()
        // 单个参数
        .route("/users/{id}", get(get_user))
        // 多个参数
        .route("/users/{user_id}/posts/{post_id}", get(get_user_post))
        // 通配符（匹配剩余路径）
        .route("/files/*path", get(serve_file))
}

// 单个路径参数
async fn get_user(Path(id): Path<u64>) -> String {
    format!("用户ID: {}", id)
}

// 多个路径参数 - 使用元组
async fn get_user_post(Path((user_id, post_id)): Path<(u64, u64)>) -> String {
    format!("用户 {} 的帖子 {}", user_id, post_id)
}

// 通配符路径
async fn serve_file(Path(path): Path<String>) -> String {
    format!("请求文件: {}", path)
}

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

fn app() -> Router {
    Router::new()
        .route("/", get(root))
        .route("/about", get(about))
        // 未匹配路由的兜底处理
        .fallback(not_found)
}

async fn root() -> &'static str { "首页" }
async fn about() -> &'static str { "关于" }

async fn not_found() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "页面不存在")
}

use axum::{
    http::StatusCode,
    response::{Html, Json, IntoResponse},
};
use serde_json::json;

// Handler 就是普通的 async 函数
// 返回值需要实现 IntoResponse

// 返回字符串
async fn plain_text() -> &'static str {
    "纯文本响应"
}

// 返回 HTML
async fn html_page() -> Html<&'static str> {
    Html("<h1>Hello, Axum!</h1>")
}

// 返回 JSON
async fn json_response() -> Json<serde_json::Value> {
    Json(json!({
        "message": "Hello",
        "status": "ok"
    }))
}

// 返回状态码 + 响应体
async fn with_status() -> (StatusCode, String) {
    (StatusCode::CREATED, "资源已创建".to_string())
}

// 返回 impl IntoResponse（灵活）
async fn flexible() -> impl IntoResponse {
    (StatusCode::OK, [("X-Custom", "value")], "自定义响应头")
}

use axum::extract::Path;
use serde::Deserialize;

// 使用结构体解析路径参数
#[derive(Deserialize)]
struct UserParams {
    user_id: u64,
    post_id: u64,
}

async fn get_user_post(Path(params): Path<UserParams>) -> String {
    format!("用户 {} 的帖子 {}", params.user_id, params.post_id)
}
// 路由: /users/{user_id}/posts/{post_id}

use axum::extract::Query;
use serde::Deserialize;

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

// GET /users?page=1&per_page=20&sort=name
async fn list_users(Query(pagination): Query<Pagination>) -> String {
    let page = pagination.page.unwrap_or(1);
    let per_page = pagination.per_page.unwrap_or(10);
    let sort = pagination.sort.unwrap_or_else(|| "id".to_string());
    format!("页码: {}, 每页: {}, 排序: {}", page, per_page, sort)
}

use axum::Json;
use serde::{Deserialize, Serialize};

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

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

// POST /users
// Content-Type: application/json
// {"username": "alice", "email": "alice@example.com", "password": "secret"}
async fn create_user(Json(payload): Json<CreateUser>) -> (axum::http::StatusCode, Json<UserResponse>) {
    let user = UserResponse {
        id: 1,
        username: payload.username,
        email: payload.email,
    };
    (axum::http::StatusCode::CREATED, Json(user))
}

use axum::{
    extract::State,
    routing::{get, post},
    Router, Json,
};
use std::sync::Arc;
use tokio::sync::RwLock;
use serde::{Deserialize, Serialize};

// 应用状态
#[derive(Clone)]
struct AppState {
    db: Arc<RwLock<Vec<User>>>,
    config: AppConfig,
}

#[derive(Clone)]
struct AppConfig {
    app_name: String,
    max_users: usize,
}

#[derive(Clone, Serialize, Deserialize)]
struct User {
    id: u64,
    name: String,
}

async fn list_users(State(state): State<AppState>) -> Json<Vec<User>> {
    let users = state.db.read().await;
    Json(users.clone())
}

async fn create_user(
    State(state): State<AppState>,
    Json(user): Json<User>,
) -> axum::http::StatusCode {
    let mut users = state.db.write().await;
    if users.len() >= state.config.max_users {
        return axum::http::StatusCode::TOO_MANY_REQUESTS;
    }
    users.push(user);
    axum::http::StatusCode::CREATED
}

async fn app_info(State(state): State<AppState>) -> String {
    format!("应用: {}", state.config.app_name)
}

#[tokio::main]
async fn main() {
    let state = AppState {
        db: Arc::new(RwLock::new(Vec::new())),
        config: AppConfig {
            app_name: "My API".to_string(),
            max_users: 100,
        },
    };

    let app = Router::new()
        .route("/users", get(list_users).post(create_user))
        .route("/info", get(app_info))
        .with_state(state);

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

use axum::{
    http::HeaderMap,
    extract::Request,
};
use axum_extra::{
    TypedHeader,
    headers::{Authorization, authorization::Bearer, UserAgent},
};

// 获取所有请求头
async fn all_headers(headers: HeaderMap) -> String {
    let mut result = String::new();
    for (key, value) in &headers {
        result.push_str(&format!("{}: {}\n", key, value.to_str().unwrap_or("")));
    }
    result
}

// 类型化的请求头（需要 axum-extra）
async fn typed_headers(
    TypedHeader(user_agent): TypedHeader<UserAgent>,
) -> String {
    format!("User-Agent: {}", user_agent)
}

// 使用 Request 直接访问
async fn raw_request(req: Request) -> String {
    let method = req.method().clone();
    let uri = req.uri().clone();
    format!("{} {}", method, uri)
}

use axum::{
    extract::FromRequestParts,
    http::{request::Parts, StatusCode, header},
    response::{IntoResponse, Response},
};

// 自定义提取器：从请求头中提取 API Key
// 注意：Axum 0.8+ 已移除 #[async_trait]，使用原生 async fn in trait
struct ApiKey(String);

impl<S> FromRequestParts<S> for ApiKey
where
    S: Send + Sync,
{
    type Rejection = ApiKeyError;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        let api_key = parts
            .headers
            .get("X-API-Key")
            .and_then(|v| v.to_str().ok())
            .ok_or(ApiKeyError::Missing)?;

        if api_key.len() < 32 {
            return Err(ApiKeyError::Invalid);
        }

        Ok(ApiKey(api_key.to_string()))
    }
}

enum ApiKeyError {
    Missing,
    Invalid,
}

impl IntoResponse for ApiKeyError {
    fn into_response(self) -> Response {
        let (status, msg) = match self {
            ApiKeyError::Missing => (StatusCode::UNAUTHORIZED, "缺少 API Key"),
            ApiKeyError::Invalid => (StatusCode::FORBIDDEN, "无效的 API Key"),
        };
        (status, msg).into_response()
    }
}

// 使用自定义提取器
async fn protected_endpoint(ApiKey(key): ApiKey) -> String {
    format!("已认证，API Key: {}...", &key[..8])
}

use axum::{Router, routing::get};
use tower_http::{
    cors::{CorsLayer, Any},
    trace::TraceLayer,
    compression::CompressionLayer,
    timeout::TimeoutLayer,
};
use std::time::Duration;
use tower::ServiceBuilder;

fn app() -> Router {
    Router::new()
        .route("/", get(root))
        .route("/api/data", get(get_data))
        .layer(
            ServiceBuilder::new()
                // 按顺序执行（从下到上）
                .layer(TraceLayer::new_for_http())       // 4. 请求追踪
                .layer(TimeoutLayer::new(Duration::from_secs(30))) // 3. 超时
                .layer(CompressionLayer::new())           // 2. 响应压缩
                .layer(
                    CorsLayer::new()                      // 1. CORS
                        .allow_origin(Any)
                        .allow_methods(Any)
                        .allow_headers(Any),
                ),
        )
}

async fn root() -> &'static str { "Hello" }
async fn get_data() -> &'static str { "Data" }

use axum::{
    Router,
    routing::get,
    middleware::{self, Next},
    extract::Request,
    response::Response,
};
use std::time::Instant;

// 自定义中间件函数
async fn logging_middleware(req: Request, next: Next) -> Response {
    let method = req.method().clone();
    let uri = req.uri().clone();
    let start = Instant::now();

    tracing::info!("→ {} {}", method, uri);

    let response = next.run(req).await;

    let duration = start.elapsed();
    tracing::info!(
        "← {} {} [{}] {:?}",
        method,
        uri,
        response.status(),
        duration
    );

    response
}

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "Hello" }))
        .layer(middleware::from_fn(logging_middleware))
}

use axum::{
    Router,
    routing::get,
    middleware::{self, Next},
    extract::Request,
    response::{Response, IntoResponse},
    http::{StatusCode, header},
};

async fn auth_middleware(req: Request, next: Next) -> Result<Response, StatusCode> {
    let auth_header = req
        .headers()
        .get(header::AUTHORIZATION)
        .and_then(|v| v.to_str().ok());

    match auth_header {
        Some(token) if token.starts_with("Bearer ") => {
            let token = &token[7..];
            if validate_token(token).await {
                Ok(next.run(req).await)
            } else {
                Err(StatusCode::UNAUTHORIZED)
            }
        }
        _ => Err(StatusCode::UNAUTHORIZED),
    }
}

async fn validate_token(token: &str) -> bool {
    // 实际应用中验证 JWT 等
    !token.is_empty()
}

fn app() -> Router {
    let public_routes = Router::new()
        .route("/login", get(login))
        .route("/health", get(health));

    let protected_routes = Router::new()
        .route("/dashboard", get(dashboard))
        .route("/profile", get(profile))
        .layer(middleware::from_fn(auth_middleware));

    Router::new()
        .merge(public_routes)
        .merge(protected_routes)
}

async fn login() -> &'static str { "登录页" }
async fn health() -> &'static str { "OK" }
async fn dashboard() -> &'static str { "仪表板" }
async fn profile() -> &'static str { "个人资料" }

use axum::{
    Router,
    routing::get,
    middleware::{self, Next},
    extract::Request,
    response::{Response, IntoResponse},
    http::StatusCode,
};
use std::sync::Arc;
use tokio::sync::Mutex;
use std::collections::HashMap;
use std::time::Instant;

#[derive(Clone)]
struct RateLimiter {
    requests: Arc<Mutex<HashMap<String, Vec<Instant>>>>,
    max_requests: usize,
    window_secs: u64,
}

impl RateLimiter {
    fn new(max_requests: usize, window_secs: u64) -> Self {
        RateLimiter {
            requests: Arc::new(Mutex::new(HashMap::new())),
            max_requests,
            window_secs,
        }
    }

    async fn check(&self, ip: &str) -> bool {
        let mut requests = self.requests.lock().await;
        let now = Instant::now();
        let window = std::time::Duration::from_secs(self.window_secs);

        let entries = requests.entry(ip.to_string()).or_insert_with(Vec::new);

        // 清理过期记录
        entries.retain(|&t| now.duration_since(t) < window);

        if entries.len() >= self.max_requests {
            false
        } else {
            entries.push(now);
            true
        }
    }
}

async fn rate_limit_middleware(
    axum::extract::State(limiter): axum::extract::State<RateLimiter>,
    req: Request,
    next: Next,
) -> Result<Response, StatusCode> {
    let ip = req
        .headers()
        .get("X-Forwarded-For")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("unknown")
        .to_string();

    if limiter.check(&ip).await {
        Ok(next.run(req).await)
    } else {
        Err(StatusCode::TOO_MANY_REQUESTS)
    }
}

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

// 统一应用错误类型
#[derive(Debug)]
pub enum AppError {
    NotFound(String),
    BadRequest(String),
    Unauthorized,
    Forbidden,
    InternalError(String),
    DatabaseError(String),
    ValidationError(Vec<String>),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, error_message) = match self {
            AppError::NotFound(msg) => (StatusCode::NOT_FOUND, msg),
            AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg),
            AppError::Unauthorized => (StatusCode::UNAUTHORIZED, "未授权".to_string()),
            AppError::Forbidden => (StatusCode::FORBIDDEN, "禁止访问".to_string()),
            AppError::InternalError(msg) => {
                tracing::error!("内部错误: {}", msg);
                (StatusCode::INTERNAL_SERVER_ERROR, "服务器内部错误".to_string())
            }
            AppError::DatabaseError(msg) => {
                tracing::error!("数据库错误: {}", msg);
                (StatusCode::INTERNAL_SERVER_ERROR, "数据库错误".to_string())
            }
            AppError::ValidationError(errors) => {
                (StatusCode::UNPROCESSABLE_ENTITY, errors.join(", "))
            }
        };

        let body = Json(json!({
            "error": {
                "code": status.as_u16(),
                "message": error_message,
            }
        }));

        (status, body).into_response()
    }
}

// 从标准库错误自动转换
impl From<std::io::Error> for AppError {
    fn from(err: std::io::Error) -> Self {
        AppError::InternalError(err.to_string())
    }
}

impl From<serde_json::Error> for AppError {
    fn from(err: serde_json::Error) -> Self {
        AppError::BadRequest(format!("JSON 解析错误: {}", err))
    }
}

use axum::{extract::Path, Json};
use serde::Serialize;

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

// 返回 Result<T, AppError> 的 Handler
async fn get_user(Path(id): Path<u64>) -> Result<Json<User>, AppError> {
    if id == 0 {
        return Err(AppError::BadRequest("ID 不能为 0".to_string()));
    }

    // 模拟数据库查询
    let user = find_user_by_id(id)
        .await
        .ok_or_else(|| AppError::NotFound(format!("用户 {} 不存在", id)))?;

    Ok(Json(user))
}

async fn find_user_by_id(id: u64) -> Option<User> {
    if id == 1 {
        Some(User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        })
    } else {
        None
    }
}

// 使用 ? 操作符链式处理错误
async fn create_user(Json(payload): Json<serde_json::Value>) -> Result<Json<User>, AppError> {
    let name = payload["name"]
        .as_str()
        .ok_or_else(|| AppError::ValidationError(vec!["name 字段必须为字符串".to_string()]))?;

    let email = payload["email"]
        .as_str()
        .ok_or_else(|| AppError::ValidationError(vec!["email 字段必须为字符串".to_string()]))?;

    let user = User {
        id: 42,
        name: name.to_string(),
        email: email.to_string(),
    };

    Ok(Json(user))
}

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

// 使用 anyhow 作为内部错误类型
struct AnyhowError(anyhow::Error);

impl IntoResponse for AnyhowError {
    fn into_response(self) -> Response {
        tracing::error!("应用错误: {:?}", self.0);
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({"error": self.0.to_string()})),
        )
            .into_response()
    }
}

// 允许 ? 操作符自动转换
impl<E> From<E> for AnyhowError
where
    E: Into<anyhow::Error>,
{
    fn from(err: E) -> Self {
        AnyhowError(err.into())
    }
}

// Handler 中使用
async fn handler() -> Result<String, AnyhowError> {
    let data = std::fs::read_to_string("config.toml")?; // 自动转换
    Ok(data)
}

use axum::{
    extract::State,
    routing::{get, post},
    Router, Json,
};
use sqlx::postgres::PgPoolOptions;
use sqlx::PgPool;
use serde::{Deserialize, Serialize};

#[derive(Clone)]
struct AppState {
    db: PgPool,
}

#[tokio::main]
async fn main() {
    // 从环境变量读取数据库 URL
    let database_url = std::env::var("DATABASE_URL")
        .unwrap_or_else(|_| "postgres://user:pass@localhost/mydb".to_string());

    // 创建连接池
    let pool = PgPoolOptions::new()
        .max_connections(20)
        .min_connections(5)
        .acquire_timeout(std::time::Duration::from_secs(3))
        .connect(&database_url)
        .await
        .expect("无法连接数据库");

    // 运行迁移
    sqlx::migrate!("./migrations")
        .run(&pool)
        .await
        .expect("迁移失败");

    let state = AppState { db: pool };

    let app = Router::new()
        .route("/users", get(list_users).post(create_user))
        .route("/users/{id}", get(get_user).delete(delete_user))
        .with_state(state);

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

use axum::{extract::{Path, State}, http::StatusCode, Json};
use serde::{Deserialize, Serialize};
use sqlx::FromRow;
use uuid::Uuid;
use chrono::{DateTime, Utc};

#[derive(Debug, Serialize, FromRow)]
struct User {
    id: Uuid,
    username: String,
    email: String,
    created_at: DateTime<Utc>,
}

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

// CREATE
async fn create_user(
    State(state): State<AppState>,
    Json(payload): Json<CreateUserRequest>,
) -> Result<(StatusCode, Json<User>), AppError> {
    let user = sqlx::query_as::<_, User>(
        r#"
        INSERT INTO users (id, username, email, created_at)
        VALUES ($1, $2, $3, $4)
        RETURNING id, username, email, created_at
        "#,
    )
    .bind(Uuid::new_v4())
    .bind(&payload.username)
    .bind(&payload.email)
    .bind(Utc::now())
    .fetch_one(&state.db)
    .await
    .map_err(|e| AppError::DatabaseError(e.to_string()))?;

    Ok((StatusCode::CREATED, Json(user)))
}

// READ (List)
async fn list_users(
    State(state): State<AppState>,
) -> Result<Json<Vec<User>>, AppError> {
    let users = sqlx::query_as::<_, User>("SELECT id, username, email, created_at FROM users ORDER BY created_at DESC")
        .fetch_all(&state.db)
        .await
        .map_err(|e| AppError::DatabaseError(e.to_string()))?;

    Ok(Json(users))
}

// READ (Single)
async fn get_user(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as::<_, User>(
        "SELECT id, username, email, created_at FROM users WHERE id = $1",
    )
    .bind(id)
    .fetch_optional(&state.db)
    .await
    .map_err(|e| AppError::DatabaseError(e.to_string()))?
    .ok_or_else(|| AppError::NotFound(format!("用户 {} 不存在", id)))?;

    Ok(Json(user))
}

// DELETE
async fn delete_user(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<StatusCode, AppError> {
    let result = sqlx::query("DELETE FROM users WHERE id = $1")
        .bind(id)
        .execute(&state.db)
        .await
        .map_err(|e| AppError::DatabaseError(e.to_string()))?;

    if result.rows_affected() == 0 {
        Err(AppError::NotFound(format!("用户 {} 不存在", id)))
    } else {
        Ok(StatusCode::NO_CONTENT)
    }
}