Rust on Liangweidong's blog

Rust 全景教程：所有权、生命周期、工程化与 22 个设计模式

Thu, 15 Aug 2024 00:00:00 +0800

为什么写这篇：Rust 的"无 GC 又内存安全"听起来矛盾，能调和它的就是 所有权 + 借用检查器。这套机制不靠运行时、不靠程序员自律，而是 编译期就把空指针、悬垂引用、数据竞争挡在门外。本文以一份"学习路径图"为目标，把语法、工程化、生态、设计模式与开发方向全部串起来——比单点教程更适合作为长期参考。

适用读者：有 C/C++/Java/Go 任意一门语言基础，想系统理解 Rust 范式与生态的开发者。

前置知识：理解指针、堆栈、并发基础，了解命令行工具使用。

教程资源
命名规范
cargo 与项目工程化
入门：关键字、宏、变量与数据类型
语句、表达式与函数
所有权：Rust 的核心范式
借用、切片与生命周期
复合类型与模式匹配
方法、泛型、特征与集合
第三方库速查（按领域）
22 个设计模式（Rust 实现）
7 大开发方向
常见坑与小结

1. 教程资源

类型	资源	说明
在线教程	Rust 语言圣经	中文系统教程，覆盖基础到进阶
在线教程	Rust Course（书籍版）	圣经的精装本
配套练习	Rust By Practice	边学边练的题目集
练习答案	basic-types/functions 答案	练习题参考答案
练习站	Practice 中文站	在线 judge 风格练习
进阶练习	Rusty Course	进阶专题练习
示例集	Rust By Example	一段代码一个概念
命名规范	Rust 命名指南	官方推荐的命名约定
关键字表	关键字清单	关键字与原生标识符
派生宏	derive 速查	`#[derive(...)]` 全部内置 trait
模块系统	Item 引用	官方模块系统权威定义

Why 多资源：没有哪一份教程能"一站式"——圣经适合系统学习，By Example 适合查阅单点，By Practice 适合练手感。三者配合用最稳。

2. 命名规范

Rust 走的是 蛇形命名法（snake case）为主，关键字小驼峰 + 蛇形穿插。下面是速查表：

命名类型	惯例	示例
常量	全部大写，下划线分隔；数字字面量可加下划线增强可读性	`const MAX_POINTS: u32 = 100_000;`
函数	蛇形命名	`fn greet_world() {}`
方法	蛇形命名	`fn add_two() {}`
变量	蛇形命名	`let user_name = "..."`
类型 / 结构体 / 枚举	大驼峰	`struct UserProfile {}`
特征	大驼峰	`trait Summary {}`
宏	蛇形 + 感叹号	`println!`, `vec!`
crate 名	蛇形	`serde_json`

原生标识符：如果你想用某个保留字做变量名，前面加 r# 即可，例如 let r#fn = 1;。这叫"原生标识符"，仅在少数和宏/外部 API 互操作时才会用到。

3. cargo 与项目工程化

3.1 cargo 是 Rust 的"一切入口"

cargo 同时管 构建、依赖、测试、文档、发布 五个维度。rustc（编译器）能直接调，但实际项目 100% 走 cargo。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


cargo new my_app --vcs none # 新建项目（不初始化 git）
cd my_app
tree # 仅含 Cargo.toml + src/main.rs
cargo run # 编译 + 运行（debug）
cargo build --release # release 模式
cargo check # 快速类型检查（不生成二进制，比 build 快 5-10x）
cargo test # 跑测试
cargo fmt # 格式化
cargo clippy # lint
cargo fix # 自动修复 clippy warning
cargo add serde # 加依赖

3.2 中小项目的模块组织

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


project/
├── Cargo.toml
├── src/
│ ├── main.rs # 二进制入口
│ ├── lib.rs # 库入口：pub mod modules;
│ ├── modules.rs # 声明 mod user;（因为有同名文件夹）
│ └── modules/
│ ├── user.rs # user 模块
│ └── user/ # user 的子模块目录
│ ├── register.rs
│ └── login.rs
└── tests/
 └── integration_test.rs # 集成测试（视为外部用户视角）

lib.rs 用 pub use 明确暴露模块接口、隐藏内部实现细节。

模块路径 ↔ 文件路径的对应关系：

模块路径	文件路径	文件内容
`crate`	`lib.rs`	`mod modules;`
`crate::modules`	`modules.rs`	`mod user;`
`crate::modules::user`	`modules/user.rs`	`mod register;`
`crate::modules::user::register`	`modules/user/register.rs`	（子模块文件）

mod.rs 的弃用：rustc 1.30 之前要靠 mod.rs 加载嵌套子模块，现在统一改成"同名文件夹 + 同名 .rs"约定，避免一个项目出现多个 mod.rs 的混乱。

3.3 多 crate Workspace

当项目要拆 library + binary + 多个微服务时，用 workspace：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


my_workspace/
├── Cargo.toml # 工作区根配置
├── README.md
├── target/ # 共享编译目录
├── Cargo.lock # 共享锁文件
├── app/ # 主程序包
│ ├── Cargo.toml
│ └── src/main.rs
└── crates/ # 子模块包
 ├── core/ # 核心库
 │ ├── Cargo.toml
 │ └── src/lib.rs
 └── utils/ # 工具库
 ├── Cargo.toml
 └── src/lib.rs

根 Cargo.toml（2024 Edition 推荐写法）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


[workspace]
# 依赖解析器版本（2024 Edition 默认 resolver = "3"，优化了多版本依赖解析）
resolver = "3"

# 声明 workspace 成员（支持通配符）
members = [
 "crates/my_lib",
 "crates/my_bin",
]

# 共享依赖（推荐）：统一管理版本，成员 crate 直接引用
[workspace.dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

成员 crate Cargo.toml：

1
2
3
4
5
6
7
8


# crates/my_lib/Cargo.toml
[package]
name = "my_lib"
version = "0.1.0"
edition = "2024"

[dependencies]
serde = { workspace = true }

workspace 一键操作：

1
2
3
4
5


cargo build --workspace
cargo test --workspace
cargo clippy --workspace --all-targets
cargo fmt --all
cargo publish -p my-crate-*

3.4 微服务架构示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


rust_iot_platform/
├── Cargo.toml # workspace 根
├── api/ # 接口定义（Proto / OpenAPI / AsyncAPI）
│ ├── proto/ # gRPC 原始定义
│ └── schema/ # 共享 JSON Schema
├── services/ # 微服务应用层（binary crates）
│ ├── auth-service/
│ ├── gateway/
│ └── device-manager/
├── components/ # 内部共享组件库（library crates）
│ ├── domain/ # 核心领域模型（纯业务，无 DB、无网络）
│ ├── infra-db/ # 数据库访问层（PostgreSQL + Diesel/SQLx）
│ ├── infra-mq/ # 消息队列适配器（NATS / RabbitMQ）
│ └── common/ # 基础工具（日志、错误处理、配置加载）
├── scripts/ # CI/CD 脚本、数据库迁移
└── tests/ # 跨服务 E2E

为什么用 workspace 而不是一个 mega crate：编译速度（增量编译只编译改动的成员）、依赖隔离（domain 不会被 SQLx 拖进依赖图）、发布灵活（每个组件可单独 publish）。

3.5 edition 与 resolver 的关系

Edition	引入版本	默认 resolver	关键变化
2015	Rust 1.0 (2015-05)	`resolver = "1"`	经典版
2018	Rust 1.31 (2018-12)	`resolver = "2"`	NLL 借用检查、路径清晰化
2021	Rust 1.56 (2021-10)	`resolver = "2"`	闭包捕获、Or 模式 prelude
2024	Rust 1.85 (2025-02-13)	`resolver = "3"`	默认开启 `resolver = "3"`；trait 推导更智能；`gen` 块；`unsafe extern` 块显式化

resolver = “3” 的核心收益：避免一些原本需要手动加 Cargo.lock 才能解析的 feature 冲突场景；对 monorepo 友好；与 2024 edition 的 unsafe 显式化配合更安全。

4. 入门：关键字、宏、变量与数据类型

4.1 关键字速查

行为	关键字	说明
方法	`fn`	函数定义
变量	`let`	默认不可变
可变	`mut`	在引用、裸指针、模式绑定中表明可变性
循环	`for ... in ...`	唯一内置的遍历循环
编译期配置	`debug_assertions`	debug 构建为 true，release 为 false
占位符	`{:?}` / `{:.2}`	调试格式 / 小数位 2
优美输出	`{:#?}`	结构化美化打印
类型别名	`type`	给复杂类型起短名
方法实现	`impl`	给类型 / 特征实现方法
泛型约束	`where`	复杂 trait 约束的另一种写法

4.2 常用宏

行为	宏	备注
控制台打印	`println!`	标准输出，有缓冲
错误输出	`eprintln!`	stderr，无缓冲
编译期求值	`cfg!`	在编译期计算条件
未实现占位	`unimplemented!`	标记"还没写"
模式匹配	`matches!`	简洁的 `match` 等价物
列表	`vec!`	`vec![1, 2, 3]`
调试	`dbg!`	输出到 stderr，含文件名 + 行号 + 表达式 + 值
断言	`assert!` / `assert_eq!`	测试 / 不变量检查

4.3 派生宏（derive）

最常用的是 #[derive(Debug)]，它自动为结构体 / 枚举生成 {:?} 格式化实现：

1
2


#[derive(Debug)]
struct Point { x: i32, y: i32 }

其他常见的：Clone、Copy、PartialEq、Eq、Hash、Default、PartialOrd、Ord，需要在 Cargo.toml 加 derive feature（部分 trait 由标准库派生宏提供）。

4.4 变量与解构

Rust 的变量 默认不可变——既要灵活性又要安全，所以"可变"必须显式声明：

1
2
3


let x = 5; // 不可变
let mut y = 5; // 可变
y += 1;

什么时候选哪个？

决策	适用场景
不可变 `let`	默认；写小代码、函数式风格
可变 `let mut`	大数据结构、热点路径（避免克隆带来的再分配）
遮蔽 `let x = ...`	同一名字多次用、做类型转换

未被使用的变量会触发 warning。用下划线开头即可消除，如 let _unused = ...。

变量遮蔽（shadowing） 与 mut 的区别：遮蔽是 创建了一个新的、拥有相同名称的变量，可以换类型；mut 是同一变量的可写权限。

1
2


let spaces = " "; // &str
let spaces = spaces.len(); // usize，类型都换了

下面的写法不行（类型不一致）：

1
2


let mut spaces = " ";
spaces = spaces.len(); // 编译错误：&str ≠ usize

解构的本质是"把整体拆解并绑定到多个具体的名字上"：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


fn main() {
 struct Point { e: i32 }

 let (a, b, c, d, e);
 (a, b) = (1, 2);
 [c, .., d, _] = [1, 2, 3, 4, 5];
 Point { e, .. } = Point { e: 5 };

 assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
}

4.5 数据类型

类型	关键字	说明
有符号整数	`i8` / `i16` / `i32` / `i64` / `i128` / `isize`	默认整型 `i32`
无符号整数	`u8` / `u16` / `u32` / `u64` / `u128` / `usize`	`usize` 取决于平台字长
浮点	`f32` / `f64`	默认 `f64`，现代 CPU 上两者速度相当
字符串切片	`&str`	栈上 16 字节（指针 + 长度），不可变
字符串	`String`	栈上 24 字节（指针 + 长度 + 容量），堆上 UTF-8
字符	`char`	单个 Unicode 字符（4 字节）
布尔	`bool`	1 字节，`true` / `false`
单元	`()`	唯一值是 `()`，0 字节
数组	`[T; N]`	栈上，长度是类型一部分
切片	`&[T]`	运行时长度

isize / usize 在 32 位平台是 4 字节、64 位平台是 8 字节。

数值字面量：

1
2
3
4
5
6


let a = 98_222; // 十进制，下划线增强可读
let b = 0xff; // 十六进制
let c = 0o77; // 八进制
let d = 0b1111_0000; // 二进制
let e = b'A'; // u8 字节字面量
let f = -42.1_f32; // 类型后缀（防类型推导走偏）

字符 / 布尔 / 单元：

1
2
3


let c = 'z'; // 单引号
let t = true;
let u = (); // 单元类型，0 字节

5. 语句、表达式与函数

Rust 是基于表达式的语言——表达式总要返回值，语句不返回。

1
2
3
4
5


fn add_with_extra(x: i32, y: i32) -> i32 {
 let x = x + 1; // 语句
 let y = y + 5; // 语句
 x + y // 表达式（不能加 `;`）
}

if / match / 块都是表达式，可以直接赋值：

1

let y = if x % 2 == 1 { "odd" } else { "even" };

表达式不显式 return 时，隐式返回 ()（单元类型）。

函数定义要点：

1

fn add(i: i32, j: i32) -> i32 { i + j }

函数名 / 变量名：蛇形命名
函数位置：随便放，编译器不关心
每个参数都必须标注类型

永不返回类型 !（diverging functions）：

1
2
3
4
5
6
7


fn dead_end() -> ! {
 panic!("你已经到了穷途末路，崩溃吧！");
}

fn forever() -> ! {
 loop { /* 永不跳出 */ };
}

! 是 bottom type，能匹配任何类型——panic! / loop {} / continue / break 都有 ! 类型的语义。

6. 所有权：Rust 的核心范式

这是 Rust 唯一不可绕过的概念。其他特性都可以边写边学，所有权是编译器的"宪法"。

6.1 堆栈视角：理解所有权的前提

	栈	堆
组织方式	后进先出（LIFO）	散乱无序，依赖指针寻址
大小	编译期已知且固定	运行时动态申请
速度	极快（移动栈指针即可）	较慢（要走分配器）
线程关系	与线程绑定	进程内共享
默认上限	Linux/macOS 8MB / Windows 1MB	物理内存上限

500KB 局部变量的"生与死"：

1
2
3
4


fn process_data() {
 let buffer = [0u8; 500 * 1024]; // 500KB
 println!("首字节: {}", buffer[0]);
}

阶段	动作
进入函数	CPU 指令 `sub rsp, 512000`（栈指针下移 500KB）
函数体内	栈帧建立，buffer 的"家"在这 500KB
函数结束	指令 `add rsp, 512000`（栈指针上移 500KB），逻辑释放
物理残留	那 500KB 物理内存仍含 0，但无法再访问——下个函数会覆盖

架构师视角的注意点：

临界点：500KB + 已用 600KB 超过 Linux 默认 8MB → Stack Overflow
复制开销：500KB 按值传参会再开 500KB 并物理复制 → 用 &buffer 引用只传 8 字节地址
缓存抖动：短时间大量栈申请 / 释放会让 L1/L2 频繁失效

6.2 三条铁律

每个值都被一个变量所拥有
一个值同时只能被一个变量拥有（所有权唯一）
当所有者离开作用域，值被 drop

函数返回值也有所有权——return value 本质是把所有权"移"给调用方。

6.3 移动（Move）语义

1
2
3
4
5


fn main() {
 let s1 = String::from("hello");
 let s2 = s1; // s1 的所有权"移动"到 s2，s1 失效
 // println!("{}", s1); // 编译错误：s1 已经无效
}

为什么不直接让 s1、s2 都指向同一块堆？ 因为"双重释放"（两个 drop 调同一块堆）会让程序崩溃。

函数间转移所有权：

1
2
3
4
5
6
7
8


fn gives_ownership() -> String {
 let s = String::from("hello");
 s // 移出给调用者
}

fn takes_and_gives_back(s: String) -> String {
 s // 拿进来再返回
}

6.4 Copy 与 Clone

i32 / f64 / bool / char 实现 Copy trait——赋值复制而非移动
String / Vec<T> 不实现 Copy——赋值移动
想"复制" String 用 s.clone()（深拷贝）

1
2
3
4
5


let x = 5;
let y = x; // 复制（Copy），x 仍可用

let s1 = String::from("hi");
let s2 = s1.clone(); // 深拷贝，s1、s2 都能用

7. 借用、切片与生命周期

7.1 引用：`&` 与 `&mut`

引用 = 不夺所有权地使用值：

1
2
3
4
5
6
7
8
9


fn main() {
 let s1 = String::from("hello");
 let len = calculate_length(&s1); // 传引用
 println!("'{}' 长度 {}", s1, len);
}

fn calculate_length(s: &String) -> usize {
 s.len()
}

引用类型	语法	规则
不可变引用	`&T`	同一作用域可存在多个
可变引用	`&mut T`	同一作用域只能有一个，且不能与不可变引用共存

违规的混合借用：

1
2
3
4
5


let mut s = String::from("hello");
let r1 = &s; // 不可变
let r2 = &s; // 不可变
let r3 = &mut s; // 编译错误：r1/r2 还在作用域
println!("{},{},{}", r1, r2, r3);

合法的非词法作用域版本：

1
2
3
4
5
6


let mut s = String::from("hello");
let r1 = &s;
let r2 = &s;
println!("{} and {}", r1, r2); // r1/r2 最后一次使用，作用域结束
let r3 = &mut s; // 此时安全
println!("{}", r3);

7.2 悬垂引用（Dangling References）

Rust 在编译期拒绝悬垂引用：

1
2
3
4


fn dangle() -> &String { // 编译错误
 let s = String::from("hello");
 &s // s 出作用域被 drop
}

修复：返回所有权，不要返回引用。

1
2
3
4


fn no_dangle() -> String {
 let s = String::from("hello");
 s
}

7.3 字符串切片

1
2
3


let s = String::from("hello world");
let hello = &s[0..5]; // "hello"
let world = &s[6..11]; // "world"

左闭右开区间。&str 是 胖指针（指针 + 长度），是 &String 之外更通用的字符串引用形式。

7.4 字符串字面值 vs String

	`&str`（字符串字面值）	`String`
内存	编译期硬编码进二进制	运行时在堆上分配
可变性	不可变	可变、可增长
分配	静态	`String::from` / `String::new`
释放	进程结束	变量离开作用域时 `drop`

Rust 的"无 GC 又安全"靠的就是变量离开作用域自动 drop——GC 牺牲性能，手动管理牺牲安全，Rust 选了第三条路。

7.5 生命周期标注

大多数时候编译器能自动推导，有歧义时才需手动标：

1
2
3


fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
 if x.len() > y.len() { x } else { y }
}

'a 的含义：返回的引用的生命周期 ≤ 入参引用的生命周期中较短的那个。

生命周期省略规则（编译器自动推的）：

每个引用参数都有独立生命周期参数
若只有一个引用参数，那个生命周期赋给所有输出
若有 &self / &mut self，输出生命周期跟 self

结构体中含引用时必须加生命周期——编译器不让你"借用不该借用的数据"。

8. 复合类型与模式匹配

8.1 元组

多种类型组合，长度固定、顺序固定。let (x, y) = (1, "hi"); 是常用解构。

8.2 结构体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#[derive(Debug)]
struct File {
 name: String,
 data: Vec<u8>,
}

fn main() {
 let f1 = File {
 name: String::from("f1.txt"),
 data: Vec::new(),
 };
 let f1_name = &f1.name;
 let f1_length = &f1.data.len();
 println!("{:?}", f1);
}

内存布局：File 本身在栈上（name 的 String 数据 24 字节 + data 的 Vec 数据 24 字节），两个字段的 ptr 指针分别指向各自的堆内存。把字段转移出去后该字段就不可访问，其它字段仍可用。

元组结构体（字段没名字）：

1
2
3


struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
let black = Color(0, 0, 0);

单元结构体（无字段，只关心行为）：

1
2
3
4


struct AlwaysEqual;
let subject = AlwaysEqual;

impl SomeTrait for AlwaysEqual { /* ... */ }

8.3 枚举

枚举允许"列举可能的成员"来定义一个类型，任何类型的数据都可以放入枚举成员中（字符串、数值、结构体、甚至另一个枚举）：

1
2
3


enum PokerSuit {
 Clubs, Spades, Diamonds, Hearts,
}

Option<T> 枚举是 Rust 处理"空值"的方式——没有 null，需要表达"可能不存在"时用 Some(T) 或 None。

8.4 数组与切片

类型	存储	长度	常用形式
`[T; N]` 数组	栈	编译期固定	`let a = [1, 2, 3];`
`Vec<T>` 动态数组	堆	运行时可变	`let mut v = vec![1, 2];`
`&[T]` 切片	胖指针	运行时	`&a[1..3]`、`&v[..]`

[u8; 3] 和 [u8; 4] 是不同的类型——长度是类型的一部分
实际开发中 数组切片 &[T] 最常用，因为有固定类型大小

8.5 模式匹配

1
2
3
4
5
6
7
8
9


enum Direction { East, West, North, South }

fn main() {
 let dire = Direction::South;
 match dire {
 Direction::East => println!("East"),
 other => println!("other: {:?}", other),
 }
}

要点：

match 必须穷举，用 _ 兜底
每个分支都是 表达式，返回值类型必须一致
X | Y 表示"或"
if let 是单分支版的 match
match / if let 的块是新作用域，绑定相当于新变量——同名会发生变量遮蔽，要小心

9. 方法、泛型、特征与集合

9.1 方法（method）

Rust 把"数据"和"行为"分离——结构体定义数据，impl 块定义方法。方法名可以跟字段名相同（常用于 getter）。一个类型可以有多个 impl 块，按职责拆分：

1
2
3
4
5
6
7
8


impl File {
 pub fn new(name: &str) -> Self { /* ... */ }
 pub fn name(&self) -> &str { &self.name }
}

impl File {
 pub fn read(&self) -> &[u8] { &self.data }
}

好处：

不用在函数签名中重复写 self 类型
代码组织性、内聚性更强

9.2 泛型

泛型就是多态——T 是惯例首选（type 首字母）：

1
2
3
4
5
6
7


fn largest<T: PartialOrd>(list: &[T]) -> &T {
 let mut largest = &list[0];
 for item in &list[1..] {
 if item > largest { largest = item; }
 }
 largest
}

约束有两种写法：fn foo<T: Trait>(...) 或 where T: Trait。后者更适合复杂约束。

9.3 特征（trait）

特征定义了"一组可以被共享的行为"——只要实现特征，你就能使用这组行为：

1
2
3
4
5
6
7


trait Summary {
 fn summarize(&self) -> String;
}

impl Summary for Article {
 fn summarize(&self) -> String { format!("{}: {}", self.title, self.author) }
}

特征是 Rust 实现 接口抽象、零成本抽象、对象安全多态 的核心机制。

9.4 集合（Collection）

集合	类型	特点
动态数组	`Vec<T>`	堆上、可增长、最常用
双端队列	`VecDeque<T>`	两端 O(1) push/pop
哈希表	`HashMap<K, V>`	O(1) 查找；无序
BTreeMap	`BTreeMap<K, V>`	有序、O(log n)
哈希集合	`HashSet<T>`	去重、O(1) 查找
BTreeSet	`BTreeSet<T>`	有序去重

10. 第三方库速查（按领域）

10.1 核心与基础工具

库	用途
Serde	Rust 序列化和反序列化事实标准，与 JSON / YAML / TOML / BSON 无缝集成
Tokio	异步 Rust 的基石，多线程异步运行时
Rayon	数据并行化，把计算密集任务快速转多线程
Anyhow	灵活的、易用的错误处理（适合应用层）
Thiserror	库中定义结构化错误类型

10.2 Web 开发与网络

库	用途
Axum	Tokio 团队维护的异步 Web 框架，模块化、类型安全、人体工程学极佳
Actix-web	极其快速、成熟的 Web 框架
Rocket	易用性极高的 Web 框架，代码简洁、类型安全
Reqwest	强大的 HTTP 客户端（同步 + 异步）
Tonic	HTTP/2 的高性能 gRPC 框架

10.3 数据库与数据持久化

库	用途
SQLx	异步、纯 Rust 的 SQL 驱动，编译期 SQL 语法检查，支持 PG / MySQL / SQLite
Diesel	安全、强大的 ORM 框架
Redis-rs	Rust 官方维护的 Redis 驱动

10.4 命令行工具

库	用途
Clap	解析命令行参数的顶级库，支持子命令、自动帮助
Indicatif	优雅的进度条 / 微调器
Colored	终端彩色文本输出

10.5 序列化与数据格式

库	用途
Serde JSON	Serde 的 JSON 实现，最广泛
Toml	TOML 配置文件
CSV	高性能 CSV 处理

10.6 其它优质工具

库	用途
Tracing	结构化、异步的诊断信息追踪与日志
UUID	UUID 生成与处理
Chrono	日期 / 时间处理
Lazy Static	运行时安全初始化静态变量

选型原则：底层用 Serde + Tokio + SQLx 几乎不会错；Web 框架优先 Axum（生态最热）；CLI 必装 Clap + Indicatif；日志统一 Tracing。

11. 22 个设计模式（Rust 实现）

Refactoring Guru 设计模式（Rust 版）是最权威的 Rust 实现对照表。下面给出 22 个模式 + 一句话定义 + 适用场景：

11.1 创建型模式

#	模式	一句话
1	抽象工厂 Abstract Factory	创建一系列相关对象，无需指定其具体类
2	生成器 Builder	分步骤创建复杂对象，相同代码生成不同形式
3	工厂方法 Factory Method	父类接口决定子类实例化哪个类
4	原型 Prototype	复制已有对象，不依赖它们所属的类
5	单例 Singleton	保证类只有一个实例，提供全局访问点

11.2 结构型模式

#	模式	一句话
6	适配器 Adapter	让接口不兼容的对象互相合作
7	桥接 Bridge	把大类拆成"抽象"和"实现"两个独立层次结构
8	组合 Composite	把对象组合成树状，像用独立对象一样用它们
9	装饰 Decorator	把对象放入"包装对象"中，绑定新行为
10	外观 Facade	为复杂库 / 框架提供简单接口
11	享元 Flyweight	通过共享相同状态，在有限内存中载更多对象
12	代理 Proxy	为原对象提供替代品，控制访问

11.3 行为模式

#	模式	一句话
13	责任链 Chain of Responsibility	把请求沿处理者链发送
14	命令 Command	把请求转为独立对象，支持参数化、队列化、撤销
15	迭代器 Iterator	不暴露集合底层表现形式的情况下遍历
16	中介者 Mediator	限制对象直接交互，迫使通过中介者合作
17	备忘录 Memento	不暴露实现细节的情况下保存 / 恢复之前状态
18	观察者 Observer	订阅机制，事件发生时通知多个观察者
19	状态 State	内部状态变化时改变行为（看起来像换了类）
20	策略 Strategy	把一系列算法分别封装成类，使它们可互换
21	模板方法 Template Method	超类定义算法框架，子类重写特定步骤
22	访问者 Visitor	把算法与其作用的对象隔离开

Rust 实现这些模式的差异：因为所有权和特征的存在，“继承"在 Rust 里是反模式（用组合 + trait 实现）。很多模式在 Rust 里 天然契合（如 Newtype、RAII、Builder、Iterator），但也有 不适合的模式（如抽象工厂在高度泛型代码里会更复杂）。

12. 7 大开发方向

以下不是"应该学哪个"的单选题，而是 7 个真实存在的生态位。Rust 的"无 GC + 内存安全 + 高性能"让它在多个垂直领域都成为首选之一。

方向	关键特性契合点	代表项目 / 框架
嵌入式开发	接近金属、可预测性能、无 GC 暂停、适合 256KB RAM MCU	Rust Embedded
游戏引擎	高性能游戏逻辑，ECS 模式天然契合所有权 + 借用	Bevy（ECS 优先）、amethyst、macroquad、ggez
区块链 / 密码学	内存安全 + 高性能，密码学库与共识实现可避免空指针、悬垂引用	solana-program、ink!（智能合约）、parity-common
桌面端	Tauri（Web 前端 + Rust 后端，体积小）、egui（immediate mode）	Tauri、Slint、egui
Web 后端	异步运行时成熟，类型安全	Axum、Actix-web、Rocket
前端 WebAssembly	WASM 体积小、性能可预测、与 JS 互操作自然	wasm-bindgen、Yew（类 React）、Leptos
命令行工具	单文件二进制、跨平台、启动快	ripgrep、fd、bat、eza、starship
操作系统	内核、驱动、系统级工具	redox-os、coreboot 组件、tock

跨端复用套路（Rust + React 系）：

类型	后端	前端
web	rust	react
桌面	rust	react
移动	rust	react native

核心套路：Rust 做底层（性能敏感、调系统 API），前端 / UI 用 React 系。一套技能树覆盖桌面、Web、移动。

13. 常见坑与小结

13.1 编译期就能挡掉的常见坑

坑	表现	修法
同时存在可变 + 不可变引用	编译错误	缩小不可变引用的作用域（让 r1/r2 在 r3 创建前用完）
`String` 不是 `Copy`	编译错误	用 `clone()` 或返回所有权
迭代时修改容器	编译错误	先收完再改、用 `iter_mut` / 索引遍历
悬垂引用	编译错误	返回所有权，不要返回引用
生命周期标注歧义	编译错误	编译器提示加 `'a`
`cargo search` 不能用镜像	命令无结果	必须直连 crates.io
5KB+ 局部数组	运行时栈溢出	改成 `Vec<T>`（堆）或缩小

13.2 编辑器与工具链

编辑器	推荐
VSCode	`rust-analyzer` 扩展（基于 LSP）
IntelliJ IDEA	`Rust` 插件（官方收费）
Neovim	`rust-tools.nvim` + `rust-analyzer`
Helix	内置 LSP 客户端，配 `rust-analyzer`

.vscode/settings.json 推荐配置：

1
2
3
4
5
6


{
 "[rust]": {
 "editor.defaultFormatter": "rust-lang.rust",
 "editor.formatOnSave": true
 }
}

13.3 安装与镜像

1
2
3
4
5


# Linux / macOS
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

# Windows：先装 Microsoft C++ Build Tools（提供 MSVC 链接器）
# 下载 https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-msvc/rustup-init.exe

国内镜像（$HOME/.cargo/config.toml）：

1
2
3
4
5


[source.crates-io]
replace-with = 'ustc'

[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index/"

注意：cargo search 不能用镜像，搜索需直连 crates.io。

13.4 一句话总结

Rust 的"无 GC 又内存安全"靠的就是所有权 + 借用检查器——编译器是警察，你在写代码时就已经在和它博弈。度过这个适应期后，写出来的 Rust 是又安全又快。

5 个最核心概念：

所有权：每个值有唯一所有者，drop 时释放
借用：用引用不夺所有权，可变借用唯一性
生命周期：引用的有效范围，编译期检查
模式匹配：match / if let 替代 switch
Cargo workspace：管理多 crate 项目的事实标准

5 个最容易踩的坑：

同时有可变 + 不可变引用 → 缩小不可变引用的作用域
迭代时修改容器 → 先收完再改、用 iter_mut / 索引遍历
忘了 clone()，以为 String 是 Copy → 它不是
生命周期标注冗余或缺失 → 编译器提示加 'a
cargo search 用不了镜像 → 必须直连 crates.io

数据来源：

Tauri 2.x 跨平台桌面应用：Rust + WebView2 实战

Fri, 15 May 2020 00:00:00 +0800

什么是 Tauri 2.x

Tauri 是 2020 年起 Rust 生态的跨平台桌面应用框架，2.0 版本（2024-10 GA）带来更完善的插件体系和移动端支持。

核心架构

前端：任意 Web 框架（React / Vue / Svelte / Solid）
后端：Rust 二进制，编译成原生代码
WebView：复用系统 WebView（Windows WebView2 / macOS WKWebView / Linux WebKitGTK）
进程间通信：Rust 命令 + JS 桥

优势

包大小 2~10MB（vs Electron 80MB+）
内存低：复用系统 WebView，不开新 Chromium
Rust 内存安全：无 GC 抖动
细粒度权限：声明式 ACL
移动端支持（2.0+）：iOS / Android

前置环境

通用

Rust 工具链：curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Node.js 18+（推荐 22 LTS）
包管理：pnpm

Windows

Microsoft C++ Build Tools（安装时勾选"使用 C++ 的桌面开发"）
WebView2 Runtime（Win10 1803+ 预装）
- 旧版：下载 https://developer.microsoft.com/zh-cn/microsoft-edge/webview2/

macOS

1

xcode-select --install

Linux (Debian/Ubuntu)

1
2
3
4
5
6
7
8


sudo apt install -y \
 libwebkit2gtk-4.1-dev \
 libgtk-3-dev \
 libayatana-appindicator3-dev \
 librsvg2-dev \
 libssl-dev \
 libjavascriptcoregtk-4.1-dev \
 libsoup-3.0-dev

创建项目

1. 创建工作区

1
2
3
4


mkdir -p tauri-app && cd tauri-app

# pnpm-workspace.yaml
nvim pnpm-workspace.yaml

1
2
3


packages:
 - 'frontend'
 - 'src-tauri'

2. 创建 Vite + React 前端

1

pnpm create vite frontend --template react-ts

3. 添加 Tauri CLI

1

pnpm add -D @tauri-apps/cli@latest -w

package.json 会加：

1

"@tauri-apps/cli": "^2.11.1"

4. 初始化 Tauri

1

pnpm tauri init

按提示填写：

1
2
3
4
5
6


✔ What is your app name? · tauri-app
✔ What should the window title be? · tauri-app
✔ Where are your web assets (HTML/CSS/JS) located, relative to the "<current dir>/src-tauri/tauri.conf.json" file that will be created? · ../frontend/dist
✔ What is the url of your dev server? http://localhost:1420
✔ What is your frontend dev command? · pnpm -F frontend dev
✔ What is your frontend build command? · pnpm -F frontend build

5. 安装依赖

1
2


pnpm install
mkdir -p frontend/dist # dist 必须存在

6. 修改 tauri.conf.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


{
 "productName": "tauri-app",
 "version": "0.1.0",
 "identifier": "com.example.tauri-app",
 "build": {
 "frontendDist": "../frontend/dist",
 "devUrl": "http://localhost:1420",
 "beforeDevCommand": "pnpm -F frontend dev",
 "beforeBuildCommand": "pnpm -F frontend build"
 },
 "app": {
 "windows": [
 {
 "title": "tauri-app",
 "width": 1200,
 "height": 800
 }
 ],
 "security": {
 "csp": null
 }
 }
}

开发与打包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 开发（自动打开 DevTools 调试）
pnpm tauri dev

# 打包
pnpm tauri build

# 结果
# Windows: src-tauri/target/release/tauri-app.exe
# macOS: src-tauri/target/release/bundle/macos/tauri-app.app
# Linux: src-tauri/target/release/bundle/deb/*.deb

Cargo 工作区改造

Tauri 2.x 推荐用 Cargo 工作区管理（多包）：

1
2
3
4


# Cargo.toml (根目录)
[workspace]
members = ["src-tauri"]
resolver = "2"

迁移步骤：

删 src-tauri/target（构建会在根目录的 target 重新生成）
迁移 src-tauri/.gitignore 到根目录并修改
删 frontend/.gitignore（如果根目录有覆盖）

根目录 .gitignore：

1
2
3
4
5


**/target/
/src-tauri/gen/schemas

**/node_modules
**/dist

Vite 配置

frontend/vite.config.ts：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

const host = process.env.TAURI_DEV_HOST;

export default defineConfig({
 plugins: [react()],
 // 防止 Vite 清除 Rust 显示的错误
 clearScreen: false,
 server: {
 port: 5173,
 strictPort: true, // Tauri 需要固定端口
 host: host || false,
 hmr: host
 ? {
 protocol: "ws",
 host,
 port: 5174,
 }
 : undefined,
 watch: {
 // 告诉 Vite 忽略 src-tauri 目录
 ignored: ["**/src-tauri/**"],
 },
 },
 envPrefix: ["VITE_", "TAURI_ENV_*"],
 build: {
 // Windows 用 chromium，其他用 safari13
 target:
 process.env.TAURI_ENV_PLATFORM == "windows" ? "chrome105" : "safari13",
 minify: !process.env.TAURI_ENV_DEBUG ? "esbuild" : false,
 sourcemap: !!process.env.TAURI_ENV_DEBUG,
 },
});

Rust 后端命令

Tauri 2.x 用 #[tauri::command] 宏定义命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


// src-tauri/src/main.rs (或 src/lib.rs)
use tauri::Manager;

#[tauri::command]
fn greet(name: &str) -> String {
 format!("Hello, {}! 你好, Tauri!", name)
}

#[tauri::command]
async fn fetch_data(url: String) -> Result<String, String> {
 reqwest::get(&url)
 .await
 .map_err(|e| e.to_string())?
 .text()
 .await
 .map_err(|e| e.to_string())
}

fn main() {
 tauri::Builder::default()
 .invoke_handler(tauri::generate_handler![greet, fetch_data])
 .setup(|app| {
 #[cfg(debug_assertions)]
 {
 let window = app.get_webview_window("main").unwrap();
 window.open_devtools();
 }
 Ok(())
 })
 .run(tauri::generate_context!())
 .expect("error while running tauri application");
}

前端调用 Rust 命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// frontend/src/App.tsx
import { invoke } from "@tauri-apps/api/core";
import { useState } from "react";

function App() {
 const [greeting, setGreeting] = useState("");

 async function handleClick() {
 const msg = await invoke<string>("greet", { name: "World" });
 setGreeting(msg);
 }

 return (
 <div>
 <button onClick={handleClick}>调用 Rust</button>
 <p>{greeting}</p>
 </div>
 );
}

export default App;

常用插件

1
2
3
4
5
6
7
8


pnpm tauri add fs
pnpm tauri add dialog
pnpm tauri add notification
pnpm tauri add shell
pnpm tauri add http
pnpm tauri add store
pnpm tauri add window
pnpm tauri add updater

权限配置

src-tauri/capabilities/default.json：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


{
 "$schema": "../gen/schemas/desktop-schema.json",
 "identifier": "default",
 "description": "默认权限",
 "windows": ["main"],
 "permissions": [
 "core:default",
 "fs:allow-read-text-file",
 "fs:allow-write-text-file",
 "dialog:default",
 "notification:default"
 ]
}

文件系统

1
2
3
4
5
6
7
8


// Rust
use tauri_plugin_fs::FsExt;

#[tauri::command]
fn read_config(app: tauri::AppHandle) -> Result<String, String> {
 let path = app.path().app_config_dir().unwrap().join("config.json");
 std::fs::read_to_string(path).map_err(|e| e.to_string())
}

1
2
3
4


// 前端
import { readTextFile } from '@tauri-apps/plugin-fs';

const content = await readTextFile('/path/to/file.txt');

状态管理

Tauri 用 tauri::State 在命令间共享状态：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


use std::sync::Mutex;

struct AppState {
 counter: Mutex<i32>,
}

#[tauri::command]
fn increment(state: tauri::State<AppState>) -> i32 {
 let mut count = state.counter.lock().unwrap();
 *count += 1;
 *count
}

fn main() {
 tauri::Builder::default()
 .manage(AppState { counter: Mutex::new(0) })
 .invoke_handler(tauri::generate_handler![increment])
 .run(tauri::generate_context!())
 .expect("failed to run app");
}

事件系统

1
2
3
4
5
6
7


// Rust 发送事件
use tauri::Emitter;

#[tauri::command]
fn start_task(app: tauri::AppHandle) {
 app.emit("task-progress", "started").unwrap();
}

1
2
3
4
5
6
7
8
9


// 前端监听
import { listen } from '@tauri-apps/api/event';

const unlisten = await listen<string>('task-progress', (event) => {
 console.log('收到:', event.payload);
});

// 取消监听
unlisten();

跨平台打包

1
2
3
4
5
6
7
8


# 当前平台
pnpm tauri build

# 指定平台（需要对应工具链）
pnpm tauri build --target x86_64-pc-windows-msvc
pnpm tauri build --target x86_64-apple-darwin
pnpm tauri build --target aarch64-apple-darwin
pnpm tauri build --target x86_64-unknown-linux-gnu

性能对比

指标	Tauri 2.x	Electron
包大小（Hello World）	3~5MB	80MB
内存空闲	30~80MB	100~200MB
启动时间	0.3~1s	1.5~3s
CPU 占用	低	中等

下一步

Electron 入门，看 2018-12-15《Electron 跨平台桌面应用》
桌面开发技术栈对比，看 2014-08-15《桌面开发技术栈对比》

参考资料

Tauri 官方：https://tauri.app/
Tauri 2.x 文档：https://v2.tauri.app/
Awesome Tauri：https://github.com/tauri-apps/awesome-tauri
tauri-plugin-* 插件列表：https://v2.tauri.app/plugin/

Linux 办公与开发工具链：钉钉/飞书/Navicat/Zsh/sdkman/Go/Rust/Docker

Fri, 15 Jul 2016 00:00:00 +0800

办公三件套

钉钉：fix_dingtalk.sh 修 GNU_STACK RWE 坑

钉钉 8.x 系列的 .deb 包在 Kali / Debian 上的常见问题是：可执行文件带 GNU_STACK RWE（可执行栈），触发安全告警。fix_dingtalk.sh 用 patchelf 把 RWE 改成 RW：

1
2
3
4
5
6
7
8
9


sudo dpkg -i com.alibabainc.dingtalk_8.1.0.6021101_amd64.deb
sudo bash ~/Downloads/fix_dingtalk.sh

# 修复前：
# GNU_STACK 0x0000000000000000 0x0000000000000000 ... RWE 0x10
# 已修复: 0x7 (RWE) -> 0x6 (RW)

# 修复后：
# GNU_STACK 0x0000000000000000 0x0000000000000000 ... RW 0x10

飞书

1
2


sudo dpkg -i ./Feishu-linux_x64-7.62.9.deb
sudo apt --fix-broken install # 依赖缺失时修复

Navicat 17 Premium

Navicat Premium 17 改成了 AppImage，免安装：

1
2
3
4
5
6
7
8


# make it executable
chmod +x navicat17-premium-en-x86_64.AppImage
# run
./navicat17-premium-en-x86_64.AppImage

# 试用重置：删除配置 + dconf
rm -rf ~/.config/navicat
rm -rf ~/.config/dconf/user

永久试用脚本 /etc/init.d/navicat.trial.sh：开机自动重置 dconf，免去手动删除。

1

sudo chmod +x /etc/init.d/navicat.trial.sh

终端：Zsh + Oh My Zsh + Powerlevel10k

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 1. 查看当前 shell
echo $SHELL
/bin/bash

# 2. 切换为 zsh
chsh -s /bin/zsh

# 3. 退出 WSL 后再进
exit
wsl -t kali-linux
wsl

# 4. 安装 Oh My Zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

主题：Powerlevel10k

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 1. 克隆主题
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git \
 ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

# 2. 修改 ~/.zshrc
nvim ~/.zshrc
# ZSH_THEME="robbyrussell" 改成
ZSH_THEME="powerlevel10k/powerlevel10k"
source ~/.zshrc

# 3. 重新配置（按终端提示走）
p10k configure

插件：自动补全 + 语法高亮

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 自动提示历史记录
git clone https://github.com/zsh-users/zsh-autosuggestions \
 ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

# 语法高亮
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git \
 ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

# 写入 ~/.zshrc
nvim ~/.zshrc
# plugins=(git) 改成
plugins=(
 git
 zsh-autosuggestions
 zsh-syntax-highlighting
)
source ~/.zshrc

字体：Meslo Nerd Font

Powerlevel10k 的图标需要 Nerd Font：

1
2
3
4
5
6
7
8
9


# 下载 Meslo Nerd Font
wget https://github.com/ryanoasis/nerd-fonts/releases/latest/download/Meslo.zip
mkdir -p ~/.local/share/fonts
unzip Meslo.zip -d ~/.local/share/fonts/Meslo/
fc-cache -fv

# VSCode / Code 设置字体
# ~/.config/Code/user/settings.json
"terminal.integrated.fontFamily": "JetBrainsMono Nerd Font"

开发工具链

sdkman：JDK + Maven 多版本管理

sdkman 是 JVM 生态的版本管理工具，可以同时装 Java 8 / 11 / 17 / 21 并秒切：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# 1. 安装
apt install zip unzip -y
curl -s "https://get.sdkman.io" | bash
source ~/.sdkman/bin/sdkman-init.sh
sdk version

# 2. 卸载 Debian 默认 JDK
dpkg --list | grep -i jdk
sudo apt purge openjdk-*-jdk openjdk-*-jre
sudo apt autoremove --purge

# 3. 清理 update-alternatives 软链接
sudo update-alternatives --get-selections | grep java
sudo update-alternatives --remove-all jexec
sudo update-alternatives --remove-all jpackage
sudo update-alternatives --remove-all keytool
sudo update-alternatives --remove-all rmiregistry

# 4. 安装 JDK
sdk list java # 查可用版本
sdk install java 21.0.10-librca
sdk install java 8.0.482-librca

# 5. 切换
sdk use java 21.0.10-librca
sdk default java 21.0.10-librca # 全局默认
sdk current java
java -version

Maven

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


sdk list maven
sdk install maven 3.9.14

# PATH 写入
cat << 'EOF' >> ~/.zshrc
export PATH="$HOME/.sdkman/candidates/maven/current/bin:$PATH"
EOF

source ~/.zshrc
mvn -v

# 复用配置
cp /path/to/maven/settings.xml \
 ~/.sdkman/candidates/maven/current/conf/settings.xml

Go 1.x

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


cd /usr/local
sudo wget https://go.dev/dl/go1.26.3.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && \
 sudo tar -C /usr/local -xzf go1.26.3.linux-amd64.tar.gz
sudo rm -rf go1.26.3.linux-amd64.tar.gz

cat << 'EOF' >> ~/.zshrc
export PATH=$PATH:/usr/local/go/bin
EOF

source ~/.zshrc
go version

# 1. 开启 Go Modules
go env -w GO111MODULE=on
# 2. 设置 GOPROXY 代理（goproxy.cn 国内友好）
go env -w GOPROXY=https://goproxy.cn,direct

Rust

1
2
3
4
5
6
7
8
9


curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
. "$HOME/.cargo/env"

rustc --version
rustup --version
cargo --version

# 卸载
rustup self uninstall

Lua

1
2


sudo apt install lua5.4 -y
lua -v

Docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


sudo apt install -y docker.io

# 配置 daemon.json
sudo tee /etc/docker/daemon.json << "EOF"
{
 "exec-opts": ["native.cgroupdriver=systemd"],
 "log-driver": "json-file",
 "log-opts": { "max-size": "50m", "max-file": "1" }
}
EOF

# 服务配置
sudo systemctl daemon-reload
sudo systemctl enable docker
sudo systemctl restart docker
sudo docker info
sudo docker ps

# 添加组（docker 命令不用 sudo）
sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker

IDE 工具

Cursor

1

sudo dpkg -i ./cursor_3.3.30_amd64.deb

IntelliJ IDEA 2026.1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


sudo tar -zxvf idea*.tar.gz -C /opt
/opt/idea-IU-261.23567.138

cd /opt/idea*/bin
./idea.sh

# 写入 PATH
cat << 'EOF' >> ~/.zshrc
export IDEA_HOME=/opt/idea-IU-261.23567.138
export PATH=:$PATH:${IDEA_HOME}/bin
EOF

source ~/.zshrc

wsl-screenshot-cli：截图同步给 AI

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# wsl 内安装到 /root/go/bin/wsl-screenshot-cli
go install github.com/nailuu/wsl-screenshot-cli@latest

# 写入 zshrc
cat << "EOF" >> ~/.zshrc
export PATH=$PATH:$(go env GOPATH)/bin
wsl-screenshot-cli start --daemon --quiet
EOF

source ~/.zshrc

# 启动 / 状态 / 停止 / 更新
wsl-screenshot-cli start --daemon
wsl-screenshot-cli status
wsl-screenshot-cli stop
wsl-screenshot-cli update

配合 Claude Code 钩子，截图后自动可用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


{
 "hooks": {
 "SessionStart": [{
 "matcher": "",
 "hooks": [{
 "type": "command",
 "command": "wsl-screenshot-cli start --daemon --quiet 2>/dev/null; echo 'wsl-screenshot-cli started'"
 }]
 }],
 "SessionEnd": [{
 "matcher": "",
 "hooks": [{
 "type": "command",
 "command": "wsl-screenshot-cli stop 2>/dev/null"
 }]
 }]
 }
}

下一步

想要更丝滑的 WSL2 体验，看 2017-01-15《WSL2 完整使用手册》
想了解 Windows 同等工具链，看 2017-11-15《Windows 终端与 Shell 工具链》