RESTful API 实战 #

api-project/
├── Cargo.toml
├── src/
│   ├── main.rs
│   ├── config.rs
│   ├── error.rs
│   ├── handlers/
│   │   ├── mod.rs
│   │   └── user.rs
│   ├── models/
│   │   ├── mod.rs
│   │   └── user.rs
│   └── repository/
│       ├── mod.rs
│       └── user.rs
└── tests/
    └── integration_test.rs

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

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

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

struct AppState {
    users: Mutex<HashMap<u32, User>>,
    next_id: Mutex<u32>,
}

#[actix_web::get("/users")]
async fn list_users(state: web::Data<Arc<AppState>>) -> impl Responder {
    let users = state.users.lock().unwrap();
    let users: Vec<&User> = users.values().collect();
    HttpResponse::Ok().json(users)
}

#[actix_web::get("/users/{id}")]
async fn get_user(path: web::Path<u32>, state: web::Data<Arc<AppState>>) -> impl Responder {
    let users = state.users.lock().unwrap();
    match users.get(&path.into_inner()) {
        Some(user) => HttpResponse::Ok().json(user),
        None => HttpResponse::NotFound().json(serde_json::json!({ "error": "Not found" })),
    }
}

#[actix_web::post("/users")]
async fn create_user(
    body: web::Json<CreateUser>,
    state: web::Data<Arc<AppState>>,
) -> impl Responder {
    let mut next_id = state.next_id.lock().unwrap();
    let id = *next_id;
    *next_id += 1;
    
    let user = User {
        id,
        name: body.name.clone(),
        email: body.email.clone(),
    };
    
    state.users.lock().unwrap().insert(id, user.clone());
    HttpResponse::Created().json(user)
}

#[actix_web::delete("/users/{id}")]
async fn delete_user(path: web::Path<u32>, state: web::Data<Arc<AppState>>) -> impl Responder {
    let mut users = state.users.lock().unwrap();
    match users.remove(&path.into_inner()) {
        Some(_) => HttpResponse::NoContent().finish(),
        None => HttpResponse::NotFound().finish(),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let state = Arc::new(AppState {
        users: Mutex::new(HashMap::new()),
        next_id: Mutex::new(1),
    });
    
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(state.clone()))
            .service(list_users)
            .service(get_user)
            .service(create_user)
            .service(delete_user)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

# 创建用户
curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "email": "alice@example.com"}'

# 获取用户列表
curl http://localhost:8080/users

# 获取单个用户
curl http://localhost:8080/users/1

# 删除用户
curl -X DELETE http://localhost:8080/users/1