Rust入门实战：从所有权系统到构建高性能Web API

昨天 6阅读

文章最后更新时间：2026年05月04日

Rust连续多年蝉联Stack Overflow「最受喜爱编程语言」榜首，但它的学习曲线也让人望而却步。本文从一个实际项目出发，带你快速掌握Rust的核心概念。

为什么选择Rust？

零成本抽象：Rust的高层语法不会带来运行时开销，性能媲美C/C++。

内存安全无GC：通过所有权系统在编译期保证内存安全，无需垃圾回收器。

并发无忧：类型系统在编译期防止数据竞争，这是其他语言难以做到的。

生态完善：Cargo包管理器、丰富的crate生态、出色的文档和编译器错误提示。

核心概念一：所有权（Ownership）

Rust最独特的特性是所有权系统，它用三条规则完全消除了内存bug：

每个值有且只有一个所有者（owner）
同一时间只能有一个可变引用或多个不可变引用
引用必须始终有效

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1的所有权转移给s2，s1不再有效
    
    // println!("{}", s1);  // 编译错误！s1已被移动
    
    let s3 = s2.clone();  // 深拷贝，s2仍然有效
    println!("s2: {}, s3: {}", s2, s3);  // 正常
    
    // 借用（Borrowing）
    let len = calculate_length(&s2);  // 不可变借用
    println!("s2长度: {}", len);
    println!("s2仍然可用: {}", s2);  // s2仍然有效，因为只是借用
}

fn calculate_length(s: &String) -> usize {
    s.len()  // s是引用，离开作用域时不会释放内存
}

核心概念二：生命周期（Lifetimes）

生命周期是Rust用来确保引用始终有效的机制。编译器会自动推断大部分生命周期，只在复杂场景需要显式标注：

// 'a 是生命周期标注，表示x和y的引用必须活的一样长
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

实战：构建高性能Web API

使用Actix-web框架构建一个RESTful API：

use actix_web::{web, App, HttpServer, HttpResponse, get, post};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;

#[derive(Debug, Serialize, Deserialize, sqlx::FromRow)]
struct User {
    id: i32,
    name: String,
    email: String,
}

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

#[get("/users")]
async fn list_users(pool: web::Data) -> HttpResponse {
    let users = sqlx::query_as::<_, User>("SELECT id, name, email FROM users")
        .fetch_all(pool.get_ref())
        .await;
    
    match users {
        Ok(users) => HttpResponse::Ok().json(users),
        Err(e) => HttpResponse::InternalServerError().json(
            serde_json::json!({"error": e.to_string()})
        ),
    }
}

#[post("/users")]
async fn create_user(
    pool: web::Data,
    user: web::Json,
) -> HttpResponse {
    let result = sqlx::query(
        "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email"
    )
    .bind(&user.name)
    .bind(&user.email)
    .fetch_one(pool.get_ref())
    .await;
    
    match result {
        Ok(row) => {
            let user = sqlx::FromRow::from_row(&row).unwrap();
            HttpResponse::Created().json(user)
        }
        Err(e) => HttpResponse::InternalServerError().json(
            serde_json::json!({"error": e.to_string()})
        ),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let database_url = std::env::var("DATABASE_URL")
        .unwrap_or_else(|_| "postgres://localhost/rust_api".into());
    let pool = PgPool::connect(&database_url).await.unwrap();
    
    println!("Server running at http://localhost:8080");
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(pool.clone()))
            .service(list_users)
            .service(create_user)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Rust的错误处理哲学

Rust没有异常，而是通过Result<T, E>和Option<T>枚举类型强制处理错误：

use std::fs::File;

fn read_config() -> Result {
    let mut file = File::open("config.toml")?;  // ? 自动传播错误
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

// 使用match处理
match read_config() {
    Ok(config) => println!("配置: {}", config),
    Err(e) => eprintln!("读取配置失败: {}", e),
}

// 使用unwrap（快速原型，生产环境避免）
let config = read_config().unwrap();