Rust网络通信库nc的使用：高效异步TCP/UDP网络编程工具包

以下是基于nc库的完整TCP/UDP通信示例，包含客户端和服务器的完整实现：

完整TCP通信示例

TCP服务器端

use nc::tcp::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 绑定到本地8080端口
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("TCP server started 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];
            
            // 读取客户端数据
            match stream.read(&mut buf).await {
                Ok(n) if n == 0 => {
                    println!("Connection closed by client: {}", addr);
                    return;
                }
                Ok(n) => {
                    let received = String::from_utf8_lossy(&buf[..n]);
                    println!("Received from {}: {}", addr, received);
                    
                    // 发送响应
                    let response = format!("Server received {} bytes", n);
                    if let Err(e) = stream.write_all(response.as_bytes()).await {
                        eprintln!("Error writing to socket: {}", e);
                    }
                }
                Err(e) => {
                    eprintln!("Error reading from socket {}: {}", addr, e);
                }
            }
        });
    }
}

TCP客户端端

use nc::tcp::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 带超时连接到服务器
    let connect_result = tokio::time::timeout(
        Duration::from_secs(5),
        TcpStream::connect("127.0.0.1:8080")
    ).await;
    
    let mut stream = match connect_result {
        Ok(Ok(s)) => {
            println!("Connected to server!");
            s
        }
        Ok(Err(e)) => return Err(e.into()),
        Err(_) => return Err("Connection timeout".into()),
    };
    
    // 发送消息
    let message = "Hello from TCP client!";
    stream.write_all(message.as_bytes()).await?;
    println!("Sent: {}", message);
    
    // 接收响应
    let mut buf = [0; 1024];
    let n = stream.read(&mut buf).await?;
    println!("Server response: {}", String::from_utf8_lossy(&buf[..n]));
    
    Ok(())
}

完整UDP通信示例

UDP服务器端

use nc::udp::UdpSocket;
use tokio::io::AsyncReadExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 绑定到本地8080端口
    let socket = UdpSocket::bind("127.0.0.1:8080").await?;
    println!("UDP server started on {}", socket.local_addr()?);
    
    let mut buf = [0; 1024];
    
    loop {
        // 接收数据
        let (n, addr) = socket.recv_from(&mut buf).await?;
        let received = String::from_utf8_lossy(&buf[..n]);
        println!("Received from {}: {}", addr, received);
        
        // 发送响应
        let response = format!("UDP server received {} bytes", n);
        socket.send_to(response.as_bytes(), addr).await?;
    }
}

UDP客户端端

use nc::udp::UdpSocket;
use tokio::io::AsyncReadExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建并绑定UDP socket
    let socket = UdpSocket::bind("127.0.0.1:0").await?;
    println!("Client socket bound to {}", socket.local_addr()?);
    
    // 发送数据到服务器
    let message = "Hello from UDP client!";
    socket.send_to(message.as_bytes(), "127.0.0.1:8080").await?;
    println!("Sent: {}", message);
    
    // 接收响应
    let mut buf = [0; 1024];
    let (n, addr) = socket.recv_from(&mut buf).await?;
    println!("Received from {}: {}", addr, String::from_utf8_lossy(&buf[..n]));
    
    Ok(())
}

高级功能示例：带心跳的TCP长连接

use nc::tcp::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::time::{self, Duration};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    
    // 心跳任务
    let heartbeat = tokio::spawn(async move {
        let mut interval = time::interval(Duration::from_secs(5));
        loop {
            interval.tick().await;
            if let Err(e) = stream.write_all(b"HEARTBEAT").await {
                eprintln!("Heartbeat failed: {}", e);
                break;
            }
        }
    });
    
    // 数据接收任务
    let mut buf = [0; 1024];
    loop {
        match stream.read(&mut buf).await {
            Ok(0) => break,  // 连接关闭
            Ok(n) => {
                println!("Received: {}", String::from_utf8_lossy(&buf[..n]));
            }
            Err(e) => {
                eprintln!("Read error: {}", e);
                break;
            }
        }
    }
    
    heartbeat.abort();
    Ok(())
}

使用建议

1. 错误处理：在实际应用中，应该为每个网络操作添加适当的错误处理
2. 资源管理：使用Arc/Mutex等工具管理共享状态
3. 性能优化：对于高并发场景，考虑使用连接池和对象池技术
4. 日志记录：添加详细的日志记录以帮助调试

这些示例展示了nc库在TCP/UDP通信中的基本用法和高级功能，可以根据实际需求进行调整和扩展。