Rust异步网络库lightning-net-tokio的使用，支持高性能Tokio运行时驱动的TCP/UDP通信

安装

在项目目录中运行以下Cargo命令：

cargo add lightning-net-tokio

或者在Cargo.toml中添加以下行：

lightning-net-tokio = "0.1.0"

使用示例

TCP服务器示例

use lightning_net_tokio::socket::TcpSocket;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建TCP服务器
    let socket = TcpSocket::new();
    let listener = socket.bind("127.0.0.1:8080").await?;
    
    println!("TCP server listening on 127.0.0.1:8080");
    
    loop {
        // 接受新连接
        let (mut stream, _) = listener.accept().await?;
        
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            
            // 读取客户端数据
            let n = match stream.read(&mut buf).await {
                Ok(n) if n == 0 => return,
                Ok(n) => n,
                Err(e) => {
                    eprintln!("failed to read from socket; err = {:?}", e);
                    return;
                }
            };
            
            // 回写数据给客户端
            if let Err(e) = stream.write_all(&buf[0..n].await {
                eprintln!("failed to write to socket; err = {:?}", e);
                return;
            }
        });
    }
}

TCP客户端示例

use lightning_net_tokio::socket::TcpSocket;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建TCP客户端
    let socket = TcpSocket::new();
    let mut stream = socket.connect("127.0.0.1:8080").await?;
    
    // 发送数据
    stream.write_all(b"hello world").await?;
    
    // 接收响应
    let mut buf = [0; 1024];
    let n = stream.read(&mut buf).await?;
    
    println!("Received: {}", String::from_utf8_lossy(&buf[..n]));
    
    Ok(())
}

UDP示例

use lightning_net_tokio::socket::UdpSocket;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建UDP服务器
    let server_socket = UdpSocket::new();
    server_socket.bind("127.0.0.1:8081").await?;
    
    tokio::spawn(async move {
        let mut buf = [0; 1024];
        
        // 接收UDP数据包
        let (len, addr) = server_socket.recv_from(&mut buf).await.unwrap();
        println!("Received {} bytes from {}", len, addr);
        
        // 发送响应
        server_socket.send_to(&buf[..len], addr).await.unwrap();
    });
    
    // 创建UDP客户端
    let client_socket = UdpSocket::new();
    client_socket.bind("127.0.0.1:0").await?;
    
    // 发送数据
    client_socket.send_to(b"hello udp", "127.0.0.1:8081").await?;
    
    // 接收响应
    let mut buf = [0; 1024];
    let (len, _) = client_socket.recv_from(&mut buf).await?;
    println!("Received: {}", String::from_utf8_lossy(&buf[..len]));
    
    Ok(())
}

完整示例

完整TCP Echo服务器和客户端示例

TCP服务器端 (tcp_server.rs):

use lightning_net_tokio::socket::TcpSocket;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建TCP Socket
    let socket = TcpSocket::new();
    // 绑定到本地8080端口
    let listener = socket.bind("127.0.0.1:8080").await?;
    
    println!("TCP Echo Server listening on 127.0.0.1:8080");
    
    loop {
        // 接受新连接
        let (mut stream, addr) = listener.accept().await?;
        println!("New connection from: {}", addr);
        
        // 为每个连接创建独立任务
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            
            loop {
                // 读取客户端数据
                let n = match stream.read(&mut buf).await {
                    Ok(n) if n == 0 => break,  // 连接关闭
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("Read error from {}: {:?}", addr, e);
                        break;
                    }
                };
                
                // 回显数据给客户端
                if let Err(e) = stream.write_all(&buf[..n]).await {
                    eprintln!("Write error to {}: {:?}", addr, e);
                    break;
                }
            }
            
            println!("Connection closed: {}", addr);
        });
    }
}

TCP客户端端 (tcp_client.rs):

use lightning_net_tokio::socket::TcpSocket;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建TCP Socket
    let socket = TcpSocket::new();
    // 连接到服务器
    let mut stream = socket.connect("127.0.0.1:8080").await?;
    println!("Connected to server");
    
    // 发送测试消息
    let message = "Hello, TCP Echo Server!";
    stream.write_all(message.as_bytes()).await?;
    println!("Sent: {}", message);
    
    // 接收响应
    let mut buf = [0; 1024];
    let n = stream.read(&mut buf).await?;
    let response = String::from_utf8_lossy(&buf[..n]);
    println!("Received: {}", response);
    
    Ok(())
}

完整UDP Echo服务器和客户端示例

UDP服务器端 (udp_server.rs):

use lightning_net_tokio::socket::UdpSocket;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建UDP Socket并绑定端口
    let socket = UdpSocket::new();
    socket.bind("127.0.0.1:8081").await?;
    println!("UDP Echo Server listening on 127.0.0.1:8081");
    
    let mut buf = [0; 1024];
    
    loop {
        // 接收数据
        let (len, addr) = socket.recv_from(&mut buf).await?;
        let message = String::from_utf8_lossy(&buf[..len]);
        println!("Received {} bytes from {}: {}", len, addr, message);
        
        // 发送回响应
        socket.send_to(&buf[..len], addr).await?;
        println!("Echoed back to {}", addr);
    }
}

UDP客户端端 (udp_client.rs):

use lightning_net_tokio::socket::UdpSocket;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建UDP Socket并绑定随机端口
    let socket = UdpSocket::new();
    socket.bind("127.0.0.1:0").await?;
    
    // 服务器地址
    let server_addr = "127.0.0.1:8081";
    
    // 发送消息
    let message = "Hello, UDP Echo Server!";
    socket.send_to(message.as_bytes(), server_addr).await?;
    println!("Sent to {}: {}", server_addr, message);
    
    // 接收响应
    let mut buf = [0; 1024];
    let (len, _) = socket.recv_from(&mut buf).await?;
    let response = String::from_utf8_lossy(&buf[..len]);
    println!("Received: {}", response);
    
    Ok(())
}

特性

1. 基于Tokio运行时的高性能异步网络通信
2. 提供TCP和UDP套接字支持
3. 简洁的API设计，易于使用
4. 适用于需要高性能网络通信的场景

许可证

该项目采用MIT或Apache-2.0许可证。