使用 Rust 和 Tokio 构建 TCP 服务器示例

Tokio 是一个用于构建异步应用程序的 Rust 框架，其核心特点是使用了基于事件循环的模型，可以实现高效的异步 IO 操作。在本文中，我们将通过一个示例程序来了解如何使用 Tokio 来构建一个基本的 TCP 服务器。

引入完整的 Tokio 功能集，将 tokio 的版本声明为 1.26.0 并指定 features = ["full"]，如下所示：

[dependencies]
tokio = { version = "1.26.0", features = ["full"] }

这将确保所有 Tokio 的功能都可用，包括网络和 I/O 相关的模块。接下来我们看一下示例代码：

use tokio::net::{TcpListener,TcpStream} ;
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!("Server listening on port 8080");

    loop {
        let (mut socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            let mut buffer = [0; 1024];

            loop {
                let n = match socket.read(&mut buffer).await {
                    Ok(n) if n == 0 => break,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("failed to read from socket; err = {:?}", e);
                        break;
                    }
                };

                if let Err(e) = socket.write_all(&buffer[0..n]).await {
                    eprintln!("failed to write to socket; err = {:?}", e);
                    break;
                }
            }

            println!("Connection closed");
        });
    }
    Ok(())
}

这段代码是一个使用Tokio实现的TCP服务器，它会监听在本地的8080端口，并接受来自客户端的连接请求。一旦连接建立，服务器将为每个客户端连接生成一个新的任务，并在任务中处理客户端发送的数据。

首先，我们使用 tokio::net::TcpListener 绑定本地地址和端口，开始监听传入连接。然后，我们使用 loop 循环来等待客户端连接，每当有新的连接进入时，使用 listener.accept().await 方法接收连接，并返回一个包含新建立连接的 TcpStream 对象和远程连接的地址的元组。

接下来，我们使用 tokio::spawn() 方法创建一个新的异步任务，每个新的连接都将创建一个任务，以避免阻塞主循环。在异步任务中，我们使用 tokio::io::AsyncReadExt 和 tokio::io::AsyncWriteExt trait 来实现异步读取和写入数据。我们使用一个循环来持续从客户端读取数据，并将读取的数据写回客户端。如果读取到的字节数为 0，则表示客户端已经关闭连接，退出循环。

最后，我们在异步任务完成后打印一条消息并返回 Ok(())。

下面是对代码的分析：

引入了 tokio 库的 net 和 io 模块：

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

定义了一个 async 函数 main，它是程序的入口函数。由于 main 函数是异步函数，因此在函数签名中加上了 async 关键字，并使用 tokio::main 宏来启动 tokio 运行时。

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // ...
}

调用 TcpListener::bind 方法创建一个 TcpListener 实例，并将其绑定到本地的 8080 端口上。

let listener = TcpListener::bind("127.0.0.1:8080").await?;

在控制台输出信息，表示服务器已经开始监听连接请求。

println!("Server listening on port 8080");

进入一个无限循环，等待客户端连接请求。当有新的连接请求到来时，调用 listener.accept() 方法，该方法会返回一个包含新连接的 TcpStream 实例以及一个表示远程地址的元组（由于我们不需要远程地址，因此用 _ 占位符来表示）。

loop {
    let (mut socket, _) = listener.accept().await?;
    // ...
}

为每个新连接创建一个新的任务。tokio::spawn 方法接受一个 Future 对象，并在一个新的任务中异步执行该 Future。在这里，我们将一个闭包作为 Future 对象，并将它传递给 tokio::spawn 方法。

tokio::spawn(async move {
    // ...
});

在任务中定义一个可变的 buffer 数组，用于存储从客户端读取的数据。

let mut buffer = [0; 1024];

进入一个无限循环，不断从客户端读取数据，直到客户端关闭连接。在循环中，使用 socket.read() 方法异步读取数据，并使用 match 匹配读取结果。如果读取成功并且读取的字节数为 0，则表示客户端已经关闭连接，跳出循环。如果读取成功并且读取的字节数不为 0，则将读取到的数据写回客户端，使用 socket.write_all() 方法将数据异步写回。

 loop {
   let n = match socket.read(&mut buffer).await {
     Ok(n) if n == 0 => break,
       Ok(n) => n,
         Err(e) => {
         eprintln!("failed to read from socket; err = {:?}", e);
         break;
       }
   };

   if let Err(e) = socket.write_all(&buffer[0..n]).await {
     eprintln!("failed to write to socket; err = {:?}", e);
     break;
   }
 }

要运行该示例程序，我们需要在控制台中执行以下命令：

 cargo run

该程序将会开始监听本地的 8080 端口，当有客户端连接时，会返回 "Server listening on port 8080" 消息。当客户端发送数据时，程序将会将接收到的数据返回给客户端，直到客户端关闭连接。

在本文中，我们了解了如何使用 Tokio 来构建一个基本的 TCP 服务器。通过使用 Tokio 提供的异步 IO 操作，我们可以实现高效的网络应用程序。