Rust + Web 全栈实战：从 0 搭建高性能 API 服务

一句话结论：Rust 在 Web 后端的最大优势不是"性能"，而是"性能 + 内存安全 + 部署简单"三位一体。

5 个核心优势

1. 内存安全无 GC

Java/Go：GC 暂停（10-100ms）
Rust：零 GC 暂停（确定性释放）

实测：1 万 RPS 下
Go:     p99 延迟 12ms（含 GC）
Rust:   p99 延迟 1.2ms

2. 极小部署体积

# Go 二进制
ls -la main
-rwxr-xr-x  12M  main  # Go

# Rust 二进制
ls -la target/release/api
-rwxr-xr-x  4.2M  api  # Rust（stripped）

3. 零成本抽象

// Rust 的 trait / 泛型编译后和手写代码一样快
fn process<T: AsRef<str>>(input: T) -> String {
    // 编译后等价于 fn process(input: &str) -> String
}

4. 强类型系统

// 编译期捕获错误
let user: User = serde_json::from_str(json)?;  // 类型不匹配 → 编译失败

5. async/await 原生

async fn fetch_user(id: u64) -> Result<User> {
    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
        .fetch_one(&pool)
        .await?;
    Ok(user)
}

实战：用 Axum 搭建 API

项目结构

src/
├── main.rs           # 入口
├── routes/
│   ├── mod.rs
│   ├── users.rs
│   └── posts.rs
├── models/
│   ├── mod.rs
│   ├── user.rs
│   └── post.rs
├── db.rs             # 数据库连接池
└── error.rs          # 错误处理

main.rs

use axum::{Router, routing::get};
use sqlx::postgres::PgPoolOptions;
use std::net::SocketAddr;
use tower_http::trace::TraceLayer;

mod routes;
mod db;
mod error;
mod models;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::fmt::init();

    // 数据库连接池
    let pool = PgPoolOptions::new()
        .max_connections(50)
        .connect(&std::env::var("DATABASE_URL")?)
        .await?;

    // 路由
    let app = Router::new()
        .route("/health", get(|| async { "OK" }))
        .nest("/api/users", routes::users::router())
        .nest("/api/posts", routes::posts::router())
        .with_state(pool)
        .layer(TraceLayer::new_for_http());

    // 启动服务器
    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    let listener = tokio::net::TcpListener::bind(addr).await?;
    tracing::info!("Listening on {}", addr);
    axum::serve(listener, app).await?;

    Ok(())
}

用户路由

// routes/users.rs
use axum::{
    Router,
    routing::{get, post},
    extract::{State, Path, Json},
};
use sqlx::PgPool;
use crate::models::User;

pub fn router() -> Router<PgPool> {
    Router::new()
        .route("/", get(list_users).post(create_user))
        .route("/:id", get(get_user).put(update_user).delete(delete_user))
}

async fn list_users(State(pool): State<PgPool>) -> Result<Json<Vec<User>>, AppError> {
    let users = sqlx::query_as!(User, "SELECT * FROM users ORDER BY id")
        .fetch_all(&pool)
        .await?;
    Ok(Json(users))
}

async fn create_user(
    State(pool): State<PgPool>,
    Json(input): Json<CreateUserInput>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as!(
        User,
        "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *",
        input.name,
        input.email,
    )
    .fetch_one(&pool)
    .await?;
    Ok(Json(user))
}

async fn get_user(
    State(pool): State<PgPool>,
    Path(id): Path<i64>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
        .fetch_optional(&pool)
        .await?
        .ok_or(AppError::NotFound)?;
    Ok(Json(user))
}

错误处理

// error.rs
use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

#[derive(Debug, thiserror::Error)]
pub enum AppError {
    #[error("Database error")]
    Database(#[from] sqlx::Error),
    
    #[error("Not found")]
    NotFound,
    
    #[error("Validation error: {0}")]
    Validation(String),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match self {
            AppError::Database(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
            AppError::NotFound => (StatusCode::NOT_FOUND, "Not found".to_string()),
            AppError::Validation(msg) => (StatusCode::BAD_REQUEST, msg),
        };
        
        (status, Json(json!({ "error": message }))).into_response()
    }
}

性能基准

测试：JSON 返回 1000 个用户

| 框架 | RPS | p99 延迟 | 内存 |
|------|-----|---------|------|
| Express (Node) | 12K | 18ms | 280MB |
| Spring Boot (JVM) | 28K | 22ms | 1.2GB |
| Gin (Go) | 65K | 8ms | 80MB |
| Axum (Rust) | 95K | 3.2ms | 18MB |

Axum 性能比 Gin 快 50%，内存只用 1/4。

5 个常见坑

坑 1：生命周期报错

// ❌ 编译失败
fn get_user(pool: &PgPool) -> &User {
    sqlx::query_as!(...).fetch_one(pool)
}

// ✅ 用 owned 类型
async fn get_user(pool: &PgPool) -> Result<User> {
    Ok(sqlx::query_as!(...).fetch_one(pool).await?)
}

坑 2：unwrap 满天飞

// ❌ panic 风险
let user = find_user(id).unwrap();

// ✅ 用 ? 操作符
let user = find_user(id).await?;

坑 3：async 阻塞

// ❌ 在 async 里阻塞线程
async fn process() {
    std::thread::sleep(Duration::from_secs(5));  // 阻塞整个 runtime
}

// ✅ 用 tokio::time::sleep
async fn process() {
    tokio::time::sleep(Duration::from_secs(5)).await;
}

坑 4：循环引用

// Arc 循环引用 → 内存泄漏
let a = Arc::new(Mutex::new(Some(b)));
let b = Arc::new(Mutex::new(Some(a)));  // 循环

// ✅ 用 Weak 打破循环

坑 5：错误处理不一致

// ❌ 部分函数返回 Result，部分 panic
fn foo() -> Result<X> { ... }
fn bar() -> X { panic!("error") }  // 不一致

// ✅ 全部用 Result，自定义 Error 类型

何时选 Rust

✅ 适合

• 高性能 API 服务
• 系统编程
• WebAssembly 目标
• CLI 工具
• 嵌入式

❌ 不适合

• 快速原型（用 Node / Python）
• 团队不熟悉 Rust
• 需要大量现成业务库（Rust 生态较新）

我的看法

Rust 在 Web 后端的崛起是必然：

1. 性能：比 Go 还快 50%
2. 部署：单二进制，无运行时依赖
3. 内存：安全 + 低占用（适合 Serverless）
4. 生态：Axum / Tokio / SQLx 生产可用

对独立开发者的意义：

• 部署到 Cloudflare Workers / Fly.io 时更便宜
• 单二进制部署（不需要 Docker）
• 性能敏感场景（实时 API）

学习曲线较陡，建议从小型项目开始。

参考

• Axum 官方文档
• Tokio 教程
• SQLx 文档
• Rust Book

---

本文基于 Axum 0.7 + Tokio 1.40 + Rust 1.85，2026 年 5 月最新版本。