以下是基于提供的async-wsocket使用指南整理的完整示例代码及说明：

完整WebSocket客户端+服务器示例

1. WebSocket客户端完整示例

use async_wsocket::{ClientBuilder, Error};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Error> {
    // 1. 创建带心跳的客户端
    let mut client = ClientBuilder::new()
        .url("ws://127.0.0.1:8080")?  // 连接本地服务器
        .heartbeat_interval(Duration::from_secs(15)) // 15秒心跳
        .connect()
        .await?;
    
    // 2. 发送文本消息
    client.send_text("Hello Server!").await?;
    
    // 3. 发送二进制数据
    let binary_data = vec![0xDE, 0xAD, 0xBE, 0xEF];
    client.send_binary(binary_data).await?;

    // 4. 持续接收消息
    loop {
        match client.receive().await? {
            async_wsocket::Message::Text(text) => {
                println!("[Client] Received text: {}", text);
            }
            async_wsocket::Message::Binary(bin) => {
                println!("[Client] Received binary: {:?}", bin);
            }
            async_wsocket::Message::Close(_) => {
                println!("[Client] Connection closed");
                break;
            }
            _ => {}
        }
    }
    
    Ok(())
}

2. WebSocket服务器完整示例

use async_wsocket::{ServerBuilder, Error};
use tokio::sync::broadcast;

#[tokio::main]
async fn main() -> Result<(), Error> {
    // 1. 创建消息广播通道
    let (tx, _) = broadcast::channel(32);
    
    // 2. 启动服务器
    let server = ServerBuilder::new()
        .bind("127.0.0.1:8080")
        .await?;
    
    println!("Server started on ws://127.0.0.1:8080");

    // 3. 接受客户端连接
    while let Ok((mut client, addr)) = server.accept().await {
        let tx = tx.clone();
        let mut rx = tx.subscribe();
        
        tokio::spawn(async move {
            println!("[Server] New client: {}", addr);
            
            // 4. 接收客户端消息
            while let Ok(msg) = client.receive().await {
                match msg {
                    async_wsocket::Message::Text(text) => {
                        println!("[Server] Received from {}: {}", addr, text);
                        // 广播消息给所有客户端
                        let _ = tx.send(format!("[Broadcast] {}", text));
                    }
                    async_wsocket::Message::Binary(bin) => {
                        println!("[Server] Binary from {}: {:?}", addr, bin);
                        // 回传二进制数据
                        client.send_binary(bin).await.ok();
                    }
                    async_wsocket::Message::Close(_) => {
                        println!("[Server] Client disconnected: {}", addr);
                        break;
                    }
                    _ => {}
                }
            }
        });
    }
    
    Ok(())
}

3. 带TLS加密的客户端示例

use async_wsocket::{ClientBuilder, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // 1. 创建TLS加密连接
    let mut client = ClientBuilder::new()
        .url("wss://secure-server.example.com")?
        .connect()
        .await?;
    
    // 2. 安全通信
    client.send_text("Secret Message").await?;
    
    match client.receive().await? {
        async_wsocket::Message::Text(text) => {
            println!("Secure response: {}", text);
        }
        _ => {}
    }
    
    Ok(())
}

关键功能说明

1. 双工通信：客户端和服务器同时具备发送/接收能力
2. 消息类型处理：
   • 文本消息：Message::Text
   • 二进制消息：Message::Binary
   • 关闭帧：Message::Close
3. 并发处理：服务器使用tokio::spawn为每个连接创建独立任务
4. 错误处理：所有操作返回Result类型，需处理潜在错误

执行流程建议

1. 先启动服务器程序
2. 再运行客户端程序
3. 观察控制台输出的消息交互
4. 可同时启动多个客户端测试广播功能

注意事项

1. 测试时请确保端口未被占用
2. TLS示例需要有效的证书配置
3. 生产环境建议：
   • 添加更完善的错误处理
   • 实现连接重试机制
   • 使用消息序列化协议(如JSON/Protobuf)