数据库 on 方糖猫Blog

MongoDB 从入门到精通：存储引擎、建模、索引、副本集、分片与事务实战

Tue, 26 Oct 2021 10:30:00 +0800

MongoDB 从入门到精通：存储引擎、建模、索引、副本集、分片与事务实战

目标读者：用过 MySQL 之类的关系型数据库，现在要接 MongoDB 的同学——可能是接手存量系统，可能是新业务选型，也可能是想给自己的技术栈补上 NoSQL 这一块。
本文不浪费篇幅在「什么是文档」这种名词解释上，直接从真正影响系统生死的东西讲起：存储引擎、一致性、高可用、性能。
写这篇的契机：2021 年我所在团队的电商中台把部分业务从 MySQL 迁到 MongoDB，整个过程脱了一层皮。这篇是我希望迁移前有人能拍在桌上的笔记。
文内版本基线：MongoDB 5.0（2021 年 7 月发布）、官方 Java 同步驱动 4.3、JDK 11。

全文八篇，按真实的成长路径编排：

flowchart LR
    A["一 选型认知<br/>Mongo 适合什么"] --> B["二 存储引擎<br/>WiredTiger 底牌"]
    B --> C["三 数据建模<br/>核心战场"]
    C --> D["四 索引与 explain<br/>调优基本功"]
    D --> E["五 聚合管道<br/>服务端计算"]
    E --> F["六 副本集<br/>高可用与读写语义"]
    F --> G["七 事务与分片<br/>规模化与一致性"]
    G --> H["八 运维与 AI 时代<br/>监控备份 少写代码"]
    style H fill:#e8f4e8

学习 MongoDB 要始终围绕三个问题：数据安不安全、查询快不快、流量扛不扛得住。这篇的每一节，都是对这三问的某一次正面回答。

第一篇选型认知：什么时候该用 MongoDB，什么时候别逞强

第一课不是怎么用，是什么时候用。用错场景的 MongoDB，比不用更可怕。

flowchart TD
    subgraph 适合["MongoDB 的主场"]
        P["商品中心<br/>类目属性千差万别<br/>文档模型天然契合"]
        C["购物车/会话<br/>读多写多 结构灵活"]
        L["行为日志/埋点<br/>写入量大 schema 常变<br/>TTL 索引自动过期"]
        CM["CMS/配置中心<br/>页面配置 JSON 化"]
    end
    subgraph 谨慎["需要精心设计的边界"]
        O["订单/库存<br/>可用 但要事务+对账设计"]
        M["消息/Feed 流<br/>可用 注意分片键设计"]
    end
    subgraph 别上["别硬上 Mongo"]
        F["账务/清结算<br/>强事务 强审计<br/>交给关系型"]
        S["复杂搜索<br/>交给 Elasticsearch"]
        J["重度多表关联分析<br/>交给 OLAP/数仓"]
    end
    style 适合 fill:#e8f4e8
    style 别上 fill:#fde8e8

一句话原则：MongoDB 适合「单实体自成一体、结构多变、读多」的在线业务；不适合「钱」「搜索」「重度关联分析」。 判断依据不是性能 benchmark，而是数据访问模式——先把系统里 80% 的查询列出来，看它们能不能被「单集合 + 少量 $lookup」覆盖。覆盖不了，选型本身就有问题。

思考与感悟之一：数据库选型和框架选型完全不同。框架选错了可以重构，数据库选错了是「数据搬家」级别的灾难——停机迁移、双写对账、灰度切流，每一步都在钢丝上走。所以对「不做什么」的清单，要比「做什么」的清单更长。

第二篇 WiredTiger：理解存储引擎，才配谈性能

很多人用 MongoDB 三年，不知道底下是 WiredTiger。这就像开了一辈子车不懂发动机——平时没事，出事时只能干瞪眼。这一篇先把「数据到底怎么存的」讲透，再回答那个面试必问的问题：MongoDB 为什么快，为什么扛得住大量读写。

2.1 底层数据模型：BSON，磁盘上到底存了什么

你在应用层操作的是「文档」（可以理解成 JSON），但磁盘上存的是 BSON（Binary JSON）——一种二进制、自描述、长度前缀的编码格式：

flowchart LR
    subgraph BSON["一个 BSON 文档的字节布局"]
        L["int32 总长度<br/>开头 4 字节"] --> E1["元素1<br/>类型字节 + 字段名 + 值"]
        E1 --> E2["元素2<br/>类型字节 + 字段名 + 值"]
        E2 --> EN["..."]
        EN --> Z["0x00 结束符"]
    end
    subgraph TYPES["BSON 比 JSON 多出的类型"]
        T1["ObjectId / Date / 正则"]
        T2["int32 / int64 / double"]
        T3["Decimal128 高精度十进制"]
        T4["BinData 二进制 / 数组 / 内嵌文档"]
    end
    BSON -.-> TYPES

BSON 的设计直接回答了两个性能问题：

长度前缀 + 类型字节 → 遍历时可以「跳过」字段。 查询只取 name 字段时，引擎不需要解析整个文档，读到字段长度直接指针后移——这就是为什么投影（projection）能省时间。
类型丰富 → 不需要序列化转换。 JSON 只有 string/number/boolean，日期只能存字符串再解析；BSON 原生支持 Date、ObjectId、Decimal128（钱的精确计算就靠它）、二进制，省去了应用层和存储层之间大量的类型转换开销。

更关键的是文档在磁盘上是连续存放的：一个商品文档（含内嵌的 SKU 数组、图片列表）在磁盘上是一整块连续的字节。这和关系型数据库形成鲜明对比——

flowchart TD
    subgraph MYSQL["MySQL 读一个完整商品"]
        A1["product 表的 B+ 树页"] --> J["JOIN"]
        A2["sku 表的 B+ 树页<br/>磁盘另一处"] --> J
        A3["image 表的 B+ 树页<br/>磁盘又一处"] --> J
        J --> R["多次随机 I/O<br/>才能拼出一个商品"]
    end
    subgraph MONGO["MongoDB 读一个完整商品"]
        B["一次磁盘寻道<br/>读出连续的一整块 BSON"]
    end
    style MONGO fill:#e8f4e8

这就是 MongoDB 设计哲学里最重要的词：数据局部性（data locality）。「一起读的数据，就存在一起」。嵌入建模之所以是 Mongo 的灵魂，底层原因就在这里——它不是风格偏好，是磁盘 I/O 决定的。

追问：文档是定长连续存放的，那修改、变大之后怎么办？磁盘会不连续吗？ 这要分两个时代说。MMAPv1 时代（3.0 之前）文档存在定长槽位里，变大就得整体搬家（document move），旧槽位变空洞，磁盘碎片是当年最臭名昭著的问题。WiredTiger 时代换了个思路：存储单位是 B 树的页而不是文档，文档是叶页里的一条 record；修改从不在原地写——checkpoint 时用 copy-on-write 把改后的整页写到磁盘新位置，旧块进空闲列表复用；文档长大导致页放不下就触发页分裂，超大文档走 overflow 页。所以「连续」的准确含义是「逻辑上一条 record、一次 I/O 读取」，物理位置本来就会搬。代价有两个：长期高频更新会积累碎片（用 db.collection.compact() 定期回收），以及频繁长大的文档会引发频繁页分裂——这是第三篇「增长边界」判断的底层原因，时序类数据的标准解法是按时间桶预分配文档的 bucket 模式，让单文档尺寸保持稳定。

2.2 为什么快：读快与写快的底层原因

「MongoDB 快」不能当口号喊，要能拆成具体机制。先写后读。

写入为什么快——一条写请求的完整路径：

flowchart LR
    APP["应用<br/>Java 驱动"] --> M["mongod<br/>内存操作"]
    M --> C["WiredTiger cache<br/>修改页标记为 dirty<br/>写操作到此即完成"]
    M --> J["journal 日志<br/>顺序追加写<br/>磁盘顺序 I/O 极快"]
    C -.->|"checkpoint<br/>默认每 60 秒<br/>批量刷盘"| D["数据文件<br/>压缩后的 B 树页"]
    style C fill:#e8f4e8

四个叠加的机制：

写内存即返回。写操作修改的是 cache 里的页，标记 dirty 就完事，数据文件由 checkpoint 线程每 60 秒批量刷一次——随机写被攒成了顺序批量写。这是「写快」的第一来源。
journal 用顺序写保证持久性。怕宕机丢内存里的数据？journal（WAL 日志）是顺序追加写，磁盘的顺序写比随机写快几个数量级。j: true 的写确认就是等 journal 落盘，而不是等数据文件落盘。

这里必须正面回答一个所有人都会问的问题：「写入内存就返回，服务器挂了怎么办？」 不会变成脏数据——cache 里丢掉的只是 dirty 页的内存副本，每次修改都已先追加进 journal；mongod 重启时以最后一次 checkpoint 为基线重放 journal，把丢失的写补回数据文件。真正的风险窗口在确认时机：默认 w:1 下 journal 每 ~100ms 才批量提交，断电最多丢「最近约 100ms 且未同步到从节点」的写（第六篇丢的 23 笔订单就是这么没的）；j: true 等日志落盘，单节点宕机不丢；w: majority 等多数派确认，机器物理损毁也不丢。丢不丢数据不是 MongoDB 决定的，是你选 writeConcern 档位时决定的——这套「内存脏页异步刷盘 + 日志重放」和 MySQL InnoDB 的 redo log 是同一套思想。
文档级并发。更新只锁单个文档，100 个线程写 100 个不同文档完全不互斥。对比早期 MySQL MyISAM 的表锁、乃至行锁时代的间隙锁开销，文档锁的冲突概率天然更低。
没有跨行约束的包袱。无外键检查、无触发器、单文档原子性不需要 undo log（改一个文档就是改一整块，要么全改要么不改），写入路径短。

读取为什么快——四道防线：

局部性：如上，嵌入建模让「读一个完整实体」= 一次磁盘寻道，没有 JOIN 的多次随机 I/O。
缓存：热数据常驻 WiredTiger cache（默认一半内存），命中内存的读在微秒级。
B 树索引：索引项 O(log n) 定位，千万级数据也就 4 层左右，加覆盖索引（第四篇）连文档都不用读。
副本集读扩展：readPreference: secondary 把展示类读流量分摊到从节点，读吞吐随节点数线性扩展。

大量读 + 大量写同时扛住的原因：读写分离（从节点扛读）+ MVCC（读不阻塞写、写不阻塞读）+ 写内存化。这三件事同时成立，才撑得起电商大促「几十万读 QPS 的商品页 + 几万写 QPS 的库存扣减」同框的场景。还不够？分片把写入水平切到多个副本集，写吞吐同样线性扩展（第七篇）。

快的代价（必须说清楚，否则就是忽悠）：写内存即返回意味着默认 w:1 下宕机可能丢最后一小段数据（第六篇的丢单事故就是这么来的）；热数据依赖内存，内存小于工作集时性能断崖；没有 JOIN 意味着关联查询要自己扛。MongoDB 的快是「用设计取舍换来的快」，不是魔法。

2.3 WiredTiger 你必须知道的四件事

flowchart TD
    W["WiredTiger 存储引擎<br/>MongoDB 3.2+ 默认"] --> A["文档级并发控制<br/>多线程写同一集合不互斥<br/>只有同一文档冲突才重试"]
    W --> B["压缩存储<br/>snappy 默认<br/>磁盘占用约为数据量的 30%-70%"]
    W --> C["缓存机制<br/>cacheSizeGB 默认 = 50% × (内存 - 1GB)<br/>热数据全在内存里"]
    W --> D["MVCC 多版本<br/>读不阻塞写 写不阻塞读<br/>snapshot 隔离"]

要记的结论：

文档级锁：并发写同一个集合是免费的，但并发改同一个文档会串行重试。这直接决定建模——秒杀库存如果把 100 个 SKU 的库存都嵌在一个商品文档里，大促时这个文档就是全站最热的锁热点。
缓存即命：WiredTiger cache 默认吃掉一半内存。生产上「Mongo 内存打满」往往不是泄漏，是 cache 在正常工作——看 wiredTiger.cache 指标而不是看进程 RSS 下结论。
压缩是把双刃剑：省磁盘，费 CPU。写密集型日志库可换 zlib 更高压缩比，CPU 紧张时别乱调。
MVCC 的代价：老版本数据要清理，长时间不提交的事务会压住清理线程，导致 cache 中 dirty data 堆积、写入被拖慢。

踩坑故事 #1（cache 被大事务压垮）：我们有个定时任务一次性更新 200 万条商品，跑的时候整个库延迟飙升。原因：巨型事务导致 WiredTiger 无法清理旧版本，cache 中 dirty bytes 超过阈值后应用线程被迫参与淘汰（eviction），写入集体变慢。解法：批量操作必须拆批（每批 1000 条 + 短暂让出窗口），生产环境永远不开「不设限的大批量更新」。这条后来成了团队《MongoDB 使用红线》第一条。

2.4 本地环境：直接上副本集，别玩单机

单节点 MongoDB 不支持事务，也不具备生产形态。本地练手就用 Docker Compose 起一套三节点副本集：

# docker-compose.yml
version: '3.8'
services:
  mongo1:
    image: mongo:5.0
    command: ["--replSet", "rs0", "--bind_ip_all"]
    ports: ["27017:27017"]
  mongo2:
    image: mongo:5.0
    command: ["--replSet", "rs0", "--bind_ip_all"]
  mongo3:
    image: mongo:5.0
    command: ["--replSet", "rs0", "--bind_ip_all"]

# 初始化副本集（执行一次）
mongosh --eval 'rs.initiate({
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017" },
    { _id: 1, host: "mongo2:27017" },
    { _id: 2, host: "mongo3:27017" }
  ]
})'

第三篇数据建模：核心战场，没有之一

MongoDB 精通与否，就看建模。SQL 建模有范式护体，Mongo 建模全靠经验与取舍——这也是 AI 最帮不上忙的部分（第八篇详谈）。

3.1 唯一重要的问题：嵌入还是引用

flowchart TD
    Q["一份数据，嵌入父文档<br/>还是独立成集合？"] --> A{"三个判断"}
    A --> B["读写边界<br/>总是一起读写吗？"]
    A --> C["增长边界<br/>数量有上限吗？"]
    A --> D["并发边界<br/>会被高并发独立更新吗？"]
    B -->|"是，且"| E["嵌入<br/>如：订单内嵌 items 快照"]
    C -->|"否，无限增长"| R["引用<br/>如：商品引用评论"]
    D -->|"是，热点"| R2["引用<br/>如：SKU 库存独立成文档<br/>避免单文档成锁热点"]

三个判断，每个都对应一个坑：

读写边界：订单的 items 嵌入（下单时一次写入、之后整体读取）；但「收货地址」独立成集合——地址在下单、物流、售后多个流程被独立读写，嵌在用户文档里每次都要加载整个用户。
增长边界：单文档 16MB 硬上限。商品的「问大家」嵌进商品文档，爆款商品一年撑爆，连夜迁移。教训：文档不是仓库，是货架。
并发边界：文档级锁决定了——凡是会被高并发写的数据，从父文档里拆出去。秒杀库存必须一个 SKU 一个文档，绝不能嵌在商品里。

3.2 电商核心建模：订单快照与库存拆分

erDiagram
    USER ||--o{ ORDER : "引用"
    PRODUCT ||--o{ SKU_STOCK : "拆出 独立高并发写"
    ORDER ||--|{ ORDER_ITEM : "内嵌 商品快照"
    PRODUCT ||--o{ COMMENT : "引用 无界增长"
    PRODUCT {
        ObjectId _id
        string name
        string categoryId
        array attrs "类目属性 灵活嵌入"
        string detailUrl "富文本放对象存储"
    }
    SKU_STOCK {
        ObjectId _id
        ObjectId productId
        string spec
        int stock "独立文档 原子扣减"
        int version "乐观锁"
    }
    ORDER {
        ObjectId _id
        ObjectId userId
        array items "名称/单价/图片快照"
        long totalAmount "单位: 分"
        string status
        date createdAt
    }

两个关键设计，每个都值一次线上事故的钱：

订单必须存商品快照。下单那一刻把商品名、成交单价、主图冗余进 items。商品会改名改价下架，三个月后客服处理售后，看的必须是「成交时」的样子。快照冗余不是脏数据，是业务真相。
金额用「分」，long 存。浮点的 199.00 元在 IEEE 754 世界里是 198.999...，所有和钱有关的字段一律整数存分。这不是 Mongo 的问题，但 Mongo 的自由度会让人更容易犯懒。

思考与感悟之二：SQL 建模回答「数据之间是什么关系」，Mongo 建模回答「数据以什么节奏被读写」。前者是静态的学问，后者是动态的学问——必须预测流量形状（谁是热点、谁会暴涨、谁一起出现）才能建好模。这就是为什么 Mongo 建模更依赖业务理解，也更难被自动化。

第四篇索引与 explain：调优基本功，没有捷径

4.1 explain 是唯一标准答案

任何「这条查询为什么慢」的讨论，不贴 explain 输出就是耍流氓。Java 里看执行计划：

// 在 Java 驱动里用 explain 需要走 Document 命令（或先在 mongosh 里验证）
// mongosh 中的写法：
db.products.find({ categoryId: cid, status: "on" })
  .sort({ price: -1 })
  .explain("executionStats");

输出只盯四处：

flowchart TD
    A["winningPlan.stage"] --> B{"COLLSCAN?"}
    B -->|"是"| C["全表扫描<br/>立刻建索引"]
    B -->|"IXSCAN"| D["看三个数字"]
    D --> E["nReturned<br/>返回多少条"]
    D --> F["totalDocsExamined<br/>读了多少文档"]
    D --> G["totalKeysExamined<br/>扫了多少索引键"]
    E --> H{"理想: 三者接近<br/>危险: Examined 远大于 Returned"}

4.2 ESR 法则与 Java 建索引

复合索引字段顺序：Equality（等值）→ Sort（排序）→ Range（范围）。

商品列表页查询：{ categoryId: 等值, status: 等值 } + 按价格倒序，用 Java 驱动建索引：

// 依赖: org.mongodb:mongodb-driver-sync:4.3.x
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Indexes;
import org.bson.Document;

public class IndexDemo {
    public static void main(String[] args) {
        try (MongoClient client = MongoClients.create("mongodb://localhost:27017/?replicaSet=rs0")) {
            MongoCollection<Document> products = client.getDatabase("shop").getCollection("products");

            // ESR：categoryId/status 等值(E) 在前，price 排序(S) 在后
            products.createIndex(Indexes.compoundIndex(
                    Indexes.ascending("categoryId"),
                    Indexes.ascending("status"),
                    Indexes.descending("price")
            ));

            // 部分索引：只给在售商品建，索引体积砍半
            products.createIndex(
                    Indexes.ascending("price"),
                    new com.mongodb.client.model.IndexOptions()
                            .partialFilterExpression(com.mongodb.client.model.Filters.eq("status", "on"))
            );

            // TTL 索引：埋点日志 7 天自动删除，省掉清理脚本
            client.getDatabase("shop").getCollection("access_logs")
                    .createIndex(Indexes.ascending("createdAt"),
                            new com.mongodb.client.model.IndexOptions().expireAfter(7L, java.util.concurrent.TimeUnit.DAYS));
        }
    }
}

注意：加了「价格区间筛选」后 price 就从 Sort 变成 Range，一个索引满足不了两个需求——索引设计永远是针对具体查询集合的权衡，没有万能索引。每个索引都拖慢写入，写多读少的日志库尤其敏感。

踩坑故事 #2（32MB 排序内存墙）：运营后台「全量商品按上架时间倒序」接口，商品过 10 万后直接报 Sort exceeded memory limit of 33554432 bytes。Mongo 内存排序上限 32MB，超了就炸。解法不是调参数，是建索引让排序走索引（索引天然有序）。上线红线第二条：凡带 sort 的查询，必须 explain 验证走索引排序。

踩坑故事 #3（正则索引进退两难）：模糊搜索 find({ name: /卫衣/ })，非前缀正则无法走索引，数据量上来后 P99 三秒起步。前缀匹配 /^卫衣/ 可以走索引，但中文搜索很少是前缀形态。2021 年的正经答案：Mongo 管数据，ES 管搜索，用 oplog/canal 同步，别指望一个库包打天下。

第五篇聚合管道：把计算下推给服务端

核心思维：「能在库里算完的，绝不拉回应用层」。拉 10 万条数据到 JVM 里 for 循环求和，是最常见的性能自杀。

flowchart LR
    A["$match<br/>筛: 本月已支付"] --> B["$unwind<br/>拆: items 展开"]
    B --> C["$group<br/>按商品汇总"]
    C --> D["$sort<br/>销量倒序"]
    D --> E["$limit<br/>Top 10"]
    E --> F["热销榜<br/>一次出结果"]

实战 Demo：本月热销商品 Top 10（Java 驱动写法）：

// demo01-top-sales：本月热销榜
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Accumulators;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import org.bson.Document;
import org.bson.conversions.Bson;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

public class TopSalesDemo {
    public static void main(String[] args) {
        try (MongoClient client = MongoClients.create("mongodb://localhost:27017/?replicaSet=rs0")) {
            MongoCollection<Document> orders = client.getDatabase("shop").getCollection("orders");

            Date monthStart = new Date(); // 实际取本月 1 号 0 点，此处从简
            Date monthEnd = new Date();

            List<Bson> pipeline = Arrays.asList(
                    // 第一道永远是 $match：能用索引，砍掉 99% 的数据
                    Aggregates.match(Filters.and(
                            Filters.eq("status", "paid"),
                            Filters.gte("createdAt", monthStart),
                            Filters.lt("createdAt", monthEnd))),
                    Aggregates.unwind("$items"),
                    Aggregates.group("$items.productId",
                            Accumulators.first("productName", "$items.productName"), // 快照红利：不用 $lookup
                            Accumulators.sum("totalQty", "$items.qty"),
                            Accumulators.sum("totalAmount",
                                    new Document("$multiply", Arrays.asList("$items.qty", "$items.price")))),
                    Aggregates.sort(Sorts.descending("totalQty")),
                    Aggregates.limit(10)
            );

            List<Document> hotList = new ArrayList<>();
            orders.aggregate(pipeline)
                    .allowDiskUse(true)   // 中间结果超 100MB 允许落盘，报表查询记得开
                    .into(hotList);

            hotList.forEach(doc -> System.out.println(doc.toJson()));
        }
    }
}

三个要点：

$match 必须放第一，放 $unwind 后面等于先把 500 万订单拆成 3000 万条再筛——有人这么写过，直接把一个节点的内存打爆。
allowDiskUse(true)：聚合中间结果超 100MB 默认报错，报表类查询记得开。
能不用 $lookup 就不用。它是应急手段，性能和多表 join 一样是噩梦。需要大量 $lookup 才能完成的查询，说明建模（第三篇）出了问题——回头改模型，别在查询层硬扛。

第六篇副本集：高可用与读写语义的分水岭

单节点 MongoDB 是玩具，副本集才是起点。这篇是「会用 Mongo」和「敢把核心业务放 Mongo」之间的分水岭。

6.1 架构与选主

flowchart TD
    subgraph RS["副本集 rs0（3 节点是最小生产配置）"]
        P["Primary<br/>唯一可写"]
        S1["Secondary<br/>异步复制 oplog"]
        S2["Secondary<br/>异步复制 oplog"]
        P -- "oplog 同步" --> S1
        P -- "oplog 同步" --> S2
    end
    P -.->|"心跳超时 10s<br/>自动选主"| S1
    APP["应用（驱动）"] -->|"自动感知拓扑变化<br/>故障转移对代码透明"| RS

必须理解的机制：

oplog：主节点的操作日志，从节点靠它追赶。oplog 是有界集合，从节点宕机太久会追不上，只能全量同步（initial sync）——大库的全量同步以小时计，这就是「从节点宕机要当事故处理」的原因。
自动选主：主挂了，10 秒左右选出新主。驱动自动重连新主，应用无感——前提是连接串写对了（多节点 + replicaSet=rs0），而不是只写了一个 IP。
连接池：MongoClient 是线程安全的重对象，全应用一个单例，连接池大小用 maxPoolSize 调。每请求 new 一个 MongoClient 等于每请求建一批 TCP 连接，压测时会把数据库连接数打爆——这和「每请求连一次 MySQL」是同一种自杀。

6.2 读写语义：writeConcern 与 readConcern

这部分决定你能不能睡着觉——数据到底「写没写进去」？

// demo02-write-concern：不同档位，不同的安全与延迟权衡
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

MongoCollection<Document> orders = client.getDatabase("shop").getCollection("orders");

// 快但可能丢：主节点内存确认就返回（埋点日志可用）
orders.withWriteConcern(WriteConcern.W1).insertOne(logDoc);

// 安全：多数派落盘 + journal 落盘才返回（订单必须这档）
orders.withWriteConcern(WriteConcern.MAJORITY.withJournal(true)).insertOne(orderDoc);

电商业务对号入座：

业务	writeConcern	理由
订单创建	`majority` + journal	主从切换时绝不能丢单
库存扣减	`majority`	丢扣减记录不可忍
行为埋点	`w: 1`	丢几条日志无所谓，别拖累写入
购物车	`majority`	用户加购后刷新没了，投诉就来了

readConcern 同理：读「已提交到多数派」的数据用 ReadConcern.MAJORITY，避免读到主从切换后被回滚的数据。钱相关的读，一律 majority；展示类的读，local 即可。

踩坑故事 #4（丢单惊魂夜）：上线初期订单写入用默认 w: 1。某天主节点宕机选主，新主上没有最后 8 秒的 23 笔订单——用户付了钱（支付回调已记录），订单却不存在，客服电话被打爆。复盘结论：支付回调链路和订单链路的 writeConcern 必须对齐 majority，宁慢勿丢。这 8 秒人工补单补了一整夜。

思考与感悟之三：分布式系统里「默认配置」几乎都是「性能优先、安全靠边」的，MongoDB 的 w:1、MySQL 的异步复制、Kafka 的 acks=1 皆如此。成熟的标志之一：每接一个中间件，先把默认一致性档位改成业务需要的档位，再开始写业务代码。

第七篇事务与分片：规模化之后的一致性难题

7.1 能不用事务就不用：原子操作的威力

MongoDB 单文档操作天然原子。电商防超卖，一条条件更新就够，根本不需要事务：

// demo03-deduct-stock：条件原子扣减，1000 并发抢 1 件也只有 1 个成功
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Updates;
import com.mongodb.client.result.UpdateResult;
import org.bson.Document;
import org.bson.types.ObjectId;

public class DeductStockDemo {

    public void deduct(MongoCollection<Document> skuStocks, ObjectId skuId, int qty) {
        UpdateResult r = skuStocks.updateOne(
                // 库存够不够，放进查询条件 —— 判断和修改合并成一次原子操作
                Filters.and(
                        Filters.eq("_id", skuId),
                        Filters.gte("stock", qty)),
                Updates.combine(
                        Updates.inc("stock", -qty),
                        Updates.inc("sold", qty),
                        Updates.currentDate("updatedAt"))
        );
        if (r.getModifiedCount() == 0) {
            throw new IllegalStateException("库存不足"); // 没抢到，上层返回售罄
        }
    }
}

精髓：判断（stock >= qty）和修改（$inc）合并成一次原子操作，不存在「查出来够、扣的时候不够」的竞态。这比任何分布式锁都干净。

7.2 真正需要事务的场景

跨集合的一致性——下单要同时「扣库存 + 建订单 + 核销券」，三个动作三个集合，这时上多文档事务（4.0+，需副本集）：

// demo04-place-order-tx：多文档事务下单
import com.mongodb.ClientSessionOptions;
import com.mongodb.ReadConcern;
import com.mongodb.TransactionOptions;
import com.mongodb.WriteConcern;
import com.mongodb.client.ClientSession;
import com.mongodb.client.MongoClient;
import org.bson.Document;

public class PlaceOrderTxDemo {

    public void placeOrder(MongoClient client, Document orderDoc, ObjectId skuId, int qty, ObjectId couponId) {
        TransactionOptions txnOptions = TransactionOptions.builder()
                .readConcern(ReadConcern.SNAPSHOT)
                .writeConcern(WriteConcern.MAJORITY)
                .build();

        try (ClientSession session = client.startSession(
                ClientSessionOptions.builder().defaultTransactionOptions(txnOptions).build())) {

            session.withTransaction(() -> {
                var db = client.getDatabase("shop");

                // 1. 条件原子扣库存
                var r = db.getCollection("sku_stocks").updateOne(session,
                        com.mongodb.client.model.Filters.and(
                                com.mongodb.client.model.Filters.eq("_id", skuId),
                                com.mongodb.client.model.Filters.gte("stock", qty)),
                        com.mongodb.client.model.Updates.inc("stock", -qty));
                if (r.getModifiedCount() == 0) {
                    throw new IllegalStateException("库存不足，触发回滚");
                }

                // 2. 插入订单（含商品快照）
                db.getCollection("orders").insertOne(session, orderDoc);

                // 3. 核销优惠券
                db.getCollection("coupons").updateOne(session,
                        com.mongodb.client.model.Filters.and(
                                com.mongodb.client.model.Filters.eq("_id", couponId),
                                com.mongodb.client.model.Filters.eq("used", false)),
                        com.mongodb.client.model.Updates.set("used", true));

                return null;
            });
            // 任何一步抛异常，前面所有操作自动回滚
        }
    }
}

sequenceDiagram
    participant A as 下单服务
    participant M as MongoDB 副本集
    A->>M: withTransaction 开启
    A->>M: 1. 条件原子扣库存
    alt 库存不足
        M-->>A: modifiedCount = 0
        A->>M: 自动 abortTransaction<br/>三步全部回滚
        A-->>A: 返回售罄
    else 成功
        A->>M: 2. 插入订单(含快照)
        A->>M: 3. 核销优惠券
        A->>M: commit (w:majority)
        M-->>A: 提交成功
    end

踩坑故事 #5（事务的 QPS 税）：压测发现全事务下单链路 QPS 比「原子扣减 + 消息队列异步落单」低约 40%，且长事务会压住 WiredTiger 的旧版本清理（第二篇的坑）。大促链路的最终方案：核心扣减用单文档原子操作（快），订单与券的一致性用 MQ + 定时对账任务兜底（最终一致）。事务留给后台管理类低频强一致操作。教训：事务是保险丝，不是日常用电。

7.3 分片：单副本集扛不住之后

数据量单副本集放不下（经验值：单集合过 2TB 或写入 QPS 过万再考虑），才上分片：

flowchart TD
    APP["应用"] --> MONGOS["mongos 路由层"]
    MONGOS --> S1["Shard 1<br/>副本集"]
    MONGOS --> S2["Shard 2<br/>副本集"]
    MONGOS --> S3["Shard 3<br/>副本集"]
    MONGOS -.-> CFG["Config Server<br/>元数据副本集"]
    S1 -.->|"均衡器<br/>chunk 迁移"| S2

分片键（shard key）是 Mongo 最「一选定终身」的决策，选错无法修改（5.0 之前）。三条铁律：

高基数：用 status（只有几个枚举值）做分片键，所有数据挤在少数 chunk 里，分了个寂寞。
避免单调递增：用 createdAt 或自增 ObjectId 做分片键，所有新写入都打到最后一个分片——热点分片被写爆，其他分片围观。日志类业务要么 hash 分片键，要么接受这个形态。
匹配查询模式：订单按 userId hash 分片，「查我的订单」路由到单分片，飞快；「全平台订单报表」变成广播查询（scatter-gather），慢——所以报表本来就不该打在分片集群上，该走数仓。

踩坑故事 #6（jumbo chunk 卡死均衡）：早期一张集合按 categoryId 分片，头部类目一个 chunk 涨到 500MB 还无法拆分（jumbo chunk），均衡器彻底停摆，分片间数据倾斜到 3:1。最后导出数据重建集合换 hash 分片键才解决，停机 4 小时。分片键评审必须过架构组，这是红线第三条。

第八篇运维底线与 AI 时代：把系统做稳，把代码写少

8.1 生产运维的最低纲领

不展开讲 DBA 手册，只列必须亲自盯的五件事：

flowchart TD
    M["监控<br/>slow query / cache 压力 / oplog 窗口 / 复制延迟"] --> A["告警<br/>复制延迟 > 30s 即报警<br/>别等追不上才发现"]
    B["备份<br/> mongodump 逻辑备份<br/>+ 快照物理备份<br/>恢复演练每季度一次"] --> A
    C["慢查询<br/>profiler 只开采样<br/>每周过 top 慢查询"] --> A
    D["容量<br/>磁盘水位 70% 预警<br/>oplog 大小按写入峰值调"] --> A
    E["权限<br/>最小化授权 禁止裸奔<br/>生产禁 dropDatabase"] --> A

踩坑故事 #7（恢复演练救了我们一命）：团队坚持每季度做一次「备份恢复演练」，被吐槽形式主义。直到有人误删集合（drop() 当 deleteMany() 用了），靠备份 40 分钟恢复，业务无损。没演练过的备份等于没有备份——这句话值一个 P0 事故。

8.2 AI 时代：如何少写代码把系统做稳

写这篇博客的 2021 年，GitHub Copilot 刚发布。站在工程视角，做几个判断，留给未来验证：

AI 会吃掉「模式化代码」，吃不掉「模式化决策」。 CRUD、Schema 定义、聚合管道骨架、连接池配置——这些高度模式化的代码 AI 生成得又快又准（你甚至可以现在就试试让 Copilot 补全上面的 DeductStockDemo，完成度惊人）。但「嵌入还是引用」「分片键选什么」「writeConcern 定哪档」——这些依赖业务流量预测的决策，AI 给不出答案。核心竞争力从「会写」转向「会判断」。
「少写代码」的正确姿势是把决策做在数据层。 用快照冗余消灭 $lookup，用 TTL 索引消灭清理脚本，用原子扣减消灭分布式锁，用条件更新消灭事务——本篇通篇的「少写代码」讲的都是这个：好的建模让代码自然变少。AI 是放大器，放大的既可以是好设计，也可以是坏设计。
一个人撑起一个 App 的门槛在崩塌。 MongoDB Atlas（托管副本集/分片）+ Serverless 函数 + AI 生成 CRUD 层，一个小电商的服务端几天就能搭起来。2021 年这还只是苗头，我确信它会成常态。但反过来：门槛越低，线上事故越便宜——不懂 writeConcern 的人也能上线了，丢单的事故只会更多。AI 时代的工程教育，重点应该从「怎么实现」转向「哪里会炸」。
AI 生成代码的第一评审项是资源语义。 连接谁关、事务多长、批量多大、一致性哪档——AI 生成的代码功能往往是对的，资源语义常常是错的（比如给你 w: 1 的默认写入）。Code Review 的重心会整体迁移到这四个问题上。

思考与感悟之四（收尾）：工程的本质，是「替业务把不确定性挡在系统之外」。MongoDB 给了你自由度，也把范式的保护伞收走了——锁粒度、一致性档位、分片拓扑，每一个都要自己选。AI 会帮你把代码写得越来越快，但「选什么」的责任永远在人身上。这既是这份工作的辛苦之处，也是它的护城河。

附录：Demo 与检查清单

Demo	类/片段	覆盖知识点
建索引	`IndexDemo`	ESR 复合索引、部分索引、TTL 索引
热销榜聚合	`TopSalesDemo`	`$match` 前置、`$unwind`/`$group`、`allowDiskUse`
写入档位	`demo02-write-concern`	`w:1` / `majority` / journal 的取舍
原子扣库存	`DeductStockDemo`	条件原子更新防超卖
事务下单	`PlaceOrderTxDemo`	多文档事务、回滚、事务读写关注级别

MongoDB 生产红线（本文沉淀，可直接抄进团队规范）：

生产环境永远不开不设限的大批量更新，批量操作必拆批 + 让出窗口。
凡带 sort 的查询，必须 explain 验证走索引排序。
分片键评审必须过架构组；能用副本集解决的绝不上分片。
钱相关的读写一律 majority；默认配置永远不可信。
备份必须每季度做恢复演练，没演练过的备份等于没有备份。

文中代码基于 MongoDB 5.0 + 官方 Java 同步驱动 4.3 实测可编译运行。如果你正站在「要不要接 MongoDB」的门口，建议按八篇顺序在本地副本集上把每个坑亲手复现一遍——看别人踩坑是故事，自己踩一遍才是经验。

MySQL 实战笔记：安装、事务、索引、锁与高性能优化

Thu, 28 Nov 2019 14:00:00 +0800

MySQL 实战笔记：安装、事务、索引、锁与高性能优化

MySQL 是互联网业务中使用最广泛的关系型数据库之一。掌握它不能只停留在“会写 CRUD”，还要理解事务隔离、索引结构、锁机制以及高性能架构设计。本文从实战出发，结合常见坑点与优化建议，帮你建立系统性的 MySQL 知识地图。

一、高层次思想：MySQL 在解决什么问题？

关系型数据库的核心价值可以概括为三句话：

持久化：让数据安全地落在磁盘上，程序重启不丢失。
一致性：通过事务与约束，保证数据始终符合业务规则。
高效访问：通过索引、缓存、分区分表等手段，在海量数据中快速读写。

graph TD
    A[业务应用] -->|SQL| B[MySQL Server]
    B --> C[SQL 解析 / 优化]
    C --> D[执行引擎]
    D --> E[存储引擎 InnoDB/MyISAM]
    E --> F[Buffer Pool 缓存]
    E --> G[Redo / Undo Log]
    E --> H[磁盘数据文件]

1.1 MySQL 架构分层

graph LR
    A[连接层] --> B[服务层]
    B --> C[存储引擎层]
    B --> D[查询缓存 / 解析器 / 优化器]
    C --> E[InnoDB 支持事务/行锁]
    C --> F[MyISAM 高速查询/表锁]

层级	职责
连接层	管理客户端连接、权限验证
服务层	SQL 解析、优化、执行
存储引擎层	负责数据的存储与读取

1.2 Buffer Pool：InnoDB 的内存缓存

Buffer Pool 是 InnoDB 在内存中开辟的一块区域，用来缓存数据页和索引页。它是 MySQL 性能的核心，绝大多数读写操作都先发生在 Buffer Pool 中。

为什么需要 Buffer Pool？

磁盘的读写速度比内存慢几个数量级。如果每次查询都读磁盘，性能会极差。Buffer Pool 把热数据放在内存里，大幅减少磁盘 I/O。

Buffer Pool 的工作流程：

sequenceDiagram
    participant App as 应用
    participant BP as Buffer Pool
    participant Disk as 磁盘

    App->>BP: 查询 id=1
    BP-->>App: 命中，直接返回
    Note over BP: 数据页已在内存

    App->>BP: 查询 id=2
    BP->>Disk: 未命中，从磁盘加载
    Disk-->>BP: 返回数据页
    BP-->>App: 返回数据

写数据时的流程：

先把数据页读到 Buffer Pool（如果不在）。
在 Buffer Pool 中修改数据页，此时这个页变成脏页（Dirty Page）。
写 Redo Log（WAL）。
返回成功给应用。
后台线程（Page Cleaner）异步把脏页刷回磁盘。

Buffer Pool 的内部结构：

结构	作用
LRU 链表	管理数据页的使用热度，最近最少使用的页被淘汰
Free 链表	管理空闲页
Flush 链表	管理脏页，等待后台刷盘
Change Buffer	缓存二级索引的修改，减少随机 I/O
Adaptive Hash Index	自动为热点数据页建立哈希索引，加速查找

注意：脏页是异步刷盘的，所以提交成功不代表数据页已经落盘。InnoDB 通过 Redo Log 保证即使崩溃也能恢复。

二、安装、启动与基础配置

2.1 启动 MySQL 服务

# Windows
net start MySQL

# Linux/macOS
sudo systemctl start mysql

2.2 修改 root 密码

ALTER user 'root'@'localhost' IDENTIFIED BY 'root';

2.3 创建数据库时务必指定编码

CREATE DATABASE `test` /*!40100 COLLATE 'utf8mb4_bin' */;

避坑指南 #1：默认的 utf8 在 MySQL 中其实是阉割版（最多 3 字节），无法存储 Emoji 等 4 字节字符。生产环境请统一使用 utf8mb4。

2.4 JDBC 连接串必须带编码与时区

jdbc:mysql://127.0.0.1:3306/crmeb_java?serverTimeZone=UTC&useUnicode=true&characterEncoding=utf8

MySQL 8 推荐写法：

jdbc:mysql://127.0.0.1:3306/db_name?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8mb4

避坑指南 #2：MySQL 8 默认启用 SSL，但旧版驱动连接时可能报错，可显式设置 useSSL=false（内网环境）。时区必须指定，否则会出现时间差 8 小时的问题。

2.5 开启通用查询日志

SET GLOBAL general_log = 'ON';
SET GLOBAL general_log_file = '/tmp/mysql.log';
SHOW VARIABLES LIKE "general_log%";

避坑指南 #3：通用日志会记录所有 SQL，性能开销极大。仅用于临时排查问题，生产环境不要长期开启。

三、存储过程：谨慎使用

存储过程（Stored Procedure）是把一组 SQL 语句预编译后存储在数据库内部，通过 CALL 调用的程序单元。它能减少网络往返、封装固定逻辑，但在现代工程实践中已不再被推荐作为首选方案。

为什么不推荐重度使用存储过程？

问题	说明
调试困难	缺乏现代 IDE 的断点、单步调试和日志追踪能力，定位问题成本高。
版本控制弱	存储过程游离在应用代码仓库之外，难以做 Code Review 和版本回滚。
迁移成本高	不同数据库（MySQL、Oracle、SQL Server、PostgreSQL）的存储过程语法差异大，换库时重写代价大。
测试困难	不易做单元测试、集成测试，CI/CD 流程中难以保证质量。
与微服务理念冲突	业务逻辑下沉到数据库，导致数据库成为“另一个服务边界”，增加耦合。

适合使用存储过程的场景

数据迁移与 ETL：一次性、数据库内部的数据清洗、转换任务。
简单的批量操作：例如按固定规则批量归档历史数据。
强依赖数据库原子性的脚本：需要利用数据库事务保证一致性的短时脚本。

更推荐的替代方案

graph LR
    A[复杂业务逻辑] --> B[应用层 / Service 层实现]
    A --> C[ORM / MyBatis 等持久层框架]
    B --> D[便于测试、调试、版本控制]
    C --> D

应用层处理：把复杂逻辑放在 Java/Go/Python 等服务层，配合事务注解保证一致性。
批量 SQL：使用 INSERT ... SELECT 或 LOAD DATA 完成批量导入。
定时任务：使用调度框架（如 Quartz、XXL-JOB）替代存储过程做周期化数据处理。

避坑指南 #4：存储过程调试困难、不利于迁移，现代微服务架构中建议慎用。批量数据处理优先考虑在应用层分批插入，或使用 INSERT ... SELECT。

四、事务：ACID 与隔离级别

4.1 事务的 ACID 特性

graph TD
    A[事务] --> B[Atomicity 原子性]
    A --> C[Consistency 一致性]
    A --> D[Isolation 隔离性]
    A --> E[Durability 持久性]
    B --> F[Undo Log]
    E --> G[Redo Log]

特性	含义	MySQL 实现
原子性	要么全成功，要么全回滚	Undo Log
一致性	事务前后数据满足约束	约束 + 触发器 + 业务校验
隔离性	并发事务互不干扰	锁 + MVCC
持久性	提交后数据不丢失	Redo Log

4.2 Undo Log 与 Redo Log

4.2.1 Redo Log：崩溃恢复与“何时返回成功”

InnoDB 使用 WAL（Write-Ahead Logging） 保证持久性：事务提交前先把修改写到 Redo Log，真正的脏页可以延迟异步刷回磁盘。核心流程如下：

sequenceDiagram
    participant App as 应用/客户端
    participant MySQL as MySQL Server
    participant BP as Buffer Pool
    participant Redo as Redo Log Buffer / 文件
    participant Disk as 磁盘数据文件

    App->>MySQL: BEGIN
    App->>MySQL: UPDATE user SET age=20 WHERE id=1
    MySQL->>BP: 读取数据页并修改 age=20
    MySQL->>Redo: 写入 Redo Log：<br/>"将 id=1 的 age 改为 20"
    Note over Redo: WAL：先写日志，再写磁盘
    App->>MySQL: COMMIT
    MySQL->>Redo: 按策略刷新 Redo Log
    MySQL-->>App: 返回 Commit 成功
    Note over BP,Disk: 脏页由后台线程异步刷盘

Redo 写完后，MySQL 才告诉应用写完成了吗？

答案是：默认配置（innodb_flush_log_at_trx_commit = 1）下，是的。 MySQL 把 Redo Log fsync 到磁盘后，才会返回 COMMIT 成功。

参数值	提交时的行为	持久性	典型场景
1（默认）	每次提交都 `fsync` 刷盘	最高，提交即持久	生产默认，强一致业务
2	写到 OS Page Cache，每秒刷盘	可能丢失 1 秒内数据	追求性能，可容忍少量丢失
0	由后台线程每秒刷一次	最低，进程崩溃可能丢 1 秒	极少使用

关键结论：默认情况下，应用收到 COMMIT 成功，就意味着对应事务的 Redo Log 已经持久化到磁盘。此后即使 MySQL 立刻崩溃，重启时也能根据 Redo Log 恢复这条已提交事务；如果崩溃发生在 fsync 之前，则该事务会被回滚或视为未提交。

崩溃恢复流程：

flowchart TD
    A[MySQL 崩溃后重启] --> B[加载磁盘 Redo Log]
    B --> C[找到上一次 Checkpoint LSN]
    C --> D[扫描 Checkpoint 之后的 Redo 记录]
    D --> E{Redo 记录对应页<br/>是否需要重放?}
    E -->|Redo LSN > 页 LSN| F[重放该条 Redo]
    F --> G[恢复已提交事务的修改]
    E -->|已落盘，无需重放| H[跳过]
    G --> I[恢复完成，数据库可用]
    H --> I
    J[崩溃时 Redo 尚未 fsync] --> K[事务视为未提交<br/>不会恢复]

注意：Redo Log 是物理逻辑日志，恢复时按 LSN 顺序重放。InnoDB 会对比 Redo 记录与数据页上的 LSN，避免对已经落盘的页重复应用，保证幂等性。

4.2.2 Undo Log：回滚是如何实现的？

Redo 记录“新值”用于崩溃后重做；Undo 记录“旧值”用于事务回滚和 MVCC。

Undo Log 回滚流程：

flowchart TD
    A[事务开始 BEGIN] --> B[执行 UPDATE / DELETE]
    B --> C[生成 Undo Log<br/>记录修改前的旧值]
    C --> D[修改 Buffer Pool 数据页]
    D --> E{事务结果}
    E -->|ROLLBACK| F[读取本事务的 Undo Log]
    F --> G[用旧值覆盖 Buffer Pool 中的修改]
    G --> H[释放事务持有的锁]
    H --> I[事务结束，修改被撤销]
    E -->|COMMIT| J[Redo Log 持久化后提交]
    J --> K[Undo Log 标记为可清理]
    K --> L[Purge 线程异步回收]
    L --> M[事务结束]

Undo Log 的两个核心作用：

事务回滚：ROLLBACK 或语句失败时，InnoDB 沿着 Undo Log 把修改逐项撤销，恢复数据到事务开始前的状态，保证原子性。
MVCC 一致性读：RR/RC 级别下，普通 SELECT 不加锁，而是通过 Undo Log 链构造事务开始时可见的数据版本（ReadView），实现无锁并发读。

注意：Undo Log 的修改本身也受到 Redo Log 保护。崩溃恢复时，Undo Log 页也会通过 Redo Log 重建，否则回滚能力会丢失。

注意：事务提交后，Undo Log 不会立即删除。如果其他事务还需要用它构造快照，Undo Log 会继续保留，直到没有事务依赖该旧版本后，Purge 线程才会回收。长事务会导致 Undo 堆积、表空间膨胀。

4.3 事务的并发问题

问题	描述
脏读	事务 A 读到事务 B 未提交的数据，B 回滚后 A 读到的是脏数据
不可重复读	事务 A 多次读取同一行，事务 B 修改并提交，导致 A 两次结果不同
幻读	事务 A 按条件查询一批数据，事务 B 新增/删除满足条件的数据，导致 A 再次查询时结果集不同

避坑指南 #5：不可重复读侧重“修改”，幻读侧重“新增或删除”。InnoDB 默认的可重复读通过 MVCC + 间隙锁（Gap Lock）在很大程度上解决了幻读。

4.4 四种隔离级别

graph LR
    A[读未提交<br>Read Uncommitted] --> B[读已提交<br>Read Committed]
    B --> C[可重复读<br>Repeatable Read]
    C --> D[串行化<br>Serializable]
    style C fill:#e1f5e1

隔离级别	脏读	不可重复读	幻读	说明
读未提交（RU）	是	是	是	基本不使用
读已提交（RC）	否	是	是	Oracle / SQL Server 默认
可重复读（RR）	否	否	否*	MySQL 默认，InnoDB 通过 MVCC + Gap Lock 解决幻读
串行化（S）	否	否	否	性能最差，完全串行

避坑指南 #6：MySQL 默认是可重复读（RR），但很多互联网项目会改为读已提交（RC），因为 RC 锁粒度更小、并发更高。但改为 RC 后，需要业务层自行处理不可重复读问题。

五、索引类型

索引是 MySQL 高性能的基石。理解索引类型与适用场景，比单纯记住语法更重要。

graph TD
    A[MySQL 索引] --> B[普通索引]
    A --> C[唯一索引]
    A --> D[主键索引]
    A --> E[组合索引]
    A --> F[全文索引]
    D --> G[聚簇索引：数据与索引在一起]
    B --> H[二级索引：叶子节点存主键]

5.1 普通索引

CREATE INDEX index_name ON table(column(length));

5.2 唯一索引

CREATE UNIQUE INDEX indexName ON table(column(length));

5.3 主键索引

主键索引是一种特殊的唯一索引，一张表只能有一个主键，且不允许为空。

5.4 组合索引

CREATE INDEX idx_name_age ON user(name, age);

避坑指南 #7：组合索引遵循最左前缀原则。idx_name_age 对 name、name+age 有效，但对单独 age 无效。

5.5 全文索引

适用于 LIKE '%关键词%' 场景，MyISAM 和 InnoDB 5.6+ 都支持。

六、锁机制与 MVCC

6.1 共享锁与排他锁

锁类型	英文	读/写	兼容性
共享锁	S Lock / 读锁	`SELECT ... LOCK IN SHARE MODE`	读读兼容，读写互斥
排他锁	X Lock / 写锁	`SELECT ... FOR UPDATE` / 增删改	与任何锁都互斥

graph LR
    A[共享锁 S] -- 兼容 --> B[共享锁 S]
    A -- 互斥 --> C[排他锁 X]
    C -- 互斥 --> D[排他锁 X]

避坑指南 #8：只有 INSERT / UPDATE / DELETE 会自动加排他锁；普通 SELECT 不加锁。如果需要保证读取的是最新已提交数据并防止被修改，应显式使用 SELECT ... FOR UPDATE。

6.2 MVCC 实现可重复读

sequenceDiagram
    participant T1 as 事务 A
    participant DB as InnoDB
    participant T2 as 事务 B

    T1->>DB: START TRANSACTION<br>创建 ReadView
    T2->>DB: UPDATE row SET x=2<br>并提交
    T1->>DB: SELECT x<br>仍读取快照中的 x=1
    Note over T1,DB: 事务 A 始终使用开始时的 ReadView

MVCC 不是复制一份数据，而是通过 ReadView + 数据行隐藏字段 + Undo Log 版本链，来判断当前事务应该看到哪个版本的数据。

6.2.1 数据行的两个隐藏字段

InnoDB 每行数据都有两个隐藏字段：

DB_TRX_ID：最后修改这行的事务 ID。
DB_ROLL_PTR：回滚指针，指向这行数据在 Undo Log 中的上一个版本。

6.2.2 ReadView 里面有什么？

ReadView 是一个轻量的结构，不保存任何实际数据，只保存生成时刻的事务状态：

字段	含义
`m_ids`	生成 ReadView 时，所有未提交事务的 ID 列表
`min_trx_id`	`m_ids` 中的最小事务 ID
`max_trx_id`	生成 ReadView 时，系统下一个要分配的事务 ID
`creator_trx_id`	创建该 ReadView 的事务自身 ID

6.2.3 可见性判断算法

对于查询到的一行数据，取出它的 DB_TRX_ID，按以下规则判断：

DB_TRX_ID == creator_trx_id：当前事务自己修改的，可见。
DB_TRX_ID < min_trx_id：在 ReadView 创建前已提交，可见。
DB_TRX_ID >= max_trx_id：在 ReadView 创建后才启动的事务修改的，不可见。
min_trx_id <= DB_TRX_ID < max_trx_id：
- DB_TRX_ID 在 m_ids 列表中 → 事务未提交，不可见。
- DB_TRX_ID 不在 m_ids 列表中 → 事务已提交，可见。

如果当前版本不可见，就沿着 DB_ROLL_PTR 到 Undo Log 链中找上一个版本，重复判断，直到找到可见版本。

flowchart TD
    A[SELECT 读取一行] --> B[获取 DB_TRX_ID]
    B --> C{可见性判断}
    C -->|可见| D[返回当前版本]
    C -->|不可见| E[沿 DB_ROLL_PTR 读 Undo Log 上一个版本]
    E --> C

6.2.4 一个具体例子

假设 id=1 的行初始值为 x=1，事务时间线如下：

时间	事务 10	事务 20	事务 30（查询）
T1	开始
T2		开始
T3	更新 x=2，未提交
T4		更新 x=3，未提交
T5			开始，SELECT x

事务 30 生成的 ReadView：

m_ids = [10, 20]
min_trx_id = 10
max_trx_id = 31
creator_trx_id = 30

查询时，当前行最新版本的 DB_TRX_ID = 20：

20 在 m_ids 中 → 未提交 → 不可见。
沿 Undo Log 找到上一个版本，DB_TRX_ID = 10。
10 在 m_ids 中 → 未提交 → 不可见。
再沿 Undo Log 找到初始版本，DB_TRX_ID = 5（假设为初始插入）。
5 < min_trx_id 10 → 已提交 → 可见。

所以事务 30 读到的是 x=1。

6.2.5 RR 与 RC 的区别

RR（可重复读）：ReadView 在事务的第一次 SELECT 时创建，之后整个事务复用该 ReadView。因此同一个事务内多次查询结果一致。
RC（读已提交）：每次 SELECT 都会创建新的 ReadView，所以能看到其他事务已经提交的最新数据。

避坑指南 #9：RR 级别下，事务开始后创建一致性视图，后续查询都基于该快照。FOR UPDATE 可以读到最新数据，同时解决第二类更新丢失问题。

七、MySQL 优化四大方向

graph LR
    A[MySQL 优化] --> B[设计层面]
    A --> C[功能层面]
    A --> D[架构层面]
    A --> E[SQL 层面]
    B --> B1[存储引擎 / 字段类型 / 范式]
    C --> C1[索引 / 缓存 / 分区分表]
    D --> D1[主从复制 / 读写分离 / 负载均衡]
    E --> E1[慢 SQL 分析 / 执行计划]

7.1 存储引擎选择

引擎	特点	适用场景
InnoDB	支持事务、行锁、外键、崩溃恢复	需要数据完整性、高并发的 OLTP 业务
MyISAM	表锁、无事务、查询和插入速度快	读多写少、日志型、临时统计表

避坑指南 #10：MySQL 5.5+ 默认引擎是 InnoDB，新项目无脑选 InnoDB。除非有非常明确的只读/归档场景，否则不要用 MyISAM。

7.2 字段类型选择原则

原则	说明
尽可能小	能用 `INT` 不用 `BIGINT`，能用 `TINYINT` 不用 `INT`
尽可能定长	`CHAR` 比 `VARCHAR` 更适合短定长文本
尽可能用整数	整数比较和索引效率高于字符串
短文本定长	用 `CHAR`
短文本变长	用 `VARCHAR`
长文本	用 `TEXT` / `BLOB`，避免直接索引大字段

7.3 数据库三大范式

graph LR
    A[1NF 原子性] --> B[2NF 消除部分依赖]
    B --> C[3NF 消除传递依赖]

范式	核心要求
第一范式 1NF	字段不可再分，每个字段只存单一值
第二范式 2NF	非主键字段必须完全依赖主键，不能依赖部分主键
第三范式 3NF	消除传递依赖，非主键字段只依赖主键

避坑指南 #11：不要过度范式化。互联网业务为了查询性能，常采用逆范式设计，允许适当冗余，用空间换时间。

7.4 功能层面优化：索引、缓存、分区分表

功能层面优化是在不改变核心业务表结构的前提下，通过索引、缓存、分区分表等手段提升性能。

索引优化

索引是最常用的功能优化手段。核心原则：

WHERE、JOIN、ORDER BY 字段建立索引。
覆盖索引：查询字段都在索引中，避免回表。
最左前缀：组合索引按使用频率和字段顺序设计。
避免索引失效：如函数操作索引列、隐式类型转换、前模糊 LIKE、OR 半边无索引等。

缓存策略

查询缓存：MySQL 8.0 已移除，不建议依赖。
应用层缓存：Redis / Memcached 缓存热点数据，减少数据库压力。
注意缓存一致性：写数据库后要及时失效或更新缓存，避免脏读。

分区分表

当单表数据量过大（通常超过 500 万 - 1000 万行，或单表超过 10GB）时，需要考虑拆分。主要分为两种：

方式	说明	对应用是否透明
分区（Partition）	单张表在物理上拆成多个分区文件，逻辑上仍是一张表	基本透明，应用按普通表读写
分表（Sharding）	把数据拆到多张物理表中，如 `user_0` - `user_15`	不透明，通常需要分库分表中间件或应用层路由

分区（Partition）

分区是 MySQL 提供的原生功能，一张逻辑表由多个物理分区组成，每个分区独立存储。

常见分区类型：

类型	说明	适用场景
RANGE	按连续范围分区，如按时间、ID 范围	日志表、订单表按月份归档
LIST	按离散值列表分区	按地区、状态等枚举值
HASH	按分区键哈希取模	数据分布均匀，无业务热点
KEY	类似 HASH，但由 MySQL 内部决定哈希函数	简化使用

创建分区表示例（RANGE）：

CREATE TABLE user_log (
    id BIGINT NOT NULL,
    user_id BIGINT NOT NULL,
    action VARCHAR(50),
    created_at DATETIME NOT NULL
) PARTITION BY RANGE (YEAR(created_at)) (
    PARTITION p2022 VALUES LESS THAN (2023),
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025),
    PARTITION pfuture VALUES LESS THAN MAXVALUE
);

分区表的增删改查：

-- 查询整个表（和普通表一样）
SELECT * FROM user_log WHERE created_at >= '2024-01-01';

-- 指定分区查询（强制扫描某个分区）
SELECT * FROM user_log PARTITION (p2024) WHERE action = 'login';

-- 插入数据（MySQL 自动根据分区键路由）
INSERT INTO user_log VALUES (1, 10086, 'login', '2024-06-01 10:00:00');

-- 更新数据（如果修改分区键，可能需要跨分区移动行）
UPDATE user_log SET created_at = '2025-01-01' WHERE id = 1;

-- 删除整个分区的数据（比分批 DELETE 快得多）
ALTER TABLE user_log DROP PARTITION p2022;

分区表的关键点：

分区键必须包含在唯一索引/主键中。例如主键是 (id)，那么不能按 created_at 分区，除非主键改成 (id, created_at)。
查询要命中分区键才能裁剪。如果 WHERE 里没有分区键，MySQL 会扫描所有分区，反而更慢。
分区数量不宜过多。MySQL 官方建议单表分区数控制在 1000 以内，过多会消耗文件描述符和内存。

分表（Sharding）

分表是把一张逻辑表拆成多张物理表，通常需要配合分库分表中间件（如 ShardingSphere、MyCat）或应用层路由。

拆分方式	说明	适用场景
垂直拆分	按业务/字段拆分，如 `user_base` 和 `user_profile`	单表字段过多、冷热数据分离
水平拆分	按行拆分，如 `user_id % 16` 分 16 张表	单表数据量过大、并发过高

水平拆分策略：

策略	优点	缺点
范围分片	按时间/ID 范围，扩容简单	容易热点，如最新时间片集中写入
哈希分片	数据分布均匀	扩容需要迁移数据
一致性哈希	扩容时迁移数据量少	实现稍复杂
列表分片	按地区/类型等枚举值	适合有明显业务边界的数据

分库分表带来的问题：

分布式事务：跨库事务无法靠单机 ACID 保证。
跨库 JOIN：需要在应用层聚合，或反范式冗余字段。
全局唯一 ID：不能用自增主键，需要雪花算法、号段等方案。
分页排序：ORDER BY + LIMIT 跨多表后合并复杂。
数据迁移：扩容时需要平滑迁移历史数据。

避坑指南 #14：不要为了拆分而拆分。大多数业务先做好索引、SQL 优化、加缓存，单表撑到千万级没问题。拆分成本：分区 < 分表 < 分库。优先考虑分区；分区也撑不住时，再考虑分库分表。

7.5 SQL 层面优化：慢 SQL 分析与执行计划

SQL 层面的优化收益往往最高，因为一条烂 SQL 可以把整个数据库拖垮。

如何发现慢 SQL

慢查询日志：slow_query_log = ON，long_query_time 设置阈值。
performance_schema：MySQL 内置性能监控。
pt-query-digest：Percona Toolkit 分析慢日志。
应用层 APM：SkyWalking、Pinpoint 等追踪 SQL 耗时。

EXPLAIN 看执行计划

EXPLAIN SELECT * FROM `order` WHERE age > 18 ORDER BY created_at LIMIT 10;

关键字段：

字段	含义
`type`	访问类型，越靠前越好：`system > const > eq_ref > ref > range > index > ALL`
`key`	实际使用的索引
`rows`	预估扫描行数
`Extra`	额外信息

type 详解：

type 表示 MySQL 访问表的方式，可以理解为“查资料时翻书的方式”。

type	通俗解释	效率	典型 SQL
system	表里最多 1 条数据，直接当常量	⭐⭐⭐⭐⭐	查只有一条配置的配置表
const	通过主键/唯一索引等值查，最多 1 条	⭐⭐⭐⭐⭐	`WHERE id = 1`
eq_ref	JOIN 时，被驱动表用主键/唯一索引匹配，最多 1 条	⭐⭐⭐⭐⭐	`A JOIN B ON A.b_id = B.id`
ref	通过普通索引等值查，可能有多条	⭐⭐⭐⭐	`WHERE phone = 'xxx'`（phone 是普通索引）
range	索引范围扫描	⭐⭐⭐	`WHERE age > 18`、`BETWEEN`、`IN`、`LIKE 'prefix%'`
index	全索引扫描	⭐⭐	`SELECT 索引列 FROM 表`、按索引排序
ALL	全表扫描	⭐	没走索引，逐行读

各 type 详细说明与示例：

1. system：表本身就是常量

表里只有 0 条或 1 条数据，MySQL 把它当成常量处理。

SELECT * FROM system_config;

如果 system_config 只有一条记录，EXPLAIN 可能看到 type = system。实际业务表中很少见。

2. const：精确命中唯一值

通过主键或唯一索引做等值查询，最多返回 1 行。

-- id 是主键
SELECT * FROM user WHERE id = 10086;

-- phone 是唯一索引
SELECT * FROM user WHERE phone = '13800138000';

这是单表查询里最好的 type。

3. eq_ref：JOIN 中的 const

多表 JOIN 时，被驱动表通过主键或唯一索引与驱动表匹配，每次匹配最多返回 1 行。

SELECT o.*, u.name
FROM `order` o
JOIN user u ON o.user_id = u.id;

假设 user.id 是主键，order 表的每一行去 user 表查都是精确命中 1 行，此时 user 表的 type = eq_ref。

4. ref：普通索引等值查询

通过普通索引（非唯一索引）做等值查询，可能返回多条。

-- status 是普通索引
SELECT * FROM `order` WHERE status = 'PAID';

status = 'PAID' 可能对应很多订单。这是生产环境最常见的良好 type。

5. range：索引范围扫描

使用索引做范围查询。

-- age 有索引
SELECT * FROM user WHERE age > 18;

-- create_time 有索引
SELECT * FROM `order`
WHERE create_time BETWEEN '2024-01-01' AND '2024-01-31';

-- id 是主键
SELECT * FROM user WHERE id IN (1, 2, 3, 4);

-- phone 有索引
SELECT * FROM user WHERE phone LIKE '1380%';

注意：LIKE '1380%' 走 range；LIKE '%1380' 或 LIKE '%1380%' 会退化成 ALL。

6. index：全索引扫描

遍历整个索引树，而不是全表扫描数据。

-- name 是索引列
SELECT name FROM user;

-- 按索引列排序
SELECT id FROM user ORDER BY id;

因为索引通常比实际数据小，读索引比读整行快。但如果查询列不在索引里或需要大量回表，index 也会很慢。

7. ALL：全表扫描

没有用到索引，逐行读取整张表。

-- phone 没有索引
SELECT * FROM user WHERE phone = '13800138000';

-- 对索引列使用函数
SELECT * FROM `order` WHERE DATE(create_time) = '2024-01-01';

-- 前模糊 LIKE
SELECT * FROM user WHERE phone LIKE '%1380%';

生产环境出现 type = ALL 通常需要优化。

简单记忆口诀：

system/const 是精确，一行数据最省事；
eq_ref 是 JOIN 版 const，主键关联一对一；
ref 普通索引等值查，可能返回好几行；
range 范围扫描用得广，BETWEEN IN 都能上；
index 全扫索引比表强；
ALL 全表扫描要提防。

生产环境建议：

type	是否需要关注
`system / const / eq_ref / ref`	优秀，基本不用管
`range`	正常，注意范围不要太大
`index`	需要警惕，确认是否真的需要全索引扫描
`ALL`	必须优化，除非表很小（几万行以内）

一般原则：单表查询尽量做到 ref 或更好，范围查询 range 可接受，尽量避免 ALL 和大量数据的 index。

危险的 Extra：

Using filesort：需要额外排序，常见于无索引的 ORDER BY。
Using temporary：需要创建临时表，常见于 GROUP BY、DISTINCT。
Using index：好现象，使用了覆盖索引。
Using where：在存储引擎返回数据后再过滤。

典型慢 SQL 写法与严重踩坑案例

案例 1：`SELECT *`

SELECT * FROM `order` WHERE user_id = 10086;

问题：读取不需要的列，增加网络传输和 Buffer Pool 占用，容易触发回表。

优化：

SELECT order_id, status, amount FROM `order` WHERE user_id = 10086;

案例 2：前模糊 LIKE 导致索引失效

SELECT * FROM user WHERE phone LIKE '%1380%';

问题：% 在开头无法使用 B+ 树索引，会全表扫描。

优化：

改为后缀匹配：LIKE '1380%'（如果有索引仍可用）。
使用全文索引或 Elasticsearch。

案例 3：`OR` 条件半边无索引

SELECT * FROM user WHERE phone = '13800138000' OR email = 'a@b.com';

问题：如果 email 没有索引，MySQL 可能放弃索引，直接全表扫描。

优化：

SELECT * FROM user WHERE phone = '13800138000'
UNION ALL
SELECT * FROM user WHERE email = 'a@b.com';

或给 email 也建索引。

案例 4：隐式类型转换

SELECT * FROM user WHERE phone = 13800138000;

问题：phone 是 varchar，MySQL 会先把所有行的 phone 转成整数再比较，索引失效。

优化：

SELECT * FROM user WHERE phone = '13800138000';

案例 5：函数操作索引列

SELECT * FROM `order` WHERE DATE(create_time) = '2024-01-01';

问题：对索引列使用函数，DATE(create_time) 不是索引本身，索引失效。

优化：

SELECT * FROM `order`
WHERE create_time >= '2024-01-01'
  AND create_time < '2024-01-02';

案例 6：大 OFFSET 深分页

SELECT * FROM `order` ORDER BY id LIMIT 1000000, 10;

问题：MySQL 需要先扫描 1000010 行，再扔掉前面的 1000000 行，越往后越慢。

优化（延迟关联）：

SELECT o.*
FROM `order` o
JOIN (SELECT id FROM `order` ORDER BY id LIMIT 1000000, 10) tmp ON o.id = tmp.id;

或记录上次位置：

SELECT * FROM `order` WHERE id > ? ORDER BY id LIMIT 10;

案例 7：`IN` 子句元素过多

SELECT * FROM user WHERE id IN (1, 2, 3, ..., 50000);

问题：IN 元素过多会导致解析和执行效率下降，甚至超出限制。

优化：分批查询，或把 ID 写入临时表再 JOIN。

案例 8：大事务长时间持有锁

START TRANSACTION;
-- 大量更新操作
UPDATE huge_table SET ... WHERE ...;
-- 业务逻辑处理
-- 几分钟后才 COMMIT

问题：长时间持有行锁/间隙锁，阻塞其他事务，Undo Log 堆积，主从延迟放大。

优化：拆分为小批量事务，减少单次锁定范围。

线上最严重的几个踩坑

踩坑行为	后果	正确做法
`UPDATE / DELETE` 忘记写 `WHERE`	全表数据被改/删，可能导致业务瘫痪	先 `SELECT` 确认影响行数，使用 `LIMIT`，小批量执行
高峰期执行 `ALTER TABLE` / `OPTIMIZE`	锁表，查询堆积，服务雪崩	使用 Online DDL（如 `pt-online-schema-change`），低峰期执行
直接 `SELECT * FROM huge_table`	打满 Buffer Pool，拖垮数据库	加分页、加条件、只查必要字段
慢 SQL 打满连接池	应用无法获取连接，全面超时	设置 SQL 超时，连接池隔离，熔断降级

避坑指南 #15：上线任何 SQL 前，先用 EXPLAIN 检查执行计划。看到 type = ALL、Extra = Using filesort 或 Using temporary 时，必须优化后再上线。

八、高性能架构设计

8.1 主从复制 + 读写分离

graph LR
    A[写请求] --> B[主库 Master]
    B -->|binlog 同步| C[从库 Slave 1]
    B -->|binlog 同步| D[从库 Slave 2]
    E[读请求] --> C
    E --> D

避坑指南 #12：主从复制存在延迟。如果对实时性要求极高（如支付后立刻查询余额），读请求应强制走主库，或在业务层做延迟容忍设计。

8.2 分区分表

方式	说明
垂直拆分	按业务/字段拆分，如用户表拆成 `user_base` 和 `user_profile`
水平拆分	按行拆分，如按 `user_id % 16` 分 16 张表

九、用户权限与数据导出

9.1 创建新用户并授权

-- 创建用户
CREATE USER 'goose_vod'@'%' IDENTIFIED BY 'xxxx';

-- 授权
GRANT ALL PRIVILEGES ON `ad_db`.* TO `goose_vod`@`%`;

-- 刷新权限
FLUSH PRIVILEGES;

避坑指南 #13：生产环境请遵循最小权限原则，不要给业务账号 ALL PRIVILEGES。例如只读账号只授予 SELECT。

9.2 导出数据库

mysqldump -h xxxx-rds.xxxx.us-east-1.rds.amazonaws.com \
  -u goose_vod -p appstore_db > ~/database_dump.txt

十、避坑清单速查表

编号	避坑点
1	数据库字符集用 `utf8mb4`，不要用默认 `utf8`
2	JDBC 连接串指定 `serverTimezone` 和 `characterEncoding`
3	通用日志只用于临时排查，不要长期开启
4	存储过程谨慎使用，优先应用层处理业务逻辑
5	不可重复读 ≠ 幻读，RR 级别下 InnoDB 基本解决幻读
6	根据业务决定是否将隔离级别从 RR 改为 RC
7	组合索引遵循最左前缀原则
8	普通 `SELECT` 不加锁，需要锁时显式 `FOR UPDATE`
9	RR 下快照读基于 ReadView，`FOR UPDATE` 读最新数据
10	新项目默认使用 InnoDB，不要选 MyISAM
11	适度逆范式，用空间换查询时间
12	主从延迟存在，实时读考虑强制走主库
13	生产环境遵循最小权限原则
14	不要为了拆分而拆分；拆分成本：分区 < 分表 < 分库，优先考虑分区
15	上线前用 EXPLAIN 检查执行计划，警惕 ALL / filesort / temporary

十一、总结

MySQL 的学习路径可以概括为：

graph LR
    A[熟练 SQL 与安装配置] --> B[理解事务与隔离级别]
    B --> C[掌握索引设计与优化]
    C --> D[理解锁与 MVCC]
    D --> E[掌握主从复制与读写分离]
    E --> F[持续分析慢 SQL 与执行计划]

高性能 MySQL 没有银弹，核心在于：合理的表结构设计、精准的索引、恰到好处的事务隔离、以及能够水平扩展的架构。希望这份笔记能成为你日常开发与面试复习的速查手册。

数据库 on 方糖猫Blog

MongoDB 从入门到精通：存储引擎、建模、索引、副本集、分片与事务实战

MongoDB 从入门到精通：存储引擎、建模、索引、副本集、分片与事务实战

第一篇 选型认知：什么时候该用 MongoDB，什么时候别逞强

第二篇 WiredTiger：理解存储引擎，才配谈性能

2.1 底层数据模型：BSON，磁盘上到底存了什么

2.2 为什么快：读快与写快的底层原因

2.3 WiredTiger 你必须知道的四件事

2.4 本地环境：直接上副本集，别玩单机

第三篇 数据建模：核心战场，没有之一

3.1 唯一重要的问题：嵌入还是引用

3.2 电商核心建模：订单快照与库存拆分

第四篇 索引与 explain：调优基本功，没有捷径

4.1 explain 是唯一标准答案

4.2 ESR 法则与 Java 建索引

第五篇 聚合管道：把计算下推给服务端

第六篇 副本集：高可用与读写语义的分水岭

6.1 架构与选主

6.2 读写语义：writeConcern 与 readConcern

第七篇 事务与分片：规模化之后的一致性难题

7.1 能不用事务就不用：原子操作的威力

7.2 真正需要事务的场景

7.3 分片：单副本集扛不住之后

第八篇 运维底线与 AI 时代：把系统做稳，把代码写少

8.1 生产运维的最低纲领

8.2 AI 时代：如何少写代码把系统做稳

附录：Demo 与检查清单

MySQL 实战笔记：安装、事务、索引、锁与高性能优化

MySQL 实战笔记：安装、事务、索引、锁与高性能优化

一、高层次思想：MySQL 在解决什么问题？

1.1 MySQL 架构分层

1.2 Buffer Pool：InnoDB 的内存缓存

二、安装、启动与基础配置

2.1 启动 MySQL 服务

2.2 修改 root 密码

2.3 创建数据库时务必指定编码

2.4 JDBC 连接串必须带编码与时区

2.5 开启通用查询日志

三、存储过程：谨慎使用

为什么不推荐重度使用存储过程？

适合使用存储过程的场景

更推荐的替代方案

四、事务：ACID 与隔离级别

4.1 事务的 ACID 特性

4.2 Undo Log 与 Redo Log

4.2.1 Redo Log：崩溃恢复与“何时返回成功”

4.2.2 Undo Log：回滚是如何实现的？

4.3 事务的并发问题

4.4 四种隔离级别

五、索引类型

5.1 普通索引

5.2 唯一索引

5.3 主键索引

5.4 组合索引

5.5 全文索引

六、锁机制与 MVCC

6.1 共享锁与排他锁

6.2 MVCC 实现可重复读

6.2.1 数据行的两个隐藏字段

6.2.2 ReadView 里面有什么？

6.2.3 可见性判断算法

6.2.4 一个具体例子

6.2.5 RR 与 RC 的区别

七、MySQL 优化四大方向

7.1 存储引擎选择

7.2 字段类型选择原则

7.3 数据库三大范式

7.4 功能层面优化：索引、缓存、分区分表

索引优化

缓存策略

分区分表

分区（Partition）

分表（Sharding）

7.5 SQL 层面优化：慢 SQL 分析与执行计划

如何发现慢 SQL

EXPLAIN 看执行计划

典型慢 SQL 写法与严重踩坑案例

案例 1：SELECT *

案例 2：前模糊 LIKE 导致索引失效

案例 3：OR 条件半边无索引

第一篇选型认知：什么时候该用 MongoDB，什么时候别逞强

第三篇数据建模：核心战场，没有之一

第四篇索引与 explain：调优基本功，没有捷径

第五篇聚合管道：把计算下推给服务端

第六篇副本集：高可用与读写语义的分水岭

第七篇事务与分片：规模化之后的一致性难题

第八篇运维底线与 AI 时代：把系统做稳，把代码写少

案例 1：`SELECT *`

案例 3：`OR` 条件半边无索引

案例 7：`IN` 子句元素过多