第十一章:MySQL + Redis 最终面试总复习
你明天就去面前端实习,面试官顺着 Node.js、MySQL、Redis 和你的项目开始拷打。
MySQL 与 Redis 前端速成11 / 11

这一章我不再按照“教材”讲,而是按照:
你明天就去面前端实习,面试官顺着 Node.js、MySQL、Redis 和你的项目开始拷打。
来整理。
你的简历目前写的是 Node.js(Express)+ 了解 MySQL、Redis,同时项目里有订单状态机、AI 问诊、异步任务、复杂检索等场景,所以你不需要装成 DBA,但一定要做到:核心原理讲得准、项目设计讲得通、追问两三层不会崩。
先给你最终结论:
MySQL 真正必须吃透:索引 + 事务/MVCC/锁 + SQL 优化。
Redis 真正必须吃透:数据类型 + Cache Aside + 三大缓存问题 + 持久化/淘汰 + 分布式锁/幂等。
其他东西都围绕这两条主线展开。
一、先建立最终知识地图
以后面试官问 MySQL,你脑子里应该出现:
MySQL
│
├── 数据怎么查快?
│ └── B+树 → 索引 → 联合索引 → 回表 → 覆盖索引 → EXPLAIN
│
├── 并发修改怎么保证安全?
│ └── 事务 → ACID → 隔离级别 → MVCC → 锁
│
├── SQL 为什么慢?
│ └── 索引 → 扫描量 → 回表 → 排序 → 深分页 → N+1
│
└── 数据为什么不会乱?
└── 事务 + Undo Log + Redo Log + 锁 + 约束
Redis:
Redis
│
├── 为什么快?
│ └── 内存 + 高效数据结构 + IO多路复用
│
├── 存什么?
│ └── String / Hash / List / Set / ZSet
│
├── 怎么和 MySQL 配合?
│ └── Cache Aside
│
├── 缓存出问题怎么办?
│ └── 穿透 / 击穿 / 雪崩
│
├── 内存满了怎么办?
│ └── TTL + 过期删除 + LRU/LFU
│
├── Redis 重启怎么办?
│ └── RDB / AOF
│
└── 高并发怎么办?
└── 原子命令 + Lua + 分布式锁 + 幂等 + 限流
如果这两张图能在脑子里建立起来,你已经不会觉得 MySQL、Redis 是一堆散乱八股了。
二、MySQL 第一核心:索引
1. 索引到底是什么?
不要只背:
索引是提高查询效率的数据结构。
你应该回答:
索引本质是用额外的存储空间和写入维护成本,换取查询效率。InnoDB 的索引主要使用 B+ 树,通过有序的数据结构减少需要扫描的数据量。
这里最重要的不是:
“有索引就快。”
而是:
索引的本质是减少扫描。
三、为什么 InnoDB 用 B+ 树?
标准高质量答案:
B+ 树具有较高的扇出,一个节点能够保存很多索引项,因此即使数据量很大,树高通常也比较低,可以减少磁盘页访问次数。同时非叶子节点主要用于索引导航,完整数据集中在叶子节点,叶子节点又按顺序连接,因此既适合等值查询,也非常适合范围查询、排序和顺序扫描。
面试官追问:
为什么不用二叉树?
你回答:
二叉树一个节点最多两个子节点,数据量大时树高容易增加,而数据库一次磁盘 IO 成本远高于内存比较成本,所以数据库更希望用“矮而胖”的树减少 IO 次数。
这就不是只会背“B+树”了。
四、聚簇索引、二级索引、回表
这是必须彻底明白的。
InnoDB:
主键索引
↓
B+树叶子节点
↓
完整行数据
所以主键索引通常是:
聚簇索引。
普通索引:
name 索引
↓
B+树叶子节点
↓
name + 主键 id
查询:
-- 根据姓名查询用户完整信息
SELECT *
FROM users
WHERE name = '刘凤伟'; -- name 假设建立了普通索引
过程:
先查询 name 二级索引
↓
获得主键 ID
↓
再查询主键索引
↓
获得完整用户数据
这就是:
回表。
五、覆盖索引
如果:
-- 只查询普通索引本身以及主键字段
SELECT
id, -- 主键通常存在于二级索引叶子节点
name -- 当前二级索引字段
FROM users
WHERE name = '刘凤伟'; -- 根据 name 索引查询
二级索引已经包含需要的全部字段。
因此:
不需要回表。
这叫覆盖索引。
面试加分点
不要说:
SELECT *会导致索引失效。
这是错误的。
正确:
SELECT *不一定导致索引失效,但是容易让查询无法使用覆盖索引,从而增加回表和 IO。
六、联合索引和最左前缀
比如订单查询:
-- 查询某个用户指定状态下的最新订单
SELECT
id, -- 订单 ID
order_no, -- 订单编号
created_at -- 创建时间
FROM orders
WHERE user_id = 1001 -- 第一个等值查询条件
AND status = 20 -- 第二个等值查询条件
ORDER BY created_at DESC -- 最后按照时间排序
LIMIT 20; -- 只返回最新 20 条
可以设计:
-- 建立用户、状态、创建时间联合索引
CREATE INDEX idx_user_status_created
ON orders (
user_id, -- 第一列:用户
status, -- 第二列:状态
created_at -- 第三列:时间
);
排列逻辑:
先 user_id
↓
user_id 相同时按 status
↓
前两者相同时按 created_at
所以:
(a,b,c)
a ✅
a,b ✅
a,b,c ✅
b,c ❌ 无法充分利用最左前缀
a,c ✅ 可以利用 a,但 c 不能直接跨过 b 完整用于定位
要特别记住:
WHERE 中字段书写顺序不决定联合索引是否生效,优化器可以调整条件。真正重要的是索引自身的字段顺序。
七、索引失效不要背成绝对规则
你应该知道几个高频风险:
对索引列做函数计算
-- 不推荐:对索引列执行函数,可能影响普通索引使用
SELECT
id, -- 订单 ID
created_at -- 创建时间
FROM orders
WHERE DATE(created_at) = '2026-08-02'; -- 对 created_at 做函数计算
更好:
-- 推荐:直接按照时间范围进行查询
SELECT
id, -- 订单 ID
created_at -- 创建时间
FROM orders
WHERE created_at >= '2026-08-02 00:00:00' -- 包含当天零点
AND created_at < '2026-08-03 00:00:00'; -- 不包含第二天零点
前置 %
-- 已知字符串开头,更容易利用普通 B+ 树索引
SELECT
id, -- 用户 ID
name -- 用户名称
FROM users
WHERE name LIKE '刘%'; -- 前缀确定
而:
-- 前缀未知,普通 B+ 树通常难以快速定位起点
SELECT
id, -- 用户 ID
name -- 用户名称
FROM users
WHERE name LIKE '%凤伟%'; -- 开头就是通配符
隐式类型转换
数据库是:
phone VARCHAR
查询尽量写:
-- phone 是字符串字段,因此使用字符串进行比较
SELECT
id, -- 用户 ID
phone -- 手机号
FROM users
WHERE phone = '15118978572'; -- 类型与数据库字段一致
八、MySQL 第二核心:事务
一句话理解:
事务就是一组 SQL,要么一起成功,要么一起失败。
例如:
创建订单
+
扣库存
不能出现:
订单创建成功
库存扣减失败
事务:
-- 开启数据库事务
START TRANSACTION;
-- 创建订单
INSERT INTO orders (
order_no, -- 订单编号
user_id -- 用户 ID
)
VALUES (
'ORDER001', -- 新订单编号
1001 -- 下单用户
);
-- 在库存大于 0 时扣减库存
UPDATE products
SET stock = stock - 1 -- 库存减一
WHERE id = 2001 -- 指定商品
AND stock > 0; -- 保证库存不会直接扣成负数
-- 所有操作成功后正式提交
COMMIT;
失败:
-- 事务过程中出现异常时撤销本次修改
ROLLBACK;
九、ACID 必须能脱口而出
A Atomicity 原子性
C Consistency 一致性
I Isolation 隔离性
D Durability 持久性
推荐回答:
原子性保证事务中的操作要么全部成功要么全部失败;一致性保证事务执行前后数据符合业务规则;隔离性处理并发事务之间的相互影响;持久性保证已经提交的数据能够可靠保存。
十、这里补一个前十章没重点讲、但很值得知道的东西
Undo Log 和 Redo Log
Undo Log
主要解决:
后悔怎么办?
执行:
stock:10 → 9
Undo Log 会记录修改前的信息。
作用:
- 事务回滚;
- MVCC 历史版本。
记忆:
Undo = 撤销。
Redo Log
主要解决:
已经提交,但服务器突然断电怎么办?
数据库修改通常先操作内存页,如果每个事务都马上随机写磁盘数据页,成本很高。
Redo Log 会记录:
哪些修改已经做过。
宕机恢复时可以根据 Redo Log 恢复已提交事务。
记忆:
Redo = 重做。
非常漂亮的一句回答:
Undo Log 主要保证回滚能力并支持 MVCC,解决“修改了但需要撤销”的问题;Redo Log 记录已经完成的修改,用于崩溃恢复,是事务持久性的重要基础。
十一、binlog 要不要会?
你是前端,不需要深入。
只知道:
binlog 是 MySQL Server 层的逻辑日志,常用于主从复制、数据恢复等。
区别:
Undo Log
回滚 + MVCC
Redo Log
InnoDB 崩溃恢复
Binlog
Server 层归档 / 主从复制 / 数据恢复
这已经够你面前端实习。
十二、隔离级别必须背
从低到高:
Read Uncommitted
读未提交
Read Committed
读已提交
Repeatable Read
可重复读
Serializable
串行化
并发问题:
脏读
读到了别人没有提交的数据。
不可重复读
同一个事务,两次读同一行结果不同。
幻读
相同条件范围查询,前后数据行发生变化。
一句话:
脏读是读了未提交;不可重复读是一行变了;幻读是一批数据变了。
十三、MVCC 是面试里必须讲漂亮的地方
不要只说:
MVCC 就是多版本并发控制。
完整答案:
MVCC 是 InnoDB 用来提高并发读写性能的一套多版本并发控制机制。数据修改时通过 Undo Log 保留历史版本,并结合事务 ID 和 Read View 判断当前事务能够看到哪个版本。这样普通 SELECT 可以读取符合自身可见性规则的历史版本,不需要和写事务互相长时间阻塞。
关键结构:
Undo Log
+
事务 ID
+
Read View
↓
判断版本可见性
核心价值:
让读和写尽量互不阻塞。
十四、快照读 vs 当前读
普通:
-- 普通 SELECT 一般属于快照读,会根据 MVCC 可见性读取数据
SELECT
id, -- 订单 ID
status -- 订单状态
FROM orders
WHERE id = 1001; -- 查询指定订单
属于:
快照读。
而:
-- 查询最新数据,同时对目标记录加排他锁
SELECT
id, -- 订单 ID
stock -- 当前库存
FROM products
WHERE id = 2001 -- 指定商品
FOR UPDATE; -- 当前读,并加排他锁
属于:
当前读。
十五、MySQL RR 为什么还能处理幻读?
这是进阶加分点。
MySQL InnoDB 默认常见隔离级别是:
Repeatable Read。
它除了使用 MVCC 解决快照读的一致性,在加锁的当前读场景中还会使用:
Record Lock + Gap Lock → Next-Key Lock
简单理解:
Record Lock
锁住已经存在的记录
Gap Lock
锁住记录之间的间隙
Next-Key Lock
记录锁 + 间隙锁
例如查询:
-- 锁定金额处于指定范围的数据,用于演示范围当前读
SELECT
id, -- 订单 ID
amount -- 订单金额
FROM orders
WHERE amount > 100 -- 查询范围
AND amount < 200 -- 查询范围
FOR UPDATE; -- 当前读并加锁
InnoDB 不只是锁已有的记录,还可能锁一定范围的间隙,阻止其他事务往相关范围插入数据,从而降低幻读问题。
你不用深入算法。
面试官问到可以回答:
InnoDB 的 RR 不只是靠 MVCC。快照读主要依赖 MVCC,而当前读还会结合 Record Lock、Gap Lock 和 Next-Key Lock 来限制相关范围的插入,因此能较好处理幻读。
这句话很加分。
十六、乐观锁 vs 悲观锁
悲观锁
我觉得别人一定会和我抢,所以先锁住。
-- 查询商品最新库存,并锁住目标记录
SELECT
id, -- 商品 ID
stock -- 当前库存
FROM products
WHERE id = 2001 -- 指定商品
FOR UPDATE; -- 添加排他锁
乐观锁
我先不锁,提交修改时检查版本。
-- 只有版本号仍然为 5 时才允许更新
UPDATE products
SET
stock = stock - 1, -- 库存减一
version = version + 1 -- 更新版本号
WHERE id = 2001 -- 指定商品
AND stock > 0 -- 保证库存充足
AND version = 5; -- 保证数据没有被其他请求修改
一句话:
悲观锁是先锁再改,乐观锁是修改时检测冲突。
十七、真正优秀的库存扣减写法
不要写:
SELECT stock
判断 > 0
UPDATE stock - 1
因为两个请求可能同时读到库存 1。
更好:
-- 只有库存仍然大于零时,数据库才会完成扣减
UPDATE products
SET stock = stock - 1 -- 原子扣减库存
WHERE id = 2001 -- 指定商品
AND stock > 0; -- 保证库存不能被扣成负数
然后:
affectedRows = 1
成功
affectedRows = 0
库存不足
这种:
利用数据库条件更新保证原子性
非常值得在面试中说。
十八、MySQL 第三核心:慢 SQL
如果面试官问:
SQL 很慢怎么排查?
别只说:
加索引。
满分思路:
1. 先确定是不是数据库慢
2. 找到具体 SQL
3. EXPLAIN 分析执行计划
4. 看 type
5. 看 key
6. 看 rows
7. 看 Extra
8. 检查索引
9. 检查 SQL 写法
10. 优化后重新测试
标准回答:
我会先判断耗时到底发生在前端渲染、网络、后端业务还是数据库。如果确认 SQL 较慢,再通过慢查询日志找到 SQL,并使用 EXPLAIN 查看 type、实际使用的 key、预计扫描 rows 和 Extra。之后重点检查联合索引设计、回表、函数计算、前置模糊查询、隐式类型转换、额外排序、深分页、N+1 和返回数据量,最后通过实际执行时间验证优化效果。
这段建议背下来。
十九、EXPLAIN 最重要的字段
只背:
type
key
rows
Extra
type 常见:
const
ref
range
index
ALL
越往下通常需要越警惕。
但:
ALL不是必然有问题。
一张表只有十条数据,全表扫描很合理。
真正危险:
大表
+
高频 SQL
+
ALL
+
rows 巨大
二十、Extra 三兄弟
Using index
通常:
使用了覆盖索引。
Using filesort
需要额外排序。
不代表一定使用磁盘文件。
Using temporary
使用临时表,需要在复杂 GROUP BY / ORDER BY 等场景关注。
二十一、深分页一定会被问
普通:
-- 跳过前十万条,再查询十条
SELECT
id, -- 订单 ID
order_no -- 订单编号
FROM orders
ORDER BY id DESC -- 按主键倒序
LIMIT 100000, 10; -- 深分页
数据库可能需要:
扫描 100010 条
丢掉前 100000
留下 10 条
游标分页:
-- 根据上一页最后一条记录 ID 查询下一页
SELECT
id, -- 订单 ID
order_no -- 订单编号
FROM orders
WHERE id < 88888 -- 上一页最后一个 ID
ORDER BY id DESC -- 按 ID 倒序
LIMIT 10; -- 只获取下一页十条
前端也应该理解:
无限滚动、消息流、订单流适合 cursor / lastId,而后台需要任意跳页时 page/pageSize 更方便。
二十二、N+1 问题
错误:
// 先查询 100 条订单
const orders = await getOrders();
// 遍历 100 条订单
for (const order of orders) {
// 每条订单都再请求一次数据库查询用户
order.user = await getUserById(order.userId);
}
数据库:
1 + 100 = 101 次查询
解决:
JOIN / 批量 IN / ORM 预加载。
二十三、SQL 注入——前端转全栈最好会
不要拼字符串:
// 错误示例:直接拼接用户输入,存在 SQL 注入风险
const sql =
"SELECT * FROM users WHERE username = '" +
username +
"'";
应该参数化:
// 使用参数化 SQL,将用户输入与 SQL 结构分离
const [rows] = await pool.execute(
`
-- 根据用户名查询用户
SELECT
id, -- 用户 ID
username -- 用户名
FROM users
WHERE username = ? -- 使用占位符,不直接拼接用户输入
`,
[username], // 数据库驱动负责安全处理参数
);
一句话:
用户输入不能直接拼进 SQL,使用参数化查询 / Prepared Statement。
二十四、Redis 第一核心:五种数据类型
最终只需要这样记:
| 类型 | 一句话 | 典型场景 |
|---|---|---|
| String | 一个 Key 一个 Value | Token、验证码、缓存、计数 |
| Hash | 一个 Key 一个对象 | 用户、任务状态 |
| List | 有序可重复 | 最近记录、简单队列 |
| Set | 无序不重复 | 点赞、去重、共同关注 |
| ZSet | 有 score 的有序集合 | 排行榜、热度 |
口诀:
String 缓存计数,Hash 保存对象,List 保存队列,Set 负责去重,ZSet 负责排名。
必须背。
二十五、Redis 为什么快?
标准答案:
Redis 的主要数据存放在内存中,避免大量磁盘随机 IO;同时内部数据结构针对不同场景高度优化,命令执行路径相对简单,并采用事件驱动和 IO 多路复用处理大量连接。Redis 核心命令执行主要保持顺序性,减少线程切换和锁竞争,但 Redis 整体并不是所有工作都只有一个线程。
这一段非常值得背。
二十六、Cache Aside 是 Redis 最重要的业务模式
读取:
查 Redis
↓
有 → 返回
没有
↓
查 MySQL
↓
写 Redis
↓
返回
写:
更新 MySQL
↓
删除 Redis
不是:
更新 MySQL
+
更新 Redis
主要原因:
并发情况下两个请求更新缓存的完成顺序可能与数据库顺序不一致,旧缓存可能覆盖新缓存。
所以:
缓存更适合失效,而不是复杂地同步修改。
二十七、Redis 和 MySQL 一致性标准答案
建议整段背:
在 Cache Aside 模式下,读取时先查 Redis,未命中再查 MySQL 并回填缓存;更新时通常先更新 MySQL,再删除 Redis。这样可以降低并发场景下旧缓存覆盖新数据的风险。不过缓存和数据库很难做到绝对强一致,一般通过合理 TTL、删除失败重试、消息队列补偿等机制保证最终一致性。
非常高频。
二十八、为什么不是“先删 Redis,再更新 MySQL”?
并发场景:
请求 A 删除 Redis
↓
请求 B 查询 Redis:没有
↓
请求 B 查询 MySQL:旧数据
↓
请求 B 将旧数据写 Redis
↓
请求 A 更新 MySQL
结果:
MySQL:新
Redis:旧
所以一般:
先更新数据库,再删除缓存。
注意:
也不是绝对不会有问题,只是通常风险窗口更合理。
二十九、Redis 面试必杀三兄弟
必须形成条件反射。
缓存穿透
Redis 没有
MySQL 也没有
请求的是:
不存在的数据。
解决:
参数校验
空值缓存
布隆过滤器
限流
缓存击穿
一个超级热点 Key
突然过期
大量请求:
Redis Miss
↓
同时访问 MySQL
解决:
互斥锁
逻辑过期
后台刷新
热点数据预热
缓存雪崩
大量 Key 同时过期
或者
Redis 整体不可用
解决:
随机 TTL
缓存预热
高可用
限流
服务降级
终极口诀:
穿透:查无此人。
击穿:一个明星倒了。
雪崩:整个保安队都倒了。
三十、布隆过滤器必须理解一个坑
不要说:
布隆过滤器可以判断数据是否存在。
准确:
布隆过滤器可以非常确定地判断“某个数据不存在”,但是判断“可能存在”时存在一定误判概率。
所以:
判断不存在
→ 基本可以直接拒绝
判断可能存在
→ 还需要继续查 Redis / MySQL
三十一、Redis 过期 Key 怎么删?
两种核心策略:
惰性删除
+
定期删除
惰性删除
访问时发现已经过期,再删。
定期删除
周期性抽样检查过期 Key。
为什么不是给所有 Key 精确计时?
Key 数量巨大时,为每个 Key 维护精确定时删除成本太高。
三十二、内存满了怎么办?
记住:
过期删除 ≠ 内存淘汰。
过期:
自己寿命到了。
淘汰:
Redis 房间不够了,不得不赶人。
最值得掌握:
LRU
最近最少使用。
记:
看多久没访问。
LFU
最不经常使用。
记:
看访问次数。
面试不要强行说:
LRU 永远最好。
应该:
根据业务访问模式、哪些 Key 可以丢以及热点分布选择策略。
三十三、RDB 和 AOF
口诀:
RDB 拍照片,AOF 写日记。
RDB
定期保存整个数据快照。
优点:
- 文件紧凑;
- 恢复快。
缺点:
- 两次快照之间的数据可能丢失。
AOF
记录写操作。
优点:
- 数据丢失窗口通常更小。
缺点:
- 文件更大;
- 恢复可能更慢;
- 需要 AOF Rewrite。
标准答案:
RDB 是时间点快照,适合备份和快速恢复,但可能丢失快照间的数据;AOF 持续记录写命令,数据完整性通常更高,但文件更大,需要通过重写控制体积。实际系统可以根据数据重要性结合使用。
三十四、热 Key vs 大 Key
这是高频但很好背。
热 Key
访问次数特别多。
危险:
- 单节点压力;
- 网络带宽;
- 击穿。
解决:
- 本地缓存;
- 副本分散;
- 预热;
- 不物理过期;
- 限流。
大 Key
Value 很大或集合元素很多。
危险:
- 占内存;
- 网络传输慢;
- 删除慢;
- 阻塞;
- 集群迁移困难。
解决:
- 拆分;
- 分页;
- 避免一次读全部;
- 大 Key 删除考虑
UNLINK。
口诀:
热 Key 是人太多,大 Key 是东西太重。
三十五、Redis 分布式锁
必须记这一行:
# 只有锁不存在时才能获取,同时设置 10 秒自动过期
SET lock:order:1001 "uuid-abc" NX EX 10
分别:
NX
不存在才能创建
EX
设置过期时间
UUID
确认锁是谁的
三十六、为什么 Value 必须使用唯一 Token?
假设:
A 获得锁
↓
A 超时,锁过期
B 获得新锁
↓
A 执行完
↓
A DEL 锁
A 把 B 的锁删了。
因此:
解锁时必须检查 Redis 中的 Token 是否还是自己的 Token。
三十七、为什么解锁要 Lua?
不能:
GET
判断
DEL
因为两条命令之间锁可能变化。
Lua:
-- 判断当前锁是否仍然属于当前请求
if redis.call('GET', KEYS[1]) == ARGV[1] then
-- 属于当前请求时才删除锁
return redis.call('DEL', KEYS[1])
else
-- 已经不属于当前请求时不能删除
return 0
end
作用:
判断 + 删除原子执行。
三十八、Redis 锁不是最终保险
这一句非常容易让面试官觉得你不是死背:
对订单、支付、库存这样的核心业务,我不会把 Redis 分布式锁当成唯一一致性保证。Redis 锁主要降低并发冲突,最终仍应该通过 MySQL 唯一索引、条件更新、事务等机制兜底。
例如两名鉴定师抢订单:
-- 只有订单仍然处于待接单状态时才能接单成功
UPDATE orders
SET
status = 20, -- 状态修改为进行中
appraiser_id = 3001 -- 记录鉴定师 ID
WHERE id = 1001 -- 指定订单
AND status = 10; -- 必须仍然是待接单状态
谁:
affectedRows = 1
谁成功。
另一个:
affectedRows = 0
失败。
这是比“Redis 加个锁”更可靠的回答。
三十九、幂等一定会用到
定义:
同一个操作执行一次和执行多次,最终结果一致。
例如支付回调。
第三方支付平台可能:
第一次回调
超时没收到你的响应
第二次回调
第三次回调
你不能:
每回调一次
余额 +100
解决:
业务唯一号
+
Redis 幂等 Key
+
数据库唯一索引
+
状态条件
四十、分布式锁和幂等不要混
分布式锁
解决:
能不能同时做?
幂等
解决:
做多次会不会产生多次结果?
一句:
锁解决并发,幂等解决重复。
四十一、Redis 原子性为什么重要?
比如:
# 原子增加接口访问次数
INCR rate_limit:user:1001
Redis 单个命令是原子的。
但:
INCR
+
EXPIRE
是两条命令,就不一定作为整体原子。
可能:
INCR 成功
程序挂了
EXPIRE 没执行
所以多步操作需要:
- Lua;
- Redis 事务;
- 或本身支持组合语义的命令。
面试中重点说:
Lua 可以让多步判断和修改以原子方式在 Redis 内执行。
四十二、Pipeline 和 Lua 的区别——补一个加分点
你不需要深入,但容易被问。
Pipeline
作用主要是:
减少网络往返 RTT。
例如一次批量发 100 个 Redis 命令。
但:
Pipeline 本身不意味着这些命令具有事务原子性。
Lua
主要优势:
多步业务逻辑在 Redis 服务端原子执行。
一句:
Pipeline 解决网络效率,Lua 更侧重多命令原子逻辑。
四十三、Redis 能不能当消息队列?
可以,但要分情况。
List:
# 将任务推入任务列表左侧
LPUSH task:queue "task-1001"
# 从任务列表右侧弹出任务
RPOP task:queue
可以实现简单队列。
但专业系统里:
如果需要消费确认、重试、持久化、消费组、消息追踪等完整能力,一般优先考虑 Redis Stream、RabbitMQ、Kafka 等。
不要说:
List 就是 RabbitMQ。
四十四、结合你的简历:万福鉴酒
你的项目有多角色订单状态流转,这是数据库最好讲的项目之一。
面试官:
订单状态怎么设计?
你可以答:
核心订单数据一定落 MySQL,因为订单需要长期存储、状态流转和事务一致性。Redis 只负责验证码、热点数据、短期幂等 Key 等辅助场景。订单状态更新不能无条件覆盖,而应该通过旧状态条件控制状态机流转。
比如:
-- 只有待接单订单才能进入鉴定中状态
UPDATE orders
SET
status = 20, -- 新状态:鉴定中
updated_at = NOW() -- 更新时间
WHERE id = ? -- 当前订单 ID
AND status = 10; -- 旧状态必须是待接单
然后:
如果影响行数为 0,说明订单已经被其他请求处理,前端重新拉取最新状态。
这就是:
- 并发控制;
- 状态机;
- 轻量乐观锁;
- 幂等。
四个知识一起讲出来。
四十五、结合生猪健康系统
你的项目存在药品、疾病、文章以及 AI 问诊等读多写少/高频访问数据。
面试官:
哪些数据适合 Redis?
回答:
药品和疾病详情属于典型读多写少数据,可以使用 Cache Aside 缓存;AI 对话长期记录需要 MySQL 持久化,但短期会话上下文、限流计数或者生成状态可以放 Redis。修改药品后先更新 MySQL,再删除对应 Redis Key。
继续追问:
热门药品缓存突然过期?
你:
热点 Key 高并发失效属于缓存击穿,可以通过互斥锁、逻辑过期或者后台刷新解决。
继续:
用户一直请求不存在药品?
你:
属于缓存穿透,可以通过参数校验、短期空值缓存和数据规模较大时使用布隆过滤器。
这一套已经很完整。
四十六、结合 TripStar AI
你的 TripStar 有异步生成进度、结果展示和 AI 对话场景。
非常适合回答:
MySQL + Redis 为什么要一起使用?
你可以回答:
AI 行程生成属于异步长任务。正式用户、任务记录和最终行程需要长期保存,所以落 MySQL;生成中的 progress、status、WebSocket 房间映射等高频临时状态适合 Redis,并设置 TTL。生成完成后最终结果写入 MySQL,临时状态可以删除或自然过期。
继续问:
用户连续点五次生成怎么办?
回答:
前端按钮禁用只是第一层,后端还需要接口幂等。客户端携带幂等 Key,Redis 使用
SET NX EX快速拦截重复请求,任务表对 request_no 建唯一索引作为最终兜底。
这就是非常好的全栈回答。
四十七、面试官连续拷打模拟 1:MySQL
面试官
MySQL 索引为什么用 B+ 树?
你
B+ 树扇出高、树高低,可以减少磁盘 IO;非叶子节点主要用于索引导航,叶子节点保存数据并且有序连接,所以同时适合等值查询、范围查询和排序。
面试官
什么叫回表?
你
InnoDB 二级索引叶子节点通常保存索引字段和主键,如果查询字段没有完全被二级索引覆盖,就要根据主键再查询聚簇索引获取完整行,这叫回表。
面试官
怎么避免?
你
可以针对高频查询设计覆盖索引,并避免无意义的
SELECT *,但不能为了覆盖索引把大量业务字段全部塞入索引,因为索引本身也有存储和写入维护成本。
这最后一句非常加分。
四十八、面试官连续拷打模拟 2:事务
面试官
MVCC 是什么?
你
MVCC 是多版本并发控制。InnoDB 通过 Undo Log 保存历史版本,通过事务 ID 和 Read View 判断当前事务能够看到哪个版本,使普通查询很多时候不需要和写事务互相阻塞。
面试官
那是不是完全不需要锁?
你
不是。MVCC 主要解决快照读的并发问题,而 UPDATE、DELETE、SELECT FOR UPDATE 等当前读仍然需要锁。
面试官
RR 怎么处理幻读?
你
快照读主要依赖 MVCC,而加锁当前读会结合 Record Lock、Gap Lock 和 Next-Key Lock 对记录和一定范围加锁,从而限制其他事务向相关范围插入数据。
这一套已经明显超过“了解 MySQL”的最低要求。
四十九、面试官连续拷打模拟 3:Redis
面试官
Redis 为什么快?
你
数据主要在内存,高效数据结构,命令执行路径简单,加上事件驱动和 IO 多路复用;核心命令执行主要保持顺序性,也减少了线程切换和锁竞争。
面试官
为什么不能所有东西都放 Redis?
你
Redis 内存成本更高,也不擅长复杂关系查询和完整事务业务。订单、支付、用户、正式行程等核心数据仍应该保存在 MySQL,Redis 更适合作为缓存和临时高频数据存储。
面试官
Redis 持久化以后也不行吗?
你
RDB 和 AOF 提升的是 Redis 的恢复能力,不会改变 Redis 的数据模型和主要定位,所以持久化不等于 Redis 就能替代 MySQL。
很好。
五十、你最容易说错的 12 个地方
这些一定检查一下。
❌ 1. Redis 就是单线程,所以快
应该:
Redis 核心命令执行主要顺序处理,但整体并非所有任务单线程。
❌ 2. SELECT * 会让索引失效
应该:
不一定失效,但可能增加回表、IO 和网络传输。
❌ 3. 使用 OR 一定索引失效
应该:
要结合索引情况和优化器执行计划判断。
❌ 4. type = ALL 一定需要优化
应该:
大表高频查询时要重点关注,小表全表扫描可能更合理。
❌ 5. 建索引一定变快
应该:
优化器根据成本决定是否使用索引。
❌ 6. 索引越多越好
应该:
索引提高查询但增加存储和增删改成本。
❌ 7. Redis 和 MySQL 可以做到绝对一致
应该:
普通缓存系统通常追求最终一致性。
❌ 8. 缓存击穿就是访问不存在的数据
错。
不存在 = 穿透。
❌ 9. Redis 锁可以完全保证订单安全
应该:
数据库唯一约束、状态条件和事务才是重要最终兜底。
❌ 10. RDB 比 AOF 一定好
没有这种绝对结论。
❌ 11. Redis 持久化后可以替代 MySQL
错误。
❌ 12. 分布式锁 = 幂等
错误。
锁防同时执行,幂等防重复结果。
五十一、真正需要你背下来的 15 个问题
如果时间极限,只背这些。
MySQL
1. MySQL 索引为什么使用 B+ 树?
扇出高、树高低、减少 IO,叶子节点有序连接,支持等值、范围和排序。
2. 什么是回表?
二级索引找到主键后,再查询聚簇索引获取完整行数据。
3. 什么是覆盖索引?
查询需要的所有字段都能直接从索引获取,不需要回表。
4. 什么是最左前缀?
联合索引从最左列开始连续匹配才能充分利用索引。
5. 什么是 ACID?
原子性、一致性、隔离性、持久性。
6. 什么是 MVCC?
Undo Log + 事务 ID + Read View 管理数据多个版本,减少读写阻塞。
7. 乐观锁和悲观锁区别?
悲观锁先锁再修改;乐观锁更新时通过 version 或旧状态检查冲突。
8. SQL 慢怎么优化?
定位 SQL → EXPLAIN → type/key/rows/Extra → 索引 → SQL 改写 → 验证。
Redis
9. Redis 为什么快?
内存 + 高效数据结构 + IO 多路复用 + 简单执行模型。
10. 五种类型?
String、Hash、List、Set、ZSet。
11. Redis + MySQL 怎么配合?
Cache Aside:先 Redis,Miss 查 MySQL 回填;写入时先更新 MySQL,再删 Redis。
12. 穿透、击穿、雪崩?
不存在 / 一个热点 / 大量失效。
13. RDB 和 AOF?
快照 vs 写日志。
14. Redis 分布式锁?
SET key token NX EX,Token 唯一,Lua 判断 Token 后删除。
15. 幂等怎么实现?
幂等 Key + Redis 快速拦截 + 数据库唯一索引/状态机最终兜底。
五十二、最后给你一段“我对 MySQL 和 Redis 的理解”
如果面试官直接问:
你对 MySQL 和 Redis 掌握怎么样?
不要回答:
了解一点。
你可以这样说:
我对 MySQL 和 Redis 主要掌握在业务开发和性能设计层面。MySQL 方面,我重点理解 InnoDB 的 B+ 树索引、聚簇索引和二级索引、回表和覆盖索引、联合索引最左前缀,以及事务 ACID、MVCC、隔离级别和乐观锁/悲观锁;遇到查询性能问题会使用 EXPLAIN 分析索引、扫描行数、排序和深分页。
Redis 方面,我主要掌握 String、Hash、List、Set、ZSet 的业务场景,以及 Cache Aside 缓存模式、缓存穿透/击穿/雪崩、TTL 和淘汰策略、RDB/AOF,同时理解用
SET NX EX和 Lua 实现分布式锁,以及使用 Redis 配合数据库唯一约束实现接口幂等。对我来说 MySQL 主要负责核心业务数据的可靠持久化和事务一致性,Redis 更多承担缓存、临时状态和高并发辅助能力,两者不是互相替代,而是组合使用。
如果你能自然地讲完这段,面试官再追问:
索引?
→ 能讲
事务?
→ 能讲
MVCC?
→ 能讲
缓存?
→ 能讲
穿透击穿雪崩?
→ 能讲
分布式锁?
→ 能讲
数据一致性?
→ 能讲
对于一个前端实习生,数据库部分已经相当够用了。
五十三、最后的最终压缩版
以后忘记了,回来只看这里。
================ MySQL ================
1. 索引
B+树:矮胖、IO少、支持范围查询
主键索引:
叶子节点保存完整行
二级索引:
叶子节点保存索引值 + 主键
回表:
二级索引 → 主键 → 完整数据
覆盖索引:
数据直接从索引拿,不回表
联合索引:
遵循最左前缀
2. 事务
ACID:
原子、一致、隔离、持久
Undo Log:
回滚 + MVCC
Redo Log:
崩溃恢复
MVCC:
Undo Log + 事务ID + Read View
快照读:
普通 SELECT
当前读:
UPDATE / DELETE / FOR UPDATE
3. 锁
悲观锁:
先锁再改
乐观锁:
version / 旧状态条件
重要业务:
条件更新 + 唯一索引 + 事务兜底
4. SQL 优化
EXPLAIN:
type
key
rows
Extra
重点排查:
索引
SELECT *
函数
前置 %
隐式转换
深分页
N+1
大量返回数据
================ Redis ================
1. 五种类型
String:
缓存、Token、验证码、计数
Hash:
对象
List:
队列、最近记录
Set:
去重、点赞
ZSet:
排行榜
2. Cache Aside
读:
Redis → MySQL → 回填 Redis
写:
更新 MySQL → 删除 Redis
3. 三大缓存问题
穿透:
查询不存在的数据
→ 空值 + 布隆过滤器
击穿:
热点 Key 过期
→ 互斥锁 + 逻辑过期
雪崩:
大量 Key 同时失效
→ 随机 TTL + 预热 + 高可用
4. 内存
过期:
惰性删除 + 定期删除
淘汰:
LRU 看最近使用
LFU 看访问频率
5. 持久化
RDB:
快照
AOF:
写命令日志
6. 高并发
分布式锁:
SET key uuid NX EX 10
释放:
Lua 判断 uuid 后 DEL
幂等:
Redis Key + 唯一索引 + 状态机
核心原则:
Redis 不是最终业务真相
MySQL 才是订单/支付/库存的核心数据源
最后我希望你真正记住的不是 100 个术语,而是这六句话:
索引的本质,是减少扫描。
事务的本质,是保证一组操作的数据正确性。
MVCC 的本质,是让读写尽量不要互相阻塞。
Redis 的本质,是用内存换取高性能。
缓存的本质,是数据库数据的副本,所以允许失效和重建。
Redis 可以挡住大量并发,但核心业务最终一定要让数据库约束、事务和状态机兜底。
你把这六句话真正理解,再把上面的 15 道核心题背下来,你这一天的 MySQL + Redis 学习就已经完成了一个非常有价值的闭环。