Rust网络编程库deno_net使用指南

deno_net是Deno运行时中的一个高性能网络编程库，提供了异步网络通信能力，支持TCP和UDP协议。它专为高性能I/O操作设计，适合构建网络服务器和客户端应用。

主要特性

• 异步非阻塞I/O
• TCP和UDP协议支持
• 高性能网络通信
• 与Tokio运行时良好集成
• 简洁易用的API

基本使用方法

添加依赖

首先在Cargo.toml中添加deno_net依赖：

[dependencies]
deno_net = "0.7"
tokio = { version = "1.0", features = ["full"] }

TCP服务器示例

use deno_net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("TCP server listening on 127.0.0.1:8080");
    
    loop {
        let (mut socket, addr) = listener.accept().await?;
        println!("Accepted connection from: {}", addr);
        
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            
            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("Failed to read from socket: {}", e);
                        return;
                    }
                };
                
                println!("Received: {}", String::from_utf8_lossy(&buf[..n]));
                
                if let Err极简风格，注重实用性。

## 完整示例代码

下面是一个结合了TCP服务器和客户端的完整示例：

### TCP服务器 (echo_server.rs)

```rust
use deno_net::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 echo server started on 127.0.0.1:8080");
    
    loop {
        // 接受新连接
        let (mut socket, addr) = listener.accept().await?;
        println!("New connection from: {}", addr);
        
        // 为每个连接生成异步任务
        tokio::spawn(async move {
            let mut buf = [0; 1024];  // 1KB缓冲区
            
            loop {
                // 读取数据
                let n = match socket.read(&mut buf).await {
                    Ok(0) => {  // 连接关闭
                        println!("Connection closed by client: {}", addr);
                        return;
                    }
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("Read error from {}: {}", addr, e);
                        return;
                    }
                };
                
                // 打印接收到的数据
                let received = String::from_utf8_lossy(&buf[..n]);
                println!("Received from {}: {}", addr, received);
                
                // 回写相同数据 (echo)
                if let Err(e) = socket.write_all(&buf[..n]).await {
                    eprintln!("Write error to {}: {}", addr, e);
                    return;
                }
            }
        });
    }
}

TCP客户端 (echo_client.rs)

use deno_net::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接到服务器
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("Connected to server at 127.0.0.1:8080");
    
    // 准备要发送的消息
    let messages = vec![
        "Hello, server!",
        "This is a test message",
        "Another message",
        "quit"  // 特殊命令关闭连接
    ];
    
    for msg in messages {
        // 发送消息
        println!("Sending: {}", msg);
        stream.write_all(msg.as_bytes()).await?;
        
        // 如果是quit命令则退出
        if msg == "quit" {
            println!("Closing connection...");
            break;
        }
        
        // 接收响应
        let mut buf = [0; 1024];
        let n = stream.read(&mut buf).await?;
        let response = String::from_utf8_lossy(&buf[..n]);
        println!("Received echo: {}", response);
        
        // 短暂延迟
        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
    }
    
    Ok(())
}

UDP服务器 (udp_echo_server.rs)

use deno_net::UdpSocket;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 绑定到本地8081端口
    let socket = UdpSocket::bind("127.0.0.1:8081").await?;
    println!("UDP echo server started on 127.0.0.1:8081");
    
    let mut buf = [0; 1024];  // 1KB缓冲区
    
    loop {
        // 接收数据
        let (len, addr) = socket.recv_from(&mut buf).await?;
        let received = String::from_utf8_lossy(&buf[..len]);
        println!("Received from {}: {}", addr, received);
        
        // 如果是quit命令则退出
        if received == "quit" {
            println!("Shutting down server...");
            break;
        }
        
        // 回写相同数据 (echo)
        socket.send_to(&buf[..len], addr).await?;
    }
    
    Ok(())
}

UDP客户端 (udp_echo_client.rs)

use deno_net::UdpSocket;
use tokio::time;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 绑定到随机端口
    let socket = UdpSocket::bind("0.0.0.0:0").await?;
    let server_addr = "127.0.0.1:8081";
    
    // 准备要发送的消息
    let messages = vec![
        "Hello, UDP server!",
        "This is a UDP test",
        "Another UDP message",
        "quit"  // 特殊命令关闭服务器
    ];
    
    for msg in messages {
        // 发送消息
        println!("Sending to {}: {}", server_addr, msg);
        socket.send_to(msg.as_bytes(), server_addr).await?;
        
        // 如果是quit命令则退出
        if msg == "quit" {
            println!("Sending quit command to server...");
            break;
        }
        
        // 接收响应
        let mut buf = [0; 1024];
        let (len, _) = socket.recv_from(&mut buf).await?;
        let response = String::from_utf8_lossy(&buf[..len]);
        println!("Received echo: {}", response);
        
        // 短暂延迟
        time::sleep(time::Duration::from_millis(500)).await;
    }
    
    Ok(())
}

运行说明

1. 首先启动TCP或UDP服务器
2. 然后运行对应的客户端
3. 服务器会打印接收到的消息并回显给客户端
4. 客户端发送"quit"命令可以关闭连接或服务器

这些示例展示了deno_net的基本用法，包括TCP/UDP通信、异步I/O操作和错误处理。你可以根据实际需求修改和扩展这些代码。