Rust Web 框架 2026 生态全景：Axum vs Actix-web vs Warp，TechEmpower 160K req/s 背后的技术真相

引言：为什么 2026 年该认真看 Rust Web 框架了？

2026 年初，TechEmpower Round 23 基准测试公布了一组让人无法忽视的数据：

Rust 在吞吐量上领先 Go 1.5-1.7 倍，内存占用低 2-4 倍。

但性能只是故事的一部分。2026 年，Rust Web 框架生态已经成熟到什么程度？生产环境到底能不能用？选 Axum 还是 Actix-web？与 Go 相比开发效率如何？

本文基于 2026 年最新生态数据，从架构设计、性能基准、数据库集成、中间件生态、生产部署五个维度，给你一份完整的 Rust Web 框架选型指南。

一、三大框架定位速览

一句话选型：

• 新项目首选 → Axum（生态最活跃，Tokio 官方维护）
• 极致性能需求 → Actix-web（TechEmpower 榜首）
• 函数式风格爱好者 → Warp

二、Axum：Tokio 官方推荐，2026 年的事实标准

2.1 核心架构

Axum 基于 tower 的 Service trait 构建。所有请求处理都是 Service<Request, Response = Response, Error = Error> 的实现。这意味着你可以无缝使用 tower 生态的任何中间件。

Request → Tower Middleware Stack → Axum Router → Handler → Response
              ↑
         超时 / 限流 / 压缩 / CORS / Trace / Auth ...
         (全部来自 tower 生态，即插即用)

2.2 Hello World 到生产级 API

// Cargo.toml
// [dependencies]
// axum = "0.8"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
// tower-http = { version = "0.6", features = ["cors", "trace", "compression-gzip"] }

use axum::{
    routing::{get, post},
    Json, Router,
    extract::{Path, Query, State},
    http::StatusCode,
    middleware,
};
use serde::{Deserialize, Serialize};
use tower_http::{
    cors::{CorsLayer, Any},
    trace::TraceLayer,
    compression::CompressionLayer,
};

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/health", get(health_check))
        .route("/api/users", get(list_users).post(create_user))
        .route("/api/users/:id", get(get_user).put(update_user).delete(delete_user))
        .layer(CompressionLayer::new())
        .layer(TraceLayer::new_for_http())
        .layer(CorsLayer::new().allow_origin(Any))
        .with_state(AppState { db: DbPool::new().await });

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

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

// ---------- Handler 示例 ----------

async fn health_check() -> &'static str {
    "OK"
}

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

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

async fn create_user(
    State(state): State<AppState>,
    Json(input): Json<CreateUser>,
) -> Result<(StatusCode, Json<User>), StatusCode> {
    // 实际项目中这里会调用数据库
    let user = User {
        id: 1,
        name: input.name,
        email: input.email,
    };
    Ok((StatusCode::CREATED, Json(user)))
}

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

async fn list_users(
    State(state): State<AppState>,
    Query(pagination): Query<Pagination>,
) -> Json<Vec<User>> {
    let _page = pagination.page.unwrap_or(1);
    let _per_page = pagination.per_page.unwrap_or(20);
    // 实际查询数据库
    Json(vec![])
}

async fn get_user(
    State(state): State<AppState>,
    Path(id): Path<u64>,
) -> Result<Json<User>, StatusCode> {
    // 实际查询数据库
    Err(StatusCode::NOT_FOUND)
}

async fn update_user(
    State(state): State<AppState>,
    Path(id): Path<u64>,
    Json(input): Json<CreateUser>,
) -> Result<Json<User>, StatusCode> {
    Err(StatusCode::NOT_FOUND)
}

async fn delete_user(
    State(state): State<AppState>,
    Path(id): Path<u64>,
) -> StatusCode {
    StatusCode::NO_CONTENT
}

// ---------- 数据库连接池（SQLx 示例）----------

use sqlx::PgPool;

struct DbPool(PgPool);

impl DbPool {
    async fn new() -> Self {
        let pool = PgPool::connect("postgres://user:pass@localhost/mydb")
            .await
            .expect("Failed to connect to database");
        Self(pool)
    }
}

2.3 Axum 的杀手级特性

1. 类型安全的路由提取器

// 路径参数 + 查询参数 + 请求体 + 状态，全部自动解析
async fn complex_handler(
    Path(id): Path<u64>,              // /users/:id
    Query(filter): Query<Filter>,     // ?status=active&page=1
    State(app): State<AppState>,      // 应用共享状态
    Json(body): Json<UpdateRequest>,  // JSON 请求体
) -> impl IntoResponse {
    // 所有参数类型安全，编译时检查
}

2. 中间件 = tower Layer，零学习成本

use tower::ServiceBuilder;
use tower_http::{limit::RequestBodyLimitLayer, timeout::TimeoutLayer};

let app = Router::new()
    .route("/api", get(handler))
    .layer(ServiceBuilder::new()
        .layer(RequestBodyLimitLayer::new(10 * 1024 * 1024))  // 10MB 限制
        .layer(TimeoutLayer::new(std::time::Duration::from_secs(30)))
        .layer(TraceLayer::new_for_http())
    );

3. SSE（Server-Sent Events）原生支持

use axum::response::sse::{Event, Sse};
use tokio_stream::StreamExt;

async fn sse_handler() -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
    let stream = async_stream::stream! {
        for i in 0..10 {
            yield Ok(Event::default()
                .data(format!("实时消息 #{}", i)));
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        }
    };
    Sse::new(stream)
}

三、Actix-web：性能之王，Actor 模型的极致演绎

3.1 核心架构

Actix-web 基于 Actix Actor 框架构建，每个请求在独立的 Actor 中处理。Actor 模型天然支持高并发——每个 Actor 有自己的状态，不需要锁。

// Cargo.toml
// [dependencies]
// actix-web = "4"
// actix-rt = "2"
// serde = { version = "1", features = ["derive"] }

use actix_web::{web, App, HttpServer, HttpResponse, middleware};
use serde::{Deserialize, Serialize};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .configure(config)
            .wrap(middleware::Compress::default())
            .wrap(middleware::Logger::default())
    })
    .bind("0.0.0.0:3000")?
    .workers(4)  // 多线程 Worker
    .run()
    .await
}

fn config(cfg: &mut web::ServiceConfig) {
    cfg.service(
        web::scope("/api")
            .route("/users", web::get().to(list_users))
            .route("/users", web::post().to(create_user))
            .route("/users/{id}", web::get().to(get_user))
    );
}

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

async fn list_users() -> web::Json<Vec<User>> {
    web::Json(vec![
        User { id: 1, name: "Alice".into() },
        User { id: 2, name: "Bob".into() },
    ])
}

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

async fn create_user(
    body: web::Json<CreateUser>,
    data: web::Data<AppState>,
) -> HttpResponse {
    HttpResponse::Created().json(User {
        id: 3,
        name: body.name.clone(),
    })
}

async fn get_user(
    path: web::Path<u64>,
) -> HttpResponse {
    HttpResponse::Ok().json(User {
        id: path.into_inner(),
        name: "Unknown".into(),
    })
}

struct AppState {
    db: sqlx::PgPool,
}

3.2 为什么 Actix-web 最快？

1. 多线程 Worker 架构

HttpServer::new(|| App::new())
    .workers(num_cpus::get())  // 自动匹配 CPU 核心数
    .bind("0.0.0.0:3000")?
    .run()
    .await

每个 Worker 运行在独立线程中，共享代码但不共享内存（零锁设计）。

2. Actor 模型的优势

use actix::prelude::*;

struct MyActor {
    count: u64,
}

impl Actor for MyActor {
    type Context = Context<Self>;
}

struct Increment;

impl Message for Increment {
    type Result = u64;
}

impl Handler<Increment> for MyActor {
    type Result = u64;
    fn handle(&mut self, _msg: Increment, ctx: &mut Self::Context) -> Self::Result {
        self.count += 1;
        self.count
    }
}

// 在 Axum 中集成 Actix Actor（通过 Addr 桥接）

3. 内存复用策略

Actix-web 对 HTTP 解析和缓冲区做了精细的内存管理，减少了 alloc/dealloc 次数。在 TechEmpower 基准测试中，这直接贡献了 5-10% 的性能优势。

3.3 Actix-web 的痛点

1. 学习曲线陡峭：Actor 概念、Message/Handler trait 系统需要时间理解
2. 中间件生态独立：不基于 tower，部分中间件需要自己写或用社区版
3. 历史包袱：早期版本（Actix-web 3）有过 unsafe 代码安全隐患的争议，虽然 v4 已解决

四、Warp：函数式风格，Filter 管道的优雅

4.1 核心理念

Warp 用 Filter 组合代替路由定义。每个 Filter 是一个类型安全的管道步骤，最终组合成完整的路由。

use warp::Filter;
use serde::{Deserialize, Serialize};

#[tokio::main]
async fn main() {
    let health = warp::path!("health")
        .map(|| "OK");

    let users = warp::path!("api" / "users")
        .and(warp::get())
        .and(warp::query::<Pagination>())
        .and_then(list_users);

    let create_user = warp::path!("api" / "users")
        .and(warp::post())
        .and(warp::body::json())
        .and_then(create_user_handler);

    let routes = health.or(users).or(create_user);

    warp::serve(routes)
        .run(([0, 0, 0, 0], 3000))
        .await;
}

async fn list_users(pagination: Pagination) -> Result<impl warp::Reply, Infallible> {
    Ok(warp::reply::json(&vec![]))
}

async fn create_user_handler(user: CreateUser) -> Result<impl warp::Reply, Infallible> {
    Ok(warp::reply::with_status(
        warp::reply::json(&user),
        StatusCode::CREATED,
    ))
}

4.2 Warp 的优势与局限

优势：

• 类型安全到变态级别（编译器能帮你找到几乎所有路由错误）
• Filter 可复用性极高（认证 Filter、日志 Filter 可以跨项目共享）
• 代码简洁优雅

局限：

• 性能稍逊于 Axum/Actix-web（Filter 组合有运行时开销）
• 错误信息晦涩（类型不匹配时编译器报错难以理解）
• 社区活跃度下降（tokio-rs 团队精力集中在 Axum 上）

五、数据库集成：SQLx / SeaORM / Diesel 三选一

5.1 对比

5.2 SQLx：编译时 SQL 检查

use sqlx::PgPool;

// 编译时检查 SQL 语法和类型！
let users: Vec<(i64, String, String)> = sqlx::query_as(
    "SELECT id, name, email FROM users WHERE status = $1 AND created_at > $2"
)
.bind("active")
.bind chrono::Utc::now() - chrono::Duration::days(30))
.fetch_all(&pool)
.await?;

// 以下 SQL 在编译时就会报错：
// sqlx::query_as::<_, (i64,)>(
//     "SELECT id FROM nonexistent_table"  // 编译错误：表不存在
// )

SQLx 的杀手锏：sqlx::query! 宏在编译时连接数据库，验证 SQL 语法、表名、列名和数据类型。SQL 写错了编译都过不了。

5.3 SeaORM：Rust 世界的 Prisma

use sea_orm::*;

// 定义实体
#[derive(Clone, Debug, DeriveEntityModel)]
#[sea_orm(table_name = "users")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i64,
    pub name: String,
    pub email: String,
    pub created_at: DateTime,
}

// 查询
let users = users::Entity::find()
    .filter(users::Column::Status.eq("active"))
    .order_by_desc(users::Column::CreatedAt)
    .limit(20)
    .all(&db)
    .await?;

// 关联查询
let users_with_posts = users::Entity::find()
    .find_also_related(posts::Entity)
    .filter(users::Column::Id.eq(1))
    .all(&db)
    .await?;

SeaORM 的 API 设计借鉴了 Prisma/ActiveRecord 的理念，CRUD 开发效率比 SQLx 高 30-50%，但复杂查询的灵活性不如纯 SQL。

5.4 Diesel：同步世界的王者

use diesel::prelude::*;

// 定义 Schema（由 diesel CLI 自动生成）
table! {
    users (id) {
        id -> Int8,
        name -> Varchar,
        email -> Varchar,
    }
}

// 查询
let results: Vec<(i64, String, String)> = users::table
    .filter(users::status.eq("active"))
    .limit(20)
    .load(&mut conn)?;

注意：Diesel 2.x 仍以同步 API 为主。在 Web 框架中，需要用 spawn_blocking 桥接异步运行时：

// 在 Axum 中使用 Diesel（同步桥接）
async fn list_users(State(pool): State<DbPool>) -> Json<Vec<User>> {
    let results = tokio::task::spawn_blocking(move || {
        let mut conn = pool.get()?;
        users::table.load::<User>(&mut conn)
    }).await.unwrap().unwrap();
    Json(results)
}

这种桥接方式在高并发下有线程池瓶颈，2026 年新项目推荐 SQLx 或 SeaORM。

六、实战：10 分钟搭建一个完整的 REST API

cargo new my-api && cd my-api

# Cargo.toml 添加依赖
cat >> Cargo.toml << 'EOF'
[dependencies]
axum = { version = "0.8", features = ["macros"] }
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.8", features = ["runtime-tokio", "postgres", "uuid", "chrono"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tower-http = { version = "0.6", features = ["cors", "trace", "compression-gzip", "limit"] }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
uuid = { version = "1", features = ["v4", "serde"] }
chrono = { version = "0.4", features = ["serde"] }
EOF

数据库迁移

-- migrations/001_create_users.sql
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    status VARCHAR(50) DEFAULT 'active',
    created_at TIMESTAMPTZ DEFAULT now(),
    updated_at TIMESTAMPTZ DEFAULT now()
);

sqlx migrate run

完整实现

use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    routing::{get, post, put, delete},
    Json, Router,
};
use chrono::Utc;
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
use tower_http::{compression::CompressionLayer, cors::CorsLayer, limit::RequestBodyLimitLayer, trace::TraceLayer};
use uuid::Uuid;

#[derive(Debug, Clone, sqlx::FromRow, Serialize, Deserialize)]
pub struct User {
    pub id: Uuid,
    pub name: String,
    pub email: String,
    pub status: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub updated_at: chrono::DateTime<chrono::Utc>,
}

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

#[derive(Deserialize)]
pub struct UpdateUser {
    pub name: Option<String>,
    pub email: Option<String>,
    pub status: Option<String>,
}

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

pub type AppState = PgPool;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_env_filter("my_api=debug,tower_http=debug,axum=trace")
        .init();

    let pool = PgPool::connect("postgres://user:pass@localhost/mydb")
        .await
        .expect("Failed to connect to database");

    sqlx::migrate!("./migrations")
        .run(&pool)
        .await
        .expect("Failed to run migrations");

    let app = Router::new()
        .route("/health", get(|| async { "OK" }))
        .route("/api/users", get(list_users).post(create_user))
        .route("/api/users/{id}", get(get_user).put(update_user).delete(delete_user))
        .layer(CompressionLayer::new())
        .layer(TraceLayer::new_for_http())
        .layer(RequestBodyLimitLayer::new(10 * 1024 * 1024))
        .layer(CorsLayer::permissive())
        .with_state(pool);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    tracing::info!("Server running on http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

async fn list_users(
    State(pool): State<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 * FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2"
    )
    .bind(per_page as i64)
    .bind(offset as i64)
    .fetch_all(&pool)
    .await
    .unwrap_or_default();

    Json(users)
}

async fn get_user(
    State(pool): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<Json<User>, StatusCode> {
    sqlx::query_as::<_, User>("SELECT * FROM users WHERE id = $1")
        .bind(id)
        .fetch_one(&pool)
        .await
        .map(Json)
        .map_err(|_| StatusCode::NOT_FOUND)
}

async fn create_user(
    State(pool): State<AppState>,
    Json(input): Json<CreateUser>,
) -> Result<(StatusCode, Json<User>), (StatusCode, String)> {
    match sqlx::query(
        "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *"
    )
    .bind(&input.name)
    .bind(&input.email)
    .fetch_one(&pool)
    .await
    {
        Ok(user) => {
            let user = sqlx::query_as::<_, User>(
                "SELECT * FROM users WHERE id = $1"
            )
            .bind(user.get::<Uuid, _>("id"))
            .fetch_one(&pool)
            .await
            .unwrap();
            Ok((StatusCode::CREATED, Json(user)))
        }
        Err(e) => Err((StatusCode::CONFLICT, format!("Email already exists: {}", e))),
    }
}

async fn update_user(
    State(pool): State<AppState>,
    Path(id): Path<Uuid>,
    Json(input): Json<UpdateUser>,
) -> Result<Json<User>, StatusCode> {
    let current = sqlx::query_as::<_, User>("SELECT * FROM users WHERE id = $1")
        .bind(id)
        .fetch_one(&pool)
        .await
        .map_err(|_| StatusCode::NOT_FOUND)?;

    let name = input.name.unwrap_or(current.name);
    let email = input.email.unwrap_or(current.email);
    let status = input.status.unwrap_or(current.status);

    sqlx::query("UPDATE users SET name=$1, email=$2, status=$3, updated_at=now() WHERE id=$4")
        .bind(&name)
        .bind(&email)
        .bind(&status)
        .bind(id)
        .execute(&pool)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let updated = sqlx::query_as::<_, User>("SELECT * FROM users WHERE id = $1")
        .bind(id)
        .fetch_one(&pool)
        .await
        .unwrap();

    Ok(Json(updated))
}

async fn delete_user(
    State(pool): State<AppState>,
    Path(id): Path<Uuid>,
) -> StatusCode {
    sqlx::query("DELETE FROM users WHERE id = $1")
        .bind(id)
        .execute(&pool)
        .await
        .map(|_| StatusCode::NO_CONTENT)
        .unwrap_or(StatusCode::NOT_FOUND)
}

运行：

RUST_LOG=my_api=debug cargo run
# Server running on http://localhost:3000

curl http://localhost:3000/health
# OK

curl -X POST http://localhost:3000/api/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","email":"alice@example.com"}'
# {"id":"550e8400-...","name":"Alice","email":"alice@example.com",...}

七、Rust vs Go：2026 年后端到底选哪个？

7.1 性能维度

7.2 开发效率维度

7.3 选型建议

八、2026 年 Rust Web 生态还有哪些值得关注？

8.1 实时通信

• tokio-tungstenite：WebSocket 客户端/服务端
• axum-extra：Axum 的 WebSocket 支持（实验性）
• axum::extract::ws：Axum 0.8 原生 WebSocket

use axum::extract::ws::{WebSocket, WebSocketUpgrade, Message};

async fn ws_handler(ws: WebSocketUpgrade) -> impl IntoResponse {
    ws.on_upgrade(handle_socket)
}

async fn handle_socket(mut socket: WebSocket) {
    while let Some(msg) = socket.recv().await {
        if let Ok(Message::Text(text)) = msg {
            socket.send(Message::Text(format!("Echo: {}", text))).await;
        }
    }
}

8.2 认证与授权

// JWT 认证中间件
use jsonwebtoken::{decode, Validation, DecodingKey};
use axum::{
    extract::Request,
    http::StatusCode,
    middleware::Next,
    response::Response,
};

async fn auth_middleware(
    mut req: Request,
    next: Next,
) -> Result<Response, StatusCode> {
    let auth_header = req
        .headers()
        .get("Authorization")
        .and_then(|h| h.to_str().ok())
        .ok_or(StatusCode::UNAUTHORIZED)?;

    let token = auth_header.strip_prefix("Bearer ").unwrap_or("");
    decode::<Claims>(token, &DecodingKey::from_secret("secret"), &Validation::default())
        .map_err(|_| StatusCode::UNAUTHORIZED)?;

    Ok(next.run(req).await)
}

8.3 gRPC 集成

// tonic + axum 联合使用
use tonic::{transport::Server, Request, Response, Status};
use tonic_health::server::health_reporter;

// gRPC 服务定义 (build.rs 生成)
// #[tonic::async_trait]
// impl MyService for MyServiceImpl {
//     async fn my_method(&self, req: Request<MyRequest>) -> Result<Response<MyResponse>, Status> {
//         // 实现
//     }
// }

#[tokio::main]
async fn main() {
    // gRPC 服务和 HTTP API 共享端口
    let grpc_service = MyServiceServer::new(MyServiceImpl);
    let http_app = Router::new().route("/api/health", get(|| async { "OK" }));

    Server::builder()
        .add_service(grpc_service)
        .add_service(health_reporter())
        .serve("0.0.0.0:3000".parse().unwrap())
        .await
        .unwrap();
}

九、生产部署最佳实践

9.1 构建优化

# Cargo.toml - Release 优化
[profile.release]
opt-level = 3          # 最高优化级别
lto = true             # 链接时优化
codegen-units = 1      # 单线程编译（更优化但更慢）
strip = true           # 去除调试符号
panic = "abort"        # panic 直接 abort（减小二进制体积）

9.2 Docker 部署

# 多阶段构建
FROM rust:1.85-alpine AS builder
WORKDIR /app
COPY Cargo.toml Cargo.lock ./
RUN cargo build --release && rm -rf target/release/deps target/release/.fingerprint

COPY src ./src
RUN cargo build --release

FROM alpine:3.20
RUN apk add --no-cache ca-certificates libssl3
COPY --from=builder /app/target/release/my-api /usr/local/bin/my-api
EXPOSE 3000
CMD ["my-api"]

# docker-compose.yml
services:
  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://user:pass@db:5432/mydb
    depends_on:
      - db
  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass

9.3 监控指标

// 集成 Prometheus 指标
use metrics::{counter, histogram};
use metrics_exporter_prometheus::PrometheusBuilder;

fn init_metrics() {
    PrometheusBuilder::new()
        .install()
        .unwrap();
}

// 在中间件中记录请求指标
async fn metrics_middleware(req: Request, next: Next) -> Response {
    let start = std::time::Instant::now();
    let response = next.run(req).await;
    let latency = start.elapsed();
    counter!("http.requests.total", 1);
    histogram!("http.requests.latency", latency.as_secs_f64());
    response
}

十、总结

2026 年 Rust Web 框架选型决策树

需要极致性能？
  ├─ 是 → Actix-web（160K req/s，TechEmpower 榜首）
  └─ 否 → 新项目？
      ├─ 是 → Axum（生态最活跃，Tokio 官方维护）
      └─ 否 → 已有 Actix 项目？Actix / 已有 Warp 项目？Warp

数据库选型

复杂 SQL 查询多？
  ├─ 是 → SQLx（编译时检查，纯 SQL）
  └─ 否 → CRUD 为主？
      ├─ 是 → SeaORM（类似 Prisma，开发快）
      └─ 否 → 已有 Diesel 项目？Diesel

核心建议

1. 2026 年新项目首选 Axum——社区活跃度最高、Tokio 官方维护、tower 中间件生态丰富
2. 数据库层首选 SQLx——编译时 SQL 检查是 Rust 独有的安全网
3. 不要为了用 Rust 而用 Rust——如果团队没有 Rust 经验且时间紧迫，Go 依然是更务实的选择
4. 关注编译速度——Rust 编译是痛点，使用 cargo check 做快速类型检查、增量编译和 mold 链接器加速

Rust Web 框架已经过了「能不能用」的阶段，进入了「怎么用得更好」的阶段。2026 年，如果你追求性能和类型安全，Rust Web 值得认真投入。