基于 Rust 标准库 API 使用 200 行代码实现 Http 1.1 协议简易服务-编程知识

1. 背景

早在之前学过一波 Rust，但是由于没用武之地，没过多久又荒废了，最近想捡起来下。刚好看见有群里小伙伴说学习 Http 网络协议太难怎么办？其实很多技术都是相通的，只要你理解了技术的本质就可以自己实现它，这里就基于 Rust 用 200+ 代码通过 TCP API 实现了一个 Http 1.1 协议的雏形（全程减少使用 unwrap 等非最佳实践写法），够初学 Http 协议的小伙伴用来借鉴思路完善自己的协议学习了。

Http 1.1 协议属于应用层协议，构建于 TCP/IP 协议之上，处于 TCP/IP 协议架构层的顶端，所以，它不用处理下层协议间诸如丢包补发、握手及数据的分段及重新组装等繁琐的细节，使开发人员可以专注于应用业务。但这也是他的缺陷，具体为什么说是缺陷，建议继续看看 Http2 和 Http3 协议的演进和解决的问题就知道了。

下面是 Http 1.1 协议报文的示意图（网络配图）：
在这里插入图片描述
对应一次请求的报文典型如下：

yan% curl http://www.yan.com/ -v
*   Trying 120.232.145.144:80...
* Connected to www.baidu.com (120.232.145.144) port 80
> GET / HTTP/1.1
> Host: www.baidu.com
> User-Agent: curl/8.4.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Accept-Ranges: bytes
< Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform
< Connection: keep-alive
< Content-Length: 2381
< Content-Type: text/html
< Date: Fri, 05 Apr 2024 01:25:41 GMT
< Etag: "588604eb-94d"
< Last-Modified: Mon, 23 Jan 2017 13:28:11 GMT
< Pragma: no-cache
< Server: bfe/1.0.8.18
< Set-Cookie: BDORZ=27315; max-age=86400; domain=.baidu.com; path=/
<
加微信：bitdev
* Connection #0 to host www.baidu.com left intact

具体 Http 1.1 协议的细节可以参考官方协议规范指导，比较简单，这里主要是基于 Rust 实现而已。

2. 目标

源码位于 https://github.com/yanbober/study-http-server-rust.git。
我们要实现的是这个完整流程，如下：
在这里插入图片描述

代码量很少且非常适合 Rust 语言学习时用来实践，尽量不实用三方库，项目工程采用最佳实践组织，代码结构如下：

| - study-http-server-rust 工程目录
|   | - http_server 抽象服务 crate
|   |   | - src/lib.rs  模块对外 API
|   |   | - src/server.rs  HTTP 1.1 服务管理
|   |   | - src/server/protocol.rs 基于 TCP 的 HTTP 1.1 协议实现
|   | - demo-app 业务模拟 crate
|   |   | - src/main.rs 模拟服务承载的业务路由实现

期望实现后使用方法：

2.1 HTTP 1.1 服务端启动

github 拉取代码
根目录运行cargo run或cargo run --release
控制台看见Http Server Started at 127.0.0.1:4221日志表示服务启动成功

2.2 客户端访问服务端基于此服务实现的业务

说明：你可以使用浏览器或 Postman 等工具，这里推荐使用 curl 命令行工具进行调试。

# 场景1：GET/POST 请求根服务进入欢迎词
curl http://127.0.0.1:4221 -v# 场景2：GET/POST 请求 /user-agent 返回客户端的 User-Agent 信息
curl http://127.0.0.1:4221/user-agent -v# 场景3：GET/POST 请求 /echo/YOU_DEFINED 返回请求链接的 YOU_DEFINED
curl http://127.0.0.1:4221/echo/bitdev -v# 场景4：GET 请求 /files/readme.txt 返回服务端静态资源 readme.txt 内容
curl http://127.0.0.1:4221/files/readme.txt -v# 场景5：POST 请求 /files/upload.txt 将 POST Boday 内容写入到服务端静态资源 /files/upload.txt 里面
curl http://127.0.0.1:4221/files/aaa -v -d dsfsfsfsgsg

3 基于 Rust 实现

3.1 报文协议实现（protocol.rs）

为实现报文协议，我们需要先拆解构思结构，所以大致分为如下几个部分。

3.1.1 通用行为定义

这里我们定义 HttpMethod 和 ContentType，便于后面进行类型转换枚举，如下：

//我们只实现 GET/POST，其他的感兴趣自己补充
pub enum HttpMethod {GET,POST
}//&str 和 HttpMethod 相互转换实现
impl From<&str> for HttpMethod {fn from(value: &str) -> Self {match value.to_uppercase().as_str() {"GET" => HttpMethod::GET,"POST" => HttpMethod::POST,_ => {eprintln!("HttpMethod {} not support, please impl it, default to GET.", value);HttpMethod::GET}}}
}// 只实现了三个常见的 ContentType，其他自己感兴趣补充
pub enum ContentType {Plain,Json,OctetStream,
}//String 和 ContentType 相互转换实现
impl From<String> for ContentType {fn from(value: String) -> Self {match value.to_uppercase().as_str() {"text/plain" => ContentType::Plain,"text/json" => ContentType::Json,"application/octet-stream" => ContentType::OctetStream,_ => {eprintln!("ContentType {} not support, default to text/plain.", value);ContentType::Plain}}}
}

3.1.2 http request 报文处理

如背景部分介绍，我们需要对 Http 1.1 协议按照报文格式定义结构，以便将 TCP 传输的报文转换为 Http 1.1 格式协议，大致如下（最核心的关键就是 try_from 方法将报文协议规范化）：

// HTTP/1.1 请求协议实现
pub struct HttpRequest {pub method: HttpMethod,pub path: String,pub headers: HashMap<String, String>,pub body: String,
}//最核心的关键
impl TryFrom<String> for HttpRequest {type Error = HttpError;fn try_from(request: String) -> Result<Self, Self::Error> {//按照背景介绍中的协议规则，对上下两大块进行切分，即 head、bodylet parts: Vec<&str> = request.split("\r\n\r\n").collect();if parts.len() < 2 {return Err(HttpError::InvalidFormat(request));}let head_parts = parts[0];let body_parts = parts[1];//对 head 部分按照行切分，然后行里面再处理分段协议let head_lines: Vec<&str> = head_parts.split("\r\n").collect();let request_tokens: Vec<&str> = head_lines.first().unwrap_or(&"").split(" ").collect();let mut headers_map: HashMap<String, String> = HashMap::new();for kv_line in head_lines.iter().skip(1) {if let Some((k, v)) = kv_line.split_once(":") {headers_map.insert(k.trim().to_string(), v.trim().to_string());}}//协议解析后组装成 HttpRequest 结构即可Ok(HttpRequest {method: HttpMethod::from(request_tokens[0]),path: request_tokens[1].to_string(),headers: headers_map,body: body_parts.to_string(),})}
}

到此客户端的请求上来后我们就从 TCP 报文变为了 HttpRequest 结构。

3.1.3 http response 报文处理

类似 request 报文处理的思路，我们对 response 实现如下：

// HTTP/1.1 响应协议实现
pub struct HttpResponse {pub status: u16,pub content: String,pub content_type: ContentType,pub content_length: usize,
}impl HttpResponse {pub fn new(status: u16, content: &str, content_type: ContentType) -> Self {HttpResponse { status, content: content.to_string(), content_type, content_length: content.len() }}//将HttpResponse转为TCP报文后通过TcpStream返回客户端pub fn response(res: HttpResponse, stream: &mut TcpStream) -> Result<String, HttpError> {let mut str_buf = String::new();str_buf.push_str("HTTP/1.1 ");match res.status {200 => str_buf.push_str("200 OK\r\n"),201 => str_buf.push_str("201 OK\r\n"),404 => str_buf.push_str("404 Not Found\r\n"),_ => return Err(HttpError::UnsupportStatus(res.status.to_string())),}match res.content_type {ContentType::Plain => str_buf.push_str("Content-Type: text/plain\r\n"),ContentType::Json => str_buf.push_str("Content-Type: text/json\r\n"),ContentType::OctetStream => {str_buf.push_str("Content-Type: application/octet-stream\r\n")}}str_buf.push_str(format!("Content-Length: {}\r\n\r\n", res.content_length).as_str());str_buf.push_str(&res.content);stream.write_all(str_buf.as_bytes())?;Ok(str_buf)}
}

到此 Http1.1 协议的收发报文处理雏形就 OK 实现了。

3.2 基于上面封装协议的 HttpServer 实现（server.rs）

这里我们采用模拟一个简单的 server 路由框架，具体通过回调函数实现。

//定义给业务实现的回调函数类型，以便业务能基于 Http 协议处理自己的路由业务实现
pub type HandleHttp = fn(&HttpRequest) -> Result<HttpResponse, HttpError>;// 启动 Http 服务，基于 TCP 实现
pub fn start_http_server(address: &str, port: u16, handle_http: HandleHttp) {//TCP bind，请求后不终止链接，也就是“多路复用”socket，实际标准协议这里很复杂let listener = TcpListener::bind(format!("{}:{}", address, port));match listener {Ok(listener) => {println!("Http Server Started at {}:{}", address, port);for stream in listener.incoming() {match stream {Ok(mut stream) => {let handle_http = handle_http.clone();// 多线程并发处理，可以同时处理多个 http 请求let _ = thread::spawn(move || {//处理一个业务http请求handle_stream_connect_default(&mut stream, handle_http);});}Err(e) => {eprintln!("Accept new connection error:{}", e);}}}}Err(e) => {eprintln!("Start Http Server Error:{}", e);}}
}// 处理一个 http 连接请求，兜底容错处理
fn handle_stream_connect_default(tcp_stream: &mut TcpStream, handle_http: HandleHttp) {let result = handle_stream_connect(tcp_stream, handle_http);if result.is_err() {eprintln!("handle_stream_connect error:{}", result.err().unwrap());}
}// 处理一个 http 连接请求
fn handle_stream_connect(tcp_stream: &mut TcpStream,handle_http: HandleHttp
) -> Result<(), HttpError> {println!("Accepted a new connection from {}.",tcp_stream.peer_addr()?);// 读取整个 http 请求内容放入 buflet mut buf = [0; 1024];tcp_stream.read(&mut buf)?;let null_index = buf.iter().position(|&c| c == b'\0').unwrap_or(buf.len());let raw_string: String = String::from_utf8(buf[0..null_index].to_vec())?;// 把整个用户请求体按照 http 协议约定解析成 HttpRequest 对象let request = HttpRequest::try_from(raw_string)?;//Http Server 对外给用户自定义的路由实现层let response = handle_http(&request)?;// 把 HttpResponse 对象按照 http 协议约定包装成返回信息返回HttpResponse::response(response, tcp_stream)?;Ok(())
}

可以看到，上面最核心的是 handle_stream_connect 方法中调用了 handle_http 回调函数，入参是 HttpRequest，返回是 HttpResponse，一入一出后通过 HttpResponse::response 发了出去请求。

至此服务雏形已经有了，我们对外暴漏下 API，如下（lib.rs）：

pub mod server;
pub use server::protocol::{HttpError, HttpRequest, HttpResponse};pub fn start(address: &str, port: u16, handle_http: server::HandleHttp) {server::start_http_server(address, port, handle_http);
}

业务方就可以 Happy 的使用我们的 HttpServer 了。

3.3 业务使用 HttpServer 实现自己的路由业务（main.rs）

这里就像我们引入一个其他 HttpServer 一样，start 服务后实现自己的业务分发即可，如下样例：

fn main() {//启动服务，传入回调函数进行业务处理http_server::start("127.0.0.1", 4221, router_to_handle_request);
}// 模拟基于 http server 的业务路由处理实现
fn router_to_handle_request(request: &HttpRequest) -> Result<HttpResponse, HttpError> {//如果请求是 http://127.0.0.1:4221/files/xxxx 则进入此路由if request.path.starts_with("/files/") {let file_name = request.path.strip_prefix("/files/").unwrap_or_default();let static_res_dir = "./static_res_dir";let file_path = Path::new(static_res_dir).join(file_name);match request.method {HttpMethod::GET => {//如果是 get 请求则返回服务器静态资源目录下 http://127.0.0.1:4221/files/xxxx 中 xxxx 名的文件内容if !Path::new(static_res_dir).exists() {return Ok(HttpResponse::new(404, "dir not found", ContentType::Json));}if !file_path.exists() {return Ok(HttpResponse::new(404, "not found", ContentType::Json));} else {let file = std::fs::File::open(file_path);match file {Ok(mut file) => {let mut content = String::new();file.read_to_string(&mut content)?;return Ok(HttpResponse::new(200, content.as_str(), ContentType::OctetStream));}Err(_) => {return Ok(HttpResponse::new(404, "not found", ContentType::Json));}}}}HttpMethod::POST => {//如果是 POST 请求则向服务器静态资源目录下创建写入 http://127.0.0.1:4221/files/xxxx 中 xxxx 文件let mut f = std::fs::File::create(file_path)?;f.write_all(request.body.as_bytes())?;return Ok(HttpResponse::new(201, "created", ContentType::Plain));}}} else if request.path.starts_with("/echo/") {//如果请求是 http://127.0.0.1:4221/echo/aaaa 则返回 aaaalet end_str = request.path.strip_prefix("/echo/").unwrap_or_default();return Ok(HttpResponse::new(200, end_str, ContentType::Json));} else if request.path == "/" {return Ok(HttpResponse::new(200, "加微信：bitdev 进行交流.", ContentType::Plain));} else if request.path == "/user-agent" {let default = &"unknown".to_string();let ua: &str = request.headers.get("User-Agent").unwrap_or(default);return Ok(HttpResponse::new(200, ua, ContentType::Json));}return Ok(HttpResponse::new(404, "unsupport", ContentType::Json));
}