引言
在现代 Web 应用中，实时通信已经成为标配功能。无论是聊天应用、实时协作工具、在线游戏还是金融交易平台，都需要高效稳定的实时数据传输能力。WebSocket 协议作为 HTML5 标准的一部分，提供了全双工通信通道，成为实现实时功能的首选方案。
然而，当并发连接数达到数千甚至数万级别时，传统的 WebSocket 实现往往会遇到性能瓶颈。今天，我们将深入探讨如何使用 Rust 编程语言和 Tokio 异步运行时，构建一个能够处理高并发连接的 WebSocket 服务器。
为什么选择 Rust 和 Tokio？
Rust 的优势
Rust 以其内存安全、零成本抽象和高性能著称。对于需要处理大量并发连接的服务器应用，Rust 提供了：
- 无垃圾回收：避免 GC 停顿，保证低延迟
- 所有权系统：编译时保证内存安全，避免数据竞争
- 零成本抽象：高级特性不带来运行时开销
Tokio 的优势
Tokio 是 Rust 生态中最成熟的异步运行时：
- 基于事件驱动：高效处理 I/O 密集型任务
- 工作窃取调度器：充分利用多核 CPU
- 丰富的生态系统：提供完整的异步工具链
项目搭建
首先创建新的 Rust 项目：
cargo new websocket-server --bin
cd websocket-server
在 Cargo.toml 中添加依赖：
[package]
name = "websocket-server"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1.0", features = ["full"] }
tungstenite = "0.20"
futures-util = "0.3"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
log = "0.4"
env_logger = "0.10"
核心架构设计
我们的 WebSocket 服务器将采用以下架构：
┌─────────────────┐
│ Client Connections │
└─────────┬───────┘
│
┌─────────▼───────┐
│ WebSocket Server │
└─────────┬───────┘
│
┌─────────▼───────┐
│ Connection Manager │
└─────────┬───────┘
│
┌─────────▼───────┐
│ Message Router │
└─────────────────┘
实现 WebSocket 服务器
1. 基础服务器实现
use tokio::net::{TcpListener, TcpStream};
use tokio_tungstenite::tungstenite::protocol::Message;
use futures_util::{stream::StreamExt, SinkExt};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::{Mutex, RwLock};
type Connections = Arc<RwLock<HashMap<usize, tokio::sync::mpsc::UnboundedSender<Message>>>>;
pub struct WebSocketServer {
connections: Connections,
next_connection_id: Arc<Mutex<usize>>,
}
impl WebSocketServer {
pub fn new() -> Self {
Self {
connections: Arc::new(RwLock::new(HashMap::new())),
next_connection_id: Arc::new(Mutex::new(1)),
}
}
pub async fn run(&self, addr: &str) -> Result<(), Box<dyn std::error::Error>> {
let listener = TcpListener::bind(addr).await?;
println!("WebSocket server listening on {}", addr);
while let Ok((stream, addr)) = listener.accept().await {
println!("New connection from: {}", addr);
let connections = self.connections.clone();
let connection_id = {
let mut id = self.next_connection_id.lock().await;
let current_id = *id;
*id += 1;
current_id
};
tokio::spawn(async move {
if let Err(e) = Self::handle_connection(
stream,
addr,
connection_id,
connections
).await {
eprintln!("Error handling connection: {}", e);
}
});
}
Ok(())
}
async fn handle_connection(
stream: TcpStream,
addr: std::net::SocketAddr,
connection_id: usize,
connections: Connections,
) -> Result<(), Box<dyn std::error::Error>> {
// WebSocket 握手和连接处理
let ws_stream = tokio_tungstenite::accept_async(stream).await?;
let (mut ws_sender, mut ws_receiver) = ws_stream.split();
// 创建消息通道
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
// 保存连接
{
let mut conns = connections.write().await;
conns.insert(connection_id, tx);
}
println!("Connection {} established", connection_id);
// 发送欢迎消息
let welcome_msg = Message::Text(
serde_json::json!({
"type": "welcome",
"connection_id": connection_id,
"timestamp": chrono::Utc::now().timestamp()
}).to_string()
);
ws_sender.send(welcome_msg).await?;
// 创建发送任务
let send_task = tokio::spawn(async move {
while let Some(msg) = rx.recv().await {
if ws_sender.send(msg).await.is_err() {
break;
}
}
});
// 创建接收任务
let recv_task = tokio::spawn(async move {
while let Some(Ok(msg)) = ws_receiver.next().await {
Self::handle_message(msg, connection_id, &connections).await;
}
});
// 等待任务完成
tokio::select! {
_ = send_task => {},
_ = recv_task => {},
}
// 清理连接
{
let mut conns = connections.write().await;
conns.remove(&connection_id);
}
println!("Connection {} closed", connection_id);
Ok(())
}
async fn handle_message(
msg: Message,
connection_id: usize,
connections: &Connections,
) {
match msg {
Message::Text(text) => {
println!("Received from {}: {}", connection_id, text);
// 解析 JSON 消息
if let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) {
if let Some(msg_type) = value.get("type").and_then(|t| t.as_str()) {
match msg_type {
"broadcast" => {
Self::broadcast_message(&text, connection_id, connections).await;
}
"ping" => {
Self::send_pong(connection_id, connections).await;
}
_ => {
println!("Unknown message type: {}", msg_type);
}
}
}
}
}
Message::Ping(data) => {
println!("Ping from {}", connection_id);
// 自动回复 Pong
if let Some(tx) = connections.read().await.get(&connection_id) {
let _ = tx.send(Message::Pong(data));
}
}
Message::Close(_) => {
println!("Close frame from {}", connection_id);
}
_ => {}
}
}
async fn broadcast_message(
message: &str,
sender_id: usize,
connections: &Connections,
) {
let conns = connections.read().await;
for (&conn_id, tx) in conns.iter() {
if conn_id != sender_id {
let broadcast_msg = Message::Text(
serde_json::json!({
"type": "broadcast",
"from": sender_id,
"message": message,
"timestamp": chrono::Utc::now().timestamp()
}).to_string()
);
let _ = tx.send(broadcast_msg.clone());
}
}
println!("Message broadcast from {}", sender_id);
}
async fn send_pong(
connection_id: usize,
connections: &Connections,
) {
if let Some(tx) = connections.read().await.get(&connection_id) {
let pong_msg = Message::Text(
serde_json::json!({
"type": "pong",
"timestamp": chrono::Utc::now().timestamp()
}).to_string()
);
let _ = tx.send(pong_msg);
}
}
}
2. 连接管理优化
为了提高性能，我们需要实现连接池和心跳机制：
pub struct ConnectionManager {
connections: Connections,
heartbeat_interval: std::time::Duration,
}
