rs-connections

目录

• 介绍
• 特性
• 安装
• 使用
• API文档
• 贡献
• 许可证 x

介绍

此crate用于创建与服务器的连接。可以使用TCP或WebSocket协议创建到服务器的连接。连接使用tokio库创建。（目前不支持TCP和UDP）

特性

• 支持TCP、UDP和WebSocket协议。
• 连接状态管理（初始化、连接中、已连接、已关闭、关闭中、重新连接）。
• 处理各种连接相关事件的事件处理。

安装

将以下行添加到您的Cargo.toml文件中

[dependencies]
rs-connections = "0.2.5"

使用

use rs_connections::{ConnBuilderConfig, Protocol, ConnBuilder, ConnectError, ConnectionInterface};

#[tokio::main]
async fn main() {
    let connect_opt = ConnBuilderConfig {
        host: "127.0.0.1".to_string(),
        port: 9673,
        heartbeat_time: Some(10000),  // Optional heartbeat time
        protocol: Protocol::WEBSOCKET,
    };

    // Create a connection using the ConnBuilder
    let mut conn = ConnBuilder::new(connect_opt).build();
}

连接到服务器

为了建立到服务器的连接

async fn connect_to_server() {
    let mut conn = // ... create and configure the connection
    conn.connect().await.unwrap();
}

处理连接事件

您可以使用Emitter trait监听不同的连接事件

基本用法

use rs_connections::{
    ConnBuilder, ConnBuilderConfig, ConnectionInterface, Emitter, EventHandler, Protocol,
    CONNECTED_EVENT,
};

#[tokio::main]
async fn main() {
    let connect_opt = ConnBuilderConfig {
        host: "127.0.0.1".to_string(),
        port: 9673,
        heartbeat_time: Some(10000),
        protocol: Protocol::WEBSOCKET,
    };

    let mut conn = ConnBuilder::new(connect_opt).build();
    conn.connect().await.unwrap();

    let my_event = EventHandler::new(Box::new(|data: &str| {
        println!("event connecting: {}", data);
    }));

    conn.on("my_event", my_event.clone());
    // Emit the event
    // The parameter types must match
    conn.emit("my_event", "hello world");

    // Remove the event
    conn.off("my_event", my_event);

    // more parameters, use tuple
    conn.on("my_event", |data: (&str, &str)| {
        println!("event connecting: {}", data.0);
        println!("event connecting: {}", data.1);
    })

    conn.emit("my_event", ("hello", "world"));
}

提供的基本事件有

pub static CONNECTING_EVENT: &str = "connecting";
pub static CONNECTED_EVENT: &str = "connected";
pub static CLOSE_EVENT: &str = "close";
pub static DISCONNECT_EVENT: &str = "disconnect";
pub static ERROR_EVENT: &str = "error";
pub static MESSAGE_EVENT: &str = "message";
pub static RECONNECT_EVENT: &str = "reconnect";

• connecting：当连接正在建立时发出。
  • listen参数：&str
  • emit参数：&str
• connected：当连接建立时发出。
  • listen参数：&str
  • emit参数：&str
• disconnect：当连接断开时发出。
  • listen参数：&str
  • emit参数：&str
• reconnect：当连接重新建立时发出。
  • listen参数：String
  • emit参数：String
• close：当连接关闭时发出。
  • listen参数：String
  • emit参数：String
• error：当发生错误时发出。
  • listen参数：ConnectError
  • emit参数：ConnectError
• message：当接收到消息时发出。
  • listen参数
    • String 文本消息
    • Vec<u8> 二进制消息
  • emit参数：&str
    • String 测试消息
    • Vec<u8> 二进制消息

示例

use rs_connections::{ConnBuilderConfig, Protocol, ConnBuilder, ConnectError, ConnectionInterface};

#[tokio::main]
async fn main() {
    let connect_opt = ConnBuilderConfig {
        host: "127.0.0.1".to_string(),
        port: 9673,
        heartbeat_time: Some(10000),  // Optional heartbeat time
        protocol: Protocol::WEBSOCKET,
    };

    let mut conn = ConnBuilder::new(connect_opt).build();

    let handle_connecting = EventHandler::new(Box::new(|data: &str| {
            println!("event connecting: {}", data);
    }));

    let handle_connected = EventHandler::new(Box::new(|data: &str| {
        println!("event connected: {}", data);
    }));

    let handle_disconnect = EventHandler::new(Box::new(|data: &str| {
        println!("event disconnect: {}", data);
    }));

    let handle_reconnect = EventHandler::new(Box::new(|data: String| {
        println!("event reconnect: {}", data);
    }));

    let handle_close = EventHandler::new(Box::new(|data: String| {
        println!("event close: {}", data);
    }));

    let handle_error = EventHandler::new(Box::new(|data: ConnectError| {
        println!("event error: {}", data);
    }));

    let handle_text_message = EventHandler::new(Box::new(|data: String| {
        println!("event message: {}", data);
    }));
    let handle_binary_message = EventHandler::new(Box::new(|data: Vec<u8>| {
        println!("event binary message: {:?}", data);
    }));
    // Add event listener

    // add connecting event listener
    conn.on(CONNECTING_EVENT, handle_connecting.clone());
    // add connected event listener
    conn.on(CONNECTED_EVENT, handle_connected.clone());
    // add disconnect event listener
    conn.on(DISCONNECT_EVENT, handle_disconnect.clone());
    // add reconnect event listener
    conn.on(RECONNECT_EVENT, handle_reconnect.clone());
    // add close event listener
    conn.on(CLOSE_EVENT, handle_close.clone());
    // add error event listener
    conn.on(ERROR_EVENT, handle_error.clone());
    // add message event listener
    conn.on(MESSAGE_EVENT, handle_text_message.clone());
    // add binary message event listener
    conn.on(MESSAGE_EVENT, handle_binary_message.clone());

    conn.connect().await.unwrap();

}

发送消息

您可以使用send方法向服务器发送消息

async fn send_message() {
    let mut conn = // ... create and configure the connection
    conn.connect().await.unwrap();

    conn.send("Hello World").await.unwrap();
}

接收消息

您可以使用 receive 方法从服务器接收消息或使用消息事件

async fn receive_message() {
    let mut conn = // ... create and configure the connection
    conn.connect().await.unwrap();

    loop {
        match conn.receive().await {
            Ok(data) => {
                // data is String or Vec<u8>
                println!("receive");
            },
            Err(_) => {
                println!("receive err");
            },
        }
    }
}

async fn receive_message() {
    let mut conn = // ... create and configure the connection
    conn.connect().await.unwrap();

    conn.on(MESSAGE_EVENT, |data: String| {
        println!("Received message: {}", data);
    });

    conn.on(MESSAGE_EVENT, |data: Vec<u8>| {
        println!("Received binary message: {:?}", data);
    });

}

关闭连接

您可以使用 disconnect 方法关闭连接

async fn close_connection() {
    let mut conn = // ... create and configure the connection
    conn.connect().await.unwrap();

    conn.disconnect().await.unwrap();
}

API文档

您可以在 此处 找到API文档。

贡献

欢迎贡献！如果您有改进此项目的方法，请随时打开一个问题或提交一个拉取请求。

许可证

本项目采用MIT许可证。有关详细信息，请参阅LICENSE文件。