1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

use axum::{
    routing::get,
    Router,
};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    println!("🌐 Axum 框架演示！");

    // 定义路由
    let app = Router::new()
        .route("/", get(handler))
        .route("/api/hello", get(hello_api));

    // 启动服务器
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("🚀 服务器启动在 http://{}", addr);

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

async fn handler() -> &'static str {
    "你好，Axum 世界！" // 打印：你好，Axum 世界！
}

async fn hello_api() -> &'static str {
    "Hello from Axum API!" // 打印：Hello from Axum API!
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

use actix_web::{web, App, HttpServer, HttpResponse};

async fn index() -> HttpResponse {
    HttpResponse::Ok().body("🔥 Actix-web 性能怪兽！")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("🔥 Actix-web 性能怪兽启动中...");

    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/api/bench", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}
// 输出: 🔥 Actix-web 性能怪兽启动中...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

use rocket::serde::json::Json;
use serde::{Deserialize, Serialize};

// 定义一个请求体结构
#[derive(Deserialize)]
struct User {
    name: String,
    email: String,
}

// 定义响应结构
#[derive(Serialize)]
struct Response {
    message: String,
    id: u64,
}

// Rocket 的路由会自动处理 JSON 解析
#[post("/user", format = "json", data = "<user>")]
fn create_user(user: Json<User>) -> Json<Response> {
    Json(Response {
        message: format!("欢迎 {} 加入我们！", user.name),
        id: 42, // 模拟数据库返回的 ID
    })
}

#[launch]
fn rocket() -> _ {
    println!("🚀 Rocket 发射！类型安全，编译期检查！");

    rocket::build().mount("/api", rocket::routes![create_user])
}
// 输出: 🚀 Rocket 发射！类型安全，编译期检查！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use poem::{
    handler,
    listener::TcpListener,
    middleware::Tracing,
    web::{
        path,
        Json, Query,
    },
    Endpoint, EndpointExt, Route,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// 查询参数结构
#[derive(Deserialize, Debug)]
struct PageParams {
    page: Option<usize>,
    size: Option<usize>,
}

// 响应结构
#[derive(Serialize)]
struct ApiResponse<T> {
    data: T,
    total: usize,
}

#[handler]
async fn api_list(Query(params): Query<PageParams>) -> Json<ApiResponse<Vec<&'static str>>> {
    let page = params.page.unwrap_or(1);
    let size = params.size.unwrap_or(10);

    Json(ApiResponse {
        data: vec!["item1", "item2", "item3"],
        total: 3,
    })
}

#[handler]
async fn get_item(path::Path(id): path::Path<i32>) -> Json<HashMap<&'static str, String>> {
    Json(HashMap::from([
        ("id", id.to_string()),
        ("name", "Item".to_string()),
    ]))
}

#[tokio::main]
async fn main() {
    println!("📜 Poem 轻量级 Web 框架！");

    let app = Route::new()
        .route("/api/list", get(api_list))
        .route("/api/item/:id", get(get_item))
        .with(Tracing);

    Poem::new(TcpListener::bind("127.0.0.1:3000")).run(app).await;
}
// 输出: 📜 Poem 轻量级 Web 框架！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

use warp::{Filter, Rejection, Reply};
use std::convert::Infallible;

// 组合多个过滤器
#[tokio::main]
async fn main() {
    println!("🌀 Warp 组合式过滤器演示！");

    // 健康检查过滤器
    let health = warp::path!("health")
        .and(warp::get())
        .map(|| warp::reply::json(&serde_json::json!({
            "status": "ok"
        })));

    // 带参数的过滤器
    let hello = warp::path!("hello" / String)
        .and(warp::get())
        .map(|name| {
            warp::reply::json(&serde_json::json!({
                "message": format!("你好, {}!", name)
            }))
        });

    // POST 请求过滤器
    let echo = warp::path!("echo")
        .and(warp::post())
        .and(warp::body::json())
        .map(|body: serde_json::Value| {
            warp::reply::json(&body)
        });

    // 组合所有路由
    let routes = health.or(hello).or(echo);

    warp::serve(routes)
        .run(([127, 0, 0, 1], 3000))
        .await;
}
// 输出: 🌀 Warp 组合式过滤器演示！

1
2

cargo new my-axum-app
cd my-axum-app

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

[package]
name = "my-axum-app"
version = "0.1.0"
edition = "2021"

[dependencies]
# Axum Web 框架核心
# 这是我们的主角，所有 Web 开发的基础
axum = "0.7"

# Tokio 异步运行时
# 想象 Tokio 是那个帮你处理所有繁琐异步工作的超级管家
tokio = { version = "1", features = ["full"] }

# Tower 网络库
# Tower 提供了一整套中间件和服务抽象，让你的代码模块化、可复用
tower = "0.4"

# Tower HTTP 扩展
# 包含 CORS、压缩、静态文件服务等常用中间件
tower-http = { version = "0.5", features = ["cors", "compression-full", "fs"] }

# serde 用于序列化/反序列化
# 有了 serde，JSON 和 Rust 结构体之间转换就像变魔术一样简单
serde = { version = "1", features = ["derive"] }

# serde_json 用于 JSON 解析
serde_json = "1"

# tracing 用于日志记录
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }

# 一些实用工具
anyhow = "1"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

use axum::{
    routing::get,
    Router,
};

#[tokio::main]
async fn main() {
    println!("🌐 欢迎来到 Axum 世界！");

    // 定义路由
    let app = Router::new()
        .route("/", get(handler));

    // 启动服务器
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    println!("🚀 服务器正在监听 http://127.0.0.1:3000");

    axum::serve(listener, app).await.unwrap();
}

async fn handler() -> &'static str {
    "你好，Axum 世界！" // 打印：你好，Axum 世界！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use axum::{
    routing::{get, post, put, delete},
    Router,
};
use serde::{Deserialize, Serialize};
use axum::extract::{Path, Query, Json};

// === 路径参数 ===

// GET /users/123
async fn get_user(Path(user_id): Path<i32>) -> String {
    format!("获取用户 ID: {}", user_id)
    // 打印: 获取用户 ID: 123
}

// === 查询参数 ===

#[derive(Debug, Deserialize)]
pub struct Pagination {
    pub page: Option<usize>,
    pub size: Option<usize>,
}

async fn list_users(Query(params): Query<Pagination>) -> String {
    let page = params.page.unwrap_or(1);
    let size = params.size.unwrap_or(10);
    format!("第 {} 页，每页 {} 条", page, size)
    // 打印: 第 1 页，每页 10 条
}

// === 请求体 ===

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

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

async fn create_user(Json(payload): Json<CreateUser>) -> Json<UserResponse> {
    // 在这里可以保存到数据库
    Json(UserResponse {
        id: 42,
        name: payload.name,
        email: payload.email,
    })
}

// === 路由组合 ===

#[tokio::main]
async fn main() {
    println!("🛣️ Axum 路由演示！");

    let app = Router::new()
        .route("/users", get(list_users))
        .route("/users/:id", get(get_user))
        .route("/users", post(create_user))
        .route("/articles/:id", delete(|_| async { "删除成功！" }));

    println!("🛣️ 路由已配置: GET /users, GET /users/:id, POST /users, DELETE /articles/:id");

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use axum::{
    routing::{get, post},
    Router,
    extract::Path,
};

// 用户相关的处理器
async fn list_users() -> &'static str { "所有用户" }
async fn create_user() -> &'static str { "创建用户" }

// 文章相关的处理器
async fn list_articles() -> &'static str { "所有文章" }
async fn get_article(Path(id): Path<i32>) -> String {
    format!("文章 #{}", id)
}
async fn create_article() -> &'static str { "创建文章" }

#[tokio::main]
async fn main() {
    println!("📁 嵌套路由演示！");

    // 用户模块
    let user_routes = Router::new()
        .route("/", get(list_users))
        .route("/", post(create_user));

    // 文章模块
    let article_routes = Router::new()
        .route("/", get(list_articles))
        .route("/", post(create_article))
        .route("/:id", get(get_article));

    // 顶层路由
    let app = Router::new()
        .nest("/api/users", user_routes)  // /api/users, /api/users (POST)
        .nest("/api/articles", article_routes); // /api/articles, /api/articles/:id

    println!("📁 路由已分组:");
    println!("  - /api/users     (GET: 列表, POST: 创建)");
    println!("  - /api/articles  (GET: 列表, POST: 创建)");
    println!("  - /api/articles/:id (GET: 详情)");

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

use axum::{
    routing::get,
    Router,
};
use tower_http::cors::{CorsLayer, Any};
use tower_http::compression::CompressionLayer;
use tower_http::trace::TraceLayer;

#[tokio::main]
async fn main() {
    println!("🔧 中间件演示！");

    let app = Router::new()
        .route("/", get(|| async { "Hello World!" }))
        .layer(TraceLayer::new_for_http())         // 请求追踪
        .layer(CompressionLayer::new())             // 自动压缩响应
        .layer(
            CorsLayer::new()
                .allow_origin(Any)                   // 允许所有来源
                .allow_methods(Any)                 // 允许所有方法
                .allow_headers(Any),                // 允许所有请求头
        );

    println!("🔧 已添加中间件: Trace, Compression, CORS");

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use axum::{
    routing::get,
    Router,
    middleware::{self, Next},
    extract::Request,
};
use tower::ServiceExt;

async fn check_auth(request: Request, next: Next) -> axum::response::Response {
    // 从请求头中获取 Authorization
    let auth_header = request
        .headers()
        .get("Authorization")
        .and_then(|v| v.to_str().ok());

    match auth_header {
        Some(token) if token.starts_with("Bearer ") => {
            // 验证 Token（这里简化处理）
            println!("🔓 已认证请求，Token: {}...", &token[7..15]);
            next.run(request).await
        }
        _ => {
            println!("🔒 未认证请求，被中间件拦截！");
            axum::response::Response::builder()
                .status(401)
                .body("Unauthorized".into())
                .unwrap()
        }
    }
}

#[tokio::main]
async fn main() {
    println!("🔐 自定义中间件演示！");

    let protected_app = Router::new()
        .route("/secret", get(|| async { "这是秘密！" }))
        .route("/public", get(|| async { "这是公开的！" }))
        .layer(middleware::from_fn(check_auth));

    println!("🔐 /secret 需要认证，/public 无需认证");

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

use hyper::{
    body::HttpBody,
    server::conn::http1,
    Request, Response, StatusCode,
    body::Bytes,
};
use hyper::service::service_fn;
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    println!("⚡ hyper 底层 HTTP 演示！");

    let listener = TcpListener::bind("127.0.0.1:3000").await?;
    println!("⚡ hyper 服务器启动在 http://127.0.0.1:3000");

    loop {
        let (stream, _) = listener.accept().await?;

        let service = service_fn(|req: Request<hyper::body::Incoming>| async move {
            println!("📨 收到请求: {} {}", req.method(), req.uri());

            // 根据路径返回不同响应
            let response = match req.uri().path() {
                "/" => Response::builder()
                    .status(StatusCode::OK)
                    .body("Hello, hyper!".into())?,
                "/health" => Response::builder()
                    .status(StatusCode::OK)
                    .body(r#"{"status":"ok"}"#.into())?,
                _ => Response::builder()
                    .status(StatusCode::NOT_FOUND)
                    .body("Not Found".into())?,
            };

            Ok::<_, hyper::Error>(response)
        });

        if let Err(e) = http1::Builder::new()
            .serve_connection(stream, service)
            .await
        {
            eprintln!("⚠️ 连接错误: {}", e);
        }
    }
}
// 输出:
// ⚡ hyper 底层 HTTP 演示！
// ⚡ hyper 服务器启动在 http://127.0.0.1:3000
// 📨 收到请求: GET /
// 📨 收到请求: GET /health

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

use hyper::{body::HttpBody, Client};
use hyper::body::Bytes;
use tower::ServiceExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    println!("📡 hyper HTTP 客户端演示！");

    // 创建一个客户端连接
    let connector = hyper::client::HttpConnector::new();
    let client: Client<_, hyper::body::Incoming> =
        hyper::client::Client::builder()
            .pool_idle_timeout(std::time::Duration::from_secs(30))
            .build(connector);

    // 发送 GET 请求
    let uri: hyper::Uri = "https://httpbin.org/get".parse()?;
    let resp = client.get(uri).await?;

    println!("📥 状态码: {}", resp.status());

    // 读取响应体
    let body = hyper::body::to_bytes(resp.into_body()).await?;
    let body_str = String::from_utf8(body.to_vec())?;
    println!("📦 响应体长度: {} 字节", body_str.len());
    println!("📦 响应体前100字符: {}", &body_str[..100.min(body_str.len())]);

    Ok(())
}
// 输出:
// 📡 hyper HTTP 客户端演示！
// 📥 状态码: 200 OK
// 📦 响应体长度: 512 字节

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::future::{Future, FutureExt};
use std::task::{Context, Poll};
use std::pin::Pin;
use tower::{Service, Layer};
use std::time::Instant;

// === 基础 Service ===
// 注意：EchoService 需要实现 Clone，因为 LogService 和 TimeoutService
// 内部需要 clone 持有的 Service 实例

#[derive(Clone)]
struct EchoService;

impl Service<String> for EchoService {
    type Response = String;
    type Error = std::convert::Infallible;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, request: String) -> Self::Future {
        async move { Ok(format!("ECHO: {}", request)) }.boxed()
    }
}

// === 日志 Service Wrapper ===

struct LogService<S> {
    inner: S,
}

impl<S, T> Service<T> for LogService<S>
where
    S: Service<T> + Clone + Send + 'static,
    S::Future: Send + 'static,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, request: T) -> Self::Future {
        println!("📝 [LogService] 收到请求: {:?}", &request);

        let future = self.inner.call(request);

        Box::pin(async move {
            let result = future.await;
            println!("📝 [LogService] 响应: {:?}", &result);
            result
        })
    }
}

// === 超时 Service Wrapper ===

struct TimeoutService<S> {
    inner: S,
    timeout: std::time::Duration,
}

impl<S, T> Service<T> for TimeoutService<S>
where
    S: Service<T> + Clone + Send + 'static,
    S::Future: Send + 'static,
{
    type Response = S::Response;
    type Error = tower::timeout::TimeoutError<S::Error>;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, request: T) -> Self::Future {
        let timeout = self.timeout;
        let mut inner = self.inner.clone();

        Box::pin(async move {
            tokio::time::timeout(timeout, inner.call(request)).await
        })
    }
}

// === 使用示例 ===

#[tokio::main]
async fn main() {
    println!("🔧 tower Service trait 演示！");

    // 创建基础 Service
    let echo = EchoService;

    // 包装成日志 Service
    let logged_echo = LogService { inner: echo.clone() };

    // 调用 Service
    let response = logged_echo.call("Hello, tower!".to_string()).await;
    println!("📥 最终响应: {:?}", response);

    println!("\n👋 Service 演示结束！");
}

// Service trait 详解
fn explain_service_trait() {
    /*
    pub trait Service<T> {
        // 请求类型
        type Request;

        // 响应类型
        type Response;

        // 错误类型
        type Error;

        // 异步响应 Future
        type Future: Future<Output = Result<Self::Response, Self::Error>>;

        // 检查 Service 是否准备就绪处理请求
        fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>;

        // 处理请求
        fn call(&mut self, req: Self::Request) -> Self::Future;
    }

    // 设计哲学:
    // 1. Service 是 "懒" 的 - 必须在 poll_ready 返回 Ready 后才能调用
    // 2. 实现了 Clone 的 Service 可以在多个请求间共享
    */
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use sqlx::{postgres::PgPoolOptions, FromRow, query_as};
use serde::{Deserialize, Serialize};
use std::time::Duration;
use chrono::NaiveDateTime;

// 用户结构 - 对应数据库的 users 表
#[derive(FromRow, Serialize, Debug, Clone)]
struct User {
    id: i32,
    name: String,
    email: String,
    created_at: chrono::NaiveDateTime, // 需要 chrono 支持日期时间
}

// 博客文章结构
#[derive(FromRow, Serialize, Debug)]
struct Article {
    id: i32,
    title: String,
    content: String,
    author_id: i32,
    published_at: Option<chrono::NaiveDateTime>,
}

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    println!("🔍 sqlx 编译期查询验证演示！");

    // 建立数据库连接池
    // 使用 PostgreSQL，连接字符串（生产环境请用环境变量！）
    let database_url = "postgres://postgres:password@localhost/myapp";

    let pool = PgPoolOptions::new()
        .max_connections(5)                     // 最多 5 个连接
        .acquire_timeout(Duration::from_secs(3)) // 获取连接超时 3 秒
        .connect(database_url).await?;

    println!("✅ 数据库连接成功！");

    // === 方式一：query! 宏（编译期验证，最安全）===
    // 注意：query! 需要在编译时连接数据库
    // 如果你不想在编译时连接，可以使用 query_as! 或 fetch_optional!

    // 编译期验证的查询 - 如果 SQL 错误或列名不对，编译直接失败！
    // let users = sqlx::query!("SELECT id, name, email FROM users")
    //     .fetch_all(&pool)
    //     .await?;

    // === 方式二：query_as! 宏（带结果类型）===
    // 推荐在无法编译时连接数据库的场景使用
    let users: Vec<User> = sqlx::query_as!(
        User,
        // 编译期验证：确保列名和类型与 User 结构体匹配
        "SELECT id, name, email, created_at FROM users WHERE id > $1",
        0
    )
    .fetch_all(&pool)
    .await?;

    println!("📋 查询到 {} 个用户:", users.len());
    for user in &users {
        println!("  👤 {} <{}>", user.name, user.email);
    }

    // === 方式三：fetch_optional（查询单条或零条）===
    // 适合查用户详情、设置等场景
    let maybe_user: Option<User> = sqlx::query_as!(
        User,
        "SELECT id, name, email, created_at FROM users WHERE email = $1",
        "alice@example.com"
    )
    .fetch_optional(&pool)
    .await?;

    match maybe_user {
        Some(user) => println!("🔍 找到用户: {}", user.name),
        None => println!("❌ 用户不存在！"),
    }

    // === 方式四：事务操作 ===
    let mut tx = pool.begin().await?;
    let row = sqlx::query!("INSERT INTO articles (title, content, author_id) VALUES ($1, $2, $3) RETURNING id", "Rust真好学", "sqlx 真香，编译期验证 SQL", 1).fetch_one(&mut *tx).await?;
    let article_id: i32 = row.id;
    tx.commit().await?;
    println!("📝 新文章已创建，ID: {}", article_id);

    println!("\n👋 sqlx 演示结束！");
    Ok(())
}
// 输出示例:
// 🔍 sqlx 编译期查询验证演示！
// ✅ 数据库连接成功！
// 📋 查询到 2 个用户:
//   👤 Alice <alice@example.com>
//   👤 Bob <bob@example.com>
// 🔍 找到用户: Alice
// 📝 新文章已创建，ID: 42
// 👋 sqlx 演示结束！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// Cargo.toml 需要添加：
// sqlx = { version = "0.7", features = ["runtime-tokio", "postgres", "macros", "chrono", "migrate"] }
// 在代码顶部添加：
// #[sqlx::query_bundle] // 需要 sqlx-build 或预先准备的离线数据

// 使用离线模式的关键：在 .env 或环境变量中设置 DATABASE_URL
// 然后运行：DATABASE_URL=postgres://... cargo sqlx prepare
// 这会生成 .sqlx 目录，存储查询元数据

fn main() {
    println!("🔧 sqlx 离线模式需要先运行 prepare 命令生成缓存！");
    println!("📝 步骤: 1) 设置 DATABASE_URL  2) cargo sqlx prepare");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// 注意：diesel 需要先安装并设置数据库：
// 1. 安装 diesel_cli: cargo install diesel_cli --no-default-features --features postgres
// 2. 初始化项目: diesel database setup
// 3. diesel 会生成 schema.rs 和 types.rs

// 由于 diesel 的完整示例需要预先设置，这里展示核心用法
// === diesel 核心概念 ===

// 1. 定义表（在 src/schema.rs 中由 diesel  CLI 生成）
// diesel::table! {
//     users (id) {
//         id -> Int4,
//         name -> Varchar,
//         email -> Varchar,
//         password_hash -> Varchar,
//         created_at -> Timestamp,
//     }
// }

// 2. 定义模型（在 src/models.rs 中）
// #[derive(Queryable, Selectable, Serialize)]
// #[diesel(table_name = users)]
// struct User {
//     id: i32,
//     name: String,
//     email: String,
//     password_hash: String,
//     created_at: chrono::NaiveDateTime,
// }

// 3. 定义插入结构
// #[derive(Insertable)]
// #[diesel(table_name = users)]
// struct NewUser<'a> {
//     name: &'a str,
//     email: &'a str,
//     password_hash: &'a str,
// }

// === diesel CRUD 操作示例（伪代码，实际运行需要完整项目结构）===

fn diesel_crud_example() {
    println!("🔧 diesel ORM CRUD 演示！");

    // 建立连接（同步的！）
    // let conn = &mut establish_connection();

    // === 增 (Create) ===
    // let new_user = NewUser {
    //     name: "Alice",
    //     email: "alice@example.com",
    //     password_hash: "hashed_password_here",
    // };
    // diesel::insert_into(users::table)
    //     .values(&new_user)
    //     .execute(conn)
    //     .expect("插入用户失败！");

    // === 查 (Read) ===
    // let all_users = users::table
    //     .load::<User>(conn)
    //     .expect("查询用户失败！");

    // let alice = users::table
    //     .filter(users::email.eq("alice@example.com"))
    //     .first::<User>(conn)
    //     .optional()
    //     .expect("查询失败！");

    // === 改 (Update) ===
    // diesel::update(users::table.find(1))
    //     .set(users::name.eq("Alice Updated"))
    //     .execute(conn)
    //     .expect("更新用户失败！");

    // === 删 (Delete) ===
    // diesel::delete(users::table.find(1))
    //     .execute(conn)
    //     .expect("删除用户失败！");

    println!("📝 diesel 使用步骤：");
    println!("  1. 添加 diesel 和数据库驱动到 Cargo.toml");
    println!("  2. 安装 diesel_cli 并初始化数据库");
    println!("  3. diesel 自动生成 schema.rs");
    println!("  4. 定义模型并编写 CRUD");
    println!("\n👋 diesel 是同步 ORM 的最佳选择！");
}

fn main() {
    diesel_crud_example();
}
// 输出:
// 🔧 diesel ORM CRUD 演示！
// 📝 diesel 使用步骤：
//   1. 添加 diesel 和数据库驱动到 Cargo.toml
//   2. 安装 diesel_cli 并初始化数据库
//   3. diesel 自动生成 schema.rs
//   4. 定义模型并编写 CRUD
// 👋 diesel 是同步 ORM 的最佳选择！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use sqlx::{postgres::PgPoolOptions, PgPool};
use std::time::Duration;

async fn pool_demo() {
    println!("🏊 数据库连接池演示！");

    // === sqlx 内置连接池（最常用）===
    let pool = PgPoolOptions::new()
        .max_connections(10)                  // 最大连接数
        .min_connections(2)                    // 最小连接数（预热）
        .acquire_timeout(Duration::from_secs(30)) // 获取超时
        .idle_timeout(Duration::from_secs(600))   // 空闲回收时间
        .max_lifetime(Duration::from_secs(1800)) // 单连接最大生命周期
        .connect("postgres://postgres:password@localhost/myapp")
        .await
        .expect("连接池创建失败！");

    println!("✅ 连接池创建成功！最大 {} 个连接", pool.max_connections());

    // 使用连接池并发查询
    // let results = sqlx::query!("SELECT * FROM users")
    //     .fetch_all(&pool)
    //     .await;

    // === 手动借用连接（如果需要事务）===
    {
        let mut conn = pool.acquire().await.expect("获取连接失败");
        // let tx = conn.begin().await?;
        // 在这里执行需要事务的操作
        // tx.commit().await?;
        println!("🔄 手动获取连接成功！");
    } // 连接在这里自动归还给池子

    // === deadpool 连接池（更适合需要池化多种资源）===
    println!("\n📦 deadpool 支持的资源类型：");
    println!("  - deadpool-postgres (PostgreSQL)");
    println!("  - deadpool-redis (Redis)");
    println!("  - deadpool-managed (通用池)");
    println!("  - deadpool-mongodb (MongoDB)");

    println!("\n🏊 连接池是 Web 应用的性能倍增器！");
}

// === 连接池配置最佳实践 ===

fn pool_best_practices() {
    println!("⚙️ 连接池配置建议：");
    println!("  max_connections: CPU 核心数 * 2 ~ 4");
    println!("    - 太多连接 = 数据库压力过大");
    println!("    - 太少连接 = 并发能力不足");
    println!("  acquire_timeout: 3~10 秒，避免无限等待");
    println!("  idle_timeout: 5~10 分钟，防止连接腐烂");
    println!("  max_lifetime: 30~60 分钟，定期刷新连接");
}

#[tokio::main]
async fn main() {
    pool_demo().await;
    pool_best_practices();
}
// 输出:
// 🏊 数据库连接池演示！
// ✅ 连接池创建成功！最大 10 个连接
// 🔄 手动获取连接成功！
// 📦 deadpool 支持的资源类型：
//   - deadpool-postgres (PostgreSQL)
//   - deadpool-redis (Redis)
//   - deadpool-mongodb (MongoDB)
// 🏊 连接池是 Web 应用的性能倍增器！
// ⚙️ 连接池配置建议：
//   max_connections: CPU 核心数 * 2 ~ 4
//   ...

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use sea_orm::{Database, DbConn, EntityTrait, Set, ActiveModelTrait, QueryTrait, PaginatorTrait};
use serde::{Deserialize, Serialize};

// === 定义实体 ===

// 假设我们有一个 Article 实体
// 这是 sea-orm 的风格——模型和表结构分离

mod article {
    use sea_orm::entity::prelude::*;

    #[derive(Clone, Debug, DeriveEntityModel, Serialize)]
    #[sea_orm(table_name = "articles")]
    pub struct Model {
        #[sea_orm(primary_key)]
        pub id: i32,
        pub title: String,
        pub content: String,
        pub author_id: i32,
        pub view_count: i32,
        pub created_at: chrono::NaiveDateTime,
        pub updated_at: chrono::NaiveDateTime,
    }

    #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
    pub enum Relation {}

    impl ActiveModelBehavior for ActiveModel {}

    // 手动定义 ActiveModel（sea-orm 0.12 需要手动写）
    // 注意：Set<T> 是设置值时使用的包装器，不是字段类型
    pub struct ActiveModel {
        pub id: Option<i32>,
        pub title: Option<String>,
        pub content: Option<String>,
        pub author_id: Option<i32>,
        pub view_count: Option<i32>,
        pub created_at: Option<chrono::NaiveDateTime>,
        pub updated_at: Option<chrono::NaiveDateTime>,
    }

    impl ActiveModelTrait for ActiveModel {
        fn get_id(&self) -> Option<i32> { self.id }
        fn set_id(&mut self, id: i32) { self.id = Some(id); }
    }
}

async fn sea_orm_demo() {
    println!("🐚 sea-orm 异步 ORM 演示！");

    // 建立数据库连接
    let db: DbConn = Database::connect("postgres://postgres:password@localhost/myapp")
        .await
        .expect("数据库连接失败！");

    println!("✅ sea-orm 连接成功！");

    // === 查询操作 ===
    // use article::Entity as Article;

    // let article = Article::find_by_id(1).one(&db).await.unwrap();
    // println!("📄 文章标题: {}", article.title);

    // let all_articles = Article::find().all(&db).await.unwrap();
    // for a in all_articles { println!("  📝 {}", a.title); }

    // === 条件查询 ===
    // let popular_articles = Article::find()
    //     .filter(article::Column::ViewCount.gt(100))
    //     .order_by_desc(article::Column::ViewCount)
    //     .limit(10)
    //     .all(&db)
    //     .await
    //     .unwrap();

    // === 分页查询 ===
    // let paginator = Article::find().paginate(&db, 20); // 每页 20 条
    // let total_pages = paginator.num_pages().await.unwrap();
    // let first_page = paginator.fetch_page(0).await.unwrap();

    // === 插入操作 ===
    // let new_article = article::ActiveModel {
    //     title: Set("Rust Web 开发指南".to_string()),
    //     content: Set("这是一篇关于 Rust Web 开发的好文章...".to_string()),
    //     author_id: Set(1),
    //     view_count: Set(0),
    //     created_at: Set(chrono::Utc::now().naive_utc()),
    //     updated_at: Set(chrono::Utc::now().naive_utc()),
    // };
    // let saved = new_article.insert(&db).await.unwrap();
    // println!("📝 新文章 ID: {}", saved.id);

    // === 更新操作 ===
    // let mut article: article::ActiveModel = Article::find_by_id(1)
    //     .one(&db)
    //     .await
    //     .unwrap()
    //     .into();
    // article.view_count = Set(article.view_count.unwrap() + 1);
    // article.update(&db).await.unwrap();

    // === 删除操作 ===
    // Article::delete_by_id(42).exec(&db).await.unwrap();
    // println!("🗑️ 文章已删除！");

    println!("\n🐚 sea-orm: 异步时代的 ORM 利器！");
}

#[tokio::main]
async fn main() {
    sea_orm_demo().await;
}
// 输出:
// 🐚 sea-orm 异步 ORM 演示！
// ✅ sea-orm 连接成功！
// 🐚 sea-orm: 异步时代的 ORM 利器！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use serde::{Deserialize, Serialize};
use chrono::{Utc, Duration};
use jsonwebtoken::{encode, decode, Header, Algorithm, Validation, EncodingKey, DecodingKey};
use sha2::{Sha256, Digest};

// === JWT 核心结构 ===

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String,        // 用户 ID（subject）
    name: String,       // 用户名
    role: String,      // 角色
    exp: usize,         // 过期时间
    iat: usize,         // 签发时间
}

#[derive(Debug, Serialize, Deserialize)]
struct JwtConfig {
    secret: String,
    expiration_hours: i64,
}

impl JwtConfig {
    fn new(secret: &str) -> Self {
        Self {
            secret: secret.to_string(),
            expiration_hours: 24,
        }
    }

    // 生成 JWT Token
    fn generate_token(&self, user_id: &str, username: &str, role: &str) -> Result<String, jsonwebtoken::errors::Error> {
        let now = Utc::now();
        let expiration = now + Duration::hours(self.expiration_hours);

        let claims = Claims {
            sub: user_id.to_string(),
            name: username.to_string(),
            role: role.to_string(),
            exp: expiration.timestamp() as usize,
            iat: now.timestamp() as usize,
        };

        // 使用 HS256 算法签名
        encode(
            &Header::new(Algorithm::HS256),
            &claims,
            &EncodingKey::from_secret(self.secret.as_bytes()),
        )
    }

    // 验证并解析 JWT Token
    fn verify_token(&self, token: &str) -> Result<Claims, jsonwebtoken::errors::Error> {
        let token_data = decode::<Claims>(
            token,
            &DecodingKey::from_secret(self.secret.as_bytes()),
            &Validation::new(Algorithm::HS256),
        )?;
        Ok(token_data.claims)
    }
}

#[tokio::main]
async fn main() {
    println!("🔐 JWT 认证演示！");

    let config = JwtConfig::new("super_secret_key_12345"); // 生产环境请用环境变量！

    // === 生成 Token ===
    let token = config.generate_token("user_001", "alice", "admin").unwrap();
    println!("🎫 生成 Token: {}...", &token[..50.min(token.len())]);

    // === 验证 Token ===
    match config.verify_token(&token) {
        Ok(claims) => {
            println!("✅ Token 验证成功！");
            println!("  👤 用户: {} (ID: {})", claims.name, claims.sub);
            println!("  🎭 角色: {}", claims.role);
        }
        Err(e) => println!("❌ Token 验证失败: {}", e),
    }

    // === 模拟非法 Token ===
    let fake_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImV4cCI6OTk5OTk5OTk5OX0.invalid_signature";
    match config.verify_token(fake_token) {
        Ok(_) => println!("❌ 这不应该发生！"),
        Err(e) => println!("✅ 成功拦截伪造 Token: {}", e),
    }

    println!("\n🔐 JWT 认证完成！");
}
// 输出:
// 🔐 JWT 认证演示！
// 🎫 生成 Token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzAwMS...
// ✅ Token 验证成功！
//   👤 用户: alice (ID: user_001)
//   🎭 角色: admin
// ✅ 成功拦截伪造 Token: InvalidSignature
// 🔐 JWT 认证完成！