Rust学习笔记2025.6.16-EW帮帮网

Rust学习笔记2025.6.16

以下是几个基于Rust的Web框架实现供应商管理Demo的推荐方案，结合框架特点和实际应用场景：

Axum（Tokio生态首选）

Axum是官方支持的异步框架，适合构建高性能API。供应商管理的核心CRUD操作可快速实现：

use axum::{Router, routing::get, extract::Path};
async fn get_vendor(Path(id): Path<u32>) -> String {
    format!("Fetch vendor {}", id)
}

let app = Router::new().route("/vendors/:id", get(get_vendor));

数据库集成推荐使用sqlx，支持编译期SQL检查：

#[derive(sqlx::FromRow)]
struct Vendor {
    id: i32,
    name: String,
    contact: String
}

async fn list_vendors(pool: PgPool) -> Vec<Vendor> {
    sqlx::query_as("SELECT * FROM vendors")
        .fetch_all(&pool)
        .await
}

以下是5个使用Tokio的常见异步编程示例，涵盖基本任务、网络通信和并发处理等场景。所有代码需在Cargo.toml中添加依赖：tokio = { version = "1", features = ["full"] }。

异步任务创建与等待

#[tokio::main]
async fn main() {
    let task1 = tokio::spawn(async {
        println!("Task 1 started");
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        println!("Task 1 completed");
    });

    let task2 = tokio::spawn(async {
        println!("Task 2 executed immediately");
    });

    let _ = tokio::join!(task1, task2);
}

此例演示如何创建并发任务并使用join!等待多个任务完成。

TCP服务器与客户端

服务器端：

use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    loop {
        let (mut socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            let n = socket.read(&mut buf).await.unwrap();
            println!("Received: {}", String::from_utf8_lossy(&buf[..n]));
        });
    }
}

客户端：

use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    stream.write_all(b"Hello Tokio!").await?;
    Ok(())
}

实现异步TCP通信，服务器可同时处理多个连接。

定时延迟任务

use tokio::time;

#[tokio::main]
async fn main() {
    println!("Wait for 3 seconds...");
    time::sleep(time::Duration::from_secs(3)).await;
    println!("Time's up!");
}

使用tokio::time::sleep实现非阻塞延迟。

共享状态与Mutex

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(tokio::spawn(async move {
            let mut num = counter.lock().await;
            *num += 1;
        }));
    }

    for handle in handles {
        handle.await.unwrap();
    }

    println!("Result: {}", *counter.lock().await);
}

通过Arc<Mutex<T>>安全地在任务间共享可变状态。

异步HTTP请求

需额外添加依赖：reqwest = { version = "0.11", features = ["json"] }

use reqwest;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let resp = reqwest::get("https://httpbin.org/get")
        .await?
        .text()
        .await?;
    println!("Response: {}", resp);
    Ok(())
}

使用reqwest库（基于Tokio）执行异步HTTP请求。

每个示例均体现了Tokio的核心功能：

#[tokio::main]宏简化运行时初始化
spawn创建并发任务
.await非阻塞等待
标准库的异步版本（如TcpListener）
异步同步原语（如Mutex）

Actix-web（成熟生态）

适合需要成熟中间件体系的场景，供应商管理可以这样构建路由：

use actix_web::{web, App};
HttpServer::new(|| {
    App::new()
        .service(
            web::scope("/api/vendors")
                .route("", web::post().to(add_vendor))
                .route("/{id}", web::put().to(update_vendor))
        )
})

表单处理示例：

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

async fn add_vendor(form: web::Form<VendorForm>) -> HttpResponse {
    // 验证并存储逻辑
}

Actix-web 视频管理系统

以下是一个基于 Actix-web 的简易视频管理系统的实现，类似于抖音的核心功能（视频上传、播放、列表展示）。代码分为核心模块和完整实现示例。

项目结构

src/
├── main.rs          # 入口文件
├── routes.rs        # 路由定义
├── handlers.rs      # 请求处理逻辑
├── models.rs        # 数据模型
└── storage.rs       # 视频存储逻辑

依赖配置（Cargo.toml）

[dependencies]
actix-web = "4.0"
actix-files = &#

Rust学习笔记2025.6.16