你应该知晓的 Rust Web 框架

// #[tokio::main] 宏标记了 `main` 函数，表明这是一个异步的`Tokio`应用程序。
#[tokio::main]
async fn main() {
    // 首先创建了一个 `TcpListener` 监听器，绑定到地址 "127.0.0.1:3000" 上
    // 然后，通过 `await` 等待监听器绑定完成
    // 如果绑定失败，会通过 `unwrap` 方法抛出错误。
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    println!("listening on {}", listener.local_addr().unwrap());
    // 使用 `axum::serve` 启动 Axum 框架的服务器，
    //    监听前面创建的 `TcpListener`。
    // `app()` 函数返回的是一个 `Router`
    //    它定义了一个简单的路由，将路径 "/a" 映射到处理函数 `a_handler`。
    axum::serve(listener, app()).await.unwrap();
}

// 返回一个 `Router`，它只有一个路由规则，
//    将 "/a" 路径映射到 `a_handler` 处理函数
fn app() -> Router {
    Router::new()
        .route("/a", get(a_handler))
}

// 一个WebSocket处理程序，它会回显收到的任何消息。
// 定义为一个WebSocket处理程序，
//   它接收一个 `WebSocketUpgrade` 参数，表示WebSocket升级。
async fn a_handler(ws: WebSocketUpgrade) -> Response {
    // 调用将WebSocket升级后的对象传递给 `a_handle_socket` 处理函数。
    ws.on_upgrade(a_handle_socket)
}

async fn a_handle_socket(mut socket: WebSocket) {
    // 使用 while let 循环，持续从 WebSocket 连接中接收消息。 
    // socket.recv().await 通过异步的方式接收消息，返回一个 Result，
    // 其中 Ok(msg) 表示成功接收到消息。
    while let Some(Ok(msg)) = socket.recv().await {
        //  使用 if let 匹配，判断接收到的消息是否为文本消息。
        //  WebSocket消息可以是不同类型的，这里我们只处理文本消息。
        if let Message::Text(msg) = msg {
            // 构造一个回显消息，将客户端发送的消息包含在回显消息中。
            // 然后，使用 socket.send 方法将回显消息发送回客户端。
            // await 等待发送操作完成。
            if socket
                .send(Message::Text(format!("You said: {msg}")))
                .await
                // 检查 send 操作是否返回错误。
                // 如果发送消息出现错误（例如，连接断开），
                // 就通过 break 跳出循环，结束处理函数。
                .is_err()
            {
                break;
            }
        }
    }
}

use actix::{Actor, StreamHandler};
use actix_web::{
  web, 
  App, 
  Error, 
  HttpRequest, 
  HttpResponse, 
  HttpServer
};
use actix_web_actors::ws;

/// 定义HTTP Actor
// 定义了一个名为 MyWs 的结构体，这将用作WebSocket的Actix Actor。
// Actors 是Actix框架中的并发单元，用于处理异步消息
struct MyWs;

// 为 MyWs 结构体实现了 Actor trait，指定了 WebsocketContext 作为上下文类型。
impl Actor for MyWs {
    type Context = ws::WebsocketContext<Self>;
}

/// 处理ws::Message消息的处理程序
// 为 MyWs 结构体实现了 StreamHandler trait，处理WebSocket连接中的消息。
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
    // 对接收到的不同类型的消息进行处理。例如，对于 Ping 消息，发送 Pong 消息作为响应。
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
            Ok(ws::Message::Text(text)) => ctx.text(text),
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            _ => (),
        }
    }
}

// 定义了一个处理HTTP请求的异步函数。
async fn index(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    // 将WebSocket连接升级，并将请求委托给 MyWs Actor 处理。
    let resp = ws::start(MyWs {}, &req, stream);
    println!("{:?}", resp);
    resp
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    //  创建了一个 HttpServer 实例，通过 App::new() 创建一个应用，
    // 该应用只有一个路由，将路径 "/ws/" 映射到处理函数 index 上。
    HttpServer::new(|| App::new().route("/ws/", web::get().to(index)))
        // 绑定服务器到地址 "127.0.0.1" 和端口 8080。
        .bind(("127.0.0.1", 8080))?
        // 启动服务器并等待其完成运行。
        .run()
        .await
}

// 定义了一个名为 Password 的结构体，该结构体派生了 Debug 和 FromForm traits。
// FromForm trait 用于从表单数据中提取数据。
// 该结构体包含两个字段 first 和 second，分别表示密码的第一个和第二个部分。
#[derive(Debug, FromForm)]
struct Password<'v> {
    // 表示对字段的长度进行了验证，要求长度在6个字符以上
    #[field(validate = len(6..))]
    // 表示第一个字段必须等于第二个字段
    #[field(validate = eq(self.second))]
    first: &'v str,
    //  表示第二个字段必须等于第一个字段。
    #[field(validate = eq(self.first))]
    second: &'v str,
}

// 省略其他结构体和实现...

// 定义了一个处理GET请求的函数 index，返回一个 Template 对象。
// 这个函数用于渲染首页。
#[get("/")]
fn index() -> Template {
    Template::render("index", &Context::default())
}

// 定义了一个处理POST请求的函数 submit。
// 这个函数接受一个 Form 对象，其中包含了表单的数据
#[post("/", data = "<form>")]
fn submit(form: Form<Submit<'_>>) -> (Status, Template) {
    // 通过检查 form.value 是否包含 Some(ref submission) 来判断表单是否提交。
    let template = match form.value {
        // 如果提交了表单，打印提交的内容，并渲染 "success" 页面；
        Some(ref submission) => {
            println!("submission: {:#?}", submission);
            Template::render("success", &form.context)
        }
        // 否则，渲染 "index" 页面。
        None => Template::render("index", &form.context),
    };

    (form.context.status(), template)
}

// 定义了启动Rocket应用程序的函数。
#[launch]
fn rocket() -> _ {
    // 使用 rocket::build() 创建一个Rocket应用程序实例
    rocket::build()
        // 并通过 .mount() 方法挂载路由。
        // routes![index, submit] 定义了两个路由，
        // 分别映射到 index 和 submit 函数。
        .mount("/", routes![index, submit])
        // 添加了一个模板处理的Fairing（Rocket中的中间件）
        .attach(Template::fairing())
        // 将静态文件服务挂载到根路径。
        .mount("/", FileServer::from(relative!("/static")))
}

// 定义了一个静态的原子 usize 计数器，用于为每个连接的用户分配唯一的用户ID。
static NEXT_USER_ID: AtomicUsize = AtomicUsize::new(1);

// 当前连接用户的状态。
//  定义了一个类型别名 Users，它是一个原子引用计数的可读写锁的 HashMap，将用户ID映射到消息的发送器。
// Arc 是原子引用计数的智能指针，RwLock 是读写锁。
// - 键是其id
// - 值是`warp::ws::Message`的发送器
type Users = Arc<RwLock<HashMap<usize, mpsc::UnboundedSender<Message>>>>;

#[tokio::main]
async fn main() {
    // 创建了一个 users 变量，用于存储连接的用户信息
    let users = Users::default();
    // 将其包装成 Warp 过滤器，以便在不同的路由中共享用户状态。
    let users = warp::any().map(move || users.clone());

    // chat 路由处理 WebSocket 握手
    let chat = warp::path("chat")
        // `ws()`过滤器将准备WebSocket握手...
        .and(warp::ws())
        .and(users)
        // 调用 user_connected 函数处理 WebSocket 连接。
        .map(|ws: warp::ws::Ws, users| {
            // 如果握手成功，将调用我们的函数。
            ws.on_upgrade(move |socket| user_connected(socket, users))
        });

    // 处理 HTTP GET 请求，返回一个包含聊天室链接的 HTML 页面
    let index = warp::path::end().map(|| warp::reply::html(INDEX_HTML));

    let routes = index.or(chat);

    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}


async fn user_connected(ws: WebSocket, users: Users) {
    // 使用计数器为此用户分配新的唯一ID。
    let my_id = NEXT_USER_ID.fetch_add(1, Ordering::Relaxed);

    eprintln!("new chat user: {}", my_id);

    // 将套接字拆分为消息的发送器和接收器。
    let (mut user_ws_tx, mut user_ws_rx) = ws.split();
    // 创建一个新的消息通道 (mpsc::unbounded_channel) 用于将用户的消息广播给其他用户
    let (tx, rx) = mpsc::unbounded_channel();
    let mut rx = UnboundedReceiverStream::new(rx);

    tokio::task::spawn(async move {
        // 不断接收用户的消息。一旦用户断开连接，就会退出这个循环。
        while let Some(message) = rx.next().await {
            user_ws_tx
                .send(message)
                .unwrap_or_else(|e| {
                    eprintln!("websocket send error: {}", e);
                })
                .await;
        }
    });

    //将发送器保存在我们的已连接用户列表中。
    users.write().await.insert(my_id, tx);

    // 返回一个基本上是管理此特定用户连接的状态机的“Future”。

    // 每当用户发送消息时，将其广播给
    // 所有其他用户...
    while let Some(result) = user_ws_rx.next().await {
        let msg = match result {
            Ok(msg) => msg,
            Err(e) => {
                eprintln!("websocket error(uid={}): {}", my_id, e);
                break;
            }
        };
        user_message(my_id, msg, &users).await;
    }

    // 只要用户保持连接，user_ws_rx流就会继续处理。一旦他们断开连接，那么...
    user_disconnected(my_id, &users).await;
}

// 处理用户发送的消息。它跳过非文本消息，将文本消息格式化为 <User#ID>: Message，然后将其广播给所有其他用户。
async fn user_message(my_id: usize, msg: Message, users: &Users) {
    // 跳过任何非文本消息...
    let msg = if let Ok(s) = msg.to_str() {
        s
    } else {
        return;
    };

    let new_msg = format!("<User#{}>: {}", my_id, msg);

    // 来自此用户的新消息，将其发送给所有其他用户（除了相同的uid）...
    for (&uid, tx) in users.read().await.iter() {
        if my_id != uid {
            if let Err(_disconnected) = tx.send(Message::text(new_msg.clone())) {
                // 发送器已断开连接，我们的`user_disconnected`代码
                // 应该在另一个任务中执行，这里没有更多的事情要做。
            }
        }
    }
}

async fn user_disconnected(my_id: usize, users: &Users) {
    eprintln!("good bye user: {}", my_id);

    // 流关闭，因此从用户列表中删除
    users.write().await.remove(&my_id);
}

// async-std crate 提供的异步 main 函数。它返回一个 Result，表示可能的错误。
#[async_std::main]
async fn main() -> Result<(), std::io::Error> {
    // 使用 femme crate 启用颜色日志。这是一个美观的日志记录库，可以使日志输出更易读。
    femme::start();
    // 创建一个 Tide 应用程序实例
    let mut app = tide::new();
    // 添加一个日志中间件，用于记录请求和响应的日志信息。
    app.with(tide::log::LogMiddleware::new());
    // 添加一个会话中间件，用于处理会话数据。这里使用内存存储，并提供一个密钥（TIDE_SECRET），用于加密和验证会话数据。
    app.with(tide::sessions::SessionMiddleware::new(
        tide::sessions::MemoryStore::new(),
        std::env::var("TIDE_SECRET")
            .expect(
                "Please provide a TIDE_SECRET value of at \
                      least 32 bytes in order to run this example",
            )
            .as_bytes(),
    ));
    // 添加一个 Before 中间件，它在处理请求之前执行。在这里，它用于增加访问计数，存储在会话中。
    app.with(tide::utils::Before(
        |mut request: tide::Request<()>| async move {
            let session = request.session_mut();
            let visits: usize = session.get("visits").unwrap_or_default();
            session.insert("visits", visits + 1).unwrap();
            request
        },
    ));
    // 定义了一个处理根路径的GET请求的路由。这个路由通过 async move 来处理请求，获取会话中的访问计数，并返回一个包含访问次数的字符串。
    app.at("/").get(|req: tide::Request<()>| async move {
        let visits: usize = req.session().get("visits").unwrap();
        Ok(format!("you have visited this website {} times", visits))
    });
    // 定义了一个处理 "/reset" 路径的GET请求的路由。这个路由通过 async move 处理请求，将会话数据清除，然后重定向到根路径
    app.at("/reset")
        .get(|mut req: tide::Request<()>| async move {
            req.session_mut().destroy();
            Ok(tide::Redirect::new("/"))
        });
    // 启动应用程序并监听在 "127.0.0.1:8080" 地址上。使用 await? 处理可能的启动错误。
    app.listen("127.0.0.1:8080").await?;

    Ok(())
}

// 注解表示这是一个处理器函数，用于处理 WebSocket 请求
#[handler]
fn ws(
    // 提取了 WebSocket 路径中的名字参数
    Path(name): Path<String>,
    // WebSocket 对象，表示与客户端的连接
    ws: WebSocket,
    // 是一个数据提取器，用于获取广播通道的发送器。
    sender: Data<&tokio::sync::broadcast::Sender<String>>,
) -> impl IntoResponse {
    // 克隆了广播通道的发送器 sender。
    let sender = sender.clone();
    // 它订阅了广播通道，创建了一个接收器 receiver
    let mut receiver = sender.subscribe();
    //  处理 WebSocket 连接升级
    ws.on_upgrade(move |socket| async move {
        // 将连接的读写部分拆分为 sink 和 stream
        let (mut sink, mut stream) = socket.split();
        
        // 从 WebSocket 客户端接收消息
        // 如果是文本消息，则将其格式化为 {name}: {text} 的形式，并通过广播通道发送。
        // 如果发送失败（例如，通道关闭），则任务终止。

        tokio::spawn(async move {
            while let Some(Ok(msg)) = stream.next().await {
                if let Message::Text(text) = msg {
                    if sender.send(format!("{name}: {text}")).is_err() {
                        break;
                    }
                }
            }
        });
        // 从广播通道接收消息，并将其发送到 WebSocket 客户端
        tokio::spawn(async move {
            while let Ok(msg) = receiver.recv().await {
                if sink.send(Message::Text(msg)).await.is_err() {
                    break;
                }
            }
        });
    })
}

#[tokio::main]
async fn main() -> Result<(), std::io::Error> {
    // 使用 tide::Route 创建了一个路由，其中包括两个路径：
    // - / 路径处理 HTTP GET 请求，调用 index 函数。
    // - /ws/:name 路径处理 WebSocket 请求，调用 ws 函数。
    let app = Route::new().at("/", get(index)).at(
        "/ws/:name",
        // 通过 tokio::sync::broadcast::channel 创建一个广播通道；
        // 并通过 tokio::sync::broadcast::channel::<String>(32).0 
        //   获取其发送器，将其作为数据传递给 ws 处理函数
        get(ws.data(tokio::sync::broadcast::channel::<String>(32).0)),
    );
    // 创建了一个服务器实例
    Server::new(TcpListener::bind("127.0.0.1:3000"))
         // 启动服务器，并等待其完成运行。
        .run(app)
        .await
}