Blog by AlanKSorata

（个人向）如何以Rust的眼光重学C++

Sat, 04 Apr 2026 08:23:52 +0000

## 一直以来 > 一直以来，我陷入了一段离奇魔幻的经历，因为不堪C++那庞大的知识体系，当然不乏来自各个平台上声声相传的消极评价，让我对C++生不起一丝好学的情绪。

Rust Web（三）—— 通过sqlx连接数据库(MySQL)

Mon, 30 Mar 2026 03:16:21 +0000

在学习了前辈所演示的 PostgreSQL连接方式后所进行的尝试；

通过这次尝试也能够进一步学习连接MySQL的其中一种方式；

除本文所使用的sqlx连接方法外，还有其他的方式，诸如diesel，以后有机会在进行实践；

Rust Web （三）—— 通过sqlx连接数据库(MySQL)

一、环境准备

项目创建

在自己选择的目录下，创建一个(子)项目，此处命名为 db；

在新建项目的 Cargo.toml 文件内，添加所需要的依赖，具体如下：

```toml [package] name = 'db' version = '0.1.0' edition = '2021' [dependencies] actix-rt='2.7.0' actix-web='4.1.0' dotenv = '0.15.0' chrono = {version = '0.4.19', features = ['serde']} serde = {version = '1.0.140', features = ['derive']} sqlx = {version = '0.6.0', default_features = false, features = [ 'mysql', 'runtime-tokio-rustls', 'macros', 'chrono', ]} ```

注意:

在添加 crate 时，注意使用版本要相互兼容，否则会出现编译警告：

The following warnings were discovered during the build. These warnings are an indication that the packages contain code that will become an error in a future release of Rust. These warnings typically cover changes to close soundness problems, unintended or undocumented behavior, or critical problems that cannot be fixed in a backwards-compatible fashion, and are not expected to be in wide use.

Each warning should contain a link for more information on what the warning means and how to resolve it.

To solve this problem, you can try the following approaches:

Some affected dependencies have newer versions available. You may want to consider updating them to a newer version to see if the issue has been fixed.

winapi v0.2.8 has the following newer versions available: 0.3.0, 0.3.1, 0.3.2, 0.3.3, 0.3.4, 0.3.5, 0.3.6, 0.3.7, 0.3.8, 0.3.9

If the issue is not solved by updating the dependencies, a fix has to be implemented by those dependencies. You can help with that by notifying the maintainers of this problem (e.g. by creating a bug report) or by proposing a fix to the maintainers (e.g. by creating a pull request):

winapi@0.2.8

Repository: GitHub - retep998/winapi-rs: Rust bindings to Windows API

Detailed warning command: cargo report future-incompatibilities --id 1 --package winapi@0.2.8

If waiting for an upstream fix is not an option, you can use the [patch] section in Cargo.toml to use your own version of the dependency. For more information, see: Overriding Dependencies - The Cargo Book

具体需要访问crates.io 来查看合适的版本；

而在版本兼容的的情况下，呈现的是以下结果：

连接请求

在根项目的目录下，新建名为 .env 的文件，在文件内写入请求 URL;

由于笔者所创建的项目是一个子项目，因此其位置位于所在根项目的目录之下；

```bash DATABASE_URL=mysql://{user}:{password}@{IP}:{port}/{database name} ```

二、数据库准备

笔者在此处选择的是过去在名为 test的数据库中的 tt1表；

内容如下：

三、功能实现

说明

首先简要说明一下本文所涉及 MySQL连接调用的 API

MySqlPoolOptions

new()

参考文档

sqlx::mysql - RustMySQL database driver.

代码实现

```rust // extern crate chrono; extern crate dotenv; extern crate sqlx; // use chrono::NaiveDateTime; use dotenv::dotenv; use sqlx::mysql::MySqlPoolOptions; use std::env; use std::io; #[derive(Debug)] pub struct Info { pub ind: i32, // 数据库中将此字段设置为了主键 pub email: Option, // 使用Option来处理潜在的空值情况 pub uid: Option, pub reg_time: Option, } #[actix_rt::main] async fn main() -> io::Result<()> { dotenv().ok(); // 检测并读取.env文件中的内容，若不存在也会跳过异常 let database_url = env::var('DATABASE_URL') .expect('Not configured in .env'); let db_pool = MySqlPoolOptions::new() .connect(&database_url) .await .unwrap(); let tt1_rows = sqlx::query!( r#'select ind,email,uid,regtime from tt1 where ind = ?'#, 6 ) .fetch_all(&db_pool) .await .unwrap(); let mut tt1_list = vec![]; for row in tt1_rows { tt1_list.push(Info { ind: row.ind.unwrap(), email: row.email, uid: row.uid, reg_time: row.regtime, }) } println!('Info = {:?}', tt1_list); Ok(()) } ```

运行效果

每一个不曾起舞的日子，都是对生命的辜负。

Rust Web（二）—— 自建HTTP Server

Mon, 30 Mar 2026 03:05:20 +0000

对于Rust基础以及HTTP原理，需要读者有所认识；
本文的设计思路也可以自行设计扩展进而发展成更完整的方案；

Rust Web （二）—— 自建HTTP Server

一、项目创建

在自定的目录下，创建两个子项目目录

httpserver

http

http 为·lib 库，故命令中添加 --lib

在根项目的 Cargo.toml文件中添加这两个子项目

进入 http 子项目，在 src/lib.rs 内写入公共模块 pub mod httprequest;

在同级 src 目录下新建：

httprequest.rs

httpresponse.rs

二、解析HTTP请求

在 httprequest.rs 中，先尝试实现枚举 Method，并进行一次测试

```rust #[derive(Debug, PartialEq)] pub enum Method { Get, Post, Uninitialized, } impl From<&str> for Method { fn from(s: &str) -> Method { match s { 'GET' => Method::Get, 'POST' => Method::Post, _ => Method::Uninitialized, } } } #[cfg(test)] mod tests { use super::*; #[test] fn test_method_into() { let m: Method = 'GET'.into(); assert_eq!(m, Method::Get); } } ```

测试示例

全部实现

依照HTTP协议原理以及Rust本身的特性，先实现 http 库内的内容；

httprequest.rs
```rust use std::collections::HashMap; #[derive(Debug, PartialEq)] pub enum Method { Get, Post, Uninitialized, } impl From<&str> for Method { fn from(s: &str) -> Method { match s { 'GET' => Method::Get, 'POST' => Method::Post, _ => Method::Uninitialized, } } } #[derive(Debug, PartialEq)] pub enum Version { V11, V20, Uninitialized, } impl From<&str> for Version { fn from(s: &str) -> Version { match s { 'HTTP/1.1' => Version::V11, 'HTTP/2.0' => Version::V20, _ => Version::Uninitialized, } } } #[derive(Debug, PartialEq)] pub enum Resource { Path(String), } #[derive(Debug)] pub struct HttpRequest { pub method: Method, pub version: Version, pub resource: Resource, pub headers: HashMap, pub msg_body: String, } impl From for HttpRequest { fn from(req: String) -> Self { let mut parsed_method = Method::Uninitialized; let mut parsed_version = Version::V11; let mut parsed_resource = Resource::Path(''.to_string()); let mut parsed_headers = HashMap::new(); let mut parsed_msg_body = ''; for line in req.lines() { if line.contains('HTTP') { let (method, resource, version) = process_req_line(line); parsed_method = method; parsed_resource = resource; parsed_version = version; } else if line.contains(':') { let (key, value) = process_header_line(line); parsed_headers.insert(key, value); } else if line.len() == 0 { // No operation } else { parsed_msg_body = line; } } HttpRequest { method: parsed_method, resource: parsed_resource, version: parsed_version, headers: parsed_headers, msg_body: parsed_msg_body.to_string(), } } } fn process_req_line(s: &str) -> (Method, Resource, Version) { let mut words = s.split_whitespace(); let method = words.next().unwrap(); let resource = words.next().unwrap(); let version = words.next().unwrap(); ( method.into(), Resource::Path(resource.to_string()), version.into() ) } fn process_header_line(s: &str) -> (String, String) { let mut header_items = s.split(':'); let mut key = String::from(''); let mut value = String::from(''); if let Some(k) = header_items.next() { key = k.to_string(); } if let Some(v) = header_items.next() { value = v.to_string(); } (key, value) } #[cfg(test)] mod tests { use super::*; #[test] fn test_method_into() { let m: Method = 'GET'.into(); assert_eq!(m, Method::Get); } #[test] fn test_version_into() { let v: Version = 'HTTP/1.1'.into(); assert_eq!(v, Version::V11); } #[test] fn test_read_http() { let s: String = String::from('GET /index HTTP/1.1\r\n\ Host: localhost\r\n\ User-Agent: Curl/7.64.1\r\n\ Accept: */*\r\n\r\n'); let mut headers_expected = HashMap::new(); headers_expected.insert('Host'.into(), ' localhost'.into()); headers_expected.insert('User-Agent'.into(), ' Curl/7.64.1'.into()); headers_expected.insert('Accept'.into(), ' */*'.into()); let req: HttpRequest = s.into(); assert_eq!(Method::Get, req.method); assert_eq!(Resource::Path('/index'.to_string()), req.resource); assert_eq!(Version::V11, req.version); assert_eq!(headers_expected, req.headers); } } ```

测试

测试结果

编写过程中以下问题值得注意

测试请求中的大小写要严格区分；

由于请求头部仅以冒号分割，因此值 value 内的空格不能忽略，或者进行进一步优化；

三、构建 HTTP 响应

以下为自建库的响应构建部分；

httpresponse.rs
```rust use std::collections::HashMap; use std::io::{Result, Write}; // 当涉及到成员变量中有引用类型，就需要引入生命周期 #[derive(Debug, PartialEq, Clone)] pub struct HttpResponse<'a> { version: &'a str, status_code: &'a str, status_text: &'a str, headers: Option>, body: Option, } impl<'a> Default for HttpResponse<'a> { fn default() -> Self { Self { version: 'HTTP/1.1'.into(), status_code: '200'.into(), status_text: 'OK'.into(), headers: None, body: None, } } } impl<'a> From> for String { fn from(res: HttpResponse) -> String { let res1 = res.clone(); format!( '{} {} {}\r\n{}Content-Length: {}\r\n\r\n{}', &res1.version(), &res1.status_code(), &res1.status_text(), &res1.headers(), &res.body.unwrap().len(), &res1.body() // ) } } impl<'a> HttpResponse<'a> { pub fn new( status_code: &'a str, headers: Option>, body: Option ) -> HttpResponse<'a> { let mut response: HttpResponse<'a> = HttpResponse::default(); // mut if status_code != '200' { response.status_code = status_code.into(); }; response.headers = match &headers { Some(_h) => headers, None => { let mut h = HashMap::new(); h.insert('Content-Type', 'text/html'); Some(h) } }; response.status_text = match response.status_code { '200' => 'OK'.into(), '400' => 'Bad Request'.into(), '404' => 'Not Found'.into(), '500' => 'Internal Server Error'.into(), _ => 'Not Found'.into(), // }; response.body = body; response } pub fn send_response(&self, write_stream: &mut impl Write) -> Result<()> { let res = self.clone(); let response_string: String = String::from(res); // from trait let _ = write!(write_stream, '{}', response_string); Ok(()) } fn version(&self) -> &str { self.version } fn status_code(&self) -> &str { self.status_code } fn status_text(&self) -> &str { self.status_text } fn headers(&self) -> String { let map: HashMap<&str, &str> = self.headers.clone().unwrap(); let mut header_string: String = ''.into(); for (k, v) in map.iter() { header_string = format!('{}{}:{}\r\n', header_string, k, v); } header_string } pub fn body(&self) -> &str { match &self.body { Some(b) => b.as_str(), None => '', } } } #[cfg(test)] mod tests { use super::*; #[test] fn test_response_struct_creation_200() { let response_actual = HttpResponse::new( '200', None, Some('nothing for now'.into()), ); let response_expected = HttpResponse { version: 'HTTP/1.1', status_code: '200', status_text: 'OK', headers: { let mut h = HashMap::new(); h.insert('Content-Type', 'text/html'); Some(h) }, body: Some('nothing for now'.into()), }; assert_eq!(response_actual, response_expected); } #[test] fn test_response_struct_creation_404() { let response_actual = HttpResponse::new( '404', None, Some('nothing for now'.into()), ); let response_expected = HttpResponse { version: 'HTTP/1.1', status_code: '404', status_text: 'Not Found', headers: { let mut h = HashMap::new(); h.insert('Content-Type', 'text/html'); Some(h) }, body: Some('nothing for now'.into()), }; assert_eq!(response_actual, response_expected); } #[test] fn test_http_response_creation() { let response_expected = HttpResponse { version: 'HTTP/1.1', status_code: '404', status_text: 'Not Found', headers: { let mut h = HashMap::new(); h.insert('Content-Type', 'text/html'); Some(h) }, body: Some('nothing for now'.into()), }; let http_string: String = response_expected.into(); let actual_string: String = 'HTTP/1.1 404 Not Found\r\n\ Content-Type:text/html\r\n\ Content-Length: 15\r\n\r\n\ nothing for now'.into(); // 此处注意Content-Length值 assert_eq!(http_string, actual_string); } } ```

测试

测试结果

其中需要留意的点位

在实现 String 的 trait 时，不能从 &res1.body 获取长度，以避免内部 body 成员的所有权转移；

测试整个相应，自定义响应实例中的请求体数据长度要保持一致；

四、构建Server模块

模块准备

此时转至 httpserver 子项目内，将前文所涉及的 http 子项目导入 Cargo.toml 文件；

并在 httpserver/src 下再创建三文件

server.rs

router.rs

handler.rs

功能实现

大概的调用逻辑

main - 调用 -> server - 调用 -> router - 调用 -> handler

server.rs
```rust use super::router::Router; use http::httprequest::HttpRequest; use std::io::prelude::*; use std::net::TcpListener; use std::str; pub struct Server<'a> { socket_addr: &'a str, } impl<'a> Server<'a> { pub fn new(socket_addr: &'a str) -> Self { Server {socket_addr} } pub fn run(&self) { let connection_listener = TcpListener::bind(self.socket_addr).unwrap(); println!('Running on {}', self.socket_addr); for stream in connection_listener.incoming() { let mut stream = stream.unwrap(); println!('Connection established'); let mut read_buffer = [0; 200]; stream.read(&mut read_buffer).unwrap(); let req: HttpRequest = String::from_utf8( read_buffer.to_vec()).unwrap().into(); Router::route(req, &mut stream); } } } ```

实现至当前阶段还不能直接运行；

五、构建 Router & Handler 模块

这两个模块联合起来处理接收到的请求，其中

判定请求的合法性，适当返回错误反馈；

解析后台的数据部分，进行相应的序列化和反序列化；

不同的请求状况交由不同类型的句柄 Handler 来处理，同名可重写的方法通过 Trait 来定义；

其中的 handler.rs 需要引入两个crate

serde (本文使用的是1.0.140版本)

serde_json (本文使用的是1.0.82版本)

实现代码

router.rs
```rust use super::handler::{Handler, PageNotFoundHandler, StaticPageHandler, WebServiceHandler}; use http::{httprequest, httprequest::HttpRequest, httpresponse::HttpResponse}; use std::io::prelude::*; pub struct Router; impl Router { pub fn route(req: HttpRequest, stream: &mut impl Write) -> () { match req.method { httprequest::Method::Get => match &req.resource { httprequest::Resource::Path(s) => { let route: Vec<&str> = s.split('/').collect(); match route[1] { 'api' => { let resp: HttpResponse = WebServiceHandler::handle(&req); let _ = resp.send_response(stream); }, _ => { let resp: HttpResponse = StaticPageHandler::handle(&req); let _ = resp.send_response(stream); } } } }, _ => { let resp: HttpResponse = PageNotFoundHandler::handle(&req); let _ = resp.send_response(stream); } } } } ```

handler.rs
```rust use http::{httprequest::HttpRequest, httpresponse::HttpResponse}; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::env; use std::fs; use std::ops::Index; pub trait Handler { fn handle(req: &HttpRequest) -> HttpResponse; fn load_file(file_name: &str) -> Option { let default_path = format!('{}/public', env!('CARGO_MANIFEST_DIR')); let public_path = env::var('PUBLIC_PATH').unwrap_or(default_path); let full_path = format!('{}/{}', public_path, file_name); let contents = fs::read_to_string(full_path); contents.ok() } } pub struct StaticPageHandler; pub struct PageNotFoundHandler; pub struct WebServiceHandler; #[derive(Serialize, Deserialize)] pub struct OrderStatus { order_id: i32, order_date: String, order_status: String, } impl Handler for PageNotFoundHandler { fn handle(_req: &HttpRequest) -> HttpResponse { HttpResponse::new('404', None, Self::load_file('404.html')) } } impl Handler for StaticPageHandler { fn handle(req: &HttpRequest) -> HttpResponse { let http::httprequest::Resource::Path(s) = &req.resource; let route: Vec<&str> = s.split('/').collect(); match route[1] { '' => HttpResponse::new('200', None, Self::load_file('index.html')), 'health' => HttpResponse::new('200', None, Self::load_file('health.html')), path => match Self::load_file(path) { Some(contents) => { let mut map: HashMap<&str, &str> = HashMap::new(); if path.ends_with('.css') { map.insert('Content-Type', 'text/css'); } else if path.ends_with('.js') { map.insert('Content-Type', 'text/javascript'); } else { map.insert('Content-Type', 'text/html'); } HttpResponse::new('200', Some(map), Some(contents)) }, None => HttpResponse::new('404', None, Self::load_file('404.html')) } } } } impl WebServiceHandler { fn load_json() -> Vec { let default_path = format!('{}/data', env!('CARGO_MANIFEST_DIR')); let data_path = env::var('DATA_PATH').unwrap_or(default_path); let full_path = format!('{}/{}', data_path, 'orders.json'); let json_contents = fs::read_to_string(full_path); let orders: Vec = serde_json::from_str(json_contents.unwrap().as_str()).unwrap(); orders } } impl Handler for WebServiceHandler { fn handle(req: &HttpRequest) -> HttpResponse { let http::httprequest::Resource::Path(s) = &req.resource; let route: Vec<&str> = s.split('/').collect(); // localhost:2333/api/air/orders match route[2] { 'air' if route.len() > 2 && route[3] == 'orders' => { let body = Some(serde_json::to_string(&Self::load_json()).unwrap()); let mut headers: HashMap<&str, &str> = HashMap::new(); headers.insert('Content-Type', 'application/json'); HttpResponse::new('200', Some(headers), body) }, _ => HttpResponse::new('404', None, Self::load_file('404.html')) } } } ```

六、完整测试

在 httpserver 项目中分别添加

data/orders.json

public/index.html

public/404.html

public/health.html

styles.css

测试文件内容

```html Index
Hello,welcome to home page

This is the index page for the web site
```
```html Health!
Hello,welcome to health page!

This site is perfectly fine
```
```html Not Found!
404 Error

Sorry! The requested page does not exist
```
```css /* styles.css */ h1 { color: red; margin-left: 25px; } ```
```javascript // orders.json [ { 'order_id': 1, 'order_date': '20 June 2022', 'order_status': 'Delivered' }, { 'order_id': 2, 'order_date': '27 October 2022', 'order_status': 'Pending' } ] ```

运行

效果如下

访问 index.html

访问 health.html

访问 orders.json

访问一个错误地址

至此，HTTP的基本功能实现就到此为止；

可以基于此框架做性能优化以及扩展自己所需要的功能；

通过本次HTTP《简易》设计，可以更深刻地体会一些后端设计思想、Rust本身的特点以及基于HTTP协议的Server设计思路；

每一个不曾起舞的日子，都是对生命的辜负。

Rust Web（一）—— 自建TCP Server

Mon, 30 Mar 2026 02:48:14 +0000

前段时间小小学习了一下Rust的基础内容，出于学习Web开发的需求，也为巩固学过的Rust基础，就尝试记录一下自己学习 Rust Web 的点滴；

实现环境

OS: Ubuntu 14.0

IDE: PyCharm

本文为个人的学习随记，关于Rust的基础部分没有提及太多，难免出现某些细节上的疏漏，还请读者按需参考；

目录

Rust Web（一）—— 自建TCP Server

一、项目创建

二、TCP Server

库引入

监听器绑定

消息接收

初步运行

三、TCP Client

库引入

运行效果

四、消息收发

Server

Client

运行效果

五、项目整体结构

Rust Web （一）—— 自建TCP Server

一、项目创建

在自选的位置使用 cargo 创建初始项目，此处命名为pro1；

进入项目目录，再创建两个子项目，分别为tcpserver、tcpclient；

打开pro1中的Cargo.toml文件，将子项目加入当前的工作空间内，具体如下：

二、TCP Server

进入子项目tcpserver，打开src下的main.rs文件；

以下是具体的设计过程：

库引入

引入Rust自带的网络编程库 std::net::TcpListener

监听器绑定

创建一个带有具体IP:port绑定的监听实例；

绑定监听器

消息接收

对于消息的接收，可有两种选择：

一种是只接受一次消息后即刻结束运行（实际不常用）；

另一种是人为中断除外的无限循环接收，而这类方案是实际设计中更为所用的；

具体实现参考如下

一次性接收

循环接收

右式中的stream属于std::result::Result<>类型，因此需要使用unwrap()进行简约的异常处理；

use std::net::TcpListener; fn main() { let listener = TcpListener::bind('127.0.0.1:2333').unwrap(); println!('Running on port 2333...'); for stream in listener.incoming() { let _stream = stream.unwrap(); println!('Connection established!'); } }
rust

初步运行

以下是运行的效果；

三、TCP Client

进入子项目tcpclient，转到 src/main.rs；

具体步骤如下：

库引入

引入Rust自带库 std::net::TcpStream；

创建一个数据流实例来连接指定地址的服务端；

use std::net::TcpStream; fn main() { let stream = TcpStream::connect('127.0.0.1:2333').unwrap(); }
rust
运行

运行效果

Client

Server

四、消息收发

由于所引入的网络编程库中实现了读写的 Trait，因此需要引入两个 Trait

std::io::{Read, Write}

TCP消息传送中的读写使用原始字节串形式；

Server

use std::net::TcpListener; use std::io::{Read, Write}; fn main() { let listener = TcpListener::bind('127.0.0.1:2333').unwrap(); println!('Running on port 2333...'); for stream in listener.incoming() { let mut stream = stream.unwrap(); println!('Connection established!'); let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); stream.write(&mut buffer).unwrap(); } }
rust
运行

Client

客户端处需要额外进入库 std::str

use std::net::TcpStream; use std::io::{Read, Write}; use std::str; fn main() { let mut stream = TcpStream::connect('127.0.0.1:2333').unwrap(); stream.write('Here's CLient End'.as_bytes()).unwrap(); let mut buffer = [0; 17]; // 此处的 17 是为配合消息的长度 stream.read(&mut buffer).unwrap(); println!('Response from server: {:?}', str::from_utf8(&mut buffer).unwrap() // utf-8编码形式接收 ); }
rust
运行

运行效果

Server

Client

五、项目整体结构

每一个不曾起舞的日子，都是对生命的辜负。