学 Rust 三月小结:从能抄代码到能设计系统的转变
一、三个月前,我只会 copy-paste
先说背景:我大学学的国际贸易,跟计算机八竿子打不着。决定转码是去年底的事,选 Rust 纯粹因为看到 Linus Torvalds 说"Rust 是 C 之后第一个让人兴奋的语言"——这句话比任何培训班广告都好使。
三个月前,我的 Rust 水平是:能看懂 rustlings 的答案,能在 ChatGPT 帮助下把 Python 脚本翻译成 Rust,能把开源项目的 example 跑起来。但让我从零设计一个模块?脑子空白。
三个月后,我独立完成了 AI CLI 工具的架构设计和核心模块开发(这个项目上一篇刚复盘完性能优化)。虽然不是什么大项目,但确实是从 0 到 1 的跨越。
这篇文章不是教程,是我回看这三个月的学习路径,拆解"从抄到设计"到底发生了什么。
二、学习路径全景:三个阶段
这三个月的学习路径可以拆解为三个清晰的阶段,每个阶段都有明确的目标和侧重点:
- 第一阶段(1-4 周):语法肌肉记忆。核心是通过
rustlings练习、通读《The Book》、研读《Rust By Example》以及刷 20 道 LeetCode 题目,建立对 Rust 语法的直觉。 - 第二阶段(5-8 周):源码与实战模仿。重点转向阅读开源项目源码,模仿编写 mini 项目,同时深入理解异步编程和 trait 系统。
- 第三阶段(9-12 周):独立架构设计。开始独立设计项目架构,进行模块拆分与接口设计,制定错误处理策略,并进行性能优化实战。
阶段一:语法肌肉记忆(第 1-4 周)
这不是什么新鲜建议,但我的做法和别人不一样。大多数人看 The Book 是一页一页啃,我是"倒着看"——先写代码,碰壁了再回去查。
具体操作:
- 每天 5 道
rustlings,不查答案先自己写,编译不过才看 hint - 刷 LeetCode 的时候,要求自己对每道题写两种实现:
iter()链式调用版 和for循环版 - 用
cargo clippy检查所有练习代码,理解每个 warning 背后的原因
一个让我印象深刻的例子。写 two_sum 的时候,我先写出了:
// 初版:C 风格的解法,可读性差
fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
use std::collections::HashMap;
let mut map: HashMap<i32, usize> = HashMap::new();
for i in 0..nums.len() {
let complement = target - nums[i];
if let Some(&j) = map.get(&complement) {
return vec![j as i32, i as i32];
}
map.insert(nums[i], i);
}
vec![]
}
然后 clippy 报了 4 个 warning。修完之后:
/// 两数之和 —— Rust 惯用写法
/// 用 enumerate 替代手动索引,用 entry API 减少哈希查询次数
fn two_sum(nums: &[i32], target: i32) -> Vec<i32> {
use std::collections::HashMap;
let mut map: HashMap<i32, usize> = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
// entry API:一次查找完成"存在检查 + 插入"
match map.entry(complement) {
std::collections::hash_map::Entry::Occupied(e) => {
return vec![*e.get() as i32, i as i32];
}
std::collections::hash_map::Entry::Vacant(e) => {
e.insert(i);
}
}
}
vec![]
}
这个阶段的目标不是"学会 Rust",而是让 borrow checker 不再是你写代码时的第一障碍。什么时候你能在脑子里预判编译器会报什么错,第一阶段就毕业了。
阶段二:读源码,重构理解(第5-8周)
这个阶段是最痛苦的,也是最关键的。
我选了两个项目精读:mini-redis(Tokio 官方教学项目)和 ratatui(TUI 框架)。方法不是一行行看,而是带着问题读:
“它为什么用
Arc<Mutex<T>>而不是Rc<RefCell<T>>?”
“为什么这个 trait 要设计成 object-safe 的?”
“错误类型为什么要定义成 enum 而不是直接用Box<dyn Error>?”
读完之后,我给自己定了一个任务:模仿 mini-redis 的架构,写一个 key-value 存储的 CLI 工具。不准复制粘贴,结构可以参考,但代码必须自己敲。
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::{Mutex, RwLock};
/// 模仿 mini-redis 设计的键值存储核心
/// 读多写少场景用 RwLock,公平调度用 Mutex
pub struct KvStore {
/// 用 RwLock 而非 Mutex —— 读操作远多于写操作
data: Arc<RwLock<HashMap<String, Vec<u8>>>>,
/// 写入锁:保证写操作的顺序性
write_lock: Mutex<()>,
}
impl KvStore {
pub fn new() -> Self {
Self {
data: Arc::new(RwLock::new(HashMap::new())),
write_lock: Mutex::new(()),
}
}
/// 读取键值 —— 共享读锁,高并发友好
pub async fn get(&self, key: &str) -> Option<Vec<u8>> {
let data = self.data.read().await;
data.get(key).cloned()
}
/// 写入键值 —— 独占写锁
pub async fn set(&self, key: String, value: Vec<u8>) {
let _guard = self.write_lock.lock().await;
let mut data = self.data.write().await;
data.insert(key, value);
}
}
这个阶段我踩的最大的坑是**过度设计**。刚开始读源码时,觉得每个项目都用了很多高级特性,于是自己写的时候也硬套 GAT、关联类型、过程宏——结果代码复杂度爆炸,改一行牵动十行。后来悟了:**读源码学的是"为什么这样设计",不是"怎样把所有特性塞进去"**。
### 阶段三:从消费者变成设计者(第 9-12 周)
第三阶段的标志性事件:我开始做 AI CLI 这个项目。和之前的练习不同,这次没有参考项目,没有人告诉我模块怎么拆、接口怎么定义。
最困难的是第一刀——**模块拆分**。一个 CLI AI 工具应该有哪些模块?
经过梳理,`main.rs` 作为入口,主要协调了四个核心模块:配置管理、终端界面、API 通信以及上下文构建。其中,配置管理依赖环境变量解析;API 通信模块进一步依赖流式解析和认证管理;上下文构建模块需要模板引擎和对话历史的支持;而终端界面最终依赖上下文模块来呈现结果。
这个架构设计我推敲了一个下午,反复推翻重来。最终的体会是:**好的模块拆分不是按"功能"分,是按"变化频率"分**。
- `config` 模块变化最少,可以最先稳定
- `tui` 和 `client` 变化最频繁,要设计成高内聚低耦合
- `context` 是核心逻辑,需要最严谨的接口定义
```rust
/// 核心 trait:定义了 AI 助手的行为契约
/// 所有 AI Provider(OpenAI、本地模型等)都必须实现这个 trait
#[async_trait::async_trait]
pub trait AiProvider: Send + Sync {
/// 发送对话请求并获取流式响应
///
/// # 参数
/// * context - 对话上下文,包含历史消息和系统提示
/// * user_input - 用户当前输入
///
/// # 返回
/// 流式响应的接收端,每条消息作为一个元素
async fn chat_stream(
&self,
context: &ConversationContext,
user_input: &str,
) -> anyhow::Result<tokio::sync::mpsc::Receiver>;
/// 返回 Provider 的名称(如 "openai", "ollama" 等)
fn provider_name(&self) -> &'static str;
}
/// 对话上下文 —— 所有 Provider 共享的数据结构
#[derive(Debug, Clone)]
pub struct ConversationContext {
/// 系统提示词(只读,由模板引擎生成)
pub system_prompt: String,
/// 对话历史,最多保留最近 20 轮
pub history: Vec,
/// 最大上下文长度(token 数)
pub max_tokens: usize,
}
设计 trait 的时候我反复改了三版。第一版把 `history` 放在 trait 里,发现每个 Provider 对历史的处理方式不同;第二版用关联类型,发现根本不需要那么灵活;第三版回归简单,把共享数据抽成独立 struct,trait 只管行为。
这个迭代过程教会我:**接口设计不是一次做对的,是在不断推翻中逼近最优解**。
---
## 三、三个让我质变的关键时刻
**时刻一:第一次手动标注生命周期**
```rust
/// 实现一个字符串迭代器,需要显式标注生命周期
/// 理解 'a 代表"返回值的存活时间不能超过输入引用的存活时间"
struct WordIter<'a> {
/// 剩余待处理的字符串切片,生命周期与输入绑定
remaining: &'a str,
}
impl<'a> Iterator for WordIter<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<Self::Item> {
// 跳过前导空格,找到下一个单词边界
self.remaining = self.remaining.trim_start();
if self.remaining.is_empty() {
return None;
}
let end = self.remaining.find(' ')
.unwrap_or(self.remaining.len());
let word = &self.remaining[..end];
self.remaining = &self.remaining[end..];
Some(word)
}
}
在这之前生命周期只是概念。亲手实现一个需要标注的 struct 后,突然理解了"生命周期是类型系统的一部分"是什么意思。
时刻二:发现 Arc<Mutex<T>> 和 Arc<RwLock<T>> 的选择不是语法问题,是业务问题
读多写少的场景用 RwLock 能获得更好的并发性能,但代码复杂度也更高(需要区分 read/write guard)。如果只是简单的状态共享,Mutex 就够了。"设计"和"抄代码"的分界线就在这里——你要为业务场景做权衡。
时刻三:第一次不看任何参考,独立写出一个完整的异步模块
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
/// 事件总线 —— 发布/订阅模式的异步实现
/// 生产者和消费者解耦,通过通道传递消息
pub struct EventBus<T: Clone + Send + 'static> {
/// 事件发送端,生产者在外部持有 clone
tx: mpsc::UnboundedSender<T>,
/// 后台任务句柄,用于优雅关闭
_handle: JoinHandle<()>,
}
impl<T: Clone + Send + 'static> EventBus<T> {
/// 创建事件总线并返回 (发送端, 接收端) 的配对
pub fn new() -> (Self, mpsc::UnboundedReceiver<T>) {
let (tx, rx) = mpsc::unbounded_channel();
let (this, _handle) = (Self {
tx: tx.clone(),
_handle: tokio::spawn(async move {})
}, ());
// 实际项目中 _handle 用于追踪后台任务
(this, rx)
}
/// 获取发送端的克隆
pub fn sender(&self) -> mpsc::UnboundedSender<T> {
self.tx.clone()
}
}
写完后跑通的那一刻,我知道自己真的跨越了那道坎。
四、给同样自学编程的朋友一些话
-
别急着学"做项目",先让 borrow checker 成为本能。第一阶段走完之前不碰大项目,这帮我省了至少两周重新理解的时间。
-
Rust 的难度曲线是倒 U 型。前六周每天都在怀疑人生,第六周之后突然开窍。坚持到那个拐点。
-
AI 工具要当成"加速器"而不是"拐杖"。我用 Copilot 和 ChatGPT 只做两件事:解释看不懂的代码,和生成测试用例。绝不让他们写核心逻辑——那样你永远学不会。
-
开源社区是最好的老师。给
ratatui提了 3 个 PR(2 个文档修正,1 个 clippy fix),每个 review 评论都是免费的代码审查课。 -
的劣势是基础,优势也是基础。你不会被"这样做才对"的条条框框限制,反而更容易接受 Rust 的独特设计哲学。我就因为没用过 Java,所以从不觉得 Rust 的 trait 比 interface 复杂——对我来说它们都是第一次见。
五、总结
三个月前,Rust 是我的障碍。三个月后,Rust 成了我最趁手的工具。
“从能抄代码到能设计系统”,这句话拆开来看,本质上是三个转变:
- 从"这段代码对不对"到"这个设计合不合理":不再纠结语法,开始思考架构。
- 从"模仿别人的结构"到"为场景做权衡":不再套模板,开始分析具体场景。
- 从"编译器让我头疼"到"编译器是我的搭档":borrow checker 从敌人变成了帮你检查设计缺陷的助手。
下一步的目标:深入到 Tokio 的源码里看看 mio 是怎么工作的,然后用 Rust 写一个自己的小语言解释器——不是为了生产,就是为了把"理解"变成"能做"。
如果你也在学 Rust,遇到卡点不妨在评论区聊聊。的弯路我走了不少,也许能让你少走一些。
4万+



被折叠的 条评论
为什么被折叠?



