Rust / 系统课时

实现请求解析与响应写回

实现请求解析与响应写回

本节把一个已建立的 TCP 连接变成可持续工作的请求循环:按行读取命令、解析协议、异步写回响应,并明确区分正常关闭、EOF 与协议错误。完成后,你会得到一个最小但可运行的 Tokio 文本协议服务。

学习目标

  • 使用 BufReader 与异步写接口在单个连接中循环处理多条消息。
  • 将字节读取、命令解析和响应写回分开,避免协议错误直接拖垮连接任务。
  • 正确处理 EOF、QUIT 主动关闭和非法命令三种结束或异常路径。

定义最小行协议

示例协议以换行符作为消息边界,只支持 PING、ECHO <text> 与 QUIT。服务端对未知命令返回 ERR,但继续读取下一条消息;收到 QUIT 时回复 BYE 并主动关闭连接;若客户端直接断开,读取操作会返回 0 字节,这就是 EOF。

连接任务中的读取、解析与写回流程

实现连接处理循环

项目只需要 Tokio。Cargo.toml 中启用 full 特性,保证网络、异步 I/O、宏和运行时都可用。

toml
[package]
name = "tokio-line-server"
version = "0.1.0"
edition = "2021"

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

src/main.rs 将解析逻辑保持为同步纯函数,把网络 I/O 留在连接任务中。每次循环先清空复用的 String 缓冲区,再调用 read_line;这样一条连接可以顺序处理任意多条命令。

rust
use std::io;
use tokio::{
    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
    net::{TcpListener, TcpStream},
};

enum Command {
    Ping,
    Echo(String),
    Quit,
}

fn parse_command(line: &str) -> Result<Command, &'static str> {
    match line {
        "PING" => Ok(Command::Ping),
        "QUIT" => Ok(Command::Quit),
        _ => {
            if let Some(text) = line.strip_prefix("ECHO ") {
                if text.is_empty() {
                    Err("ECHO requires text")
                } else {
                    Ok(Command::Echo(text.to_owned()))
                }
            } else {
                Err("unknown command")
            }
        }
    }
}

async fn handle_connection(stream: TcpStream) -> io::Result<()> {
    let peer = stream.peer_addr()?;
    let (reader, mut writer) = stream.into_split();
    let mut reader = BufReader::new(reader);
    let mut line = String::new();

    loop {
        line.clear();
        let bytes = reader.read_line(&mut line).await?;

        // 0 字节表示对端已经关闭写方向,不能再等待下一条请求。
        if bytes == 0 {
            println!("{peer} EOF");
            return Ok(());
        }

        let input = line.trim_end_matches(&['\r', '\n'][..]);
        match parse_command(input) {
            Ok(Command::Ping) => writer.write_all(b"PONG\n").await?,
            Ok(Command::Echo(text)) => {
                writer.write_all(text.as_bytes()).await?;
                writer.write_all(b"\n").await?;
            }
            Ok(Command::Quit) => {
                writer.write_all(b"BYE\n").await?;
                writer.shutdown().await?;
                return Ok(());
            }
            Err(message) => {
                // 协议错误属于当前消息的问题,回复错误后继续服务此连接。
                let response = format!("ERR {message}\n");
                writer.write_all(response.as_bytes()).await?;
            }
        }
    }
}

#[tokio::main]
async fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7000").await?;
    println!("listening on 127.0.0.1:7000");

    loop {
        let (stream, _) = listener.accept().await?;
        tokio::spawn(async move {
            if let Err(error) = handle_connection(stream).await {
                eprintln!("connection error: {error}");
            }
        });
    }
}

启动服务:

bash
cargo run

预期输出(忽略 Cargo 自身可能出现的编译日志):

text
listening on 127.0.0.1:7000

验证多请求与协议错误

另开终端,用一条连接连续发送四条命令。BOGUS 会产生协议错误,但后面的 QUIT 仍能被处理,这能验证错误分支没有提前结束连接。

bash
printf 'PING\nECHO hello tokio\nBOGUS\nQUIT\n' | nc 127.0.0.1 7000

预期输出:

text
PONG
hello tokio
ERR unknown command
BYE

若客户端不发送 QUIT 而直接关闭连接,下一次 read_line 会返回 0,服务端打印 <IP>:<PORT> EOF 后结束该连接任务;实际 IP 和端口会因客户端环境不同而变化。

把错误边界放在正确层级

网络 I/O 错误通过 io::Result 返回,连接任务结束即可,不应让整个监听循环退出。协议错误则只影响当前消息,通常应返回结构化错误并继续读取;只有违反了无法恢复的帧边界或安全约束时,才需要主动关闭连接。

行协议的关键是让“读取边界、解析规则、连接生命周期”彼此独立:EOF 是传输层结束,非法命令是协议层错误,QUIT 是应用层主动关闭。分清这三类路径后,后续加入超时、长度限制或更复杂命令时也更容易保持行为可预测。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现请求解析与响应写回

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通