《Rust编程实战》14.2 WebSocket实现

January 12, 2025

14.2 WebSocket 实现

WebSocket 是一种全双工通信协议，为客户端和服务器之间的实时通信提供了高效的解决方案。相比于传统的 HTTP 请求-响应模型，WebSocket 通过保持长连接和低延迟的特性，特别适合实时数据更新、在线聊天和游戏等场景。

14.2.1 WebSocket 基础概念

全双工通信：WebSocket 允许客户端和服务器同时发送和接收数据，无需额外的握手。
持久连接：建立连接后，客户端和服务器保持单一的长连接，降低了网络开销。
低延迟：通过减少 HTTP 请求和响应的频繁开销，实现快速数据传输。
事件驱动：支持基于事件的通信模式，更适合实时交互。

14.2.2 Rust 的 WebSocket 支持

在 Rust 生态中，主流 WebSocket 实现主要包括：

tokio-tungstenite：基于 tokio 的异步 WebSocket 库，适合高并发场景。
warp 和 axum 的集成支持：现代化 Web 框架内置 WebSocket 支持。
Actix-web 的 WebSocket 模块：高性能 Web 框架内的 WebSocket 支持。

14.2.3 使用 tokio-tungstenite 构建 WebSocket 服务

示例：构建一个简单的 WebSocket 服务

 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


use futures_util::{SinkExt, StreamExt};
use tokio::net::TcpListener;
use tokio_tungstenite::tungstenite::protocol::Message;
use tokio_tungstenite::accept_async;

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
    println!("WebSocket server listening on ws://127.0.0.1:8080");

    while let Ok((stream, _)) = listener.accept().await {
        tokio::spawn(async move {
            let ws_stream = accept_async(stream).await.unwrap();
            println!("New WebSocket connection");

            let (mut write, mut read) = ws_stream.split();

            while let Some(Ok(msg)) = read.next().await {
                if msg.is_text() || msg.is_binary() {
                    println!("Received: {:?}", msg);
                    write.send(msg).await.unwrap(); // Echo the message back
                }
            }
        });
    }
}

特点：

使用 tokio-tungstenite 提供异步 WebSocket 支持。
处理客户端消息并回显。
适合构建简单、高效的 WebSocket 服务。

14.2.4 集成 WebSocket 与 Actix-web

示例：Actix-web 实现 WebSocket

 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


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

struct WebSocket;

impl Actor for WebSocket {
    type Context = ws::WebsocketContext<Self>;
}

impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WebSocket {
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Text(text)) => ctx.text(format!("Echo: {}", text)),
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            _ => (),
        }
    }
}

async fn ws_index(req: HttpRequest, stream: web::Payload) -> impl Responder {
    ws::start(WebSocket, &req, stream)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().route("/ws/", web::get().to(ws_index)))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

特点：

使用 Actix 的 actor 模型实现 WebSocket。
支持消息处理和事件驱动的架构。
更适合复杂的 WebSocket 逻辑，如状态管理和广播。

14.2.5 使用 WebSocket 构建实时应用

在线聊天
实现一个多用户在线聊天室，利用 WebSocket 进行消息广播。

示例：广播消息

 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 std::sync::{Arc, Mutex};
use warp::Filter;

#[tokio::main]
async fn main() {
    let users = Arc::new(Mutex::new(Vec::new()));

    let ws_route = warp::path("ws")
        .and(warp::ws())
        .and(warp::any().map(move || users.clone()))
        .map(|ws: warp::ws::Ws, users| {
            ws.on_upgrade(move |socket| handle_connection(socket, users))
        });

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

async fn handle_connection(ws: warp::ws::WebSocket, users: Arc<Mutex<Vec<warp::ws::WebSocket>>>) {
    let (tx, mut rx) = ws.split();
    users.lock().unwrap().push(tx);

    while let Some(result) = rx.next().await {
        if let Ok(msg) = result {
            let text = msg.to_str().unwrap();
            for user in users.lock().unwrap().iter_mut() {
                user.send(warp::ws::Message::text(text)).await.unwrap();
            }
        }
    }
}

实时数据更新
通过 WebSocket 实时推送股票价格、传感器数据等动态内容。
在线协作
实现在线文档编辑、多人游戏等场景，实时同步用户操作。

总结

Rust 提供了多种工具和框架支持 WebSocket 开发，适用于不同需求和复杂度的场景。从 tokio-tungstenite 的轻量级实现到 Actix 和 Axum 的深度集成，开发者可以根据实际需求选择最合适的工具。通过 WebSocket，Rust 能够轻松构建高性能的实时应用，为 Web 开发带来更大的可能性。