罗罗编程学习记录
本页内容 展开查看

07.6 阶段 5:数据层、缓存与队列

所属:全栈开发面试题库 / 学习路径 / 07 Node.js 全栈

本页目录

一、阶段定位

阶段 4 写好了 HTTP 服务,但数据还在内存里,重启即丢。本阶段把数据层接进来:关系型数据库(ORM/查询构造器)、Redis 缓存、异步队列(BullMQ)。这是业务系统的骨架,也是线上事故最集中的地方。

与前后阶段的衔接:往上接 阶段 4 Web 框架主线,Controller 里注入的 Service 现在要接 Prisma/Redis;往下接 阶段 6 鉴权、安全、测试与可观测,缓存 key、队列消费都要加日志与指标。再往后接 阶段 7 全栈同构、部署与生产化,连接池与队列 worker 要在容器里跑。

本阶段原有的四个卡点,展开成可判断的现象依据:

  1. 缓存与数据库更新顺序不当导致脏读。判断标准:先更新库再删缓存(或先删缓存再更新库),并发下出现旧数据;接口返回的数据与库里对不上。
  2. 队列重复消费产生重复订单或重复通知。判断标准:同一个 job 被消费两次,产生两条订单、两封邮件;没有幂等键。
  3. 长事务与连接池配置不当导致连接耗尽。判断标准:压测到一定量后接口 hang,数据库连接数打满,Too many connections;或连接池默认 10,但并发 100 时排队。
  4. ORM 遍历关联对象不做预加载形成 N+1。判断标准:列表接口日志显示执行了几百条 SELECT,一条查用户、N 条查他的订单。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能用 Prisma 或 TypeORM 连数据库,写查询、迁移、种子数据 npx prisma migrate dev 生成表,启动后接口可访问
能识别并修掉 N+1,用预加载把查询次数降到常数 日志显示 N+1 时是 N 条,修复后是 2 条
能写事务,说明隔离级别对业务的影响 事务里两个操作要么都成功要么都回滚
能配 Redis 客户端,选对数据结构(string/hash/list/zset) 用 hash 存对象、用 zset 做排行榜
能解释缓存穿透/击穿/雪崩并写出防护 加互斥锁、布隆过滤器、随机过期
能用 BullMQ 写生产者与消费者,做到幂等 重复投递不产生重复数据

建议学时:

  • 全职(每天 4–6 小时):2.5 周,约 70 小时。ORM 与连接池 15 小时、事务与 N+1 15 小时、Redis 与缓存 20 小时、BullMQ 20 小时。
  • 在职(每天 2 小时):6–7 周。缓存三兄弟与幂等是面试重灾区。

学时分配建议:ORM 与连接池 20%、事务与 N+1 20%、Redis 与缓存 30%、BullMQ 30%。

三、先修自检

先修项 合格标准 不合格时回到
SQL 基础 会 SELECT/INSERT/UPDATE/JOIN 05.1 关系型数据库通用能力
Node 异步 能写 async/await 07.1 阶段 0
Express/NestJS 能写路由与 Service 07.5 阶段 4
TypeScript 能写接口与泛型 07.4 阶段 3
命令行 能装依赖、跑迁移 07.3 阶段 2

四、知识地图

模块 知识点 掌握程度 对应题库章节
ORM Prisma/TypeORM/Sequelize/Drizzle 取舍、连接池 会用 05.1 关系型数据库通用能力
事务与隔离 ACID、隔离级别、N+1、预加载 能讲清原理 05.2 MySQL
迁移与种子 prisma migrate、seed 脚本 会用 05.1 关系型数据库通用能力
Redis 数据结构、连接复用、expire 会用 05.5 NoSQL 与专用存储
缓存三兄弟 穿透/击穿/雪崩、一致性策略 能讲清原理 09.3 缓存体系
分布式锁与限流 Redlock、SET NX EX、滑动窗口 会用 09.3 缓存体系
BullMQ Job、重试、延迟、并发、幂等、stalled 会用 09.4 消息队列
与 MQ 关系 BullMQ vs Kafka/RocketMQ 分工 了解 09.4 消息队列

进度管理建议:ORM、N+1、缓存三兄弟、幂等必须到"能讲清原理",其余到"会用"。

五、分模块精讲

5.1 ORM 取舍与连接池

为什么需要它:直接写 SQL 繁琐且易错,ORM 提供类型安全与迁移工具。但选错 ORM 会在性能与灵活性之间反复踩坑。

核心机制:

  • Prisma:schema-first,写 schema.prisma 生成 client,类型安全,迁移工具好用。
  • TypeORM:装饰器风格,实体即表,适合 NestJS 集成。
  • Sequelize:老牌,API 稳定但更新慢。
  • Drizzle:轻量,SQL 优先,类型安全。
  • 连接池:数据库连接昂贵,复用连接池。Prisma 默认 num: 10;TypeORM 配 extra.connectionLimit。
  • 连接泄漏:用完不释放,池耗尽,新请求排队。

最小可运行示例:

// prisma/schema.prisma
generator client { provider = "prisma-client-js" }
datasource db { provider = "postgresql"; url = env("DATABASE_URL") }

model User {
  id    Int     @id @default(autoincrement())
  name  String
  email String  @unique
  posts Post[]
}
model Post {
  id     Int    @id @default(autoincrement())
  title  String
  author User   @relation(fields: [authorId], references: [id])
  authorId Int
}
npx prisma migrate dev --name init
npx prisma generate
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();

const users = await prisma.user.findMany({ include: { posts: true } });

常见坑:

现象 原因 修法
Too many connections 连接池打满 调小连接池,排查泄漏
查询返回 undefined 没 await await prisma.xxx
改了 schema 不生效 没跑 migrate npx prisma migrate dev
生产连不上 DATABASE_URL 错 检查环境变量

面试考法:"Prisma 与 TypeORM 怎么选""连接池为什么重要"。答到 schema-first vs 装饰器;连接复用。

5.2 事务、隔离级别与 N+1

为什么需要它:一个业务操作常涉及多张表,必须事务保证一致性。N+1 是列表接口最常见的性能坑。

核心机制:

  • 事务:prisma.$transaction([...]) 或交互式事务。ACID。
  • 隔离级别:读未提交、读已提交、可重复读、串行化。MySQL InnoDB 默认可重复读。
  • N+1:查 N 个用户,每个用户再查一次他的帖子,执行 N+1 条 SQL。
  • 预加载:include: { posts: true } 一次性查所有用户的帖子,降到 2 条 SQL。

最小可运行示例:

// 错误:N+1
const users = await prisma.user.findMany();
for (const u of users) {
  const posts = await prisma.post.findMany({ where: { authorId: u.id } });
  console.log(u.name, posts);
}
// 日志:1 条查用户 + 10 条查帖子 = 11 条

// 正确:预加载
const users2 = await prisma.user.findMany({ include: { posts: true } });
// 日志:2 条
// 事务
await prisma.$transaction([
  prisma.user.create({ data: { name: "A", email: "a@x.com" } }),
  prisma.post.create({ data: { title: "hello", authorId: 1 } })
]);

常见坑:

现象 原因 修法
列表接口慢,日志大量 SELECT N+1 用 include 预加载
事务里一个失败一个成功 没用事务 包 $transaction
脏读/不可重复读 隔离级别 业务接受读已提交即可,金融场景加锁

面试考法:"什么是 N+1,怎么修""事务 ACID"。答到预加载;原子性一致性。

5.3 Redis 客户端与数据结构选型

为什么需要它:Redis 是缓存、会话、排行榜、分布式锁的底座。选错数据结构,要么浪费内存,要么写复杂逻辑。

核心机制:

  • string:缓存 JSON 对象、计数器。
  • hash:存对象(字段可单独改)。
  • list:队列、消息。
  • set:去重、标签。
  • zset:排行榜(score 排序)。
  • 连接复用:ioredis 单例,不要每个请求新建。
  • expire:EX key 60,缓存必须有 TTL。

最小可运行示例:

import Redis from "ioredis";
const redis = new Redis();

// string 缓存
await redis.set("user:1", JSON.stringify({ name: "Ann" }), "EX", 60);

// hash 存对象
await redis.hset("user:1", { name: "Ann", age: 18 });
const name = await redis.hget("user:1", "name");

// zset 排行榜
await redis.zadd("rank", 100, "user1", 90, "user2");
const top = await redis.zrevrange("rank", 0, 9, "WITHSCORES");

常见坑:

现象 原因 修法
连接数涨 每次新建 Redis 实例 用单例
缓存永不过期 没设 EX 加 expire
大 key 单个 value 几 MB 拆分,用 hash 分段

面试考法:"Redis 五种数据结构""缓存为什么用 string 存 JSON"。答到按场景选。

5.4 缓存三兄弟与一致性

为什么需要它:缓存与数据库不一致是线上最常见的数据事故。穿透/击穿/雪崩是缓存设计的三个经典问题。

核心机制:

  • 缓存穿透:查询不存在的数据,每次都打到 DB。防护:布隆过滤器或缓存空值。
  • 缓存击穿:热点 key 过期瞬间,大量请求同时打到 DB。防护:互斥锁(SET NX EX)重建。
  • 缓存雪崩:大量 key 同时过期,DB 瞬间压力大。防护:过期时间加随机抖动。
  • 一致性策略:先更新 DB 再删缓存(Cache Aside),这是工业界默认;先删缓存再更新 DB 有并发窗口。

最小可运行示例:

// 先更新 DB 再删缓存
async function updateUser(id: number, data: object) {
  await prisma.user.update({ where: { id }, data });
  await redis.del(`user:${id}`); // 删缓存而非更新
}

// 缓存击穿防护:互斥锁
async function getUser(id: number) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);

  const lockKey = `lock:user:${id}`;
  const acquired = await redis.set(lockKey, "1", "NX", "EX", 10);
  if (!acquired) {
    await new Promise(r => setTimeout(r, 50));
    return getUser(id); // 重试
  }
  try {
    const user = await prisma.user.findUnique({ where: { id } });
    await redis.set(`user:${id}`, JSON.stringify(user), "EX", 60 + Math.random() * 30);
    return user;
  } finally {
    await redis.del(lockKey);
  }
}

常见坑:

现象 原因 修法
接口返回旧数据 先更新缓存再更新 DB 改成先更新 DB 再删缓存
热点 key 过期 DB 打满 击穿 加互斥锁
大量 key 同时失效 雪崩 过期加随机

面试考法:"缓存穿透/击穿/雪崩区别""先删缓存还是先更 DB"。答到三种防护;先更 DB 再删缓存。

5.5 分布式锁与限流

为什么需要它:多实例部署时,定时任务、库存扣减、幂等去重需要跨进程互斥。限流保护服务不被打垮。

核心机制:

  • 分布式锁:SET lock_key random_value NX EX 10,释放时用 Lua 脚本比对 value 防止误删。
  • 限流:固定窗口、滑动窗口、令牌桶。Node 里常用 Redis + Lua 实现。
  • 简单限流:INCR key EX 60,超过阈值返回 429。

最小可运行示例:

// 简单限流:每分钟 100 次
async function rateLimit(userId: string) {
  const key = `rl:${userId}`;
  const count = await redis.incr(key);
  if (count === 1) await redis.expire(key, 60);
  return count <= 100;
}

常见坑:

现象 原因 修法
锁没释放 客户端崩溃 设 EX
误删别人锁 释放时不比对 value 用唯一 value + Lua 脚本
限流窗口边界突刺 固定窗口 用滑动窗口

面试考法:"分布式锁怎么实现""Redlock 争议"。答到 NX EX + value + Lua。

5.6 BullMQ:队列、幂等与 stalled job

为什么需要它:把耗时任务(发邮件、生成报表、图片处理)从请求链路剥离,接口只入队。BullMQ 基于 Redis,与 Node 生态集成好。

核心机制:

  • Job:一个任务,含 data、opts(延迟、重试、优先级)。
  • Producer:queue.add(name, data, opts)。
  • Worker:new Worker(queue, async job => { ... })。
  • 重试:attempts: 3,失败自动重试。
  • 延迟:delay: 5000。
  • 并发:new Worker(queue, fn, { concurrency: 5 })。
  • 幂等:业务用唯一 id(如订单号)去重,重复投递不产生副作用。
  • stalled job:worker 中途崩溃,job 没 ACK,BullMQ 检测到后重新投递。

最小可运行示例:

import { Queue, Worker } from "bullmq";

const connection = { host: "localhost", port: 6379 };

const emailQueue = new Queue("email", { connection });

// 生产者
await emailQueue.add(
  "send",
  { to: "a@x.com", subject: "hi", orderId: "ORD123" },
  { attempts: 3, delay: 1000 }
);

// 消费者
const worker = new Worker(
  "email",
  async (job) => {
    const { to, subject, orderId } = job.data;
    // 幂等:用 orderId 做唯一键,已处理过就跳过
    const processed = await redis.get(`email:${orderId}`);
    if (processed) return;
    await sendEmail(to, subject);
    await redis.set(`email:${orderId}`, "1", "EX", 86400);
  },
  { connection, concurrency: 5 }
);

常见坑:

现象 原因 修法
重复发邮件 没幂等 用业务唯一 id 去重
job 一直重试 重试次数太多 设 attempts,失败进死信
stalled job 重新投递 worker 崩溃 这是正常机制,业务要幂等
队列堆积 消费慢 加 concurrency,或加 worker

面试考法:"BullMQ 与 Kafka 区别""怎么做幂等"。答到 BullMQ 基于 Redis 轻量、Kafka 高吞吐;业务唯一键去重。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
Prisma 初始化 写 schema,跑迁移,生成 client 表建出来,接口可查 2 小时
N+1 复现 写循环查用户帖子,看 SQL 条数 日志看到 N+1 1 小时
预加载修复 用 include 改成 2 条 SQL 日志条数降到常数 1 小时
Redis 缓存 用 string 缓存用户,设 EX 60 60 秒后自动过期 1 小时
BullMQ hello 写生产者与消费者,打印 job data 消费成功 1 小时

6.2 改造型

练习 要求 验收标准 预计耗时
修缓存顺序 给定先更新缓存再更新 DB 的代码,改成先 DB 后删缓存 并发下无脏读 1 小时
加互斥锁 给热点 key 查询加 SET NX EX 缓存击穿时 DB 不被打满 1.5 小时
加幂等 给邮件 job 加 orderId 去重 重复投递不重复发 1 小时
调连接池 把 Prisma 连接池从默认调到 20,压测看连接数 连接数稳定 1 小时
修长事务 给定事务里调外部接口的代码,把外部调用挪出事务 事务时间下降 1 小时

6.3 设计型

练习 要求 验收标准 预计耗时
完整数据层 接 ORM + Redis 缓存 + BullMQ 发邮件 用户注册后异步发邮件 6 小时
排行榜 用 zset 实现实时积分榜 前 10 名可查 3 小时
库存扣减 用事务 + 乐观锁扣减库存 超卖不发生 4 小时
限流中间件 用 Redis 实现每分钟 100 次限流 超量返回 429 3 小时

七、排障表

现象 可能原因 排查步骤 解决办法
Too many connections 连接池打满 看 DB 连接数 调小池,查泄漏
列表接口慢,日志大量 SELECT N+1 开 SQL 日志 用 include 预加载
接口返回旧数据 缓存一致性 看更新顺序 先更 DB 再删缓存
热点 key 过期 DB 打满 缓存击穿 看 DB 突增时间点 加互斥锁
队列重复消费 没幂等 看 job 重复 业务唯一键去重
Redis 连接数涨 每次新建实例 看代码 new Redis() 用单例
事务部分成功 没用事务 看操作是否包事务 包 $transaction
BullMQ job 堆积 消费慢 看队列长度 加 concurrency/worker

八、出口条件

全部勾选后再进入 阶段 6 鉴权、安全、测试与可观测。

  • [ ] 能用 Prisma 或 TypeORM 连数据库,写迁移与查询
  • [ ] 能识别并修掉 N+1,用预加载降到常数条 SQL
  • [ ] 能写事务,说明 ACID 与隔离级别
  • [ ] 能配 Redis 单例,选对数据结构
  • [ ] 能解释并实现缓存穿透/击穿/雪崩防护
  • [ ] 能用 BullMQ 写生产者与消费者,做到幂等
  • [ ] 能解释缓存与 DB 的一致性策略(先更 DB 再删缓存)
  • [ ] 排障表八个现象,随机抽三个能在 5 分钟内给出排查路径

自测题:

  1. N+1 是什么?怎么修?
    • 要点:查 N 个对象再查 N 次关联;用 include/预加载一次查回。
  2. 缓存与数据库更新顺序怎么选?
    • 要点:先更新 DB 再删缓存;并发窗口用延迟双删或消息队列保证。
  3. 缓存穿透、击穿、雪崩区别?
    • 要点:穿透查不存在(布隆过滤器)、击穿热点 key 过期(互斥锁)、雪崩大量 key 同时过期(随机抖动)。
  4. BullMQ 的 stalled job 是什么?
    • 要点:worker 中途崩溃没 ACK,job 被重新投递;业务必须幂等。
  5. 分布式锁怎么实现?
    • 要点:SET key random NX EX 10;释放用 Lua 比对 value。
  6. Redis 连接为什么要单例?
    • 要点:连接是昂贵资源,复用连接池;每次新建会耗尽连接。
  7. Prisma 与 TypeORM 怎么选?
    • 要点:schema-first 类型安全选 Prisma;装饰器风格与 NestJS 深度集成选 TypeORM。