Rust / 系统课时
实现请求解析与响应写回
实现请求解析与响应写回
本节把一个已建立的 TCP 连接变成可持续工作的请求循环:按行读取命令、解析协议、异步写回响应,并明确区分正常关闭、EOF 与协议错误。完成后,你会得到一个最小但可运行的 Tokio 文本协议服务。
学习目标
- 使用
BufReader与异步写接口在单个连接中循环处理多条消息。 - 将字节读取、命令解析和响应写回分开,避免协议错误直接拖垮连接任务。
- 正确处理 EOF、
QUIT主动关闭和非法命令三种结束或异常路径。
定义最小行协议
示例协议以换行符作为消息边界,只支持 PING、ECHO <text> 与 QUIT。服务端对未知命令返回 ERR,但继续读取下一条消息;收到 QUIT 时回复 BYE 并主动关闭连接;若客户端直接断开,读取操作会返回 0 字节,这就是 EOF。

实现连接处理循环
项目只需要 Tokio。Cargo.toml 中启用 full 特性,保证网络、异步 I/O、宏和运行时都可用。
[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;这样一条连接可以顺序处理任意多条命令。
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}");
}
});
}
}启动服务:
cargo run预期输出(忽略 Cargo 自身可能出现的编译日志):
listening on 127.0.0.1:7000验证多请求与协议错误
另开终端,用一条连接连续发送四条命令。BOGUS 会产生协议错误,但后面的 QUIT 仍能被处理,这能验证错误分支没有提前结束连接。
printf 'PING\nECHO hello tokio\nBOGUS\nQUIT\n' | nc 127.0.0.1 7000预期输出:
PONG
hello tokio
ERR unknown command
BYE若客户端不发送 QUIT 而直接关闭连接,下一次 read_line 会返回 0,服务端打印 <IP>:<PORT> EOF 后结束该连接任务;实际 IP 和端口会因客户端环境不同而变化。
把错误边界放在正确层级
网络 I/O 错误通过 io::Result 返回,连接任务结束即可,不应让整个监听循环退出。协议错误则只影响当前消息,通常应返回结构化错误并继续读取;只有违反了无法恢复的帧边界或安全约束时,才需要主动关闭连接。
行协议的关键是让“读取边界、解析规则、连接生命周期”彼此独立:EOF 是传输层结束,非法命令是协议层错误,QUIT 是应用层主动关闭。分清这三类路径后,后续加入超时、长度限制或更复杂命令时也更容易保持行为可预测。