Rust在Linux上如何进行网络编程

在Linux上搞Rust网络编程，其实比很多人想象的要直接。Rust的标准库里自带了一个叫std::net的模块，里面封装了处理网络连接的基本类型和trait。换句话说，你不需要一上来就折腾第三方库，标准库就能让你跑通一个完整的TCP服务端和客户端。

先说说环境准备。如果你机器上还没装Rust，一条命令就能搞定：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

装完之后检查一下PATH，确保cargo和rustc能用就行。

接下来创建一个新项目，名字随便起，比如rust_networking：

cargo new rust_networking
cd rust_networking

然后就是核心部分——写一个TCP服务器。打开src/main.rs，把下面这段代码贴进去：

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 512];
    match stream.read(&mut buffer) {
        Ok(bytes_read) => {
            if bytes_read == 0 {
                return;
            }
            stream.write_all(&buffer[..bytes_read]).unwrap();
        }
        Err(error) => {
            eprintln!("Error reading from socket: {:?}", error);
        }
    }
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                handle_client(stream);
            }
            Err(error) => {
                eprintln!("Error: {}", error);
            }
        }
    }
    Ok(())
}

这段代码干的事很直接：监听本地的7878端口，收到客户端连接后，读取最多512字节的数据，然后原封不动地写回去——也就是一个回显服务器。

客户端代码更简单，同样写在src/main.rs里（你可以把服务端和客户端分开两个文件，不过这里为了演示方便，先放在一起）：

use std::io::{Read, Write};
use std::net::TcpStream;

fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:7878")?;
    let message = "Hello, world!";
    stream.write_all(message.as_bytes())?;
    let mut buffer = [0; 512];
    let bytes_read = stream.read(&mut buffer)?;
    println!("Received: {}", String::from_utf8_lossy(&buffer[..bytes_read]));
    Ok(())
}

注意：服务端和客户端不能同时跑同一个文件，因为main函数只能有一个。实际操作时，要么把客户端代码单独放到examples/client.rs，要么用cargo run --bin指定二进制目标。更省事的办法是开两个终端，一个先跑服务器：

cargo run

另一个终端跑客户端（同样cargo run，但你需要确保客户端代码是当前项目的入口）。如果一切顺利，客户端会打印出服务器回显的“Hello, world!”。

这个例子虽然简单，但它暴露了真实网络编程中绕不开的两个问题：错误处理和并发。上面的代码里，客户端连接只处理一次就结束了，而且没有任何并发机制——如果同时有多个客户端连上来，后面的请求得排队等前面的处理完。实际生产环境里，你至少需要做到：

• 对每个连接分配一个线程（std::thread::spawn），或者使用异步模型。
• 更细致的错误处理，比如连接中断、超时、缓冲区溢出等。
• 日志记录和配置管理，这些在小型demo里可以忽略，但线上项目一个都不能少。

说到异步，Rust生态里最常用的方案是tokio，其次是async-std和底层的mio。这些库提供了事件驱动、非阻塞I/O，能让你用少量的线程处理成千上万的并发连接。当然，标准库的std::net已经足够让你理解TCP/IP的基本交互，但真要写高并发服务，还是得拥抱异步运行时。

最后提一句安全层面：如果你的服务需要暴露在公网上，TLS/SSL是必须的。Rust这边有rustls和native-tls两个主流选择，前者纯Rust实现，后者绑定OpenSSL。具体选哪个，取决于你的部署环境和安全策略。