以下是关于Rust实时通信库rust_engineio的使用内容，包含WebSocket和Engine.IO协议的高效客户端与服务器交互的完整示例：

Rust-engineio-client

一个用Rust编程语言实现的engine.io客户端。该实现目前支持engine.io协议的第4版修订版。如果您在使用此客户端时遇到任何连接问题，请确保服务器至少使用engine.io协议的第4版修订版。

示例用法

use rust_engineio::{ClientBuilder, Client, packet::{Packet, PacketId}};
use url::Url;
use bytes::Bytes;

// 获取带有`on_open`回调的客户端
let client: Client = ClientBuilder::new(Url::parse("http://localhost:4201").unwrap())
     .on_open(|_| println!("Connection opened!"))
     .build()
     .expect("Connection failed");

// 连接到服务器
client.connect().expect("Connection failed");

// 创建一个数据包，这里是一个消息数据包并发送它
let packet = Packet::new(PacketId::Message, Bytes::from_static(b"Hello World"));
client.emit(packet).expect("Server unreachable");

// 从服务器断开连接
client.disconnect().expect("Disconnect failed")

完整示例代码

下面是一个更完整的示例，展示如何使用rust_engineio库实现WebSocket和Engine.IO协议的客户端与服务器交互：

use rust_engineio::{ClientBuilder, Client, packet::{Packet, PacketId}};
use url::Url;
use bytes::Bytes;
use std::time::Duration;

fn main() {
    // 创建客户端连接
    let client: Client = ClientBuilder::new(Url::parse("http://localhost:4201").unwrap())
        .on_open(|_| println!("连接已建立!"))
        .on_close(|_| println!("连接已关闭"))
        .on_error(|err| println!("发生错误: {:?}", err))
        .on_data(|data| println!("收到数据: {:?}", data))
        .reconnect_interval(Duration::from_secs(5))  // 设置重连间隔
        .build()
        .expect("客户端创建失败");

    // 连接到服务器
    client.connect().expect("连接失败");

    // 发送消息
    let message = Packet::new(PacketId::Message, Bytes::from_static(b"Hello Server"));
    client.emit(message).expect("消息发送失败");

    // 保持连接一段时间
    std::thread::sleep(Duration::from_secs(10));

    // 断开连接
    client.disconnect().expect("断开连接失败");
}

异步版本示例

要使用异步版本，需要在Cargo.toml中添加以下依赖：

[dependencies]
rust-engineio = { version = "0.6.0", features = ["async"] }
tokio = { version = "1.0", features = ["full"] }

然后可以使用以下异步代码：

use rust_engineio::asynchronous::{ClientBuilder, Client};
use url::Url;
use bytes::Bytes;
use std::time::Duration;

#[tokio::main]
async fn main() {
    // 创建异步客户端
    let client: Client = ClientBuilder::new(Url::parse("http://localhost:4201").unwrap())
        .on_open(|_| println!("连接已建立!"))
        .on_close(|_| println!("连接已关闭"))
        .on_error(|err| println!("发生错误: {:?}", err))
        .on_data(|data| println!("收到数据: {:?}", data))
        .reconnect_interval(Duration::from_secs(5))
        .build()
        .await
        .expect("客户端创建失败");

    // 异步连接
    client.connect().await.expect("连接失败");

    // 异步发送消息
    let message = Packet::new(PacketId::Message, Bytes::from_static(b"Hello Server"));
    client.emit(message).await.expect("消息发送失败");

    // 保持连接
    tokio::time::sleep(Duration::from_secs(10)).await;

    // 异步断开连接
    client.disconnect().await.expect("断开连接失败");
}

可用连接方法

该库提供了多种连接方法：

1. build: 如果允许则建立WebSocket连接，否则回退到轮询。标准配置。
2. build_polling: 强制使用轮询传输。
3. build_websocket_with_upgrade: 先用轮询传输建立连接，然后升级到WebSocket传输(如果可能)。
4. build_websocket: 仅用WebSocket传输建立连接，如果WebSocket不被允许则会崩溃。

当前功能

该实现支持engine.io协议的所有功能，包括：

• 多种传输选项
• 发送engine.io数据包的能力
• 注册常见的engine.io事件回调：
  • on_open
  • on_close
  • on_data
  • on_error
  • on_packet

还可以通过TlsConnector传入自定义TLS配置，以及为初始请求提供自定义头信息。

完整示例Demo

以下是一个完整的实时聊天应用示例，结合了同步和异步版本的最佳实践：

// 同步版本完整示例
use rust_engineio::{ClientBuilder, Client, packet::{Packet, PacketId}};
use url::Url;
use bytes::Bytes;
use std::time::Duration;
use std::io;

fn main() -> io::Result<()> {
    println!("正在启动Engine.IO客户端...");
    
    // 创建客户端连接
    let client = ClientBuilder::new(Url::parse("http://localhost:4201").unwrap())
        .on_open(|_| println!("✅ 已连接到服务器"))
        .on_close(|_| println!("❌ 连接已关闭"))
        .on_error(|err| eprintln!("⚠️ 连接错误: {:?}", err))
        .on_data(|data| {
            if let Packet::Message(msg) = data {
                println!("📩 收到消息: {}", String::from_utf8_lossy(&msg));
            }
        })
        .reconnect_interval(Duration::from_secs(3))
        .build()?;

    // 连接到服务器
    client.connect()?;
    
    // 发送欢迎消息
    let welcome = Packet::new(PacketId::Message, Bytes::from("用户已加入聊天"));
    client.emit(welcome)?;
    
    // 创建消息循环
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        
        if input.trim().eq_ignore_ascii_case("exit") {
            break;
        }
        
        let packet = Packet::new(PacketId::Message, Bytes::from(input.trim()));
        client.emit(packet)?;
    }
    
    // 断开连接
    let goodbye = Packet::new(PacketId::Message, Bytes::from("用户已离开聊天"));
    client.emit(goodbye)?;
    client.disconnect()?;
    
    Ok(())
}

// 异步版本完整示例
use rust_engineio::asynchronous::{ClientBuilder, Client};
use url::Url;
use bytes::Bytes;
use std::time::Duration;
use tokio::io::{self, AsyncBufReadExt, BufReader};

#[tokio::main]
async fn main() -> io::Result<()> {
    println!("正在启动异步Engine.IO客户端...");
    
    // 创建异步客户端
    let client = ClientBuilder::new(Url::parse("http://localhost:4201").unwrap())
        .on_open(|_| println!("✅ 已连接到服务器"))
        .on_close(|_| println!("❌ 连接已关闭"))
        .on_error(|err| eprintln!("⚠️ 连接错误: {:?}", err))
        .on_data(|data| {
            if let Packet::Message(msg) = data {
                println!("📩 收到消息: {}", String::from_utf8_lossy(&msg));
            }
        })
        .reconnect_interval(Duration::from_secs(3))
        .build()
        .await?;

    // 异步连接
    client.connect().await?;
    
    // 发送欢迎消息
    let welcome = Packet::new(PacketId::Message, Bytes::from("用户已加入聊天"));
    client.emit(welcome).await?;
    
    // 创建异步消息循环
    let stdin = BufReader::new(io::stdin());
    let mut lines = stdin.lines();
    
    while let Ok(Some(line)) = lines.next_line().await {
        if line.trim().eq_ignore_ascii_case("exit") {
            break;
        }
        
        let packet = Packet::new(PacketId::Message, Bytes::from(line.trim()));
        client.emit(packet).await?;
    }
    
    // 断开连接
    let goodbye = Packet::new(PacketId::Message, Bytes::from("用户已离开聊天"));
    client.emit(goodbye).await?;
    client.disconnect().await?;
    
    Ok(())
}