Rust 后端开发实战指南：Axum 与 Actix-web 从入门到生产

use axum::{
    extract::{Path, Query, State},
    routing::get,
    Json, Router,
};
use serde::{Deserialize, Serialize};
use sqlx::SqlitePool;
use std::sync::Arc;

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

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

struct AppState {
    db: SqlitePool,
}

#[tokio::main]
async fn main() {
    let pool = SqlitePool::connect("sqlite://users.db").await.unwrap();
    let state = Arc::new(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();
}

// 提取器组合：Path + Query + State
async fn get_user(
    State(state): State<Arc<AppState>>,
    Path(id): Path<i64>,
) -> Result<Json<User>, axum::http::StatusCode> {
    let user = sqlx::query_as::<_, User>(
        "SELECT id, name, email FROM users WHERE id = ?"
    )
    .bind(id)
    .fetch_optional(&state.db)
    .await
    .map_err(|_| axum::http::StatusCode::INTERNAL_SERVER_ERROR)?;

    user.map(Json).ok_or(axum::http::StatusCode::NOT_FOUND)
}

async fn list_users(
    State(state): State<Arc<AppState>>,
    Query(pagination): Query<Pagination>,
) -> Json<Vec<User>> {
    let page = pagination.page.unwrap_or(1);
    let per_page = pagination.per_page.unwrap_or(20);
    let offset = (page - 1) * per_page;

    let users = sqlx::query_as::<_, User>(
        "SELECT id, name, email FROM users LIMIT ? OFFSET ?"
    )
    .bind(per_page)
    .bind(offset)
    .fetch_all(&state.db)
    .await
    .unwrap_or_default();

    Json(users)
}

use actix_web::{web, App, HttpServer, Responder, HttpRequest, HttpResponse};
use serde::{Deserialize, Serialize};
use sqlx::SqlitePool;

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

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

async fn get_user(
    path: web::Path<i64>,
    pool: web::Data<SqlitePool>,
) -> impl Responder {
    let id = path.into_inner();
    let user = sqlx::query_as::<_, User>(
        "SELECT id, name, email FROM users WHERE id = ?"
    )
    .bind(id)
    .fetch_optional(pool.get_ref())
    .await;

    match user {
        Ok(Some(u)) => HttpResponse::Ok().json(u),
        Ok(None) => HttpResponse::NotFound().finish(),
        Err(_) => HttpResponse::InternalServerError().finish(),
    }
}

async fn list_users(
    _req: HttpRequest,
    query: web::Query<Pagination>,
    pool: web::Data<SqlitePool>,
) -> impl Responder {
    let page = query.page.unwrap_or(1);
    let per_page = query.per_page.unwrap_or(20);
    let offset = (page - 1) * per_page;

    let users = sqlx::query_as::<_, User>(
        "SELECT id, name, email FROM users LIMIT ? OFFSET ?"
    )
    .bind(per_page)
    .bind(offset)
    .fetch_all(pool.get_ref())
    .await
    .unwrap_or_default();

    HttpResponse::Ok().json(users)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let pool = SqlitePool::connect("sqlite://users.db")
        .await
        .expect("Failed to connect to DB");

    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(pool.clone()))
            .route("/users", web::get().to(list_users))
            .route("/users/{id}", web::get().to(get_user))
    })
    .bind("0.0.0.0:3000")?
    .run()
    .await
}

use anyhow::{Context, Result};
use thiserror::Error;

// thiserror: 定义应用级错误类型
#[derive(Error, Debug)]
pub enum AppError {
    #[error("用户未找到: {0}")]
    NotFound(i64),
    #[error("数据库错误: {0}")]
    Database(#[from] sqlx::Error),
    #[error("验证失败: {0}")]
    Validation(String),
}

// 将 AppError 转换为 Axum 响应
impl axum::response::IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let (status, message) = match &self {
            AppError::NotFound(_) => (StatusCode::NOT_FOUND, self.to_string()),
            AppError::Database(_) => {
                (StatusCode::INTERNAL_SERVER_ERROR, "内部错误".to_string())
            }
            AppError::Validation(msg) => (StatusCode::BAD_REQUEST, msg.clone()),
        };
        (status, Json(serde_json::json!({"error": message}))).into_response()
    }
}

async fn get_user_handler(
    Path(id): Path<i64>,
    State(state): State<AppState>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as::<_, User>("SELECT * FROM users WHERE id = ?")
        .bind(id)
        .fetch_optional(&state.db)
        .await?
        .ok_or(AppError::NotFound(id))?; // ? 运算符自动传播错误

    Ok(Json(user))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_user_validation() {
        let user = CreateUserRequest {
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            age: Some(30),
        };
        assert!(validate_user(&user).is_ok());
    }

    #[test]
    fn test_invalid_email() {
        let user = CreateUserRequest {
            name: "Bob".to_string(),
            email: "not-an-email".to_string(),
            age: None,
        };
        assert!(validate_user(&user).is_err());
    }

    #[tokio::test]
    async fn test_database_integration() {
        let pool = SqlitePool::connect("sqlite::memory:").await.unwrap();
        // 在内存数据库中测试 CRUD
        let user = create_user(&pool, "test@example.com").await.unwrap();
        assert_eq!(user.email, "test@example.com");
    }
}