高阶问题(AI 工程师)
Node.js 与 NestJS 100 题
AI 工程师面试题库 · 第三批(题号 200–299):Node.js 深入、NestJS 核心与进阶、WebSocket 与实时通信、Nest 微服务与工业化、测试与工程化。
- 面试
- AI 工程师
- Node.js
AI 工程师面试题库 · 第三批:Node.js 深入与 NestJS
- 一、Node.js 深入(200–229)
- 200. Node 事件循环的阶段模型:timers/poll/check 深入?
- 201. Stream 四种类型与 backpressure?
- 202. Buffer 与二进制处理?
- 203. child_process 与 worker_threads 选型?
- 204. Node 模块解析与 package.json 的 exports?
- 205. Node 的性能剖析:—inspect 与 heap snapshot?
- 206. Node 的 stream 高级:Web Streams 与 Readable.from?
- 207. Node 的 timer 精度与 setImmediate 的工程应用?
- 208. Node 的错误处理:Error 基类与 async 错误模式?
- 209. Node 的 http 模块:keep-alive、Agent 与大响应?
- 210. Node 的 ESM 顶层 await 与模块加载细节?
- 211. Node 的 cluster/PM2 与容器化的多进程策略?
- 212. Node 22+ 新特性:native TS、fetch、WebSocket 内建?
- 213. Node 的 cluster IPC 与进程间通信全图?
- 214. Node 的进程指标与健康监控?
- 215. Node 的环境与配置:env、config 与启动顺序?
- 216. Express/Koa/Fastify 选型与中间件洋葱模型?
- 217. async 中间件的异常捕获:为什么 try/catch 接不住?
- 218. EventEmitter 深入:监听器泄漏与 maxListeners?
- 219. V8 内存模型与 GC:新生代、老生代与堆外内存?
- 220. libuv 线程池:fs/crypto 的隐性阻塞?
- 221. Node 安全三害:ReDoS、原型污染、路径遍历?
- 222. npm 供应链安全:lockfile、audit 与依赖治理?
- 223. pino 结构化日志:traceId 贯穿、脱敏与轮转?
- 224. 文件上传:busboy 流式接收与 S3 直传?
- 225. 大文件导出:流式 CSV 与 ZIP 响应?
- 226. AbortController:统一取消传播怎么设计?
- 227. 信号处理与进程守护:SIGTERM、SIGHUP 与 PM2?
- 228. Node 大版本升级:破坏性变更怎么管?
- 229. 数据库与 Redis 客户端的连接池管理?
- 二、NestJS 核心(230–249)
- 230. Nest 的 IoC 容器解决什么问题?
- 231. Nest 请求生命周期:一次请求经过谁?
- 232. ValidationPipe 三选项:transform/whitelist/forbidNonWhitelisted?
- 233. JWT 双 token 认证在 Nest 的落地?
- 234. RBAC 权限:Guard + 装饰器元数据?
- 235. TypeORM 事务与并发更新?
- 236. Nest 中间件与 AsyncLocalStorage:请求上下文传递?
- 237. Nest 微服务:传输器选型与消息模式?
- 238. Nest 定时任务与分布式锁?
- 239. Nest 优雅停机与 shutdown hooks?
- 240. Nest 的 OpenAPI(Swagger)与接口契约?
- 241. Nest 配置管理:ConfigModule 与环境分层?
- 242. Nest 的管道:转换 Pipe 与校验 Pipe 分工?
- 243. Nest 与 Prisma:类型安全的数据库访问?
- 244. Nest 的健康检查与 readiness/liveness?
- 245. Nest 的 rate limiter 与接口限流?
- 246. Nest 的 GraphQL 模块与 N+1?
- 247. Nest 的 SSE 网关:转发 LLM 流并处理断连?
- 248. Nest 测试体系:单测、E2E 与契约?
- 249. Nest 的优雅退出:K8s 滚动更新实践?
- 三、NestJS 进阶(250–263)
- 250. 全局异常过滤器与统一错误码体系?
- 251. Interceptor 深入:超时、缓存与响应脱敏?
- 252. DynamicModule:forRoot/forRootAsync 封装可复用 SDK 模块?
- 253. 循环依赖:forwardRef 与模块边界重构?
- 254. Request-scoped provider:性能陷阱与替代方案?
- 255. 自定义装饰器与 Reflector 元编程?
- 256. CQRS:命令查询职责分离在 Nest 的落地?
- 257. Nest 模块化设计:Feature/Shared/@Global 的边界?
- 258. 生命周期钩子:onModuleInit 到 onApplicationShutdown 的工程用途?
- 259. API 版本管理与废弃流程?
- 260. GraphQL Subscription:实时推送的落地?
- 261. 多租户架构:租户解析与数据隔离三档?
- 262. DI 高级:工厂 provider、自定义 token 与初始化顺序?
- 263. Nest 混合应用:HTTP 与微服务监听共存?
- 四、WebSocket 与实时通信(264–273)
- 264. @WebSocketGateway 基础:握手、消息与房间?
- 265. WebSocket 鉴权:握手 token 与连接级权限?
- 266. 心跳与断线重连:ping/pong 与指数退避?
- 267. 消息可靠性:ack、离线消息与去重?
- 268. WebSocket 水平扩展:Redis adapter 与 sticky session?
- 269. 房间与在线状态:状态同步怎么做一致?
- 270. SSE、WebSocket 与轮询:实时方案怎么选?
- 271. AI 流式对话:WebSocket 通道的工程细节?
- 272. 连接治理:限连、封禁与降级?
- 273. socket.io 与原生 ws:协议成本与取舍?
- 五、Nest 微服务与工业化(274–287)
- 274. RabbitMQ 路由深入:exchange、死信与延迟消息?
- 275. gRPC 传输器:proto 契约、死线与拦截器?
- 276. Kafka 传输器:分区有序与消费者组?
- 277. BullMQ 任务队列:延迟、重试与并发控制?
- 278. BullMQ 的 stalled 检测与任务幂等:重复执行怎么防?
- 279. OpenTelemetry:分布式追踪接入 Nest?
- 280. 幂等设计全景:幂等键、去重表与状态机?
- 281. 分布式事务:Saga 补偿与 Outbox 模式?
- 282. 灰度发布与特性开关:feature flags 落地?
- 283. 密钥管理:环境变量的局限与 Vault/KMS?
- 284. 熔断与降级:circuit breaker 怎么落地?
- 285. 审计日志与合规留痕:谁在何时改了什么?
- 286. SLA 与容量规划:压测与限流配额怎么联动?
- 287. 单体到微服务:演进路径与拆分标准?
- 六、测试与工程化(288–299)
- 288. vitest 单元测试:mock 策略与 test doubles?
- 289. supertest 集成测试:E2E 与测试数据库怎么搭?
- 290. 测试金字塔:70/20/10 的全栈分配与反模式?
- 291. 契约测试:Pact 与 openapi-typescript 两条路?
- 292. 测试数据管理:factory、seed 与清理策略?
- 293. CI 流水线:lint→typecheck→test→build 门禁怎么设计?
- 294. monorepo:pnpm workspace 与 turbo 任务编排?
- 295. changesets:包版本与发布流程管理?
- 296. 代码规范工程化:eslint、prettier 与 husky 怎么串起来?
- 297. 提交规范与分支策略:conventional commits 与 trunk-based?
- 298. 监控告警落地:prom-client 指标与告警规则怎么设计?
- 299. 故障演练与 runbook:应急预案怎么工程化?
一、Node.js 深入(200–229)
200. Node 事件循环的阶段模型:timers/poll/check 深入?
概念 Node 的事件循环分六个阶段:timers(执行到期 setTimeout/setInterval)→ pending callbacks → idle/prepare → poll(取新 IO 事件,执行 IO 回调,必要时阻塞)→ check(setImmediate)→ close callbacks。每个阶段切换之间清空 nextTick 队列与微任务队列。
典型场景 setTimeout 与 setImmediate 的顺序判定、process.nextTick 滥用导致饥饿、IO 回调里的时序题。
解决方案 三步递进:主模块的不确定性与 IO 回调的确定性 → nextTick 与 Promise 的插队顺序 → 阶段切换的实测验证。
第一步:主模块 vs IO 回调——setTimeout 与 setImmediate 的顺序之谜
// 文件: timers-vs-immediate.js
// 主模块里: 顺序不确定(取决于进程性能, 进机器是随机的)
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// IO 回调里: setImmediate 恒先 —— poll 阶段结束后直接进 check 阶段
const fs = require('fs');
fs.readFile(__filename, () => {
setTimeout(() => console.log('io: timeout'), 0);
setImmediate(() => console.log('io: immediate'));
// 输出: io: immediate → io: timeout
});
第二步:nextTick 与 Promise——两个插队队列的优先级
// 文件: nexttick-priority.js
Promise.resolve().then(() => console.log('promise 微任务'));
process.nextTick(() => console.log('nextTick'));
console.log('同步');
// 输出: 同步 → nextTick → promise
// nextTick 队列在微任务队列之前清空; 阶段切换时: nextTick 全清 → 微任务全清 → 下一阶段
第三步:nextTick 滥用——饿死事件循环
// 文件: nexttick-starve.js
// ❌ 递归 nextTick: 队列永远非空, 事件循环永远进不了下一阶段 → IO 饿死
function recurse() {
process.nextTick(recurse);
}
// recurse(); // 打开后服务假死: 网络请求再也无法处理
// ✅ 需要"尽快异步"用 setImmediate(在阶段切换处, IO 能插进来)
function safeRecurse() {
setImmediate(safeRecurse);
}
总结:主模块中 timeout/immediate 顺序不定,IO 回调中 immediate 恒先;nextTick 优先于 Promise 微任务;递归异步用 setImmediate 而非 nextTick(防饿死)。
追问1:poll 阶段什么时候阻塞? → 队列空且无到期 timer 时会阻塞等新 IO 事件(等到的瞬间执行回调) 追问2:定时器精度受什么影响? → 阻塞主线程的同步代码会让 timer 回调延迟执行(1ms 的 timer 可能实际 50ms 才跑) 追问3:Node 11+ 的微任务时序变化? → 与浏览器对齐:每个宏任务(含 timer/IO 回调)执行后立即清空微任务,不再是”每阶段才清”
201. Stream 四种类型与 backpressure?
概念 四种流:Readable(读)、Writable(写)、Duplex(双向,如 TCP socket)、Transform(读入处理再写出,如 zlib/加密)。Backpressure(背压):写速度慢于读速度时,数据在内存堆积——pipe/pipeline 自动暂停/恢复读流来平衡。
典型场景 大文件复制内存爆涨、HTTP 响应体转发、CSV/日志流处理、LLM 流式转发(上游读快下游写慢)。
解决方案 三步递进:pipe 与手动写的内存对比 → pipeline 的错误处理优势 → Transform 实战。
第一步:手动写不看背压——内存爆炸现场
// 文件: stream-manual.js
const fs = require('fs');
// ❌ readable 流读取速度 >> writable 落盘速度 → 数据全部堆在内存
const rs = fs.createReadStream('in.log');
const ws = fs.createWriteStream('out.log');
rs.on('data', (chunk) => {
if (!ws.write(chunk)) rs.pause(); // 手动背压: write 返回 false 时暂停读
});
rs.on('end', () => ws.end());
ws.on('drain', () => rs.resume()); // 缓冲清空后恢复读 —— 这些 pipe 全都自动做
第二步:pipeline——现代标准做法(自动背压+统一错误)
// 文件: stream-pipeline.js
const { pipeline } = require('node:stream/promises');
const fs = require('fs');
const zlib = require('zlib');
// 读 → gzip → 写, 三段自动背压, 任一段抛错统一在此捕获并清理两端
async function compress(inPath, outPath) {
await pipeline(
fs.createReadStream(inPath),
zlib.createGzip(),
fs.createWriteStream(`${outPath}.gz`),
);
}
compress('in.log', 'in.log').then(() => console.log('压缩完成'))
.catch(e => console.error('流失败(任一环):', e.message));
// 对比 pipe(): 错误会吞掉且不清理另一端 —— 生产一律 pipeline
第三步:Transform 实战——逐行解析日志流
// 文件: stream-transform.js
const { Transform } = require('node:stream');
function lineParser(onLine) {
let buf = '';
return new Transform({
transform(chunk, encoding, callback) {
buf += chunk; // 分块边界不保证按行对齐, 先缓冲
const lines = buf.split('\n');
buf = lines.pop(); // 最后一段可能不完整, 留到下个 chunk
for (const line of lines) if (line.trim()) onLine(line);
callback();
},
flush(callback) { // 流结束时处理残余 buffer
if (buf.trim()) onLine(buf);
callback();
},
});
}
// 用法: fs.createReadStream('app.log').pipe(lineParser(l => count(l))).pipe(ws);
总结:四种流按方向与处理分;背压是流的核心问题——手写要 pause/resume,生产用 pipeline(自动背压+统一错误);Transform 做逐块加工,注意 chunk 边界缓冲。
追问1:objectMode 是什么? → 流的对象模式:chunk 不再是 Buffer 而是任意 JS 对象,适合”对象管道”(如逐行 JSON 解析后直接传对象) 追问2:highWaterMark 的作用? → 流的内部缓冲水位(默认 64KB):读流在水位前主动读,写流 write 返回 false 的判断依据 追问3:流式下载怎么设置断点续传? → fs.createReadStream(path, { start, end }) 按 Range 头切片读取
202. Buffer 与二进制处理?
概念 Buffer 是 Node 处理二进制的类 Uint8Array(堆外内存);字符串与 Buffer 转换必须显式编码(默认 utf8);多字节字符(中文 3 字节)在流式分块处可能被截断。
典型场景 TCP/文件字节流的解析、协议头读取(前 N 字节)、图片/加密数据处理、流式解码乱码。
解决方案 三步递进:基础读写与编码 → 截断乱码问题 → Buffer 连接与协议解析。
第一步:基础——编码是显式的
// 文件: buffer-basic.js
const buf = Buffer.from('中文字符串', 'utf8');
console.log(buf.length); // 15(每个汉字 3 字节, 不是 5)
console.log(buf.toString('base64')); // Base64 编码传输常用
console.log(buf.slice(0, 3).toString()); // '中' —— 按字节切, 3 字节恰好一个汉字
第二步:截断乱码——流式解码必须用 TextDecoder(stream 模式)
// 文件: buffer-truncated.js
const buf1 = Buffer.from([0xe4, 0xb8, 0xad]); // '中' 的前 2 字节被切断的场景:
const partial = Buffer.concat([buf1, Buffer.from([0x96])]);
// ❌ 直接 toString: 非法字节序列被替换为乱码
// ✅ TextDecoder 流式模式: 记住不完整的多字节序列, 等下一个 chunk 补齐
const dec = new TextDecoder();
console.log(dec.decode(partial.subarray(0, 2))); // 空(等待补齐)—— 设置 stream: true
const dec2 = new TextDecoder();
// 实战: SSE 分块解码(见第一批 67)—— decoder.decode(value, { stream: true })
第三步:协议解析——按字节偏移读字段
// 文件: buffer-protocol.js
// 解析自定义二进制协议: [magic 2字节][version 1字节][payloadLen 4字节][payload]
function parsePacket(buf) {
if (buf.length < 7) return null; // 头部不完整
const magic = buf.readUInt16BE(0);
if (magic !== 0x4e45) throw new Error('非法协议');
const version = buf.readUInt8(2);
const payloadLen = buf.readUInt32BE(3);
if (buf.length < 7 + payloadLen) return null; // payload 未收齐(粘包处理: 缓冲)
return { version, payload: buf.subarray(7, 7 + payloadLen) };
}
// subarray 是视图(零拷贝), 需要独立副本用 Buffer.from(sub)
总结:Buffer 是字节视角、String 是字符视角,转换必须显式编码;流式多字节解码用 TextDecoder(stream:true);二进制协议解析用 readUInt 系列按偏移读 + 粘包缓冲。
追问1:Buffer.alloc 与 Buffer.allocUnsafe 区别? → allocUnsafe 不清零(快但可能含敏感残留数据),必须完全覆写后才安全
追问2:concat 的性能? → 多次 concat 有拷贝成本;已知总长度用 Buffer.allocUnsafe(total) + set 分段写
追问3:Buffer 是堆外内存吗? → 数据在 V8 堆外的 C++ 层,Buffer 对象(壳)在堆内——所以大 Buffer 不计入 —max-old-space-size
203. child_process 与 worker_threads 选型?
概念 child_process 创建子进程(独立解释器,重;spawn/exec/fork);worker_threads 创建工作线程(轻,共享进程,postMessage 通信)。CPU 密集选 worker(轻量)或 cluster(多核 HTTP);要隔离崩溃/独立依赖用子进程。
典型场景 CPU 密集任务(图片压缩/大 JSON 解析)阻塞事件循环;需要调用外部命令(ffmpeg);多核利用 HTTP 服务。
解决方案 三步递进:worker_threads 实战 → spawn 外部命令 → cluster 多核 HTTP。
第一步:worker_threads——CPU 密集不阻塞主线程
// 文件: worker-main.js
const { Worker } = require('node:worker_threads');
const path = require('path');
function crunchInWorker(payload) {
return new Promise((resolve, reject) => {
const w = new Worker(path.resolve(__dirname, 'crunch.worker.js'), { workerData: payload });
w.on('message', resolve);
w.on('error', reject);
w.on('exit', (code) => code !== 0 && reject(new Error(`exit ${code}`)));
});
}
// 主线程保持响应: 重计算在子线程, 事件循环不受影响(区别于同步调用)
// 文件: crunch.worker.js
const { workerData, parentPort } = require('node:worker_threads');
let result = 0;
for (let i = 0; i < workerData.n; i++) result += i * i;
parentPort.postMessage(result);
第二步:spawn 外部命令——ffmpeg/CLI 工具的集成
// 文件: spawn-cmd.js
const { spawn } = require('node:child_process');
function transcode(input, output) {
return new Promise((resolve, reject) => {
const proc = spawn('ffmpeg', ['-i', input, '-c:v', 'libx264', output]);
let stderr = '';
proc.stderr.on('data', (d) => (stderr += d)); // ffmpeg 进度/错误都在 stderr
proc.on('close', (code) => code === 0 ? resolve(output) : reject(new Error(stderr.slice(-500))));
proc.on('error', reject); // 命令不存在等启动失败
});
}
// exec 适合短命令(带 shell 解析, 有注入风险); spawn 参数数组形式无注入问题
第三步:cluster——多核 HTTP 服务(对比 PM2 cluster 模式)
// 文件: cluster-http.js
const cluster = require('node:cluster');
const http = require('http');
const os = require('os');
if (cluster.isPrimary) {
for (let i = 0; i < os.cpus().length; i++) cluster.fork(); // 每核一个 worker
cluster.on('exit', (w) => cluster.fork()); // 崩溃自动重启
} else {
http.createServer((req, res) => res.end(`pid=${process.pid}`)).listen(3000);
}
// 生产更常用 PM2 cluster 模式(自带日志/监控/优雅重启); K8s 部署则单进程+多副本
总结:CPU 密集不阻塞主线程→worker_threads;调外部 CLI→spawn(参数数组防注入);多核 HTTP→cluster 或 PM2(容器化环境倾向单进程多副本)。
追问1:worker_threads 与 cluster 的通信差异? → worker 用 MessagePort(结构化克隆/SharedArrayBuffer 共享);cluster worker 间通过主进程 IPC 转发 追问2:worker 能共享大对象吗? → 能:SharedArrayBuffer + postMessage(transferList)零拷贝;普通对象走结构化克隆(有拷贝成本) 追问3:worker_threads 的适用边界? → 任务粒度要够大(>10ms),否则调度开销反噬;短小 CPU 任务合并批处理后再派发
204. Node 模块解析与 package.json 的 exports?
概念 Node 解析 import 走 package.json 的 exports 字段(条件导出:import/require/types/node/browser);无 exports 时回退 main。.mjs/"type": "module" 决定 ESM;双格式发布(ESM+CJS)靠 exports 条件映射。
典型场景 发 npm 包要同时支持 require 与 import;用户报”ESM 语法在 CJS 项目不能用”;monorepo 内部包引用失败。
解决方案 三步递进:exports 字段的完整形态 → 双格式发布 → 常见解析坑。
第一步:exports 字段——现代入口声明
// 文件: package.json(库)
{
"name": "my-lib",
"type": "module",
"exports": {
".": {
"types": "./dist/index.d.ts", // TS 解析(须放第一)
"import": "./dist/index.mjs", // ESM 消费者
"require": "./dist/index.cjs", // CJS 消费者
"default": "./dist/index.mjs"
},
"./utils": { // 子路径导出: import 'my-lib/utils'
"types": "./dist/utils.d.ts",
"import": "./dist/utils.mjs"
}
},
"files": ["dist"] // 只发布 dist
}
// exports 存在时, 包内其他路径全部封死(防深路径导入, API 边界清晰)
第二步:双格式构建——tsup 一行出双格式
# 文件: build.sh
npx tsup src/index.ts --format esm,cjs --dts --sourcemap
# tsup 读取 package.json exports 的条件映射, 产出 index.mjs + index.cjs + .d.ts
第三步:常见解析坑
1. CJS 项目 import ESM 包 → 错误: require() of ES Module
解法: 升级项目为 ESM("type":"module")或用 await import() 动态导入
2. ESM 顶级 await 在 CJS 报错 → 双格式包的两份产物语法本就不同(bundler 按 target 拆)
3. monorepo 内部包: "dependencies": { "@scope/lib": "workspace:*" }(pnpm)
4. __dirname 在 ESM 不存在 → import.meta.url + fileURLToPath 转换
总结:exports 是包的现代 API 边界(条件导出 types/import/require);双格式用 tsup 一次构建;ESM/CJS 互操作的坑集中在”动态导入”与 “__dirname 替代”。
追问1:main 与 exports 同时存在用哪个? → exports 优先;main 兼容老打包器/老 Node
追问2:exports 里 ”.” 与 ”./package.json” ? → 默认 package.json 被封死,需显式 "./package.json": "./package.json" 放行
追问3:Node 22 的 require(esm)? → 22.12 起支持在 CJS 中 require 同步 ESM 图(无顶级 await 的模块),双格式摩擦在减少
205. Node 的性能剖析:—inspect 与 heap snapshot?
概念 node --inspect 开调试协议(Chrome DevTools 接入):Sources 断点、Profiler CPU 采样、Memory 堆快照对比。内存泄漏定位三板斧:快照对比(操作前后)→ 找 Delta 增长的对象 → 看 Retainers 引用链。
典型场景 服务内存阶梯上涨;接口 P95 突增要找热点函数;线上不便 attach 用 —prof/py-spy 类采样。
解决方案 三步递进:attach 调试器 → CPU 采样找热点 → 堆快照抓泄漏。
第一步:attach——本地与远程
# 文件: inspect-attach.sh
node --inspect app.js # 默认 127.0.0.1:9229
node --inspect=0.0.0.0:9229 app.js # 容器/远程(注意安全暴露风险)
node --inspect-brk app.js # 首行暂停, 适合排查启动问题
# Chrome 打开 chrome://inspect → 配置 127.0.0.1:9229 → inspect
第二步:CPU 采样——找热点函数
DevTools → Profiler 面板 → Start → 复现负载 → Stop
自底向上视图(Bottom-Up): 按 Self Time 排序, 找自身耗时最高的函数
火焰图: 宽度=占比; 平顶(long flat top)=同步长任务
典型发现: 正则回溯(explosive regex)/JSON.parse 大对象/同步 crypto
第三步:堆快照——泄漏三步法
1. 快照 A(服务稳定运行时)
2. 复现泄漏操作 20 次(如调泄漏接口)
3. 快照 B → 选 Comparison 对比 A:
- 按 Delta 排序找 Count/Size 持续增长的对象
- 展开对象的 Retainers(谁引用着它) → 顺着引用链找到"忘了清理的数组/监听器/闭包"
(与第一批 11 的四大泄漏源对照: 定时器/监听器/全局缓存/闭包)
总结:—inspect 接 Chrome DevTools 全套工具;CPU 热点用 Profiler 的 Self Time;内存泄漏用快照对比+Retainers 引用链定位到代码行。
追问1:生产环境能开 —inspect 吗? → 有风险(调试协议=代码执行入口);临时开要绑 127.0.0.1+用完即关,或走 sidecar
追问2:不能停服务怎么剖析? → kill -USR1 <pid> 触发 inspector 监听(信号激活);或 py-spy/0x 采样式工具零侵入
追问3:heapdump 库和快照对比? → v8.writeHeapSnapshot()(内建)定时滚动拍快照,异常触发时留证后分析
206. Node 的 stream 高级:Web Streams 与 Readable.from?
概念 Node 18+ 引入 Web Streams API(与浏览器同构):ReadableStream/WritableStream/TransformStream;Readable.fromWeb/from iterable 互转。Readable.from(iterator) 让任意数据源变成流。
典型场景 前后端同构代码(同一套流处理逻辑跑两端)、把数据库游标/异步生成器接入 HTTP 响应流、SSE 生成器。
解决方案 三步递进:from iterable 把异步生成器变流 → Web Streams 与 Node Streams 互转 → 实战:DB 游标流式响应。
第一步:Readable.from——异步生成器即流
// 文件: stream-from-iterable.js
const { Readable } = require('node:stream');
async function* fetchPages() {
for (let page = 0; page < 100; page++) {
const rows = await db.query('SELECT ... LIMIT 1000 OFFSET ?', [page * 1000]); // db 为项目内客户端
if (!rows.length) break;
yield* rows; // 逐行产出 —— DB 分页拉取变成流
}
}
Readable.from(fetchPages()).pipe(csvWriter());
// 惰性: 消费速度决定拉取速度, 内存里永远只有当前页
第二步:Web Streams 互转——同构代码
// 文件: stream-web.js
const { Readable } = require('node:stream');
const webReadable = new ReadableStream({ // Web 标准 API
start(controller) {
controller.enqueue('hello');
controller.close();
},
});
const nodeStream = Readable.fromWeb(webReadable); // Web → Node
const backToWeb = require('node:stream').Readable.toWeb(nodeStream); // Node → Web
// FastAPI/Next.js 等框架的响应体是 Web ReadableStream —— 互转打通两边生态
第三步:实战——CSV 导出的完整流式链
// 文件: stream-csv-export.js
const { pipeline } = require('node:stream/promises');
const { Readable } = require('node:stream');
const { stringify } = require('csv-stringify'); // 项目内依赖
async function exportCsv(res) {
res.setHeader('Content-Type', 'text/csv; charset=utf-8');
res.setHeader('Content-Disposition', "attachment; filename*=UTF-8''export.csv");
await pipeline(
Readable.from(fetchRowsFromDb()), // DB 游标 → 流(第一步)
stringify({ header: true }), // 行对象 → CSV 文本(库处理转义)
res, // 直接写 HTTP 响应
);
}
// 用户点击导出立即开始下载, 边查边传, 服务端内存恒定
总结:Readable.from(异步生成器) 是把任意数据源(DB 游标/队列/分页 API)接入流世界的桥梁;Web Streams 与 Node Streams 互转打通同构场景;导出类需求用 pipeline(DB→转换→HTTP)恒定内存。
追问1:from 的对象模式? → Readable.from(objs) 默认 objectMode,chunk 为对象而非 Buffer——后续管道接对象处理
追问2:异步生成器里抛错会怎样? → 流进入 errored 状态,pipeline 会捕获并清理整条链
追问3:流式响应如何设置总大小? → 不知道总长就不设 Content-Length(用 chunked);知道的场景设 Content-Length 可让客户端显示进度
207. Node 的 timer 精度与 setImmediate 的工程应用?
概念 setTimeout(fn, 0) 实际 ≥1ms 且受事件循环阶段/系统负载影响(非精确调度);setImmediate 在 check 阶段执行(IO 后必达);unref() 让 timer 不阻止进程退出。
典型场景 “1 秒后执行”变成几秒(负载高时);优雅停机时残留 timer 阻止退出;需要”本轮 IO 处理完再执行”的调度。
解决方案 三步递进:timer 精度的误区 → unref 的工程用途 → setImmediate 做”让出主线程”。
第一步:timer 精度——延迟≠精确时刻
// 文件: timer-accuracy.js
console.time('actual');
setTimeout(() => {
console.timeEnd('actual'); // 输出 >=1000ms, 负载高时可能 1500ms+
}, 1000);
// 计时器语义是"至少延迟 X ms", 不是"精确在 X ms 执行"
// 需要精确节拍: 以时间差计算(Date.now 差值)而非累计 timer 次数(见第一批 18 的 rAF 思想)
第二步:unref——让 timer 不阻止进程退出
// 文件: timer-unref.js
const t = setInterval(() => flushMetrics(), 5000); // 指标刷新
t.unref(); // 主业务退出时不必等这个 timer
// 场景: "附带型"定时任务(日志刷盘/心跳)不应拖住进程生命周期
// 对应: worker.unref() / server.unref() 同样语义
第三步:setImmediate——把长任务切片让出 IO
// 文件: setimmediate-yield.js
async function processAll(items) {
for (let i = 0; i < items.length; i++) {
processItem(items[i]);
if (i % 100 === 99) {
await new Promise(setImmediate); // 每 100 个让出一轮: timers/poll 阶段能插入执行
// 对比 await new Promise(r => setTimeout(r, 0)): 更快(不等下一轮 timers)
}
}
}
// 批处理脚本不卡线上服务的标准写法
总结:timer 是”至少延迟”不是”精确时刻”;辅助 timer 用 unref() 不阻塞退出;批处理切片让出主线程用 setImmediate(IO 友好)而非 setTimeout(0)。
追问1:process.exit(0) 会等 timer 吗? → 立即退出(不等任何回调);正常退出(事件循环空)才受 timer 影响——所以辅助 timer 要 unref 追问2:setTimeout 递归和 setInterval 的选择? → 动态间隔(上次执行完再排下一次)用递归 setTimeout,避免 setInterval 在慢回调时重叠执行 追问3:Node 17 后默认时区? → 未变化;但容器内 TZ 常为 UTC——cron 类任务显式指定时区(见 238 的 timeZone 参数)
208. Node 的错误处理:Error 基类与 async 错误模式?
概念 自定义错误继承 Error 并附加 code/context;异步错误三种形态:回调错误优先参数、Promise reject、EventEmitter 的 error 事件(无监听器即崩溃)。unhandledRejection/uncaughtException 是最后防线。
典型场景 不同错误类型需要不同处理(重试 vs 告警 vs 崩溃);Promise 链漏 catch 静默吞错;EventEmitter emit(‘error’) 打崩进程。
解决方案 三步递进:自定义错误类 → EventEmitter 的 error 事件陷阱 → 全局兜底与退出策略。
第一步:自定义错误类——携带机器可读信息
// 文件: app-error.js
class AppError extends Error {
constructor(code, message, cause) {
super(message, { cause }); // Node 16.9+: cause 链保留原始异常
this.code = code; // 'UPSTREAM_TIMEOUT' / 'QUOTA_EXCEEDED'
this.retryable = code === 'UPSTREAM_TIMEOUT';
}
}
try {
throw new AppError('UPSTREAM_TIMEOUT', 'LLM 无响应');
} catch (e) {
console.log(e.code, e.retryable, e.cause); // 机器可读分支处理
}
第二步:EventEmitter 的 error 事件——无监听即崩
// 文件: emitter-error.js
const { EventEmitter } = require('node:events');
const ee = new EventEmitter();
ee.emit('error', new Error('boom')); // ❌ 无 'error' 监听器 → 直接 throw 打崩进程
// 正确姿势: 创建 emitter 后立即挂 error 监听(哪怕只记日志)
ee.on('error', (e) => logger.error('emitter error', e));
// 流(Stream)同理: readable.on('error') 必须挂, 否则流错误打崩进程
第三步:全局兜底——记录后有序退出
// 文件: global-guard.js
process.on('unhandledRejection', (reason) => {
logger.error('未处理的 Promise 拒绝', reason);
// 不在此退出: 单个漏 catch 不该打崩整个服务; 但必须告警
});
process.on('uncaughtException', (err) => {
logger.error('未捕获异常', err);
// 同步异常可能破坏状态 → 记录后有序退出(由 PM2/K8s 拉起)
process.exit(1);
});
// 兜底是"保险丝"不是"错误处理方式" —— 该 try/catch 的还是要 catch
总结:自定义错误带 code/retryable 供上层分支;EventEmitter/Stream 的 error 事件必须挂监听(否则崩进程);unhandledRejection 记录告警、uncaughtException 记录后退出。
追问1:Error.cause 的意义? → 替代”包一层新错误就丢原异常”的坏习惯,异常链完整保留(日志打全链)
追问2:Node 默认 unhandledRejection 行为? → 15+ 默认 throw(直接崩进程)——所以显式挂兜底监听改变行为并告警
追问3:怎么保证漏网错误能被看见? → unhandledRejection/uncaughtException 全局监听 + 告警渠道;测试阶段用 --unhandled-rejections=strict 早暴露
209. Node 的 http 模块:keep-alive、Agent 与大响应?
概念 http.Agent 管理连接池与 keep-alive(默认开启但 sockets 上限有限);大响应应流式输出(不攒整包);req.socket.setTimeout 控制空闲超时。生产多数场景走 axios/node-fetch 内置的 Agent 配置。
典型场景 高并发转发 LLM 上游(连接池耗尽 TIME_WAIT 堆积);导出大文件/流式响应;网关超时 504 排查。
解决方案 三步递进:keep-alive Agent 配置 → 流式响应 → 超时链路。
第一步:keep-alive Agent——复用连接降低延迟
// 文件: keepalive-agent.js
const http = require('node:http');
const https = require('node:https');
const agent = new https.Agent({
keepAlive: true,
maxSockets: 50, // 每目标主机最大并发连接
maxFreeSockets: 10, // 空闲保留数
keepAliveMsecs: 30000, // 空闲连接保活时长
});
// axios/fetch 传入 httpAgent/httpsAgent → 高并发下复用连接, 省去每次 TLS 握手(TLS 握手可达 100ms+)
// TIME_WAIT 堆积的常见根因就是没开 keepAlive(每请求新建连接)
第二步:流式大响应——不攒内存
// 文件: stream-response.js
const http = require('node:http');
http.createServer(async (req, res) => {
const upstream = await fetch('https://upstream-llm/stream');
res.writeHead(upstream.status, { 'Content-Type': 'text/event-stream' });
const reader = upstream.body.getReader(); // Web 流
while (true) {
const { done, value } = await reader.read();
if (done) break;
res.write(value); // 逐块透传, 内存恒定
}
res.end();
});
// ❌ 反例: await upstream.text() 攒完整响应再返回 → 大响应把内存顶爆
第三步:超时链路——三层都要设
// 文件: timeout-chain.js
const server = http.createServer();
server.headersTimeout = 60000; // 收完整请求头的超时(防慢速攻击)
server.requestTimeout = 300000; // 整个请求超时(5 分钟: LLM 流式要长)
server.keepAliveTimeout = 65000; // 空闲连接保活(应小于 LB 的 idle timeout, 防 502)
server.timeout = 0; // socket 空闲超时(流式响应设 0 或足够大)
// 504 排查顺序: 应用超时 → LB 超时 → 上游超时, 三层取值要形成梯度(外层最大)
总结:keep-alive Agent 复用连接(省 TLS 握手+防 TIME_WAIT);大响应一律流式透传;超时三层(LB>server>上游)形成梯度,keepAliveTimeout 必须小于 LB 空闲超时。
追问1:TIME_WAIT 是什么? → 主动关闭方 2MSL 的等待状态,大量短连接导致堆积耗尽端口——keepAlive 根治 追问2:为什么 keepAliveTimeout 要小于 LB? → LB 先于应用关闭空闲连接时,应用会收到打到死连接的请求,表现为偶发 502(ECONNRESET) 追问3:res.write 之后还能改状态码吗? → 不能——头已发出;所以 SSE 的错误只能在流内以消息体表达(见 66)
210. Node 的 ESM 顶层 await 与模块加载细节?
概念 ESM 顶层 await(13.3+)允许模块直接 await(模块加载等待);import 语句静态提升+编译期确定;动态 import() 返回 Promise;ESM 的 this 是 undefined、__dirname 需从 import.meta.url 推导。
典型场景 配置模块需要异步初始化(DB 连接);CJS 迁移 ESM 的批量改造;动态加载插件。
解决方案 三步递进:顶层 await 的应用 → __dirname/__filename 的 ESM 替代 → 循环依赖的处理。
第一步:顶层 await——模块级异步初始化
// 文件: top-level-await.mjs
import { createClient } from 'redis';
const redis = createClient();
await redis.connect(); // 模块加载时等待连接就绪 —— 下游 import 本模块即拿到可用客户端
export const redisClient = redis;
// 注意: 顶层 await 会阻塞"依赖本模块的所有模块"的加载 —— 只用于必须就绪的初始化
第二步:__dirname 的 ESM 替代——两行标准写法
// 文件: esm-dirname.mjs
import { fileURLToPath } from 'node:url';
import path from 'node:path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
// 用途: 加载相对模块路径的文件(worker/模板/静态资源)
new Worker(path.resolve(__dirname, 'crunch.worker.js'));
第三步:循环依赖——ESM 的活绑定 vs CJS 的 undefined
// 文件: esm-circular.mjs
// a.mjs: import { b } from './b.mjs'; export const a = 1;
// b.mjs: import { a } from './a.mjs'; export const b = () => a; // 函数体内访问: OK(活绑定)
// a.mjs 顶层直接访问 b: 此刻 b 尚未初始化(ReferenceError) → 循环依赖只在"顶层取值"时炸
// 工程解法: 消除循环(提取公共模块); 或把取值延后到函数调用时(活绑定特性)
总结:顶层 await 用于模块级异步初始化(会阻塞依赖方加载);__dirname 用 import.meta.url 推导;ESM 循环依赖是”活绑定”,顶层取值才炸,函数内访问安全。
追问1:import 提升? → import 声明提升到模块顶部且先于任何代码执行(静态确定依赖图)——所以不能写在 if 里
追问2:动态 import 的缓存? → 同一模块多次 import() 返回同一 Promise(模块只加载一次)
追问3:JSON 导入? → ESM 需 import data from './x.json' with { type: 'json' }(import attributes);CJS 直接 require
211. Node 的 cluster/PM2 与容器化的多进程策略?
概念 Node 单进程无法利用多核。方案演进:cluster 模块(原生)→ PM2 cluster(自带守护/日志/零停机重启)→ 容器化”单进程多副本”(K8s 负责多实例与拉起,进程管理交出去)。
典型场景 服务器 8 核但 Node 只用 1 核;PM2 配置文件调优;K8s 部署 Node 应用该跑几个进程。
解决方案 三步递进:PM2 cluster 配置 → K8s 单进程策略 → 两种模式的取舍。
第一步:PM2 cluster——生产级多核
// 文件: ecosystem.config.js
module.exports = {
apps: [{
name: 'ai-app',
script: 'dist/main.js',
instances: 'max', // 按核数启动(max 或数字)
exec_mode: 'cluster', // cluster: 共享端口; fork: 独立进程
max_memory_restart: '1G', // 内存超限自动重启(防泄漏拖垮)
env_production: { NODE_ENV: 'production' },
}],
};
// 零停机重启: pm2 reload(逐个重启, 旧实例处理完在途请求)—— 对应 K8s 滚动更新
第二步:K8s 单进程策略——进程管理交给编排器
# 文件: deployment.yaml
spec:
replicas: 4 # K8s 管 4 个 Pod, 每个 Pod 内 Node 单进程
containers:
- name: app
resources: { limits: { cpu: "1", memory: 1Gi } } # 每副本限 1 核
# 容器内跑 PM2 cluster 的反模式: PM2 与 K8s 双层进程管理互相打架
# (K8s 只看见主进程, 子进程 OOM/崩溃无法被独立感知与重启)
第三步:取舍——什么场景仍用 PM2
用 PM2 cluster: 传统主机/虚机部署(无 K8s), 需要"一台机器多核"且要 PM2 的运维能力
用 K8s 单进程: 容器化环境(进程编排交给 K8s), 副本即水平扩展, 语义最干净
Node 单进程内存超限(OOMKilled) → 用 worker_threads 拆 CPU 活 + 降低单实例内存,
而不是在容器里再叠一层 cluster
总结:多核利用三方案——原生 cluster、PM2 cluster、K8s 多副本;容器化环境选”单进程多副本”,进程管理交给编排器,避免双层管理。
追问1:cluster 端口冲突? → cluster 内部主进程监听端口后分发给 worker(share port),无冲突 追问2:PM2 fork 模式何时用? → 应用需要多进程各自监听不同端口/文件锁隔离时(cluster 共享端口) 追问3:容器内 CPU limit 与 Node 的关系? → Node 不感知 cgroup limit,os.cpus() 返回宿主机核数 → 库(如线程池默认)可能超额,需显式配置 UV_THREADPOOL_SIZE 等
212. Node 22+ 新特性:native TS、fetch、WebSocket 内建?
概念 Node 22+ 内建 fetch/WebSocket/EventSource(Web 标准,免依赖);实验性 native TS 支持(直接运行 .ts, 类型剥离);stable 的 test runner(node —test);require(esm)(22.12+,可同步 require 无顶层 await 的 ESM)。
典型场景 新项目减少运行时依赖;直接跑 TS 脚本省编译;想用官方测试框架替代 jest。
解决方案 三步递进:内建 fetch 与 WebSocket → native TS → 官方 test runner。
第一步:内建 fetch/WebSocket——零依赖网络
// 文件: native-fetch.js
// 18+ 全局可用 fetch, 22+ 内建 WebSocket —— 不再需要 node-fetch/ws 依赖
const ws = new WebSocket('wss://echo.example.com');
ws.onopen = () => ws.send('ping');
ws.onmessage = (e) => console.log('收到:', e.data);
const r = await fetch('https://httpbin.org/get'); // 顶级 await(ESM)
console.log(r.status);
// 意义: 减少依赖树与安全面; undici 引擎性能好(连接池/HTTP2)
第二步:native TS——类型剥离直接跑
# 文件: native-ts.sh
node --experimental-strip-types script.ts # 22.6+ 实验: 只做类型剥离(不做类型检查!)
node script.ts # 23.6+ 默认启用
# 注意: 只支持"可擦除"语法(类型注解/interface); enum/命名空间等需要 --experimental-transform-types
# 类型检查仍交给 tsc --noEmit(运行时不检查, 只是剥掉)
第三步:官方 test runner
// 文件: math.test.js
const { test, describe, expect } = require('node:test'); // node --test 自动发现 *.test.js
const assert = require('node:assert');
describe('数学工具', () => {
test('加法', () => {
assert.equal(require('./math').add(1, 2), 3);
});
});
// 运行: node --test → 输出 TAP 报告
// 定位: 轻量项目替代 jest(零配置零依赖); 复杂 mock/snapshot 场景 jest 仍更成熟
总结:Node 22+ 内建 fetch/WebSocket(免依赖)、实验 native TS(类型剥离运行)、官方 test runner(轻量测试);require(esm) 逐步缓解双格式摩擦。
追问1:native TS 会做类型检查吗? → 不会——运行时只剥离类型注解;类型安全仍靠编辑器与 tsc --noEmit/CI
追问2:node —test 与 jest 的取舍? → node:test 零依赖、启动快,适合新项目;mock 能力相对基础,重 mock 项目留 jest
追问3:22 LTS 意味着什么? → 特性进入稳定期;第一批 10 提到的 require(esm) 在 22.12 落地,双格式库可少发一份 CJS 产物
213. Node 的 cluster IPC 与进程间通信全图?
概念 Node 进程间通信(IPC)四种:cluster worker 与主进程的 IPC 通道(process.send)、child_process 的 stdio/IPC、MessagePort(worker_threads)、以及进程外的消息队列/Redis(见 237)。选型:同进程树内轻量消息用 IPC,跨服务用 MQ。
典型场景 cluster worker 间需要协调(定时任务互斥)、主进程给 worker 广播配置、worker 把计算结果回传主进程。
解决方案 三步递进:cluster 的 send/on → worker_threads 的 MessagePort → 跨进程边界用 MQ。
第一步:cluster——主进程与 worker 双向消息
// 文件: cluster-ipc.js
const cluster = require('node:cluster');
if (cluster.isPrimary) {
cluster.fork();
// 广播配置给所有 worker
for (const id in cluster.workers) cluster.workers[id].send({ type: 'config', data: {...} });
cluster.on('message', (worker, msg) => {
if (msg.type === 'metric') aggregate(worker.id, msg.data); // 汇聚各 worker 指标
});
} else {
process.on('message', (msg) => {
if (msg.type === 'config') applyConfig(msg.data);
});
process.send({ type: 'metric', data: getMetrics() });
}
// 注意: process.send 是异步非阻塞; 大对象走序列化(有拷贝成本)
第二步:worker_threads 的 MessagePort
// 文件: worker-port.js
const { Worker, MessageChannel } = require('node:worker_threads');
const { port1, port2 } = new MessageChannel(); // 一对相连端口
const w = new Worker('./worker.js', { workerData: { port: port2 }, transferList: [port2] });
port1.on('message', (m) => console.log('回传:', m));
port1.postMessage({ cmd: 'start' });
// transferList: port2 所有权转移给 worker(零拷贝转移通道本身)
第三步:跨进程边界——回到 MQ
IPC 的边界: 只在同"进程树"内(cluster 主/worker、parent/child)有效
跨服务/跨机器 → 消息队列(RabbitMQ/Kafka, 见第二批 180/185)
判断法: 发送方和接收方是否"同生共死"(同一次部署/同一个 process.exit 影响范围)?
是 → IPC; 否 → MQ(网络级可靠投递)
总结:同进程树内三种 IPC(cluster process.send、child stdio/IPC、worker MessagePort);跨服务边界一律 MQ;IPC 消息有序列化成本,大对象考虑 SharedArrayBuffer。
追问1:process.send 未连接时会怎样? → 消息丢失或报错;发送前判断 process.connected
追问2:IPC 消息大小上限? → 无硬限制但大消息有序列化阻塞成本;大 payload 走共享存储+传引用(路径/id)
追问3:cluster worker 能互相直接通信吗? → 不能直连,需经主进程转发(worker.send → primary → worker.send)
214. Node 的进程指标与健康监控?
概念 进程级核心指标:内存(heapUsed/rss/external)、事件循环延迟(event loop lag,健康度核心指标)、CPU 使用、句柄数;采集途径:process.memoryUsage()/perf_hooks.monitorEventLoopDelay /Prometheus client。
典型场景 服务”越来越慢”要定位是内存/事件循环/CPU 哪个维度;接入 Prometheus 监控体系;内存泄漏告警。
解决方案 三步递进:事件循环延迟采集 → 内存指标与告警阈值 → Prometheus 暴露。
第一步:事件循环延迟——比 CPU 更准的健康度
// 文件: loop-lag.js
const { monitorEventLoopDelay, performance } = require('node:perf_hooks');
const h = monitorEventLoopDelay({ resolution: 10 });
h.enable();
setInterval(() => {
const p99 = h.percentile(99) / 1e6; // ns → ms
if (p99 > 100) logger.warn('事件循环延迟 P99', { p99 }); // >100ms 说明有长任务/阻塞
h.reset();
}, 10000).unref();
// 事件循环延迟大 = 有东西霸占主线程(同步阻塞/长同步计算) —— IO 再空闲也白搭
第二步:内存指标与阈值
// 文件: memory-metrics.js
setInterval(() => {
const mu = process.memoryUsage();
logger.info('mem', {
heapUsedMb: (mu.heapUsed / 1e6).toFixed(1), // V8 堆实际使用(泄漏看这个的趋势)
rssMb: (mu.rss / 1e6).toFixed(1), // 常驻内存(K8s OOM 判断依据!)
externalMb: (mu.external / 1e6).toFixed(1), // Buffer 等堆外
});
}, 30000).unref();
// 告警规则: rss 持续逼近容器 limit(如 1Gi) → OOMKilled 风险; heapUsed 阶梯式不回落 → 泄漏
第三步:Prometheus 暴露
// 文件: prom-metrics.js
const client = require('prom-client');
const register = client.register;
client.collectDefaultMetrics(); // Node 默认指标集(CPU/内存/GC/句柄)
const loopLag = new client.Gauge({ name: 'node_loop_lag_p99_ms', help: '事件循环延迟P99' });
const llmTokens = new client.Counter({ name: 'llm_tokens_total', help: 'LLM token 总量',
labelNames: ['model', 'user_tier'] });
async function metricsHandler(req, res) {
loopLag.set(h.percentile(99) / 1e6);
res.set('Content-Type', register.contentType);
res.end(await register.metrics());
}
// /metrics 端点被 Prometheus 抓取 → Grafana 看板 + 告警规则
总结:事件循环延迟是 Node 健康度第一指标(monitorEventLoopDelay);内存看 heapUsed 趋势(泄漏)与 rss(容器 OOM);prom-client 一行接默认指标+自定义业务指标。
追问1:rss 和 heapUsed 哪个决定 OOM? → rss(容器 cgroup 按 RSS 判 OOM)——Buffer 堆外内存大但 heap 小的场景仍会 OOM 追问2:GC 停顿怎么观测? → perf_hooks 的 PerformanceObserver 监听 ‘gc’ 条目,长 GC 停顿与内存压力相关 追问3:句柄数有什么用? → activeHandles(句柄)持续增长=定时器/socket/文件未释放(泄漏的另一个信号)
215. Node 的环境与配置:env、config 与启动顺序?
概念 Node 配置加载顺序:进程环境变量(process.env,最高)→ .env 文件(dotenv)→ 默认值;启动顺序敏感:配置加载必须先于使用它的模块初始化(ESM import 提升 + 顶层 await 的组合)。
典型场景 dotenv 加载晚了导致某模块读到 undefined;ESM 下 import 的模块在配置就绪前就初始化;多环境 .env 切换。
解决方案 三步递进:配置初始化的时序陷阱 → ESM 的加载顺序控制 → 分层配置对象。
第一步:时序陷阱——import 先于 dotenv
// 文件: env-order.mjs
// ❌ app.mjs 顶层 import { db } from './db.mjs'; 而 db.mjs 顶层 createPool(env) ——
// import 提升先执行 db.mjs, 此时 dotenv 还没跑 → env 是 undefined
// ✅ 解法一: 入口最先加载 dotenv(在一切业务 import 之前)
// 文件: main.mjs
import 'dotenv/config'; // 侧效应导入: 第一行执行
import { app } from './app.mjs'; // 之后的模块加载时 env 已就绪
第二步:ESM 加载顺序控制——惰性初始化
// 文件: env-lazy.mjs
// 解法二: 配置对象惰性初始化(不依赖 import 顺序)
let _cfg;
export function getCfg() {
if (!_cfg) _cfg = loadAndValidate(); // 首次调用时加载+校验(fail-fast)
return _cfg;
}
// 模块顶层不读 env, 函数内再读 → 顺序无关
// 或 FastAPI 式: 把初始化放 lifespan/启动函数内, 而非模块顶层
第三步:分层配置对象(对应第二批 135 的 pydantic-settings)
// 文件: config.ts
import { z } from 'zod';
const Schema = z.object({
glmBaseUrl: z.string().url(),
glmApiKey: z.string().min(1),
nodeEnv: z.enum(['development', 'production', 'test']),
port: z.coerce.number().default(3000),
});
export const config = Schema.parse({
glmBaseUrl: process.env.GLM_BASE_URL,
glmApiKey: process.env.GLM_API_KEY,
nodeEnv: process.env.NODE_ENV,
port: process.env.PORT,
});
// zod.parse: 缺失/类型错误启动即抛(fail-fast, 对应 Nest 241 的 Joi 与 Python 123 的 Settings)
总结:配置时序两解法——入口第一行 import 'dotenv/config',或惰性初始化 getCfg();zod schema 校验让配置错误启动即暴露;同构思想已覆盖 Nest(Joi)与 Python(pydantic-settings)。
追问1:dotenv 会覆盖已存在的环境变量吗? → 默认不覆盖(K8s/CI 注入的优先)——正确的分层行为
追问2:多环境 .env 怎么切? → dotenv 的 path 参数按 NODE_ENV 选文件,或 dotenv-cli dotenv -e .env.test --
追问3:配置变更要重启吗? → env 方案需重启;热更走配置中心+文件监听(见 241 追问),注意热更后连接池等持有旧值的资源
216. Express/Koa/Fastify 选型与中间件洋葱模型?
概念 三代 Node Web 框架:Express 中间件线性排队(app.use 依次 next(),走过不回头);Koa 中间件洋葱模型(async 函数,await next() 之前是请求进入段、之后是响应出去段,天然包裹整个后续链);Fastify 在洋葱模型之上加 schema 驱动(JSON Schema 校验 + 快速序列化)与插件封装,性能三家里最高。
典型场景 需要”包裹整个请求”的统一计时/日志/事务,Koa/Fastify 一层中间件搞定、Express 得两头挂钩;老项目 Express 迁移评估;新服务选型(QPS 敏感选 Fastify,生态优先选 Express,轻量自研中间件链选 Koa)。
解决方案 三步递进:Express 线性模型的局限 → Koa 洋葱模型实测 → Fastify 的 schema 性能来源。
第一步:Express 线性中间件——走过就回不了头
// 文件: express-linear.js
const express = require('express');
const app = express();
app.use((req, res, next) => {
const start = Date.now();
res.on('finish', () => { // Express 只能靠事件钩子拿到"出去"的时机
console.log(req.path, Date.now() - start, 'ms');
});
next(); // 一旦 next() 就进入下一个中间件, 不再回来
});
app.get('/api', (req, res) => res.json({ ok: 1 }));
app.listen(3000);
第二步:Koa 洋葱模型——await next() 前后就是进出两段
// 文件: koa-onion.js
const Koa = require('koa');
const app = new Koa();
app.use(async (ctx, next) => {
const start = Date.now();
try {
await next(); // 进入段结束, 后续所有中间件执行完毕才回到这里
ctx.set('X-Response-Time', `${Date.now() - start}ms`); // 出去段: 统一计时/改写响应
} catch (err) {
ctx.status = 500; // 最外层中间件天然是全局错误处理器(217 题)
ctx.body = { message: err.message };
}
});
app.listen(3000);
// 洋葱模型: 请求像穿洋葱逐层进入, 再逐层穿出 —— 每层都能同时看到"进来"和"出去"
第三步:Fastify 的性能来源:schema 驱动序列化
// 文件: fastify-schema.ts
import Fastify from 'fastify';
const app = Fastify({ logger: true });
// 响应定义 JSON Schema 后, Fastify 按 schema 直接生成序列化路径,
// 跳过通用 JSON.stringify 的属性遍历 —— 大响应体吞吐显著高于另两家
app.get('/orders', {
schema: {
response: {
200: {
type: 'array',
items: {
type: 'object',
properties: { id: { type: 'number' }, amount: { type: 'number' } },
required: ['id', 'amount'], // schema 外的字段直接不输出: 序列化路径最短
},
},
},
},
}, async () => [{ id: 1, amount: 99, note: '这个字段不会出现在响应里' }]);
app.listen({ port: 3000 });
总结:Express 线性、Koa 洋葱、Fastify schema 加速;要包裹请求全过程的横切逻辑(计时/事务/日志)选洋葱模型最自然;性能敏感的网关型服务选 Fastify;Express 胜在生态和历史项目。
追问1:洋葱模型里两个中间件的执行顺序? → A 包裹 B:A 的进入段 → B 全部 → A 的出去段;await next() 是分界线
追问2:Fastify 为什么还要做回复序列化优化? → JSON.stringify 是热点(属性遍历+类型判断), 按 schema 预生成字段写入路径, 大响应吞吐可翻倍
追问3:Nest 底层换成 Fastify 值得吗? → @nestjs/platform-fastify 平台包可切换, 路由层有收益; 但多数业务瓶颈在 DB/下游, 先压测再决定
217. async 中间件的异常捕获:为什么 try/catch 接不住?
概念 Express 4 的 next() 不认识 Promise:async 中间件里 throw 会变成 unhandledRejection,Express 的错误中间件(四参函数)根本收不到。Koa 从 v2 起 async 中间件的 rejection 会沿 await next() 链冒泡到最外层(洋葱模型的天然红利)。Nest 在最外层用 Interceptor 的 RxJS catchError + ExceptionFilter 统一接。判断标准就一条:框架替你 await 了吗。
典型场景 上线后偶发 500 但日志没有任何错误栈(async throw 静默丢失);每秒一条 unhandledRejection 告警;老 Express 项目接 async 路由。
解决方案 三步:复现 Express 的丢失 → 包装器修复 → 三家框架的错误路径对照。
第一步:Express async 丢失现场与修复
// 文件: express-async.js
const express = require('express');
const app = express();
// ❌ throw 发生在 Promise 里, express 4 的调度器没有 await 它:
// 错误变成进程级 unhandledRejection(Node 15+ 默认崩进程), 响应永远挂起直到超时
app.get('/boom', async (req, res) => {
throw new Error('db timeout');
});
// ✅ 手写高阶包装: 把 async 错误转交给 express 错误中间件
const wrap = (fn) => (req, res, next) => fn(req, res, next).catch(next);
app.get('/fixed', wrap(async (req, res) => {
throw new Error('db timeout'); // 现在会落到下面的四参错误中间件
}));
// 四参函数 = express 的错误中间件, 必须放最后注册
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).json({ message: err.message });
});
app.listen(3000);
// 生产替代手写 wrap: require('express-async-errors') 一行注册全局生效; express v5 内建支持
第二步:Koa 洋葱自动捕获原理
// 文件: koa-catch.js
const Koa = require('koa');
const app = new Koa();
// koa-compose 的实现本质: 每层中间件都是 promise 链的一环,
// 任何一层 reject 都会沿着 await next() 冒泡到最外层 —— 第一个中间件就是全局错误边界
app.use(async (ctx, next) => {
try {
await next();
} catch (err) {
ctx.status = err.status ?? 500;
ctx.body = { message: err.message };
ctx.app.emit('error', err, ctx); // 再交给 app.on('error') 做日志/上报
}
});
app.use(async () => { throw new Error('any layer'); });
app.listen(3001);
第三步:Nest 的统一错误路径
// 文件: error-path.ts
// Nest 请求链: Guard → Interceptor(pre) → Pipe → Handler → Interceptor(post, RxJS 流)
// handler 里 throw 的错误天然进入 Interceptor 的 catchError 与 ExceptionFilter, 无需手写包装
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable, catchError, throwError } from 'rxjs';
@Injectable()
export class ErrorTraceInterceptor implements NestInterceptor {
intercept(ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
return next.handle().pipe(
catchError((err) => {
console.error('route error:', ctx.getHandler().name, err); // 统一埋点位置
return throwError(() => err); // 继续抛给全局 ExceptionFilter 转响应体(250 题)
}),
);
}
}
总结:async 错误丢失的根因是框架调度器不 await 你的中间件;Express 要 wrap 或 express-async-errors,Koa 洋葱天然冒泡,Nest 用 Interceptor/ExceptionFilter;进程兜底 process.on('unhandledRejection') 记日志后按需退出。
追问1:unhandledRejection 兜底怎么写? → process.on('unhandledRejection', (err) => { log(err); });Node 15+ 默认策略是崩溃退出, 兜底日志后仍建议交给进程管理器重启
追问2:错误中间件为什么必须四个参数? → Express 靠 fn.length === 4 识别错误处理中间件, 少一个参数就会被当普通中间件挂到链上
追问3:Promise.race 包 timeout 为什么不算解决方案? → 输掉的 promise 无法真正取消(计时器还可能泄漏), 只是把等待切走了; 真取消用 AbortController(226 题)
218. EventEmitter 深入:监听器泄漏与 maxListeners?
概念 Node 事件驱动的基础:emitter.on(name, fn) 注册、emit 同步遍历调用(不是异步);同一事件默认最多 10 个监听器,超过打 MaxListenersExceededWarning(只是警告不报错);once 包装成”触发即注销”;error 事件特殊——没有任何监听器时直接 throw 崩溃进程;listenerCount/eventNames 是排查工具。
典型场景 长跑进程日志出现 MaxListenersExceededWarning 后内存缓涨;全局事件总线上每请求订阅、响应后忘记清理;想用 once 等一次性结果但超时后监听器残留。
解决方案 三步:泄漏复现 → 清理的三种模式 → error 事件与排查工具。
第一步:泄漏复现——每请求订阅,从不注销
// 文件: emitter-leak.js
const { EventEmitter } = require('node:events');
const bus = new EventEmitter();
setInterval(() => {
bus.on('order.created', function leak(reqId) { // ❌ 每次注册一个新监听器, 闭包持有 reqId
console.log('notify for', reqId);
});
}, 100);
setTimeout(() => {
console.log('listeners:', bus.listenerCount('order.created')); // 100 秒后 ≈ 1000 个
// 超过 10 个时启动日志就有 MaxListenersExceededWarning(每种事件只提示一次)
}, 10_000);
// 危害不只是内存: 每次事件同步遍历全部监听器, 数量上去后事件处理本身变慢
第二步:正确姿势——用完注销的三种模式
// 文件: emitter-cleanup.js
const { once } = require('node:events');
// 模式 1: 命名函数 + finally off —— 匿名函数 off 不掉(引用对不上)
function onOrder(reqId) { console.log('notify', reqId); }
bus.on('order.created', onOrder);
try { /* 业务 */ } finally { bus.off('order.created', onOrder); } // off 是 removeListener 的别名
// 模式 2: 一次性等待 —— promise 版 once, 超时用 AbortSignal 清理
async function waitOrder() {
const ac = new AbortController();
const timer = setTimeout(() => ac.abort(), 5000);
try {
const [payload] = await once(bus, 'order.created', { signal: ac.signal });
return payload;
} finally { clearTimeout(timer); } // abort 后监听器自动移除, 不残留
}
// 模式 3: 提高阈值要有理由(确实需要多监听器), 而不是掩盖泄漏
bus.setMaxListeners(50);
第三步:error 事件与排查工具
// 文件: emitter-error.js
// 没有监听器的 error 事件 = 进程直接崩溃(不是警告) —— 自定义 EventEmitter 类必挂
class Repo extends EventEmitter {}
const repo = new Repo();
repo.on('error', (err) => console.error('captured:', err.message));
// 排查: 哪些事件积累最多监听器 —— 泄漏巡检脚本的核心
for (const name of bus.eventNames()) {
console.log(String(name), bus.listenerCount(name));
}
// 自定义类抛 Error 实例而不是字符串(字符串 throw 丢失栈)
总结:监听器泄漏是长跑 Node 服务最经典的慢泄漏;注册与注销成对写(命名函数手柄模式 / AbortSignal);error 事件必挂;MaxListeners 警告是免费的前置告警,别急着调大阈值。
追问1:emit 是同步还是异步? → 同步:emit 按注册顺序逐个执行完才返回; 监听器里的 async 函数返回的 promise 无人等待 追问2:为什么默认阈值是 10? → 工程经验值: 绝大多数事件不该超过个位数监听器, 超过多半是泄漏, 把它当烟雾报警器用 追问3:once 注册的监听器怎么手动移除? → 移不掉: on 注册的是包装函数, 手动 off 原函数对不上引用 —— 要可移除就用命名函数自己管理
219. V8 内存模型与 GC:新生代、老生代与堆外内存?
概念 V8 堆分两代:新生代(小、回收频繁,Scavenger 半空间复制算法——活对象复制到另一半空间,死对象自然留下,快但空间利用率一半)、老生代(大,标记-清除 + 标记-整理,增量/并发标记把停顿摊薄)。--max-old-space-size 限的是老生代为主的堆上限。堆外内存不计入 heapUsed:Buffer/ArrayBuffer 计入 external,rss 包含进程驻留一切。容器内存 = V8 堆 + 堆外 + 线程栈 + native 缓冲,要留余量。
典型场景 容器 limit 512MB,Node 默认堆上限按宿主机内存推算(不感知容器限制),结果先被 OOMKill 而不是 V8 OOM;大 Buffer 处理服务 heapUsed 平稳但 rss 持续上涨;GC 频繁导致 P99 毛刺。
解决方案 三步:内存三档对齐(容器→堆→堆外)→ 观察 GC 行为 → 定位堆外增长。
第一步:容器内存对齐三件套
# 文件: mem-align.sh
# 1) 容器 limit 512Mi(K8s resources 或 docker --memory)
# 2) 堆上限设到约 70%: 512 * 0.7 ≈ 358 → --max-old-space-size=358
node --max-old-space-size=358 dist/main.js
# 3) 余量留给: Buffer 堆外、线程栈(每条 worker 数 MB)、zlib/crypto 的 native 内存
# 验证: 稳态 rss 应低于 limit 且有余量; 被 OOMKill 的进程退出码 137(收到 SIGKILL)
# 注意: 默认堆上限来自系统可用内存的推算, 不感知 cgroup —— 容器里必须显式设置
第二步:观察 GC 行为找停顿
# 文件: gc-observe.sh
# --trace-gc 打印每次回收: 代际、耗时、堆变化
node --trace-gc dist/main.js | head -50
# 病征解读:
# Scavenge 频繁且耗时升 → 新生代压力大(大量短命大对象, 检查每请求创建的大数组)
# Mark-Compact 频繁 → 老生代增长过快(缓存无上限/泄漏, 配合 205 题堆快照)
# 单次 pause 超过百 ms → P99 毛刺嫌疑对象; 必要时调 --max-semi-space-size
# 实验环境精确计量: --expose-gc 后手动 global.gc() 前后对比 process.memoryUsage()
第三步:heapUsed 平稳但 rss 涨——堆外定位
// 文件: external-check.js
// Buffer 计入 external 与 rss, 不进 heapUsed —— 常见误判"没泄漏"
const hold = [];
setInterval(() => {
hold.push(Buffer.alloc(1024 * 1024)); // 每秒 1MB 堆外
const m = process.memoryUsage();
console.log('heapUsed', (m.heapUsed / 1e6).toFixed(0),
'external', (m.external / 1e6).toFixed(0),
'rss', (m.rss / 1e6).toFixed(0)); // heapUsed 不动, external/rss 同步涨
}, 1000);
// 排查方向: 未 destroy 的流内部缓冲、Buffer 池、zlib 上下文、worker 序列化缓冲
总结:GC 算法决定行为:新生代复制快、老生代标记慢但增量摊薄停顿;容器内存必须显式约束 V8 堆并给堆外留约 30% 余量;rss 涨 heapUsed 不涨先查 external(堆外),再查 native。
追问1:为什么新生代用复制算法? → 新生代对象多数朝生夕死, 复制少量活对象成本远低于遍历整理全堆; 两个 semi-space 轮换, 空间换速度 追问2:对象什么时候晋升老生代? → 存活过一两轮回收, 或 to-space 超限; 大量本该短命的对象晋升 = 新生代太小或对象活得比预期久 追问3:—max-semi-space-size 什么时候调? → Scavenge 过频且晋升率高时适当调大(如 16→64MB), 让短命对象死在新生代, 别进老生代拖慢标记
220. libuv 线程池:fs/crypto 的隐性阻塞?
概念 事件循环跑在主线程,但四类系统调用被 libuv 丢进线程池(默认 4 条):文件 IO、dns.lookup(getaddrinfo 是同步 libc 接口)、crypto 的 pbkdf2/scrypt/randomBytes(带回调版)、zlib 流式压缩。池子占满时后续任务排队——表现像”事件循环卡了”,其实是池饿死;CPU 密集的同步 JS 则是真正卡主线程,两回事解法不同(203 题 worker_threads)。
典型场景 登录接口用 pbkdf2 校验密码,并发 5 个请求后所有文件 IO 跟着变慢(读静态文件走同一个池);高并发注册把整站文件读拖死。
解决方案 三步:复现池饿死 → 调大 UV_THREADPOOL_SIZE 验证 → 架构级根治。
第一步:复现——密码哈希占满池,文件读排队
// 文件: pool-starve.js
// node pool-starve.js
const fs = require('node:fs');
const { pbkdf2 } = require('node:crypto');
for (let i = 0; i < 5; i++) { // 5 个 pbkdf2, 默认线程池只有 4 条
pbkdf2('pw', 'salt', 600_000, 32, 'sha256', () => console.log(`hash ${i} done`, Date.now()));
}
const t = Date.now();
fs.readFile('/etc/hosts', () => console.log('readFile done +', Date.now() - t, 'ms'));
// 现象: readFile 要等某个 pbkdf2 腾出线程 —— 几 KB 的小文件读变成几百 ms 级
// 事件循环延迟指标(214 题)平稳, 印证主线程没卡 —— 是池排队
第二步:验证与调参
# 文件: pool-tune.sh
# 线程池大小必须在进程启动前设置(环境变量), 运行中不可改
UV_THREADPOOL_SIZE=8 node pool-starve.js # readFile 恢复毫秒级 → 证实瓶颈在池
# 调参上限: 每条线程占内存(栈), 且 CPU 核数才是吞吐天花板 —— 一般 4~16, 超过没意义
第三步:根治——挪走重活
// 文件: pool-fix.js
// 1) 安全参数不能降(600k 轮次是安全要求), 正确做法是把哈希移出主进程
const { Worker } = require('node:worker_threads');
function hashOffMain(password) {
return new Promise((resolve, reject) => {
const w = new Worker('./hash-worker.js', { workerData: { password } });
w.on('message', resolve);
w.on('error', reject);
});
}
// 2) bcrypt 类库选 native 实现(如 bcrypt native 版), 计算发生在 native 线程, 不占 libuv 池
// 3) 极端场景: 认证服务独立部署, 与 IO 型服务物理隔离(287 题拆分思想)
总结:fs/dns.lookup/crypto(回调版)/zlib 走默认 4 条线程;症状是”无关 IO 莫名变慢”而事件循环延迟平稳;先 UV_THREADPOOL_SIZE 验证,再靠架构(worker/native 库/独立服务)根治;同步 CPU 密集 JS 卡的是主线程,别混淆。
追问1:怎么区分主线程卡和线程池饿死? → monitorEventLoopDelay 平稳但 IO 慢 → 池饿死;事件循环延迟飙升 → 主线程被同步计算卡住 追问2:为什么 dns.lookup 在池里而 dns.resolve 不在? → lookup 走 libc 的 getaddrinfo(同步接口, 必须丢线程);resolve 直接发 UDP 查询 DNS 服务器, 天然非阻塞 追问3:randomBytes 同步版和回调版的区别? → 无回调的同步版在调用线程阻塞取熵;带回调版进线程池 —— 高并发路径用回调版或 crypto.randomBytes 的 promise 化
221. Node 安全三害:ReDoS、原型污染、路径遍历?
概念 ReDoS:灾难性回溯正则(嵌套量词如 (a+)+$),攻击输入让匹配耗时指数级,单个请求占死主线程。原型污染:不可信对象被 merge/深拷贝写进 __proto__,污染 Object.prototype 后所有对象读到投毒属性。路径遍历:用户输入拼路径,../ 逃出白名单目录(注意 URL 编码 %2e%2e%2f 绕过与绝对路径注入)。
典型场景 校验用户名的正则被打挂整站;老版本 lodash/qs 的 merge 漏洞;静态文件服务 /files?name=../../etc/passwd 读任意文件。
解决方案 三步一害:逐个复现与防御。
第一步:ReDoS——单个请求卡死主线程
// 文件: redos.js
const evil = 'a'.repeat(30) + '!';
const bad = /^(a+)+$/; // 嵌套量词: 回溯组合爆炸
// bad.test(evil) 需要数秒 —— 期间整个进程无法响应任何请求(连 SIGTERM 处理都排不上)
// 防御:
// 1) 写线性正则: 避免嵌套量词与重叠分支; 工具 safe-regex 静态检测风险
// 2) 高危面换 re2 引擎(线性时间保证):
// const RE2 = require('re2');
// new RE2('^(a+)+$').test(evil); // 毫秒级返回或直接报错
第二步:原型污染——merge 是重灾区
// 文件: proto-pollution.js
function unsafeMerge(target, source) {
for (const key in source) {
target[key] = (typeof source[key] === 'object' && source[key] !== null)
? unsafeMerge(target[key] ?? {}, source[key])
: source[key];
}
return target;
}
unsafeMerge({}, JSON.parse('{"__proto__":{"isAdmin":true}}')); // 恶意 payload
console.log(({}).isAdmin); // true: Object.prototype 已被投毒
// 防御三件套:
// 1) 拒绝危险 key
const BLOCK = new Set(['__proto__', 'constructor', 'prototype']);
function safeMerge(t, s) {
for (const k of Object.keys(s)) {
if (BLOCK.has(k)) continue;
t[k] = (s[k] && typeof s[k] === 'object') ? safeMerge(t[k] ?? {}, s[k]) : s[k];
}
return t;
}
// 2) 不可信数据用 Object.create(null) / Map 承载(没有原型链可污染)
// 3) Nest 侧 ValidationPipe forbidNonWhitelisted 把多余字段挡在门口(232 题), __proto__ 进不来
第三步:路径遍历——resolve 后白名单校验
// 文件: path-traversal.js
const path = require('node:path');
const fs = require('node:fs');
const ROOT = path.resolve('/var/app/uploads');
function safeRead(filename) {
const decoded = decodeURIComponent(filename); // 先解码, 防 %2e%2e%2f 绕过
const target = path.resolve(ROOT, decoded); // resolve 会展开 ../ 与绝对路径注入
if (!target.startsWith(ROOT + path.sep)) { // 必须带分隔符: 否则 /var/app/uploads-evil 骗过前缀判断
throw new Error('path escape');
}
return fs.createReadStream(target);
}
// 更严格: fs.realpath 解开 symlink 后再校验(防软链逃逸); 上传文件名服务端重命名, 不信任原名
总结:三害共同点是”不可信输入进入危险操作”;防御:正则写线性或换 re2、merge 过滤 __proto__ 族 key、路径 resolve 后做带分隔符的前缀校验;再配 ValidationPipe 白名单,输入在门口洗干净。
追问1:ReDoS 为什么不靠超时解决? → 正则执行占着主线程, 超时回调也排不上队; 只能预防(线性正则/re2)或把校验挪 worker 追问2:原型污染怎么升级成 RCE? → 污染常见 gadget(child_process 的 options 合并、模板引擎选项)可执行任意命令 —— 按高危处理, 不只是”数据错乱” 追问3:symlink 怎么绕过前缀校验? → uploads 里放软链指向 /etc; 防御用 fs.realpath 解析真实路径后再 startsWith
222. npm 供应链安全:lockfile、audit 与依赖治理?
概念 供应链攻击面:语义化版本的 ^ 在没有 lockfile 约束时让 npm install 解析到新版本(可能被投毒);postinstall 类脚本在安装时执行任意代码;typosquatting(拼错包名);维护者账号被盗后直接发恶意版本。防线四层:lockfile 入库 + npm ci、安装脚本禁用、audit 门禁、最小化依赖与私有 registry。
典型场景 新成员本地 npm install 装到投毒版本;CI 缓存被投毒包穿透;紧急 CVE 出来不知道哪些服务受影响。
解决方案 三步:安装环节收紧 → 依赖变更流程化 → registry 与审计常态化。
第一步:安装环节——npm ci + 禁 scripts
# 文件: install-hardening.sh
# npm ci: 严格按 package-lock.json 安装, lockfile 与 package.json 不一致直接失败(不会静默解析新版本)
npm ci --omit=dev
# 禁用三方包的安装脚本(postinstall/preinstall 是最常见的任意代码执行入口)
npm ci --ignore-scripts
# 原生模块(sharp/bcrypt)需要编译脚本的: 白名单放行(pkgA --ignore-scripts 配 per-package 配置)
第二步:依赖变更流程——renovate 白名单 + 冷却期
// 文件: renovate-config.js
// .renovate.json: 依赖升级走 PR 审查, 而不是谁本地顺手升级
module.exports = {
extends: ['config:recommended'],
rangeStrategy: 'bump', // 连 package.json 的 ^ 范围一起收紧
lockFileMaintenance: { enabled: true, schedule: ['before 6am on monday'] },
vulnerabilityAlerts: { enabled: true }, // CVE 出来自动开修复 PR
packageRules: [
{ matchPackageNames: ['*'], minimumReleaseAge: '3 days' }, // 新版本冷却 3 天
],
};
// 冷却期逻辑: 投毒包通常几小时内被 npm 下架, "发布即安装"变成"发布数天后才可能进入"
第三步:audit 门禁与私有 registry
// 文件: audit-ci.json —— CI 里阻断高危: npx audit-ci --high
{
"high": true,
"allowlist": ["GHSA-xxxx-yyyy-zzzz"],
"skipDevDependencies": false
}
# 文件: private-registry.sh
# Verdaccio 私有代理: 上游缓存 + 发布管控, 投毒包进不来
# docker run -d --name registry -p 4873:4873 verdaccio/verdaccio
# .npmrc: registry=http://npm.corp.local:4873/
# 大团队终极闸门: 只有白名单包能被代理, 新依赖走申请
总结:供应链安全 = 安装严格化(ci + ignore-scripts)+ 变更流程化(renovate PR + 冷却期)+ 检测常态化(audit-ci 门禁);私有 registry 是大团队的闸门;依赖越少攻击面越小。
追问1:npm install 和 npm ci 的本质区别? → install 按 semver 范围重新解析并改写 lockfile;ci 只按 lockfile 精确还原, 不一致即失败 —— CI 必须用 ci 追问2:lockfile 合并冲突怎么解? → 删 lockfile 重装是反模式(等于全量重新解析);正确是解决冲突后 npm ci 验证一致性 追问3:怎么知道哪些服务用了漏洞包? → 组织级 SBOM 清单(syft)入库 + CVE 出来反查; 没有清单时只能全仓 grep 依赖名
223. pino 结构化日志:traceId 贯穿、脱敏与轮转?
概念 pino 是低开销结构化日志:每行一个 JSON 对象(字段可检索);性能来自极简序列化 + sonic-boom 直接写 fd,child logger 把上下文字段固化在 logger 实例上(不必每条拼参数);transport 模式把格式化/分发挪到 worker 线程。配套:redact 脱敏、轮转、对接 Loki/ELK。对比 console.log:文本无结构、无法按字段过滤、同步写拖慢事件循环。
典型场景 线上排查”这个请求经过了哪些服务”要靠 traceId 串日志;日志里打出手机号/token 被安全审计打回;日志量太大存储成本爆炸。
解决方案 三步:基础接入 + child 上下文 → ALS 自动 traceId → 脱敏/分级/轮转治理。
第一步:child logger 绑定请求上下文
// 文件: logger.js
const pino = require('pino');
const logger = pino({
level: process.env.LOG_LEVEL ?? 'info',
redact: { paths: ['req.headers.authorization', '*.password', '*.phone'], censor: '[REDACTED]' },
});
// 每个请求 create 一次 child: traceId 固化, 之后每条日志自动携带, 不用手动传参
function requestLogger(traceId) {
return logger.child({ traceId });
}
module.exports = { logger, requestLogger };
第二步:ALS 注入——中间件一次绑定,深层调用免传参
// 文件: with-trace.js
const { AsyncLocalStorage } = require('node:async_hooks');
const { requestLogger } = require('./logger');
const crypto = require('node:crypto');
const als = new AsyncLocalStorage();
function withTrace(req, res, next) {
const traceId = req.headers['x-trace-id'] ?? crypto.randomUUID();
res.setHeader('x-trace-id', traceId);
als.run({ traceId }, () => next()); // 后续整条异步链可取(236 题)
}
function log() {
const ctx = als.getStore() ?? {};
return requestLogger(ctx.traceId);
}
// 深层任意模块: log().info({ orderId }, 'order created') —— traceId 自动带上, 无侵入
第三步:分级、采样与轮转治理
// 文件: pino-tuning.js
const pino = require('pino');
const transport = pino.transport({
targets: [
{ target: 'pino/file', level: 'error', options: { destination: 1 } }, // error 直进 stdout
{ target: 'pino-roll', level: 'info',
options: { file: '/var/log/app', frequency: 'daily', limit: { count: 14 } } }, // 按天轮转保留 14 份
],
});
const logger = pino({ level: 'info' }, transport);
// 体积治理三板斧: 1) 生产 level=info 2) 高频 debug 改采样(每 N 条记 1 条) 3) 大对象截断
// 对接 Loki: JSON 行直接被识别字段, LogQL 查 {app="order"} | traceId="abc" 串联一次请求
// traceId 与 OpenTelemetry 的 trace_id 打通后, 日志成为 trace 的附属事件(279 题)
总结:结构化日志的可检索性是排障效率的根;child logger 固化上下文 + ALS 免传参;redact 出门前脱敏;采样分级控成本;pino 的低开销让”敢在每个请求打多条日志”成为可能。
追问1:pino 为什么快? → 单次拼接直接写 fd(sonic-boom), 避免深遍历与异步队列开销;transport 模式把格式化/分发挪 worker 线程, 不占事件循环 追问2:transport 模式的日志会丢吗? → worker 崩溃期间会丢;强一致场景用同步 destination, 或接受极小概率丢失并靠告警兜底 追问3:日志与指标怎么分工? → 日志记”发生过什么”(详情), 指标记”状态如何”(聚合, 298 题);高频事件只进指标, 低频异常进日志
224. 文件上传:busboy 流式接收与 S3 直传?
概念 multipart 上传两种处理姿势:multer 默认把文件写内存或临时目录(内存模式大文件直接把堆打爆);busboy 把 multipart 拆成流,file 流边收边转发。对象存储落地三条路:服务端收完再传(两次流量)、服务端流式管道直传(S3 分片上传)、预签名 URL 客户端直传(文件流量不过服务端,只传签名)。
典型场景 用户传 500MB 视频把 Node 内存打爆;上传带宽把 API 服务的网卡吃满;需要断点续传与秒传。
解决方案 三步:busboy 流式接收 → S3 分片流式直传 → 预签名 URL 架构演进。
第一步:busboy 流式接收——不落内存
// 文件: upload-busboy.js
const Busboy = require('busboy');
app.post('/upload', (req, res) => {
const bb = Busboy({ headers: req.headers, limits: { fileSize: 200 * 1024 * 1024 } });
bb.on('file', (name, file, info) => {
console.log('receiving', info.filename, info.mimeType);
file.on('limit', () => file.truncate()); // 超限截断 + 标记拒绝, 防恶意大文件
const out = getUploadTarget(info); // 下游可写流: S3 分片/本地/转码服务
file.pipe(out);
});
bb.on('field', (k, v) => console.log(k, v));
bb.on('close', () => res.end('ok'));
req.pipe(bb); // 请求体本身是流, 边解析边消费
});
第二步:服务端流式直传 S3——分片上传
// 文件: s3-stream-upload.ts
import { Upload } from '@aws-sdk/lib-storage';
import { S3Client } from '@aws-sdk/client-s3';
const s3 = new S3Client({});
async function pipeToS3(fileStream: NodeJS.ReadableStream, key: string) {
// lib-storage 的 Upload 内部自动: 攒够 8MB 一个 part → UploadPart → 完成后 CompleteMultipartUpload
// 全程内存只持有一个分片, 500MB 文件也不会堆内存
const upload = new Upload({
client: s3,
params: { Bucket: 'docs', Key: key, Body: fileStream },
queueSize: 4, // 并发上传的 part 数
partSize: 8 * 1024 * 1024,
leavePartsOnError: false, // 失败即中止并清理已传分片
});
return upload.done(); // 返回含 ETag; 断点续传可凭 UploadId + 已传 part 恢复
}
第三步:预签名 URL——文件流量绕开服务端
// 文件: presign.ts
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
import { PutObjectCommand } from '@aws-sdk/client-s3';
// 客户端先请求签名(鉴权/配额/格式检查都在这一步做), 拿着 URL 直传 S3
async function createUploadUrl(userId: string, contentType: string) {
const key = `uploads/${userId}/${Date.now()}`;
const cmd = new PutObjectCommand({ Bucket: 'docs', Key: key, ContentType: contentType });
const url = await getSignedUrl(s3, cmd, { expiresIn: 600 }); // 10 分钟有效
return { url, key };
}
// 服务端只出签名与完成回调校验(ETag/大小核对), 网卡与内存压力同时消失
// 秒传: 客户端先算文件内容 hash → 服务端查同 hash 已存在对象直接返回(跳过上传)
// 完成后处理: S3 事件通知 → 队列 → 解析/入库(与 277 题任务队列衔接)
总结:大文件上传铁律是”不整读进内存”:busboy 流式解析、S3 分片管道直传;规模再大上预签名 URL 客户端直传,服务端只管鉴权与登记;配额用 limits 与服务端核对双保险。
追问1:断点续传怎么做? → S3 分片上传天然支持:保存 UploadId 与已完成 part 列表, 重连后 listParts 续传;秒传再加内容 hash 索引 追问2:预签名 URL 的安全边界? → URL 即凭证(有效期内任何人可 PUT);收紧:限定 ContentType、路径含 userId 隔离、一次性登记、短有效期 追问3:上传与业务解耦? → 上传完成发对象存储事件通知, 触发解析/转码/入库 —— 上传通道只管字节, 业务状态机自己走
225. 大文件导出:流式 CSV 与 ZIP 响应?
概念 导出 50 万行不能先在内存拼完整文件:响应本身是可写流,DB 游标是可读流,pipeline 串起来边查边发(客户端立刻开始下载)。CSV 注意转义与公式注入;ZIP 用流式库边生成边写;不设 Content-Length 走 chunked 传输。
典型场景 运营导出全量订单把服务 OOM;导出期间内存锯齿引发 GC 长停顿(219 题);导出的 Excel 打开丢列(CSV 转义错误)。
解决方案 三步:游标 + pipeline 到响应 → CSV 转义与公式注入 → ZIP 多文件流式打包。
第一步:游标流 → 响应流
// 文件: export-csv.ts
import { pipeline } from 'node:stream/promises';
import { stringify } from 'csv-stringify';
async function exportOrders(res: Response) {
res.setHeader('Content-Type', 'text/csv; charset=utf-8');
res.setHeader('Content-Disposition', 'attachment; filename="orders.csv"');
// 不设 Content-Length → chunked 传输, 客户端立即开始下载
async function* queryStream() { // keyset 游标: 比 offset 深翻页稳定
let cursor = 0;
while (true) {
const rows = await db.query(
'SELECT id, order_no, amount, created_at FROM orders WHERE id > $1 ORDER BY id LIMIT 5000',
[cursor],
);
if (rows.length === 0) break;
cursor = rows[rows.length - 1].id;
yield* rows; // 惰性: 消费多快查多快, 背压自动传导(201 题)
}
}
await pipeline(queryStream(), stringify({ header: true }), res);
}
第二步:CSV 转义与公式注入防护
// 文件: csv-safe.js
// 公式注入: 值以 = + - @ 开头会被 Excel 当公式执行(=HYPERLINK 钓鱼)
function safeCell(v) {
const s = String(v ?? '');
if (/^[=+\-@\t\r]/.test(s)) return `'${s}`; // 前缀单引号强制文本
return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; // 逗号/引号/换行 → RFC 4180 转义
}
// csv-stringify 能处理 RFC 转义, 但公式注入防护要自己包一层 —— 安全默认自己给
第三步:ZIP 流式打包与异步导出演进
// 文件: export-zip.js
const Archiver = require('archiver');
function exportZip(res, files) {
res.setHeader('Content-Type', 'application/zip');
const zip = Archiver('zip', { zlib: { level: 5 } }); // 压缩级别换 CPU: 越高越吃 CPU
zip.on('warning', (e) => console.warn(e.message));
zip.pipe(res);
for (const f of files) {
zip.append(createCsvStream(f.query), { name: `${f.name}.csv` }); // 每个成员也是流
}
void zip.finalize(); // 收尾写中央目录; 全程内存只有压缩窗口
}
// ⚠️ zip 中央目录在文件末尾, 中途断开客户端拿到的是坏 zip —— 大文件导出失败重试成本高
// 更稳的架构: 异步导出(任务落 277 题队列 → 先流式写对象存储 → 完成后给下载链接),
// HTTP 长连接不扛到底, 进度还能推送(264 题网关)
总结:导出的内存安全 = 游标读流 + pipeline 到响应;CSV 双重防护(RFC 转义 + 公式注入);ZIP 流式打包;超大数据量转异步导出落存储。
追问1:keyset 与 offset 分页的区别? → offset 深翻页要扫描跳过的行(越翻越慢);keyset 用 id > cursor 走索引, 速度恒定 —— 导出全量必须 keyset 追问2:客户端下载进度怎么做? → 无 Content-Length 时按 chunk 计数估算;异步导出方案里用任务进度(277 题 job.updateProgress)推送更准 追问3:Excel(xlsx)能流式导出吗? → xlsx 本质是 zip, exceljs 的 stream workbook 支持逐行写;超大仍建议 CSV(xlsx 单 sheet 上限 104 万行)
226. AbortController:统一取消传播怎么设计?
概念 AbortController/AbortSignal 是跨 API 的取消标准:fetch(第二参 signal)、流迭代、promisified 定时器、child_process、addEventListener 都支持。核心工程问题不是”能不能取消”,而是”一个取消源如何传播到整条链路”:用户断开 → 中止上游 fetch → 取消计费循环 → 释放资源。
典型场景 用户关掉 LLM 对话页,上游 token 还在烧钱(247 题的深化);聚合接口的 3 个下游,超时要一起取消而不是各自等待;请求断开后 DB 慢查询还在跑。
解决方案 三步:单点超时 → 多源组合(AbortSignal.any)→ 请求断开驱动的全链取消。
第一步:单点超时——AbortSignal.timeout
// 文件: abort-timeout.js
// 旧写法 Promise.race 包 timeout 的两个问题: 输掉的请求无法真正取消 + 计时器泄漏
const res = await fetch('https://api.llm.dev/v1/chat', {
signal: AbortSignal.timeout(10_000), // 到点真正中止 fetch, 抛 TimeoutError
});
// 错误类型区分: err.name === 'TimeoutError'(超时) vs 'AbortError'(手动取消)
第二步:多源组合——超时与用户取消任一触发
// 文件: abort-any.ts
// 聚合接口等 3 个下游, 任一超时或客户端断开都全部取消
async function aggregate(clientGone: AbortSignal) {
const timeout = AbortSignal.timeout(8_000);
const combined = AbortSignal.any([clientGone, timeout]); // 任一源触发即中止(Node 20+)
const [a, b] = await Promise.all([
fetch('http://svc-a', { signal: combined }),
fetch('http://svc-b', { signal: combined }),
]);
return { a: await a.json(), b: await b.json() };
}
// 旧版本手写组合: 自建 controller, 各源 addEventListener('abort', () => ctrl.abort(reason))
第三步:请求断开 → 全链取消(Nest 落地)
// 文件: cancel-chain.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
export const AbortSignalOf = createParamDecorator(
(_: unknown, ctx: ExecutionContext) => {
const req = ctx.switchToHttp().getRequest();
if (req.abortSignal) return req.abortSignal;
const ctrl = new AbortController();
req.on('close', () => { // 客户端断开(页面取消/网络断)
if (req.writableEnded === false) ctrl.abort('client disconnected');
});
req.abortSignal = ctrl.signal;
return ctrl.signal;
},
);
// controller 里 signal 一路传给 fetch / 游标流 / 计费循环 —— 取消一次传播, 不留孤儿任务
// @Get('chat')
// async chat(@AbortSignalOf() signal: AbortSignal) {
// const upstream = await fetch(LLM_URL, { signal });
// return new StreamableFile(upstream.body); // 247 题 SSE 网关的通用底座
// }
总结:取消是资源问题(连接、token、CPU);AbortSignal 是统一货币:timeout 造源、any 组合、close 事件驱动;关键是把 signal 当参数显式穿透整条调用链,别在中途丢掉。
追问1:AbortSignal.timeout 的计时器会泄漏吗? → 不会,fetch 正常完成后 timeout 源随 GC 回收;这正是比手写 setTimeout+race 强的地方 追问2:DB 查询能被 signal 取消吗? → 取决于驱动:node-postgres 支持发 cancel 指令,mysql2 不完全支持 —— 慢查询防线主要靠 statement_timeout(229 题) 追问3:取消后业务怎么收尾? → catch AbortError 分支做轻量清理(记日志/释放句柄);计费等强一致收尾放服务端 finally, 不依赖客户端
227. 信号处理与进程守护:SIGTERM、SIGHUP 与 PM2?
概念 常见信号:SIGINT(Ctrl+C)、SIGTERM(终止请求,可捕获——优雅停机的唯一入口)、SIGKILL(不可捕获不可忽略)、SIGHUP(终端断开,守护进程约定当 reload)、SIGUSR2(nodemon/PM2 借来做热重启)。关键语义:一旦为信号注册监听,Node 默认行为被取消,退出责任归你。Docker/K8s 停容器发 SIGTERM,宽限期后补 SIGKILL。
典型场景 容器滚动更新时进程不响应 SIGTERM,宽限期后被 SIGKILL 强杀,在途请求全断;PM2 reload 的零停机依赖信号协作;本地 nodemon 热重启其实是收到 SIGUSR2。
解决方案 三步:信号处理骨架 → PM2 信号协作 → K8s 信号链路。
第一步:信号处理骨架——注册了监听就要负责退出
// 文件: signals.js
const http = require('node:http');
const server = http.createServer((req, res) => res.end('ok'));
server.listen(3000);
for (const sig of ['SIGTERM', 'SIGINT']) {
process.once(sig, () => {
console.log(sig, 'received, draining...');
server.close(() => process.exit(0)); // 停止接新连接, 等在途完成再退出
setTimeout(() => process.exit(1), 15_000).unref(); // 兜底强退, 防残留句柄挂死
});
}
// ⚠️ 注册监听后 Node 不再默认退出 —— 忘记 process.exit 会"卡住不退", 最终被 SIGKILL
// keep-alive 连接会阻止 server.close 完成: 配 server.closeIdleConnections()(Node 18.2+)
第二步:PM2 的信号协作
// 文件: ecosystem.config.js
module.exports = {
apps: [{
name: 'api',
script: 'dist/main.js',
instances: 4, // cluster 模式: 4 个 worker
exec_mode: 'cluster',
max_memory_restart: '400M', // 超限 PM2 kill 后重新拉起(不是信号, 是重启)
kill_timeout: 10000, // SIGTERM 后等 10s 再 SIGKILL —— 与应用收尾时长对齐
}],
};
// pm2 reload api: 逐个重启 worker(新起来再停旧的)= 零停机;
// 前提: 应用正确响应 SIGTERM(第一步骨架)+ 前置 LB 健康检查
第三步:K8s 环境的信号链路
# 文件: deployment-signal.yaml
spec:
terminationGracePeriodSeconds: 20 # SIGTERM 后最多等 20s 才 SIGKILL
containers:
- name: api
image: api:1.0.0
# 信号发给 PID 1 —— 容器里 PID 1 必须是 node 本体(或能转发信号的 init):
# ✅ CMD ["node", "dist/main.js"]
# ❌ CMD ["npm", "start"] → 部分 npm 版本不转发 SIGTERM 给 node 子进程
lifecycle:
preStop:
exec: { command: ["sleep", "3"] } # 先等 LB 摘流量, 再收 SIGTERM
总结:信号是进程与外部世界的关闭协议:SIGTERM 可谈、SIGKILL 没得谈;注册监听后退出责任归你;容器里确认 PID 1 是 node、宽限期与收尾时长匹配;PM2 reload 的零停机建立在信号协作之上(211 题的容器视角)。
追问1:为什么 CMD npm start 可能收不到信号? → npm 起的 shell/npm 进程占 PID 1,不转发 SIGTERM 给 node —— 直接 exec node 或用 tini 当 init 追问2:SIGHUP 当 reload 用是惯例吗? → 是(nginx -s reload 同源);Node 守护进程可用它重载配置,但要自己实现,框架没有内建 追问3:SIGUSR2 做热重载安全吗? → nodemon/PM2 用它触发的是”整进程重启”不是热更新;运行中换代码仍是实验特性,生产别玩
228. Node 大版本升级:破坏性变更怎么管?
概念 Node 偶数版是 LTS(30 个月支持窗口),升级风险四类:V8 行为变化(解析与优化差异)、废弃 API 移除(url.parse 类)、原生模块 ABI 变化(bcrypt/sharp 要重编译或换预编译版本)、默认配置变化(18+ 全局 fetch、22+ require(esm))。方法论:engines 锁定 + CI 版本矩阵双轨 + canary 分级放量。
典型场景 16→20 跳级后 sharp 原生模块报 NODE_MODULE_VERSION 不匹配;测试全绿上线后一个冷门路径踩了 V8 行为差异;团队各用各的 Node 版本,“我这没问题”。
解决方案 三步:升级前盘点 → CI 双轨矩阵 → canary 对比放量。
第一步:升级前盘点清单
# 文件: upgrade-audit.sh
# 1) 废弃 API 使用扫描(未来的移除就是今天的 deprecated)
grep -rn "url.parse\|new Buffer(" src/ --include='*.ts' | head -20
# 2) 原生模块清单(重编译风险名单: 带 binary 的依赖)
grep -l '"node-gyp"' node_modules/*/package.json 2>/dev/null | head
# 3) engines 从宽泛改锁定, 本地 nvm/volta 统一
node -e "const p=require('./package.json'); p.engines={node:'>=20 <21'}; \
require('fs').writeFileSync('package.json', JSON.stringify(p,null,2))"
# 4) 依赖逐个升级不如先升 Node 再修依赖: 大版本间隔的依赖通常已适配新 LTS
第二步:CI 版本矩阵双轨
# 文件: ci-matrix.yml
jobs:
test:
strategy:
matrix:
node: [20, 22] # 旧 LTS + 新 LTS 同时跑, 升级期全程双轨
steps:
- uses: actions/setup-node@v4
with: { node-version: '${{ matrix.node }}' }
- run: npm ci && npm run build && npm test
# 原生模块在矩阵里各自重编译, ABI 不匹配在此暴露而不是上线后
第三步:canary 分级放量
// 文件: canary-check.js
// 上线路径: 1 个 canary 实例跑新版 → 核心指标观察 24h → 10% → 全量
// 观察点专挑升级敏感项:
setInterval(() => {
const m = process.memoryUsage();
console.log(JSON.stringify({
v: process.version, v8: process.versions.v8,
rss: m.rss, heap: m.heapUsed, // 堆行为变化: 稳态曲线对比旧版
}));
}, 30_000); // 输出直接进指标系统(298 题), 与旧版本曲线叠图对比
// 性能回归: 同机器同压测对比 QPS 与 P99; GC 差异看 --trace-gc(219 题)
// 回滚预案: 镜像回退先于升级存在(这是发布问题, 249 题)
总结:升级是工程问题不是技术问题:盘点(废弃 API/原生模块)→ 双轨矩阵验证 → canary 指标对比放量;engines 锁定保证环境一致;别等旧 LTS 进维护末期才动。
追问1:LTS 时间线怎么规划升级节奏? → 跟”维护中的两个 LTS”策略:新 LTS 发布后一年内切,别等旧 LTS 停止维护倒计时 追问2:require(esm) 意味着什么? → Node 22 起 CJS 里能直接 require ESM 包(同步加载),双格式包互操作坑(204 题)大幅缓解 追问3:升级后性能反退怎么排查? → 同机器压测对比 V8 版本差异点(序列化/正则/GC),CPU profile 找回归点,必要时锁定旧版并上报 issue
229. 数据库与 Redis 客户端的连接池管理?
概念 池的存在原因:建连成本高(TCP 握手 + TLS + 认证),连接是服务端稀缺资源(MySQL max_connections 上限,每连接内存开销)。mysql2 的 createPool(connectionLimit 等参数);Redis 特殊:单连接上命令天然流水线化,池主要用于阻塞命令与 subscribe(订阅连接独占);池耗尽的症状是排队等待而不是报错,直到超时。
典型场景 流量高峰 DBA 报 Too many connections;慢 SQL 占住连接,池被拖干后全站接口挂;Redis 订阅和普通命令共用连接导致互相阻塞。
解决方案 三步:mysql2 池参数与用法 → 池监控与容量核算 → Redis 的连接模型。
第一步:mysql2 池化与参数
// 文件: db-pool.js
const mysql = require('mysql2/promise');
const pool = mysql.createPool({
host: 'db.corp.local',
database: 'order',
connectionLimit: 20, // 单实例上限; 全局上限 = 实例数 × 20, 必须小于 max_connections 并留预留
waitForConnections: true, // 池满时排队(而不是立即报错)
queueLimit: 0, // 排队不设上限(靠慢查询治理兜底)
connectTimeout: 5_000,
maxIdle: 10, // 空闲收缩: 低谷自动降到 10, 别把峰值连接常驻
idleTimeout: 60_000,
});
// 用法: pool.execute() 自动借还; 手动 getConnection 必须 finally release
const [rows] = await pool.execute('SELECT id FROM orders WHERE user_id = ?', [userId]);
第二步:池监控——池是隐形队列,不监控等于盲飞
// 文件: pool-metrics.js
// 关键信号: enqueue 事件 = 有请求在等连接 —— 偶发可接受, 持续出现就是容量或慢 SQL 问题
pool.on('enqueue', () => metrics.counter('db_pool_enqueue').inc());
// 状态巡检(内部字段, 适合调试与低频采集; 正式监控用 prom-counter 暴露三类计数)
setInterval(() => {
const p = pool.pool;
console.log('all:', p._allConnections.length,
'free:', p._freeConnections.length,
'queue:', p._connectionQueue.length);
}, 5_000);
// 排查顺序: queue 持续 > 0 → 抓慢 SQL(它占住连接)→ 治慢查询 → 再谈加连接
// ⚠️ 加 connectionLimit 掩盖慢 SQL 是经典误区: 只会把压力转嫁给 DB 的 max_connections
第三步:Redis 的连接模型
// 文件: redis-conn.js
const Redis = require('ioredis');
const redis = new Redis({ maxRetriesPerRequest: 3, enableAutoPipelining: true });
// enableAutoPipelining: 同一 tick 的命令自动打包流水线 —— 普通命令不需要手动池化
// 两类必须独立连接的场景:
const sub = redis.duplicate(); // 订阅连接: 进入 subscriber 模式后不能再发普通命令
await sub.subscribe('order.events');
const blocker = redis.duplicate(); // 阻塞命令(BLPOP)独占连接期间不响应其他命令
// 容量视角: Redis 单线程, 连接数增多不提升吞吐(反而增内存) —— 连接够并发即可, 别按 DB 思路放大
总结:池管理三件事:上限核算(实例数 × connectionLimit < max_connections)、排队可见(enqueue 监控 + 慢 SQL 治理)、空闲收缩;Redis 不吃”池提吞吐”这一套:普通命令靠 pipeline,订阅/阻塞命令独立连接。
追问1:池大小是不是越大越好? → 不是:DB 每连接有内存与上下文切换成本,且加连接掩盖不了慢 SQL —— 顺序永远是先治慢查询再谈池 追问2:连接泄漏怎么发生? → getConnection 后异常路径没 release;用 pool.execute 自动借还或 finally 兜底;泄漏症状是 free 持续下降到 0 追问3:服务重启时的连接风暴? → 大量实例同时启动抢建连:启动加随机延迟抖动、maxIdle/idleTimeout 平滑收缩、DB 侧给运维留预留连接
二、NestJS 核心(230–249)
230. Nest 的 IoC 容器解决什么问题?
概念 IoC(控制反转)把对象的创建与组装交给框架:类只声明依赖(constructor(private svc: Svc)),容器负责实例化、注入、生命周期管理。
典型场景 项目变大后 new Service() 到处散落、单元测试想替换真实依赖、横切服务(日志/配置)需要全局唯一。
解决方案 三步递进:没有 IoC 的痛 → IoC 注册与注入 → 单测里换 mock。
第一步:没有 IoC 的痛
// 文件: no-ioc.ts
class OrderService {
private payment = new PaymentService(); // 手动 new: 依赖硬编码
private notify = new NotifyService();
create() {
this.payment.charge(); // 测试时无法替换 payment → 无法单测
}
}
// new 的传染性: PaymentService 又 new 它的依赖 → 构造链越深越失控
第二步:IoC 注册与注入——只声明,不 new
// 文件: ioc-basic.ts
import { Injectable, Module, Controller, Get } from '@nestjs/common';
@Injectable() // 声明: 我是容器管理的
export class PaymentService {
charge() { return 'charged'; }
}
@Controller('orders')
export class OrderController {
constructor(private readonly payment: PaymentService) {} // 只声明依赖
@Get()
create() { return this.payment.charge(); }
}
@Module({
controllers: [OrderController],
providers: [PaymentService], // 容器登记
})
export class OrderModule {}
第三步:单测换 mock——IoC 的第一红利
// 文件: order.service.spec.ts
import { Test } from '@nestjs/testing';
import { PaymentService } from './payment.service';
import { OrderController } from './order.controller';
it('创建订单调用支付', async () => {
const charge = jest.fn().mockReturnValue('mock-charged');
const module = await Test.createTestingModule({
controllers: [OrderController],
providers: [{ provide: PaymentService, useValue: { charge } }], // 真实实现 → mock
}).compile();
const ctrl = module.get(OrderController);
expect(ctrl.create()).toBe('mock-charged');
expect(charge).toHaveBeenCalled();
});
总结:IoC 解决三件事——依赖组装自动化、实现可替换(可测试)、生命周期统一(单例/请求级)。new 是它的反义词。
追问1:四种 provider 注册方式? → useClass(默认)/useValue(常量或 mock)/useFactory(工厂+依赖)/useExisting(别名) 追问2:接口为什么不能直接当 token? → TS 接口编译后擦除,运行时不存在;用 Symbol/InjectionToken 或抽象类 追问3:useFactory 什么时候用? → 依赖异步初始化(如数据库连接就绪)或需要运行时参数时
231. Nest 请求生命周期:一次请求经过谁?
概念 请求链:Middleware → Guard → Interceptor(前) → Pipe → Handler → Interceptor(后) → ExceptionFilter。五件套各司其职,顺序由框架固定。
典型场景 鉴权放错了位置被绕过、日志想拿到处理后的响应却发现拦截器更合适、异常格式不统一。
解决方案 三步递进:全景顺序 → 每一环的职责边界 → 全局注册顺序的影响。
第一步:全景——背下这张图
Request
└→ Middleware Express 层: 计时/日志/CORS
└→ Guard 认证/授权: 决定能不能进来(返回 401/403)
└→ Interceptor 前 包装 RxJS 流: 缓存/转换/超时
└→ Pipe 参数校验/转换: ValidationPipe
└→ Handler 业务逻辑
└→ Interceptor 后 拿到响应做包装(统一 code/data)
└→ ExceptionFilter 兜底: 异常 → 统一错误响应
Response
第二步:职责边界——同一逻辑放哪一层?
接口耗时日志 → Middleware(最外层)或 Interceptor(可访问上下文)
登录校验 → Guard(JwtAuthGuard), 早于业务执行
参数字符串转数字 → Pipe(transform), 业务拿到的已是干净类型
响应包装 code/data → Interceptor(map), Handler 只返回业务数据
错误统一格式 → ExceptionFilter, 全局兜底
判断法: 这件事发生在进业务前还是出业务后? 会不会需要业务上下文?
第三步:全局注册顺序即执行顺序
// 文件: app.module.ts
providers: [
{ provide: APP_GUARD, useClass: JwtAuthGuard }, // 先认证
{ provide: APP_GUARD, useClass: PermissionGuard }, // 后鉴权 —— 顺序不可颠倒
{ provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
{ provide: APP_INTERCEPTOR, useClass: TransformInterceptor },
]
总结:生命周期是 Nest 的骨架图——所有”这段逻辑放哪”的问题都回到这张图;全局 provider 注册顺序即执行顺序。
追问1:Guard 和 Middleware 都能做鉴权,选谁? → Guard 能读装饰器元数据(@SetMetadata 权限码)且类型安全;Middleware 不知道路由元信息
追问2:Interceptor 里怎么改响应体? → next.handle().pipe(map(data => ({code: 0, data})))
追问3:Pipe 校验失败抛的错误谁接? → BadRequestException → 全局 ExceptionFilter 统一包装
232. ValidationPipe 三选项:transform/whitelist/forbidNonWhitelisted?
概念 全局 ValidationPipe 的三个开关:transform 把请求体实例化为 DTO 类并做类型转换;whitelist 剥离 DTO 未声明的字段;forbidNonWhitelisted 对多余字段直接报 400。
典型场景 前端多传了 isAdmin: true 被写进库(mass-assignment 越权)、query 的 “1” + 1 变 “11”、DTO 计算属性拿到 undefined。
解决方案 三步递进:全局配置 → 三个选项各自关掉会怎样 → 转换的配套装饰器。
第一步:全局配置——main.ts 一处声明
// 文件: main.ts
import { ValidationPipe } from '@nestjs/common';
app.useGlobalPipes(new ValidationPipe({
transform: true, // 字符串 "42" → number 42, 请求体实例化为 DTO
whitelist: true, // 多余字段静默剥离
forbidNonWhitelisted: true, // 多余字段直接 400(公开接口建议开)
}));
第二步:关掉会怎样——三个事故现场
关 transform: @Param('id') id: number 实际是 "42"(字符串)→ findOne("42") 查询异常
DTO 的 get skip() 计算属性 undefined → 分页算出 NaN
关 whitelist: POST /users 带 {"isAdmin": true} → DTO 没这字段但 create(payload) 原样入库
→ 权限提升漏洞(mass-assignment)
关 forbid: 同上但多余字段被静默剥掉 —— 与 whitelist 二选一: 严格对外接口用 forbid
第三步:transform 的配套——@Type 与嵌套
// 文件: page.dto.ts
import { Type } from 'class-transformer';
import { IsInt, IsOptional, Max, Min } from 'class-validator';
export class PageDto {
@IsOptional() @Type(() => Number) @IsInt() @Min(1)
page?: number = 1; // query 的 "2" → 2
@IsOptional() @Type(() => Number) @IsInt() @Min(1) @Max(100)
size?: number = 20;
get skip() { return (this.page - 1) * this.size; } // 依赖 transform 后的数字
}
// 嵌套对象校验: @ValidateNested() 每个字段 + @Type(() => NestedDto)
总结:三选项一句话——transform 管类型对,whitelist 管多余字段删,forbid 管多余字段拒;mass-assignment 防线必须开。
追问1:transform 和 class-transformer 的关系? → ValidationPipe 内部用 plainToInstance(class-transformer)做实例化,@Type 指定嵌套类型
追问2:Nest 12 的 Standard Schema? → 新增 Zod 等 schema 校验的一等支持;class-validator 仍完全兼容,存量项目不必迁移
追问3:如何只对某些路由关闭 whitelist? → 不全局开,在特定路由 @UsePipes(new ValidationPipe({whitelist: true})) 局部开
233. JWT 双 token 认证在 Nest 的落地?
概念 Access Token(15min,随请求携带,无状态验证)+ Refresh Token(7d,仅刷新接口用,服务端存储可吊销)。签发在 AuthModule,校验由 APP_GUARD 的 JwtAuthGuard 全局执行,@Public 标记免认证路由。
典型场景 登录态管理、前端 401 自动续期、“登出后 token 还能用”的质疑。
解决方案 三步递进:签发与策略 → 全局 Guard 与 @Public → Refresh 轮换接口。
第一步:签发与 Passport 策略
// 文件: auth.service.ts
import { JwtService } from '@nestjs/jwt';
@Injectable()
export class AuthService {
constructor(private jwt: JwtService, private users: UsersService) {}
async issueTokens(user: User) {
const payload = { sub: user.id, username: user.username };
return {
access_token: await this.jwt.signAsync(payload, { expiresIn: '15m' }),
refresh_token: await this.jwt.signAsync(payload, { expiresIn: '7d' }),
// 生产: refresh 需存库(哈希)实现吊销, 并做轮换(每次刷新换新)
};
}
}
// 文件: jwt.strategy.ts
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
validate(payload: { sub: number }) {
return { userId: payload.sub }; // 返回值挂到 request.user
}
}
第二步:全局 Guard 与 @Public 豁免
// 文件: jwt-auth.guard.ts
import { Reflector } from '@nestjs/core';
@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
constructor(reflector: Reflector) { super(reflector); }
canActivate(ctx: ExecutionContext) {
const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
ctx.getHandler(), ctx.getClass(),
]);
if (isPublic) return true; // @Public() 装饰的路由跳过认证
return super.canActivate(ctx);
}
}
// main: APP_GUARD 全局注册 → 默认全需登录, @Public 显式豁免(白名单反转, 更安全)
第三步:Refresh 轮换接口
// 文件: auth.controller.ts
@Public()
@Post('auth/refresh')
async refresh(@Body() dto: RefreshDto) {
const payload = await this.jwt.verifyAsync(dto.refresh_token); // 验签
const user = await this.users.findById(payload.sub);
// 生产检查: refresh 是否在白名单库 + 是否已被使用(一次性)
return this.auth.issueTokens(user); // 新的 access + refresh(旧的作废 = 轮换)
}
总结:双 token = 短命无状态 access + 长命可吊销 refresh;全局 Guard + @Public 反转白名单;refresh 轮换+服务端校验是吊销能力的关键。
追问1:access 泄露了怎么办? → 等 15min 自然过期(短命的意义);refresh 单独存储(HttpOnly Cookie)+服务端吊销 追问2:前端无感刷新怎么处理并发 401? → 拦截器排队:第一个 401 触发刷新,其余请求挂起等新 token 后重放 追问3:refresh 轮换检测到旧 token 重放怎么办? → 判定泄露,吊销该用户全部 refresh 强制重新登录
234. RBAC 权限:Guard + 装饰器元数据?
概念 RBAC(Role-Based Access Control):用户→角色→权限三层。Nest 落地:@RequirePermissions('post:delete') 装饰器用 SetMetadata 写元数据,PermissionGuard 读取并对比用户权限集。
典型场景 按钮级/接口级权限控制;编辑只能改自己的帖子这类行级规则;前后端权限联动。
解决方案 三步递进:元数据装饰器 → Guard 校验 → 行级权限(RBAC+ABAC 混合)。
第一步:权限装饰器——把需求写进元数据
// 文件: permissions.decorator.ts
import { SetMetadata } from '@nestjs/common';
export const PERMISSION_KEY = 'permissions';
export const RequirePermissions = (...perms: string[]) => SetMetadata(PERMISSION_KEY, perms);
// 使用: @RequirePermissions('post:delete')
第二步:Guard 读取并校验
// 文件: permission.guard.ts
@Injectable()
export class PermissionGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(ctx: ExecutionContext): boolean {
const required = this.reflector.getAllAndOverride<string[]>(PERMISSION_KEY, [
ctx.getHandler(), ctx.getClass(),
]);
if (!required?.length) return true; // 没标权限要求 → 放行
const { user } = ctx.switchToHttp().getRequest();
const userPerms = user.permissions ?? []; // 登录时随 token 或查库得到
const ok = required.every((p) => userPerms.includes(p));
if (!ok) throw new ForbiddenException('无操作权限');
return true;
}
}
// 注册顺序: JwtAuthGuard 之后(JwtAuthGuard 先给 request.user 赋值)
第三步:行级权限——owner 或 admin 才能改
// 文件: posts.service.ts
async update(id: number, dto: UpdatePostDto, user: AuthUser) {
const post = await this.repo.findOneByOrFail({ id });
const isOwner = post.user_id === user.userId;
const isAdmin = user.permissions.includes('post:manage');
if (!isOwner && !isAdmin) throw new ForbiddenException('只能编辑自己的帖子');
return this.repo.update(id, dto);
}
// 接口级 RBAC 管能不能调这个接口; 行级规则在 service 里判这条数据归不归你
总结:RBAC 接口级用装饰器+Guard(声明式),数据级(行级)在 service 内校验;前端按钮显隐只是体验,后端才是安全边界。
追问1:权限表怎么设计? → users/roles/permissions + user_roles/role_permissions 两张关联表 追问2:权限集放 token 还是每次查库? → 权限变更不频繁放 JWT claims(快);需即时生效则查库或 Redis 追问3:装饰器元数据怎么合并类与方法? → getAllAndOverride:方法级覆盖类级(方法上标注优先)
235. TypeORM 事务与并发更新?
概念 多表写用事务保证原子性;并发更新靠乐观锁(version 字段)或悲观锁(SELECT ... FOR UPDATE);TypeORM 提供 transaction API 与 Pessimistic Lock。
典型场景 下单扣库存(超卖)、账户转账(部分成功)、两人同时编辑同一配置。
解决方案 三步递进:事务基础 → 乐观锁 → 悲观锁适用场景。
第一步:事务——多表写原子化
// 文件: order.service.ts
async createOrder(userId: number, skuId: number, qty: number) {
return this.dataSource.transaction(async (em) => { // em: 事务内专属管理器
const sku = await em.findOneByOrFail(Sku, { id: skuId });
if (sku.stock < qty) throw new BadRequestException('库存不足');
await em.decrement(Sku, { id: skuId }, { stock: qty }); // 扣库存
const order = await em.save(Order, { user_id: userId, sku_id: skuId, qty });
await em.save(OrderLog, { order_id: order.id, action: 'create' });
return order; // 任一步抛异常 → 全部回滚
});
}
第二步:乐观锁——version 字段防覆盖
// 文件: config.entity.ts
@VersionColumn()
version: number; // 每次更新自动 +1; where 条件带 version, 不匹配即更新 0 行
// 更新: repo.update(id, dto) 影响行数为 0 → 抛 ConflictException(已被他人修改, 请刷新)
第三步:悲观锁——热点行用 SELECT FOR UPDATE
// 文件: stock.service.ts
async deductStock(skuId: number, qty: number) {
return this.dataSource.transaction(async (em) => {
// 高并发秒杀场景: 直接锁行, 事务提交前其他事务阻塞等待
const sku = await em.findOne(Sku, {
where: { id: skuId },
lock: { mode: 'pessimistic_write' }, // SELECT ... FOR UPDATE
});
if (sku.stock < qty) throw new BadRequestException('库存不足');
sku.stock -= qty;
await em.save(sku);
return sku;
});
}
总结:多表写必须事务(transaction 回调);并发覆盖用乐观锁(version,低冲突场景);热点行用悲观锁(FOR UPDATE,秒杀场景)。
追问1:乐观锁和悲观锁怎么选? → 冲突率低(读多写少)乐观锁无锁开销;热点行(秒杀)悲观锁把冲突排队到数据库层 追问2:事务里能调外部 API 吗? → 不该——API 成功但后续 DB 回滚就不一致;用本地消息表+最终一致,或事务提交后再调 追问3:transaction 回调里的 em 和普通 repo 区别? → em 绑定当前事务连接;普通 repo 走池中任意连接,不在事务内
236. Nest 中间件与 AsyncLocalStorage:请求上下文传递?
概念 AsyncLocalStorage(ALS)在异步链路中隐式携带请求级数据(traceId、当前用户),任意层 als.getStore() 取出——替代层层传参和 REQUEST 作用域。
典型场景 日志要带 traceId 串联全链、service 层需要当前操作人但不想改签名、多租户隔离。
解决方案 三步递进:ALS 中间件 → 日志自动带 traceId → service 里取当前用户。
第一步:ALS 中间件——入口设置
// 文件: als.middleware.ts
import { AsyncLocalStorage } from 'node:async_hooks';
import { Injectable, NestMiddleware } from '@nestjs/common';
export const als = new AsyncLocalStorage<{ traceId: string; userId?: number }>();
@Injectable()
export class ContextMiddleware implements NestMiddleware {
use(req: Request, res: Response, next: NextFunction) {
const traceId = (req.headers['x-request-id'] as string) || crypto.randomUUID();
als.run({ traceId, userId: undefined }, () => next());
// next() 之后的整条异步链都在这个 store 作用域内
}
}
第二步:日志自动带 traceId
// 文件: app-logger.ts
export class AppLogger {
private base = logging.getLogger('app'); // 项目内 logging 封装
info(msg: string, extra?: object) {
const store = als.getStore();
this.base.info(msg, { traceId: store?.traceId, ...extra });
}
}
// 全局任意 service 调 logger.info() 都自动带本请求的 traceId —— 无需层层传递
第三步:service 取当前用户
// 文件: any.service.ts
@Injectable()
export class AuditService {
log(action: string) {
const { userId } = als.getStore() ?? {};
return this.repo.save({ action, operator_id: userId }); // 不改任何方法签名
}
}
总结:ALS 是异步链路的隐式背包;入口 middleware.run 设置,任意深度 getStore 读取;比 REQUEST 作用域(整链升级实例化)性能好。
追问1:ALS 和 thread-local 区别? → ALS 基于 AsyncResource,协程切换(async/await)后 store 依然正确跟随 追问2:队列任务(MQ 消费)里能用吗? → 消费入口同样 als.run 包一层,把消息头里的 traceId 延续到消费链路 追问3:ALS 会内存泄漏吗? → run() 作用域结束后 store 即可回收;只要不在全局存 store 引用就安全
237. Nest 微服务:传输器选型与消息模式?
概念 Nest 微服务通过传输器(Transport)通信:TCP(点对点)、Redis Pub/Sub(广播)、RabbitMQ(可靠队列)、Kafka(日志流)、gRPC(强类型 RPC)。消息模式:emit(事件广播)与 send(RPC 等待响应)。
典型场景 订单服务要通知库存/积分服务;解耦下单成功后的后续动作;跨服务调用不想走 HTTP。
解决方案 三步递进:RabbitMQ 事件发布 → 消费端订阅 → 可靠性三件套(持久化/确认/预取)。
第一步:发布端——下单成功发事件
// 文件: order.controller.ts
@Controller('orders')
export class OrderController {
constructor(@Inject('ORDER_EVENT') private client: ClientProxy) {}
@Post()
async create(@Body() dto: CreateOrderDto) {
const order = await this.orderService.create(dto);
// emit: fire-and-forget 事件; 下游失败不影响下单响应
this.client.emit('order.created', { orderId: order.id, userId: dto.userId });
return order;
}
}
// main.ts: app.connectMicroservice<RmqOptions>({ transport: Transport.RMQ,
// options: { urls: [AMQP_URL], queue: 'order_events' } })
第二步:消费端——@EventPattern 订阅
// 文件: points.controller.ts
@Controller()
export class PointsController {
@EventPattern('order.created') // 订阅事件
async onOrderCreated(data: { orderId: number; userId: number }) {
await this.pointsService.award(data.userId, 100); // 加积分
}
}
第三步:可靠性——RabbitMQ 三件套配置
// 文件: main.ts(消费端)
app.connectMicroservice<RmqOptions>({
transport: Transport.RMQ,
options: {
urls: [config.amqpUrl],
queue: 'points_queue',
queueOptions: { durable: true }, // 队列持久化: broker 重启不丢
noAck: false, // 手动 ack: 处理成功才确认
prefetchCount: 10, // 每消费者预取上限, 防压垮
},
}, { inheritAppConfig: true });
// 消费抛异常 → 消息重回队列重试; 多次失败进死信队列(dlx)人工处理
总结:传输器选型=可靠性要求(RabbitMQ)+吞吐(Kafka)+内部 RPC(gRPC);emit 是事件广播,@EventPattern 订阅;durable+手动 ack+死信队列是可靠性底线。
追问1:emit 和 send 区别? → emit fire-and-forget(事件);send 期待响应(RPC,返回 Observable) 追问2:消息重复消费怎么办? → 消费端幂等:按 message id 或业务唯一键去重(见第一批 72) 追问3:Kafka 和 RabbitMQ 怎么选? → 队列语义+复杂路由+死信选 RabbitMQ;高吞吐日志流+分区回放选 Kafka
238. Nest 定时任务与分布式锁?
概念 @nestjs/schedule 提供 @Cron/@Interval/@Timeout 装饰器;多实例部署时任务会重复执行——需要分布式锁(Redis SETNX)或单实例调度。
典型场景 每日对账任务在 4 台机器各跑一遍;每分钟轮询任务的重复副作用。
解决方案 三步递进:注册调度器 → Cron 任务 → Redis 锁防重复。
第一步:注册与基础任务
// 文件: tasks.module.ts
@Module({
imports: [ScheduleModule.forRoot()],
providers: [ReportTask],
})
export class TasksModule {}
// 文件: report.task.ts
@Injectable()
export class ReportTask {
@Cron('0 3 * * *', { timeZone: 'Asia/Shanghai' }) // 每天凌晨 3 点(明确时区!)
async dailyReport() { /* ... */ }
}
第二步:Redis 分布式锁——多实例只跑一份
// 文件: report.task.ts(加锁版)
@Injectable()
export class ReportTask {
constructor(private redis: Redis) {}
@Cron('0 3 * * *', { timeZone: 'Asia/Shanghai' })
async dailyReport() {
const lockKey = 'lock:daily-report';
const acquired = await this.redis.set(lockKey, '1', 'EX', 600, 'NX'); // 10min 自动过期
if (!acquired) return; // 别的实例已拿到锁 → 本实例跳过
try {
await this.generateReport();
} finally {
await this.redis.del(lockKey); // 用完释放
}
}
}
第三步:锁的边界——任务超时怎么办
锁过期时间 600s < 任务实际耗时 700s → 第二台机器在锁过期后重复进入
解法:
1. 锁过期时间 > 任务最坏耗时(简单直接)
2. 看门狗续期: 后台定时把锁 TTL 重置(Redisson 思想)
3. 任务幂等: 即便重复执行结果一致(对账类天然幂等) —— 最稳的兜底
总结:@Cron 多实例必重复——Redis SETNX 锁 + 过期时间 + finally 释放;真正稳妥靠任务幂等。
追问1:锁释放失败(进程崩溃)怎么办? → 过期时间兜底自动释放;这就是必须设 EX 的原因 追问2:动态定时(cron 表达式存库)怎么做? → 运行时管理 job 引用,提供增删改查 API 包装 ScheduleModule 追问3:不用锁的替代方案? → K8s CronJob 只调一个实例;或任务中心统一调度推送
239. Nest 优雅停机与 shutdown hooks?
概念 K8s 发 SIGTERM → Nest app.enableShutdownHooks() 触发 beforeApplicationShutdown/applicationShutdown 钩子:停接新请求、等在途请求、关闭连接池/MQ 连接。
典型场景 发版时在途请求被掐断;MQ 消费到一半进程死掉;连接池未释放导致数据库报错。
解决方案 三步递进:启用钩子 → 服务实现清理 → K8s 宽限期配合。
第一步:启用与实现钩子
// 文件: main.ts
app.enableShutdownHooks(); // Nest 默认不监听信号, 必须显式开启
// 文件: amqp.service.ts
@Injectable()
export class AmqpService implements OnApplicationShutdown {
private channel: Channel;
async onApplicationShutdown(signal?: string) {
await this.channel.close(); // 收到 SIGTERM: 停止消费、关闭 MQ 连接
// 在途消息: noAck=false 模式下未 ack 的消息重回队列, 下次启动继续
}
}
第二步:停机流程——HTTP 服务器与钩子的顺序
Nest(Express) 停机流程:
1. SIGTERM → 不再接受新连接
2. 现有连接处理完当前请求
3. beforeApplicationShutdown → 自定义清理(MQ/定时器/后台任务)
4. applicationShutdown → 最后兜底(连接池 dispose)
K8s: terminationGracePeriodSeconds=30 必须大于清理总耗时, 超时 SIGKILL 强杀
第三步:验证方法——压测中滚动发版
# 文件: verify-rolling.sh
# 1. 压测挂上 wrk 保持流量
wrk -t4 -c100 -d300s http://localhost:3000/api/posts
# 2. 触发滚动更新
kubectl rollout restart deployment/ai-app
# 3. 观察: wrk 的 Non-2xx 与错误率应无尖刺; 日志确认每实例打印完整关闭流程
总结:enableShutdownHooks → 各服务实现 OnApplicationShutdown → 清理顺序”停接新→等在途→关资源”;K8s 宽限期是硬约束。
追问1:onModuleDestroy 和 onApplicationShutdown 区别? → 前者由测试或模块销毁触发;后者由信号触发且按依赖逆序执行 追问2:后台 cron 任务停机时怎么办? → 锁机制天然安全(下个周期别的实例会跑);长任务记录 checkpoint 断点续跑 追问3:SIGKILL 前还能做什么? → 什么都做不了——这就是为什么收尾逻辑必须在宽限期内完成,不要赌
240. Nest 的 OpenAPI(Swagger)与接口契约?
概念 @nestjs/swagger 从装饰器生成 OpenAPI JSON:DTO 的 class-validator 注解自动成为参数说明,响应结构用 @ApiResponse 声明。文档即契约,前端可用 openapi-typescript 生成 TS 类型。
典型场景 前后端联调扯皮字段类型;接口变更前端不知道;希望接口变更在前端编译期暴露。
解决方案 三步递进:开启 Swagger → DTO 注解增强 → 导出 JSON 喂给前端生成类型。
第一步:开启与分组
// 文件: main.ts
const config = new DocumentBuilder()
.setTitle('AI Platform API')
.setVersion('1.0')
.addBearerAuth() // 支持在文档里调试带 token
.build();
const document = SwaggerModule.createDocument(config, app);
SwaggerModule.setup('docs', app, document);
// 访问 /docs(Swagger UI)与 /docs-json(OpenAPI JSON)
第二步:DTO 注解——校验即文档
// 文件: chat.dto.ts
export class ChatDto {
@ApiProperty({ description: '用户问题', maxLength: 2000, example: '什么是球状闪电' })
@IsString() @IsNotEmpty() @MaxLength(2000)
prompt: string;
@ApiPropertyOptional({ description: '温度', minimum: 0, maximum: 2, default: 0.7 })
@IsOptional() @Type(() => Number) @IsNumber()
temperature?: number;
@ApiProperty({ enum: ['keyword', 'vector', 'hybrid'], default: 'hybrid' })
@IsIn(['keyword', 'vector', 'hybrid'])
mode: string;
}
// IsXxx 校验装饰器会被 swagger 读取 → 文档自动带必填/长度/枚举
第三步:导出 JSON 生成前端类型
# 文件: gen-types.sh
curl -s localhost:3000/docs-json > openapi.json
npx openapi-typescript openapi.json -o src/api/schema.d.ts
# 前端: import { paths } from './schema.d.ts' —— 接口路径/参数/响应全部类型安全
# CI 里跑, 接口一变前端类型就报错 —— 契约测试的廉价实现
总结:Swagger 从 DTO 注解自动生成;docs-json + openapi-typescript 让接口变更在前端编译期暴露——契约自动化。
追问1:响应结构怎么声明? → 响应也建 DTO + @ApiResponse({type: XxxOutDto});不声明则文档只有 200 空壳
追问2:内部接口不想出现在文档? → 用 @ApiExcludeEndpoint 或不挂入文档模块
追问3:版本化怎么做? → URI 版本 app.setGlobalPrefix('api/v1') + Nest 内置 VersioningType.URI,文档按版本分组
241. Nest 配置管理:ConfigModule 与环境分层?
概念 @nestjs/config 读环境变量并做 schema 校验(Joi);ConfigService 点路径取值;isGlobal: true 免模块重复 import。配置校验 fail-fast:缺配置启动即崩。
典型场景 生产缺 DB_PASSWORD 半夜报错;多模块重复 import ConfigModule;配置名拼错静默 undefined。
解决方案 三步递进:注册与校验 schema → 结构化配置工厂 → 按功能域拆配置类。
第一步:注册与校验——缺配置启动即崩
// 文件: app.module.ts
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true, // 全局可用, 其他模块无需再 import
envFilePath: process.env.NODE_ENV === 'test' ? '.env.test' : '.env',
validationSchema: Joi.object({
DB_URL: Joi.string().required(),
GLM_API_KEY: Joi.string().required(),
GLM_MODEL_ID: Joi.string().default('glm-4-flash'),
NODE_ENV: Joi.string().valid('development', 'production', 'test').required(),
}),
validationOptions: { abortEarly: false }, // 一次报出所有缺失项
}),
],
})
第二步:结构化配置工厂
// 文件: config/configuration.ts
export default () => ({
db: { url: process.env.DB_URL },
jwt: { secret: process.env.JWT_SECRET, expires: '15m' },
glm: { baseUrl: process.env.GLM_BASE_URL, apiKey: process.env.GLM_API_KEY },
});
// 使用:
constructor(private config: ConfigService) {}
this.config.get<string>('glm.apiKey'); // 点路径; 泛型标注返回类型
第三步:按域拆依赖——不要到处 get 字符串
// 文件: config/glm.config.ts
@Injectable()
export class GlmConfig {
constructor(private config: ConfigService) {}
get baseUrl() { return this.config.getOrThrow<string>('glm.baseUrl'); }
get apiKey() { return this.config.getOrThrow<string>('glm.apiKey'); }
}
// getOrThrow: 取不到直接抛(而不是静默 undefined 传到深处)
// 消费方注入 GlmConfig, IDE 自动补全属性名 —— 拼错编译期就暴露
总结:ConfigModule 全局 + Joi schema 启动校验(fail-fast);按域拆 Config 类用 getOrThrow,消灭静默 undefined。
追问1:.env 提交 git 吗? → 不提交;提交 .env.example 列变量名当文档;生产由 K8s Secret 注入 追问2:配置热更新? → ConfigService 有内部缓存,热更需自定义 reload 逻辑或上配置中心 追问3:测试环境怎么注入配置? → Test.createTestingModule 的 ConfigModule.forRoot({isGlobal:true, load:[testConfig]}) 覆盖
242. Nest 的管道:转换 Pipe 与校验 Pipe 分工?
概念 Pipe 在 Guard 之后、Handler 之前执行,两类职责:转换(ParseIntPipe 把 “42”→42)与校验(ValidationPipe 按 DTO 验证)。可全局、控制器、方法、参数四级注册,管道可注入依赖。
典型场景 路径参数 id 是字符串、单个查询参数也要校验(不想为它建 DTO)、自定义格式复用(如手机号)。
解决方案 三步递进:内置转换管道 → 参数级校验管道 → 自定义解析管道。
第一步:内置转换管道——参数级挂载
// 文件: posts.controller.ts
@Get(':id')
async detail(@Param('id', ParseIntPipe) id: number) {} // "abc" → 400; "42" → 42(number)
@Get()
async list(@Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number) {}
// DefaultValuePipe 前置: 不传给默认值, 再转数字
第二步:参数级校验管道——单参数也要严
// 文件: query.pipe.ts
export class PhonePipe implements PipeTransform<string, string> {
transform(value: string) {
if (!/^1[3-9]\d{9}$/.test(value)) throw new BadRequestException('手机号格式错误');
return value;
}
}
// 使用: @Query('phone', PhonePipe) phone: string —— 不用为单个字段建整个 DTO
第三步:自定义管道做解析——slug → 实体
// 文件: post-by-slug.pipe.ts
@Injectable()
export class PostBySlugPipe implements PipeTransform<string, Promise<Post>> {
constructor(private repo: Repository<Post>) {} // 管道可以注入依赖!
async transform(slug: string) {
const post = await this.repo.findOneBy({ slug });
if (!post) throw new NotFoundException(`文章不存在: ${slug}`);
return post; // handler 直接拿到 Post 实体
}
}
// 使用: @Get(':slug') detail(@Param('slug', PostBySlugPipe) post: Post) —— 查询逻辑从 handler 消失
总结:Pipe 两职责——转换(ParseInt/DefaultValue)与校验(ValidationPipe/自定义);四级注册粒度按需选;管道可注入依赖做查库解析。
追问1:管道和拦截器都在业务前执行,区别? → Pipe 只处理参数(进 handler 前),拦截器处理整个调用链(含响应) 追问2:多个管道的执行顺序? → 按注册顺序链式执行,前一个输出是后一个输入 追问3:ValidationPipe 全局与参数级能共存吗? → 能,各自独立作用;全局管 body DTO,参数级管单个 query/param
243. Nest 与 Prisma:类型安全的数据库访问?
概念 Prisma 以 schema.prisma 为唯一事实源:generate 生成类型化客户端;迁移由 prisma migrate 管理;查询 API 全程类型推导(字段拼错编译期报错)。
典型场景 厌烦 TypeORM 的运行时才暴露的拼写错误;复杂关联查询想有完整类型;新项目从零建库。
解决方案 三步递进:schema 与生成 → Nest 集成与类型化查询 → 交互式事务。
第一步:schema——唯一事实源
// 文件: prisma/schema.prisma
model User {
id Int @id @default(autoincrement())
name String
posts Post[]
}
model Post {
id Int @id @default(autoincrement())
title String
author User @relation(fields: [authorId], references: [id])
authorId Int
@@index([authorId])
}
第二步:类型化查询——拼错字段编译期报错
// 文件: prisma.service.ts
@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
async onModuleInit() { await this.$connect(); } // 模块初始化时连接
}
// 使用:
const posts = await this.prisma.post.findMany({
where: { authorId: user.id },
include: { author: { select: { name: true } } }, // 关联预加载, 全程类型推导
orderBy: { id: 'desc' },
take: 20,
});
// posts[0].author.name 有完整类型; 把 title 写成 titles → 编译报错(TypeORM 此处运行时才炸)
第三步:交互式事务
await this.prisma.$transaction(async (tx) => {
await tx.post.update({ where: { id: 1 }, data: { published: true } });
await tx.user.update({ where: { id: user.id }, data: { postCount: { increment: 1 } } });
// tx 内所有操作同库同事务; 任一抛异常自动回滚
});
总结:Prisma 三件套 schema(唯一事实源)/generate(类型客户端)/migrate(迁移);include 防 N+1;$transaction 支持交互式事务。
追问1:Prisma 和 TypeORM 怎么选? → 新项目+类型安全优先选 Prisma;存量 TypeORM/复杂 QueryBuilder/多数据源留 TypeORM(可共存) 追问2:Prisma 的 N+1 问题? → include 预加载;无 include 的关联访问在异步下直接报错,变相强制预加载 追问3:迁移和 synchronize 的区别? → synchronize:true 直接改表(生产禁用);Prisma migrate 生成迁移文件可审查可回滚
244. Nest 的健康检查与 readiness/liveness?
概念 @nestjs/terminus 提供健康检查端点:liveness(进程活着)+ readiness(依赖就绪:DB/Redis 可达)。K8s 按端点决定重启容器或摘流量。
典型场景 滚动更新时流量打到还没连上数据库的实例;数据库挂了实例还在收请求全 500。
解决方案 两步递进:健康检查控制器 → K8s 探针配置。
第一步:健康检查控制器
// 文件: health.controller.ts
@Controller('health')
export class HealthController {
constructor(
private health: HealthCheckService,
private db: TypeOrmHealthIndicator,
private redis: RedisHealthIndicator,
) {}
@Get('live')
@HealthCheck()
live() { return this.health.check([]); } // liveness: 进程活着即可, 不查依赖
@Get('ready')
@HealthCheck()
ready() {
return this.health.check([
() => this.db.pingCheck('database'), // DB 执行简单查询
() => this.redis.check('redis'),
]);
}
}
第二步:K8s 探针——两个探针的分工
# 文件: deployment.yaml
livenessProbe:
httpGet: { path: /health/live, port: 3000 }
failureThreshold: 3 # 连续 3 次失败 → 重启容器(DB 挂了不该重启, 所以 live 不查 DB)
readinessProbe:
httpGet: { path: /health/ready, port: 3000 }
periodSeconds: 10 # DB 挂 → ready 失败 → 摘流量(不重启), 恢复后自动加回
总结:liveness 查进程、readiness 查依赖;DB 故障时正确表现是摘流量而非重启雪崩——两者必须分开。
追问1:readiness 里查上游 LLM 可达吗? → 不建议——上游抖动会把整个服务摘光;上游健康放业务层熔断降级 追问2:探针的超时怎么设? → timeoutSeconds 略小于 periodSeconds;DB ping 一般小于 1s 追问3:启动顺序怎么保证 ready 才接流量? → K8s 初始 delay + readiness 天然完成;Nest 侧把重活放 onModuleInit 完成后再 listen
245. Nest 的 rate limiter 与接口限流?
概念 @nestjs/throttler 基于 guard 实现限流:@Throttle 装饰器按路由设窗口与次数;默认内存存储,分布式用 Redis 存储(自定义 ThrottlerStorage)。
典型场景 公开接口被刷;LLM 代理接口防止 token 消耗失控;登录接口防爆破。
解决方案 三步递进:全局与局部配置 → 分布式存储 → 按 Key 维度限流。
第一步:全局与局部配置
// 文件: app.module.ts
ThrottlerModule.forRoot([
{ name: 'short', ttl: 1000, limit: 5 }, // 1s 5 次
{ name: 'long', ttl: 60000, limit: 100 }, // 1min 100 次(双层: 突发+总量)
])
// 文件: chat.controller.ts
@Throttle({ long: { ttl: 60000, limit: 20 } }) // LLM 接口单独收紧: 1min 20 次
@Post('chat')
async chat() {}
// 免限流: @SkipThrottle()
第二步:分布式存储——多实例共享计数
// 文件: custom-throttler-storage.ts
@Injectable()
export class RedisThrottlerStorage extends ThrottlerStorageRedisService {
constructor(@Inject(REDIS) client) { super(client); } // 计数挪到 Redis, 多实例一致
}
// forRoot({ storage: new RedisThrottlerStorage(...) })
第三步:按维度限流——不是按 IP 而是按用户
// 文件: user-throttler.guard.ts
@Injectable()
export class UserThrottlerGuard extends ThrottlerGuard {
protected async getTracker(req: Request): Promise<string> {
return req.user?.id ? `user:${req.user.id}` : req.ip; // 登录用户按 ID, 匿名按 IP
}
}
// APP_GUARD 注册 UserThrottlerGuard 替换默认 Guard
总结:双层限流(秒级突发+分钟级总量);分布式部署必须 Redis 存储;限流维度按登录身份优于 IP(NAT 后多用户共享 IP)。
追问1:429 响应带什么头? → Retry-After(建议等待秒数)、X-RateLimit-Limit/Remaining(剩余配额),前端据此提示 追问2:LLM 接口按请求数限流合理吗? → 不够——一次请求可能几十万 token;应叠加 token 配额(用量预算,见网关计费) 追问3:限流和熔断区别? → 限流防请求过多(保护自己);熔断防下游故障(保护系统不被拖垮),如断路器模式
246. Nest 的 GraphQL 模块与 N+1?
概念 @nestjs/graphql(Apollo 驱动)以 code-first(SDL 由装饰器生成)提供 GraphQL;resolver 处理查询;关联字段默认逐条解析会产生 N+1,用 DataLoader 批量合并。
典型场景 分析看板要一次取帖子+作者+评论数的聚合结构;前端字段需求多变不想改后端接口。
解决方案 三步递进:code-first 定义 → resolver 与关联字段 → DataLoader 解 N+1。
第一步:code-first 类型与查询
// 文件: post.object.ts
@ObjectType()
export class PostType {
@Field(() => Int) id: number;
@Field() title: string;
@Field(() => AuthorType) author: AuthorType; // 关联字段
}
// 文件: post.resolver.ts
@Resolver(() => PostType)
export class PostResolver {
@Query(() => [PostType])
async posts(@Args('page', { defaultValue: 1, type: () => Int }) page: number) {
return this.service.list(page);
}
// 关联字段: 每个帖子单独触发一次 author 解析 → N 帖子 N 次查库(N+1!)
@ResolveField(() => AuthorType)
async author(@Parent() post: Post) {
return this.authorService.findById(post.authorId);
}
}
第二步:DataLoader——同帧请求合并成 IN 查询
// 文件: author-loader.ts
// 每次 HTTP 请求新建一个 loader(上下文级): 收集一帧内的所有 authorId, 一次 IN 查询
const loader = new DataLoader(async (authorIds: number[]) => {
const authors = await this.authorRepo.find({ where: { id: In(authorIds) } });
return authorIds.map((id) => authors.find((a) => a.id === id)); // 必须按入参顺序返回
});
// ResolveField 里: return loader.load(post.authorId) —— N 次 load 合并为 1 次 IN
总结:GraphQL 解决前端按需取字段;N+1 是它的经典坑——DataLoader 按单请求帧批量+缓存根治;loader 必须请求级新建(防跨请求缓存污染)。
追问1:GraphQL 的缓存为什么难? → 无 URL 寻址,同查询不同参数难用 HTTP 缓存;需持久化查询(APQ)或响应级缓存 追问2:什么时候不该用 GraphQL? → 简单 CRUD/强缓存需求/团队无 GraphQL 经验——REST + OpenAPI 更简单 追问3:权限怎么做? → 授权装饰器 + 全局 guard 读字段级元数据;字段级权限是 GraphQL 特有考量
247. Nest 的 SSE 网关:转发 LLM 流并处理断连?
概念 Nest 做 LLM 网关:用 axios(responseType: stream)接上游 SSE,把内容经 @Sse() 端点推给前端;断连时要中止上游调用。
典型场景 前端打字机效果;多用户共用模型 Key 需网关统一计费限流(见 245)。
解决方案 两步递进:@Sse 端点 → 上游转发与断连中止。
第一步:@Sse 端点——Observable 消息流
// 文件: chat.controller.ts
@Sse('chat/stream')
async chatStream(@Body() dto: ChatDto, @Req() req: Request): Promise<Observable<MessageEvent>> {
return new Observable((observer) => {
const ctrl = new AbortController();
// 调上游(流式)
axios.post(UPSTREAM_URL, { prompt: dto.prompt, stream: true },
{ responseType: 'stream', signal: ctrl.signal, headers: authHeaders() })
.then((res) => {
res.data.on('data', (buf: Buffer) => {
for (const line of buf.toString().split('\n\n')) {
if (line.startsWith('data: ')) {
observer.next({ data: JSON.parse(line.slice(6)) }); // 包装成 MessageEvent
}
}
});
res.data.on('end', () => { observer.next({ data: '[DONE]' }); observer.complete(); });
})
.catch((e) => observer.error(e));
// 断连: 客户端关闭 → 中止上游(省 token!)
req.on('close', () => ctrl.abort());
return () => ctrl.abort(); // Observable 取消时的兜底
});
}
// 前端 EventSource('/chat/stream') 或 fetch 流读取
第二步:三个生产细节
1. 计费: 上游流最后一个 chunk 带 usage → 在 end 事件里读出并异步落库
2. 超时: ctrl.signal 配 setTimeout, 上游无首字节超时中止(防挂死连接占资源)
3. 背压: 前端消费慢时 observer.next 会堆积 —— Node stream 天然有 backpressure,
且 Compression 中间件需关闭对 SSE 路由的压缩(否则流被攒成一坨)
总结:@Sse 返回 Observable;断连中止上游是省钱关键(双重保险 req.close + observer 取消);压缩中间件必须绕过 SSE 路由。
追问1:nginx 代理 SSE 注意什么? → proxy_buffering off(或响应头 X-Accel-Buffering: no)、proxy_read_timeout 加长
追问2:SSE 心跳要不要? → 中间代理可能掐空闲连接,每 15-30s 发一条 : ping 注释行保活
追问3:多实例下 SSE 会话粘性? → SSE 是单请求内行为无状态,不需要粘性;若做断线续传才需要会话亲和
248. Nest 测试体系:单测、E2E 与契约?
概念 单测(Service 层,依赖全 mock,毫秒级)+ E2E(起完整 app,接测试库)+ 契约测试(OpenAPI 生成前端类型,接口变更编译期暴露)。
典型场景 改一处坏三处(无回归测试);CI 需要快速反馈(全跑 E2E 太慢);前后端接口契约漂移。
解决方案 三步递进:Service 单测 → E2E 测试 → 测试金字塔的分配。
第一步:Service 单测——mock 依赖测业务分支
// 文件: posts.service.spec.ts
it('无权限用户删除抛 Forbidden', async () => {
const repo = { findOneByOrFail: jest.fn().mockResolvedValue({ id: 1, user_id: 2 }) };
const svc = new PostsService(repo as any);
expect(() => svc.remove(1, { userId: 3, permissions: [] }))
.toThrow(ForbiddenException); // 只测业务分支, 不碰数据库, 毫秒级
});
第二步:E2E——起完整 app 测契约
// 文件: test/posts.e2e-spec.ts
let app: INestApplication;
beforeAll(async () => {
const module = await Test.createTestingModule({ imports: [AppModule] })
.overrideProvider(getRepositoryToken(Post)) // 换测试库或内存实现
.useValue(testRepo)
.compile();
app = module.createNestApplication();
app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true })); // 与生产一致的管道!
await app.init();
});
it('POST /posts 校验失败返回 400', () =>
request(app.getHttpServer()).post('/posts').send({ title: '' }).expect(400));
// 注意: E2E 必须复刻生产配置(管道/guard), 否则测的是另一个应用
第三步:金字塔分配——快测试多写,慢测试精选
单元测试(70%): service 业务分支, 全 mock, 10s 内全跑完, 每次 push 跑
E2E(20%): 关键链路(登录→发帖→删除), 精选 20 条, CI 每次跑
契约(10%): OpenAPI → TS 类型, 编译期暴露漂移
反模式: 只写 E2E —— 慢、脆、失败难定位
总结:单测测分支(mock 快),E2E 测链路(带真实管道),契约测漂移(类型生成);E2E 必须复刻生产管道配置。
追问1:jest 的 mock 怎么恢复? → jest.restoreAllMocks() 在 afterEach,防止用例间污染
追问2:E2E 测试数据怎么隔离? → 事务回滚(每用例包事务)、随机前缀数据、或每套独立 schema
追问3:覆盖率目标定多少? → service 层 80% 以上;一刀切全仓 80% 会逼人写无意义测试凑数
249. Nest 的优雅退出:K8s 滚动更新实践?
概念 滚动更新零感知三要素:readiness 探针摘流量、preStop/SIGTERM 给在途请求收尾时间、资源清理钩子完整。Nest 侧 enableShutdownHooks + 各服务 OnApplicationShutdown。
典型场景 发版瞬间线上报错尖刺;SSE 长连接被掐断;MQ 消息未 ack 丢失。
解决方案 三步递进:K8s 配置 → Nest 侧钩子 → 验证手段。
第一步:K8s 配置——三个参数
# 文件: deployment.yaml
strategy:
rollingUpdate: { maxSurge: 1, maxUnavailable: 0 } # 先起新实例再停旧的, 容量不减
terminationGracePeriodSeconds: 30 # SIGTERM 宽限期
preStop:
exec: { command: ["sleep", "5"] } # 等 LB 摘流量(与 readiness 联动)
第二步:Nest 侧——信号 → 钩子链
// 文件: main.ts
app.enableShutdownHooks();
// 各服务:
@Injectable()
export class PrismaService implements OnModuleInit, OnApplicationShutdown {
async onModuleInit() { await this.$connect(); }
async onApplicationShutdown() { await this.$disconnect(); } // SIGTERM → 此处执行
}
// SSE: 转发任务在 shutdown 钩子里 abort 上游 + 通知前端带 reason 重连
第三步:验证——错误率曲线不尖刺才算过
压测工具保持流量 + kubectl rollout restart → 观察:
1. 5xx/超时错误率无尖刺(在途请求完成)
2. 新实例 readiness 通过后旧实例才被杀(maxUnavailable=0 保证)
3. 日志: 每个旧实例有完整 shutdown 日志链
不达标 → 检查宽限期是否够、preStop 是否生效、探针参数
总结:零感知发版 = maxUnavailable:0 + 宽限期足够 + preStop 错峰 + 完整 shutdown 钩子;验证靠压测中滚动的错误率曲线。
追问1:宽限期内没处理完的请求怎么办? → SIGKILL 强杀,请求失败——所以收尾逻辑要限时,兜底是前端重试 追问2:SSE 长连接的优雅退出? → 发 shutdown 事件通知前端带 sessionId 重连(断线续传协议),或接受断开由前端自动重连 追问3:多实例并发更新顺序? → maxSurge/maxUnavailable 控制节奏;部署顺序与 DB 迁移兼容性(新旧版本共存)必须提前设计
三、NestJS 进阶(250–263)
250. 全局异常过滤器与统一错误码体系?
概念 ExceptionFilter 是 Nest 错误处理的最后一环(@Catch() 捕获一切);统一错误响应体 {code, message, requestId, details};错误分两类:业务错误(可预期,错误码枚举,4xx,不打错误栈)与系统错误(不可预期,5xx,完整栈只进日志与告警)。RFC 7807(problem+json)是对外开放 API 的标准化选项。错误码分段是团队协作契约。
典型场景 前端拿到的错误格式五花八门(有的抛文本有的抛对象);系统异常把堆栈泄给客户端(安全风险);排障时无法从错误码定位到模块。
解决方案 三步:业务异常类与错误码枚举 → 全局过滤器分类处理 → 契约化与前端联动。
第一步:业务异常与错误码枚举
// 文件: biz.error.ts
import { HttpException, HttpStatus } from '@nestjs/common';
// 错误码分段: 前两位 = 模块(10 用户/20 订单/30 支付), 后两位 = 具体错误
export const ErrorCode = {
USER_NOT_FOUND: { code: 10001, message: '用户不存在' },
ORDER_ALREADY_PAID: { code: 20010, message: '订单已支付,请勿重复操作' },
PAYMENT_CHANNEL_DOWN: { code: 30005, message: '支付通道暂不可用' },
} as const;
export class BizException extends HttpException {
constructor(
entry: { code: number; message: string },
public readonly details?: unknown,
status = HttpStatus.BAD_REQUEST,
) {
super({ code: entry.code, message: entry.message, details }, status);
}
}
// 业务代码里: throw new BizException(ErrorCode.ORDER_ALREADY_PAID, { orderId })
第二步:全局过滤器——两类错误两种待遇
// 文件: all-exceptions.filter.ts
import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus, Logger } from '@nestjs/common';
import type { Response } from 'express';
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
private readonly logger = new Logger('Exception');
catch(exception: unknown, host: ArgumentsHost) {
const ctx = host.switchToHttp();
const res = ctx.getResponse<Response>();
const requestId = ctx.getRequest().id; // 请求中间件注入的排障凭证(236 题)
if (exception instanceof HttpException) {
const status = exception.getStatus();
const body = exception.getResponse(); // 业务异常: 结构化内容直接透出
if (status >= 500) this.logger.error(exception); // 5xx 记完整栈 + 告警
return res.status(status).json({ ...wrap(body), requestId });
}
// 未知异常: 统一 500, 不泄内部细节(堆栈只进日志/Sentry)
this.logger.error(exception);
return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
code: 50000, message: '服务开小差了,请稍后重试', requestId,
});
}
}
// 注册: app.useGlobalFilters(new AllExceptionsFilter())
// wrap(): 保证非对象 body(如纯字符串 message)也包装成统一结构
第三步:契约化——OpenAPI 与前端类型联动
// 文件: error-contract.ts
// 错误响应也进 Swagger 契约, 前端拿到类型化的 code 做分支处理
// @ApiBadRequestResponse({ type: ErrorResponseDto })
export class ErrorResponseDto {
code!: number; // 错误码: 按模块分段, 前端据此 toast/跳转
message!: string; // 可直接展示的文案
requestId!: string; // 排障凭证: 客服收集它就能查到完整链路日志(223 题)
}
// RFC 7807 替代方案: Content-Type: application/problem+json, type/title/detail/status 标准字段,
// 适合对外开放 API(通用客户端能解析);内部系统用自家 code 枚举更顺手
总结:错误体系 = 错误码枚举(分段即契约)+ 业务/系统二分(透出 vs 兜底)+ requestId 串联;过滤器是唯一出口,栈永远不泄给客户端;错误码写进 OpenAPI,前后端同源。
追问1:HttpException 之外的内置异常怎么处理? → NotFoundException 等都会进过滤器,按实例分支转统一格式;第三方库抛的原生 Error 落到兜底 500 追问2:微服务场景错误怎么传? → RpcException 序列化传输(237 题),消费端再转 HTTP;错误码要全公司唯一(加服务前缀) 追问3:错误码会不会越堆越多失控? → 给治理动作:新码必须 PR 审查 + 文档表自动生成;废弃码标记 deprecated 并监控调用清零再删
251. Interceptor 深入:超时、缓存与响应脱敏?
概念 拦截器包裹 handler 的执行(RxJS Observable),能在”调用前/调用后/异常/超时”四个时机动手;典型用途:timeout(取消慢调用)、缓存(短 TTL 读放大)、响应映射(脱敏/加字段)、审计埋点。与 Pipe(改输入)、Filter(接错误)分工明确,整体执行顺序见 231 题(生命周期)。
典型场景 会员列表接口把用户手机号原样返回;热点读接口 DB 打满;某下游偶发 30s 慢调用拖死整个聚合接口。
解决方案 三步:超时拦截 → 响应脱敏映射 → 读缓存拦截器。
第一步:超时拦截——rxjs timeout 操作符
// 文件: timeout.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor, RequestTimeoutException } from '@nestjs/common';
import { Observable, catchError, throwError, timeout } from 'rxjs';
@Injectable()
export class TimeoutInterceptor implements NestInterceptor {
intercept(_ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
return next.handle().pipe(
timeout(10_000), // 10s 内无产出 → 抛 TimeoutError
catchError((err) =>
throwError(() => new RequestTimeoutException('处理超时,请重试')),
),
);
}
}
// 使用: @UseInterceptors(TimeoutInterceptor) —— 粒度到路由; 全局就 app.useGlobalInterceptors
// 与 226 题 AbortSignal 的分工: interceptor timeout 管"响应时效", signal 管"取消传播"
第二步:响应脱敏——map 改写返回体
// 文件: mask.interceptor.ts
import { map } from 'rxjs';
@Injectable()
export class MaskInterceptor implements NestInterceptor {
intercept(_ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
return next.handle().pipe(
map((data) => {
if (data?.items) {
data.items = data.items.map((u: Record<string, unknown>) => ({
...u,
phone: typeof u.phone === 'string' ? u.phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2') : u.phone,
idCard: undefined, // 证件号不该出现在列表: 根治靠查询不选出它
}));
}
return data;
}),
);
}
}
// ⚠️ 最佳实践优先级: 查询不选敏感列 > DTO 白名单序列化 > 出口脱敏兜底(本题)
第三步:读缓存拦截器——短 TTL + 单飞
// 文件: cache.interceptor.ts
import { of, switchMap, tap } from 'rxjs';
import type Redis from 'ioredis';
@Injectable()
export class ReadCacheInterceptor implements NestInterceptor {
constructor(private readonly redis: Redis) {}
intercept(ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
const req = ctx.switchToHttp().getRequest();
const key = `rc:${ctx.getClass().name}:${ctx.getHandler().name}:${JSON.stringify(req.query ?? {})}`;
return of(null).pipe(
switchMap(async () => JSON.parse((await this.redis.get(key)) ?? 'null')),
switchMap((cached) =>
cached !== null
? of(cached)
: next.handle().pipe(
tap(async (data) => { await this.redis.set(key, JSON.stringify(data), 'EX', 30); }),
),
),
); // TTL 故意短(30s): 防雪崩先随机化, 防脏读靠写侧失效(更新时 DEL key)
}
}
// 也可直接用 cache-manager + CACHE_TTL 装饰器; 自写的价值: key 规则与单飞(合并并发回源)可控
// 多租户场景 key 必须带租户前缀(261 题)
总结:拦截器 = RxJS 管道,四个时机(前/后/异常/超时)插逻辑;timeout 保尾延迟、脱敏做兜底、缓存做读放大;单一职责一个拦截器,组合用 @UseInterceptors(A, B) 显式声明。
追问1:多个拦截器的执行顺序? → 注册顺序洋葱:A前 → B前 → handler → B后 → A后(与中间件洋葱模型同构,216 题) 追问2:缓存击穿(热点 key 失效瞬间)怎么办? → 单飞(同 key 并发只放一个回源)或逻辑过期(异步刷新,先返回旧值);进程内加 promise map 合并 追问3:拦截器里能改入参吗? → 不能(那是 Pipe 的职责);拦截器拿得到 handler 参数(ctx.getArgs()),但改动会破坏职责分层
252. DynamicModule:forRoot/forRootAsync 封装可复用 SDK 模块?
概念 静态模块的 provider 在编译期写死;DynamicModule 让模块按配置注册 provider——forRoot(options) 返回带 providers 的模块定义,forRootAsync 支持异步配置(依赖 ConfigService、异步建连)。所有官方包(ConfigModule、TypeOrmModule)都是这个范式;公司内部 SDK(短信/支付/存储)照此封装,业务侧三行接入。
典型场景 团队每个项目都手抄一遍 OSS 初始化;SDK 需要异步读配置中心才能建连;想在 forRoot 时一并注册全局增强。
解决方案 三步:定义 token 与 provider → forRoot 静态版 → forRootAsync 异步版。
第一步:token 与注入助手
// 文件: storage/sdk.ts
export const STORAGE_OPTIONS = Symbol('STORAGE_OPTIONS');
export const STORAGE_CLIENT = Symbol('STORAGE_CLIENT');
export interface StorageOptions { endpoint: string; bucket: string; timeoutMs?: number }
export interface StorageClient { put(key: string, body: Buffer): Promise<void> }
第二步:forRoot——同步配置直接注册
// 文件: storage/storage.module.ts
import { Global, Module, DynamicModule, Provider } from '@nestjs/common';
@Global() // 注册一次全局可用, 业务模块免 import
@Module({})
export class StorageModule {
static forRoot(options: StorageOptions): DynamicModule {
const optionsProvider: Provider = { provide: STORAGE_OPTIONS, useValue: options };
const clientProvider: Provider = {
provide: STORAGE_CLIENT,
useFactory: (opts: StorageOptions): StorageClient => createClient(opts), // 建连封在工厂
inject: [STORAGE_OPTIONS],
};
return { module: StorageModule, providers: [optionsProvider, clientProvider], exports: [clientProvider] };
}
}
// AppModule: StorageModule.forRoot({ endpoint: 'oss.corp', bucket: 'docs' })
第三步:forRootAsync——异步配置与依赖注入
// 文件: storage/storage.module.ts(续)
static forRootAsync(opts: {
useFactory: (...args: unknown[]) => Promise<StorageOptions>;
inject?: unknown[];
}): DynamicModule {
const asyncProvider: Provider = {
provide: STORAGE_OPTIONS,
useFactory: opts.useFactory, // 工厂可以 inject: [ConfigService] 读环境配置
inject: opts.inject ?? [],
};
return {
module: StorageModule,
imports: (opts.inject?.length ? [ConfigModule] : []), // 确保被依赖模块已注册
providers: [asyncProvider, clientProvider], // clientProvider 同第二步
exports: [clientProvider],
};
}
// AppModule:
// StorageModule.forRootAsync({
// useFactory: (cfg: ConfigService) => ({
// endpoint: cfg.getOrThrow('OSS_ENDPOINT'), bucket: cfg.getOrThrow('OSS_BUCKET'),
// }),
// inject: [ConfigService],
// })
// useExisting 变体: 复用已有的配置 provider, 不重复建工厂(283 题密钥拉取也走这条路)
总结:DynamicModule 是”库作者”视角的机制:forRoot 同步、forRootAsync 异步 + inject;把建连/校验/全局注册都封进模块,业务侧只剩配置;内部 SDK 统一这个范式,接入成本三行。
追问1:为什么 token 用 Symbol/字符串而不是类? → 类做 token 要求 client 有唯一构造函数;SDK 的 client 来自工厂,Symbol token 解耦”提供什么”与”怎么造” 追问2:@Global 的利弊? → 免 import 但形成隐式依赖;SDK 类模块适合 Global,业务模块间显式 import 更健康(257 题) 追问3:forRootAsync 的异步时序在哪一步完成? → 容器实例化模块时 await useFactory(初始化瀑布),早于 onModuleInit —— 依赖它的 provider/钩子拿到的都是就绪 client(258 题)
253. 循环依赖:forwardRef 与模块边界重构?
概念 类循环:A 服务注入 B,B 又注入 A——实例化死锁,Nest 用 forwardRef 延迟解析打破。模块循环:A 模块 imports B,B 又 imports A(module.forwardRef)。但循环几乎总是设计信号:两个模块该合并、或抽第三个模块、或用事件解耦。ESM 层面还有 import 循环(210 题),表现是运行时取值 undefined。
典型场景 OrderService 注入 UserService 查用户,UserService 又要调 OrderService 校验首单;模块相互 import 启动报 “Nest can’t resolve dependencies”。
解决方案 三步:forwardRef 快速解套 → 三种重构方向 → 预防约定。
第一步:forwardRef 快速解套(应急)
// 文件: order.service.ts
import { forwardRef, Inject, Injectable } from '@nestjs/common';
@Injectable()
export class OrderService {
constructor(
@Inject(forwardRef(() => UserService)) // 延迟到对方就绪后再解析
private readonly users: UserService,
) {}
isFirstOrder(userId: string) { return this.orders.countByUser(userId) === 0; }
}
// user.service.ts 对称写法:
// constructor(@Inject(forwardRef(() => OrderService)) private readonly orders: OrderService) {}
// 症状提示: 启动报 "Nest can't resolve dependencies of OrderService" 且日志给出依赖路径 —— 沿路径找最小环
第二步:三种重构方向(治本)
// 文件: refactor.ts
// 方向 1: 抽第三个服务 —— "首单判断"其实是营销规则, 不属于 User 也不属于 Order
@Injectable()
export class PromotionService {
constructor(private readonly orderRepo: OrderRepository) {}
isFirstOrder(userId: string) { return this.orderRepo.countByUser(userId) === 0; }
}
// Order/User 都依赖 Promotion, 依赖图变成有向无环
// 方向 2: 依赖倒置 —— Order 定义接口, User 实现它, Order 只依赖接口(token 注入)
export const ORDER_CHECKER = Symbol('ORDER_CHECKER');
export interface OrderChecker { isFirstOrder(userId: string): boolean; }
// 方向 3: 事件解耦 —— 下单完成后 Order 只发事件, User 侧监听更新"是否首单"缓存
// this.events.emit('order.created', { userId }) —— 两者编译期互不相识(256 题事件体系)
第三步:预防约定
# 文件: boundaries.txt
用 eslint-plugin-boundaries 按目录定义依赖方向(296 题), 循环在 CI 就被拦下而不是运行时炸:
user → order ❌ / order → user ❌ / 双方 → promotion ✅
规则要点: 每个 domain 只允许被上层(app)依赖, 同层单向; 出现循环 → lint 报错强制重构
Nest 启动报错也会打印依赖路径 —— 但那是最后一道防线, 别依赖它
总结:forwardRef 是止痛药不是治疗方案;遇到循环先问”是不是抽错了模块”:抽公共服务、依赖倒置、事件解耦三选一;用 lint 边界规则让循环活不过 CI。
追问1:forwardRef 的原理? → 延迟解析:一方先拿到 forwardRef 包装(token + 工厂),容器完成对方实例化后再回填真实引用 追问2:module 级循环怎么解? → Module.forwardRef(() => B);同样优先重构——抽 shared 模块放双方都要的 provider 追问3:循环依赖和 ESM 循环 import 是一回事吗? → 不是:前者是 IoC 容器的实例化环,后者是模块加载环(取值时机问题,210 题活绑定);Nest 项目里两者常常同时出现
254. Request-scoped provider:性能陷阱与替代方案?
概念 provider 默认 singleton(应用一份);@Injectable({ scope: Scope.REQUEST }) 让它每个请求新建实例——但作用域沿依赖链传染:依赖它的每个 provider 也必须 request 化,整条链每请求重新实例化。代价:GC 压力、实例化开销、破坏”启动时缓存”类优化。替代方案几乎总是更好的:ALS 上下文(236 题)+ singleton。
典型场景 想在 service 里直接读 req.user 而把 service 改成 request scope,压测 QPS 掉三成;多租户系统想在任意层拿 tenantId。
解决方案 三步:传染性与代价 → ALS 替代 → 什么时候真的需要 request scope。
第一步:request scope 的传染性与代价
// 文件: request-scope.ts
import { Injectable, Scope } from '@nestjs/common';
@Injectable({ scope: Scope.REQUEST }) // ① TenantContext request 化
export class TenantContext {
tenantId!: string;
}
@Injectable() // ② 引用它的 OrderService 被迫 request 化
export class OrderService {
constructor(private readonly tenant: TenantContext) {}
}
// ③ OrderService 的每个依赖再被传染…… 整条链每请求 new 一遍:
// 压测对比(典型): singleton 链 ~5 万 QPS vs request 链 ~3.5 万 QPS, 且 GC 停顿变长(219 题)
第二步:ALS 替代——singleton + 隐式上下文
// 文件: tenant-als.ts
import { AsyncLocalStorage } from 'node:async_hooks';
import { Injectable } from '@nestjs/common';
const tenantStorage = new AsyncLocalStorage<{ tenantId: string }>();
@Injectable() // 保持 singleton
export class TenantContext {
get tenantId(): string {
const store = tenantStorage.getStore();
if (!store) throw new Error('tenant context missing: outside request scope');
return store.tenantId;
}
static run<T>(tenantId: string, fn: () => T): T { // 中间件里包一次请求(261 题落地)
return tenantStorage.run({ tenantId }, fn);
}
}
// 任意深层 service: this.tenant.tenantId —— 无构造参数、无作用域传染
第三步:什么时候真的需要 REQUEST scope
// 文件: when-request.ts
// 场景 1: per-request 的库对象(如每请求独立的 DataLoader, 避免跨请求缓存错数据)
// 场景 2: 需要拿原始 REQUEST 对象且无法用 ALS 的遗留互操作
@Injectable({ scope: Scope.REQUEST })
export class PerRequestLoader { /* ... */ }
// 即便用, 也只把"叶子"类 request 化, 并在文档标明: 这条链每请求实例化
// 测试影响: request-scoped provider 的 mock 与解析都更绕(288 题); ALS 方案测试里 storage.run 包一层即可
总结:request scope 的本质代价是”传染 + 每请求实例化整条链”;99% 的诉求(拿请求态)用 ALS singleton 解决;真正 per-request 的库对象才用 REQUEST,并且控制它在依赖图里的位置。
追问1:TRANSIENT scope 和 REQUEST 的区别? → transient:每次注入都新实例(无请求语义);request:同一请求内共享同一实例 追问2:ALS 为什么”恰好”能跟随请求? → AsyncLocalStorage 基于异步资源追踪(async_hooks),同一请求发起的所有异步调用共享 store —— Node 原生能力,零 API 侵入 追问3:怎么排查哪些 provider 被传染了? → 构造函数打日志的探针 provider,或 nest start 时容器对 request-scoped 链的警告日志;最可靠是依赖图 lint(253 题)
255. 自定义装饰器与 Reflector 元编程?
概念 Nest 元编程三件套:参数装饰器(createParamDecorator,从 request 抽值注入参数)、方法/类装饰器元数据(SetMetadata 存、Reflector 取)、组合装饰器(applyDecorators 打包一组)。Guard/Interceptor/Filter 都靠 Reflector 读元数据实现”声明式”能力——@Public、@Roles、@Cached 是同一种机制。
典型场景 每个 controller 手写 req.user 解包;权限/缓存/审计想做到”一行声明”;框架层想给路由挂自定义行为。
解决方案 三步:参数装饰器 → 元数据存取与继承覆盖 → 组合装饰器封装。
第一步:参数装饰器——干掉 req 解包样板
// 文件: current-user.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
export const CurrentUser = createParamDecorator(
(data: 'id' | 'email' | undefined, ctx: ExecutionContext) => {
const user = ctx.switchToHttp().getRequest().user; // JWT Guard 解析后挂上(233 题)
return data ? user?.[data] : user;
},
);
// controller: async profile(@CurrentUser() user: JwtPayload)
// async orders(@CurrentUser('id') userId: string)
第二步:元数据存取 + 继承覆盖规则
// 文件: roles.decorator.ts
import { Reflector, SetMetadata } from '@nestjs/common';
export const ROLES_KEY = 'app:roles';
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);
// Guard 里读取: getAllAndOverride 方法优先于类, getAllAndMerge 合并两者
export class RolesGuard {
constructor(private readonly reflector: Reflector) {}
canActivate(ctx: ExecutionContext): boolean {
const roles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
ctx.getHandler(), // 方法上的 @Roles 优先
ctx.getClass(), // 类上的作为默认
]);
if (!roles?.length) return true; // 没声明 = 不限制(默认开放策略要团队约定一致)
return roles.includes(this.request.user.role);
}
}
第三步:组合装饰器——一行声明打包
// 文件: route-policy.decorator.ts
import { applyDecorators, SetMetadata, UseGuards, UseInterceptors } from '@nestjs/common';
export function AdminOnly() {
return applyDecorators(
UseGuards(JwtAuthGuard, RolesGuard),
Roles('admin'),
SetMetadata('audit', { action: 'admin-op', level: 'sensitive' }), // 285 题审计拦截器消费它
UseInterceptors(MaskInterceptor),
);
}
// controller: @AdminOnly() @Get('users') —— 权限+审计+脱敏一次声明, 规则收敛在一处
// key 用常量集中管理(ROLES_KEY 模式), 字符串散写 = 未来撞名事故
总结:装饰器是 Nest 声明式编程的入口:参数装饰器消样板、SetMetadata/Reflector 建”路由级配置”、applyDecorators 封装组合策略;默认值语义(未声明时放行还是拒绝)团队必须统一。
追问1:getAllAndMerge 与 getAllAndOverride 怎么选? → 语义要”合并”(权限叠加)用 merge(数组 concat);要”就近覆盖”(方法级配置压类级)用 override 追问2:装饰器元数据能在运行时改吗? → 可以 Reflect.defineMetadata 动态写,但破坏声明式可读性;动态策略放 Guard 内部逻辑更清晰 追问3:参数装饰器的执行时机? → 拿到值之后 Pipe 照常作用(自定义管道对参数装饰器产物同样生效,242 题)
256. CQRS:命令查询职责分离在 Nest 的落地?
概念 CQRS 把写(Command,改状态、走聚合根保证一致性)与读(Query,直接查投影、可任意优化)拆成两条链路;@nestjs/cqrs 提供 CommandBus/QueryBus/EventBus 与 handler 解耦。适用:业务规则复杂(多不变量约束)、读写模型差异大(写规范化、读反规范化)、需要事件留痕。CRUD 项目引入是负资产。
典型场景 订单状态机(创建/支付/发货各有不变量,写在聚合里校验);读侧要跨 7 张表拼装列表页(走宽表/物化视图);下单完成后触发积分、库存、通知(事件扇出)。
解决方案 三步:Command 链(写)→ Query 链(读)→ 事件扇出与边界纪律。
第一步:Command——写链路走聚合根
// 文件: create-order.command.ts
import { CommandBus, CommandHandler, ICommandHandler } from '@nestjs/cqrs';
export class CreateOrderCommand {
constructor(public readonly userId: string, public readonly items: OrderItem[]) {}
}
@CommandHandler(CreateOrderCommand)
export class CreateOrderHandler implements ICommandHandler<CreateOrderCommand> {
constructor(private readonly repo: OrderRepository, private readonly events: EventBus) {}
async execute(cmd: CreateOrderCommand): Promise<Order> {
const order = Order.create(cmd.userId, cmd.items); // 聚合根: 不变量(库存>0/金额>0/限购)全在内部校验
await this.repo.save(order);
order.commit(this.events); // 领域事件在此发布, 不是 handler 里散着发
return order;
}
}
// controller: this.commandBus.execute(new CreateOrderCommand(userId, dto.items))
第二步:Query——读链路直查投影
// 文件: order-list.query.ts
import { QueryHandler, IQueryHandler } from '@nestjs/cqrs';
export class OrderListQuery {
constructor(public readonly userId: string, public readonly page: number) {}
}
@QueryHandler(OrderListQuery)
export class OrderListHandler implements IQueryHandler<OrderListQuery> {
constructor(private readonly readRepo: OrderReadRepository) {}
async execute(q: OrderListQuery) {
// 读仓储直查反规范化视图(order_summary 宽表/ES 索引): 不走聚合、不加业务规则
return this.readRepo.findPage(q.userId, q.page);
}
}
// controller: this.queryBus.execute(new OrderListQuery(userId, page))
第三步:事件扇出与边界纪律
// 文件: order-events.ts
import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
export class OrderCreatedEvent {
constructor(public readonly orderId: string, public readonly userId: string) {}
}
@EventsHandler(OrderCreatedEvent)
export class GrantPointsOnOrderCreated implements IEventHandler<OrderCreatedEvent> {
async handle(e: OrderCreatedEvent) { /* 加积分 */ }
}
@EventsHandler(OrderCreatedEvent)
export class ReserveStockOnOrderCreated implements IEventHandler<OrderCreatedEvent> {
async handle(e: OrderCreatedEvent) { /* 扣库存 */ }
}
// ⚠️ 边界纪律:
// 1. @nestjs/cqrs 的 EventBus 是进程内的: handler 失败不回滚事务、挂了事件就丢
// → 可靠事件用 outbox + MQ(281 题), cqrs 总线只管解耦不管可靠
// 2. handler 之间无顺序保证, 别写隐式依赖
// 3. 事件里只放 ID + 必要快照, 消费方自己回查, 防事件体膨胀
总结:CQRS 的价值在”复杂写规则”与”高自由度读”分别优化;@nestjs/cqrs 只是总线,核心设计在聚合根与事件;引入前先自问是不是真有复杂不变量——CRUD 用它纯属自虐。
追问1:CQRS 必须两个数据库吗? → 不必:起步同库不同模型(读写 repository 分离),规模化再拆投影(宽表/ES) 追问2:读模型怎么与写模型同步? → 事件订阅更新投影(最终一致);窗口期前端要有”刚提交的数据暂不可见”的容忍设计 追问3:Command 和 Event 的本质区别? → Command 是”请求做某事”(可被拒绝,单一 handler);Event 是”某事已发生”(既成事实,多 handler 各取所需)
257. Nest 模块化设计:Feature/Shared/@Global 的边界?
概念 模块是 Nest 的代码组织与封装单元:Feature Module 按业务域切(users/orders/payments 各自聚合 controller+service+repo);Shared Module 抽公共能力;@Global 免 import 全局可见。健康信号:依赖单向、模块高内聚、跨模块只通过导出的接口。模块循环是边界画错的警报(253 题)。
典型场景 项目长大到 40 个 service 互相注入像蜘蛛网;三人协作互相踩模块;想拆微服务发现模块边界根本不存在(287 题的前置)。
解决方案 三步:Feature 模块骨架 → 依赖纪律 → @Global 的使用边界。
第一步:Feature 模块骨架——一个业务域一个盒子
// 文件: orders/orders.module.ts
import { Module } from '@nestjs/common';
@Module({
controllers: [OrdersController],
providers: [OrderService, OrderRepository, OrderFactory], // 内部实现全部私有
exports: [OrderService], // 只导出对外的门面
})
export class OrdersModule {}
// 目录: src/orders/{orders.module.ts, orders.controller.ts, orders.service.ts, domain/}
// 规则: 别的模块永远 import OrdersModule 拿 OrderService, 不准直接摸 OrderRepository
第二步:依赖纪律——分层单向
// 文件: app.module.ts
@Module({
imports: [
ConfigModule.forRoot({ isGlobal: true }),
DatabaseModule, // 基础设施: 连接/事务 helper, exports 通用能力
SharedModule, // 公共能力: 日期/加密/分页 DTO
OrdersModule, // 业务域之间平级, 域内依赖向下(域 → 基础设施/共享)
UsersModule,
BillingModule,
],
})
export class AppModule {}
// 单向规则: infra < shared < domain; domain 之间要通信, 走"对外导出的 service"或事件(256 题)
// 一旦发现 DomainB import 了 DomainA 的内部类 —— 边界破了, 重构信号
第三步:@Global 的使用边界
// 文件: shared/logger.module.ts
import { Global, Module } from '@nestjs/common';
@Global()
@Module({ providers: [AppLogger], exports: [AppLogger] })
export class LoggerModule {}
// 判断标准: 这个 provider 是"环境级单例"吗(日志/配置/追踪)→ @Global 合理;
// 是"业务能力"吗(OrderService)→ 必须 import, 显式依赖是文档
// ModuleRef 应急: 运行时按 token 解析(测试/动态场景), 常规代码别用它绕过 import(262 题)
总结:模块化三条铁律:按业务域装箱、只导出门面、依赖单向;@Global 只给环境级能力;模块边界是未来拆微服务的切割线,平时的边界纪律就是拆分预演。
追问1:模块和目录结构的关系? → 模块是运行时概念(依赖注入边界),目录是编辑器概念;保持一致(一模块一目录)让两者互相印证 追问2:大模块拆小的时机? → 一个模块超过约 10 个 provider、或一个目录的 PR 开始跨人频繁冲突,就按子域拆 追问3:ModuleRef 什么时候正当? → 动态场景:按参数选实现(多租户 driver)、测试里替换;静态依赖永远走构造注入
258. 生命周期钩子:onModuleInit 到 onApplicationShutdown 的工程用途?
概念 启动顺序:模块注册 → onModuleInit(各模块初始化,容器 await)→ onApplicationBootstrap(全部 init 完成,可挂消费者/定时器)→ listen;关闭顺序:onModuleDestroy(停入口)→ beforeApplicationShutdown(收 SIGTERM 后)→ onApplicationShutdown(进程退出前最后清理)。铁律:构造函数里不做异步工作,初始化放 onModuleInit await。
典型场景 构造函数里发起 DB 连接导致”半初始化”对象被别的服务用到;消费者在 listen 前启动把探针打挂;停机时清理顺序错乱造成消息重复消费。
解决方案 三步:初始化正确姿势 → 各钩子的典型职责 → 关闭链实战。
第一步:初始化——别在构造函数里做异步
// 文件: init-pattern.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
@Injectable()
export class EmbeddingClient implements OnModuleInit {
private client!: EmbedConn; // ❌ 构造函数里发起连接 = 别人可能拿到未就绪实例
async onModuleInit() {
this.client = await connectEmbed({ host: 'embed.corp' }); // ✅ 容器会 await 全部 init 再放行
}
async embed(text: string) { return this.client.vector(text); }
}
// 更进一步: 连接本身做成 useFactory 异步 provider(252 题), init 钩子只做"检查就绪"
第二步:钩子职责速查
// 文件: hooks-map.ts
import { Injectable, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
@Injectable()
export class ConsumerService implements OnApplicationBootstrap, OnModuleDestroy {
async onApplicationBootstrap() {
// 全部模块 onModuleInit 完成后: 整个依赖图就绪, 适合启动 MQ 消费者/定时任务首跑
await this.consumer.subscribe();
}
async onModuleDestroy() {
// 收到信号后的第一阶段: 先停"入口"(消费者停止拉新消息, 定时器清零)
await this.consumer.stop();
}
}
// onModuleInit: 本模块依赖的资源就绪(await 保证全局顺序)
// onApplicationBootstrap: 应用级启动动作(消费者/缓存预热)
// ⚠️ init 顺序 = 模块依赖顺序; 同层模块间不保证次序, 别写隐式先后
第三步:关闭链——shutdown hooks 必须显式开启
// 文件: main.ts
const app = await NestFactory.create(AppModule);
app.enableShutdownHooks(); // ❗默认关闭: 不开的话 onApplicationShutdown 永远不会跑
await app.listen(3000);
// 关闭链职责分配(239 题优雅停机的钩子层落地):
// onModuleDestroy: 停新流量(消费者 unsub、定时器 clear)
// beforeApplicationShutdown: 等 in-flight 完成(可选, 带信号参数 sig)
// onApplicationShutdown: 释放底层连接(DB disconnect、Redis quit)
总结:钩子是容器替你编排的初始化/关闭协议;异步初始化放 onModuleInit(或异步 provider);消费者/定时器等 onApplicationBootstrap;停机三段式配合 enableShutdownHooks;构造函数只赋值。
追问1:init 抛错会怎样? → 启动中断,进程退出(fail-fast 是对的:配置错/连不上就别带病上线,241 题 Joi 校验同思想) 追问2:onApplicationBootstrap 里能发 HTTP 请求吗? → 能,但 listen 可能还没开始——对外探活就绪标记要配合 244 题 readiness 探针 追问3:两个模块的 init 有依赖怎么保证顺序? → 依赖关系用 provider inject 表达(被依赖方作为注入);钩子顺序由容器按依赖拓扑排,别靠 imports 数组里的位置
259. API 版本管理与废弃流程?
概念 Nest 内置版本化:URI(/v1/orders,最直白、网关友好)、HEADER(X-API-Version,URL 稳定)、MEDIA_TYPE(Accept 头,粒度最细)。比”怎么开”更重要的是生命周期:多版本共存期的双实现维护成本、版本爆炸治理、废弃流程(Deprecation/Sunset 头 + 流量监控清零才下线)。
典型场景 移动端老版本 App 还在用 v1,后端要改字段结构;开放 API 对外承诺稳定性;版本号三年攒了 6 个没人敢删。
解决方案 三步:开启版本化与多版本路由 → 版本实现的组织 → 废弃流程。
第一步:开启与路由声明
// 文件: versioning.ts
import { VersioningType, VERSION_NEUTRAL } from '@nestjs/common';
app.enableVersioning({
type: VersioningType.URI,
defaultVersion: '1',
prefix: 'v',
}); // 路由: /v1/orders、/v2/orders
@Controller({ path: 'orders', version: ['1', '2'] }) // 双版本共存
export class OrdersController {
@Get({ path: ':id', version: '1' })
findV1() { /* 旧结构: amount 单位为分 */ }
@Get({ path: ':id', version: '2' })
findV2() { /* 新结构: amount 改为元 + 币种字段 */ }
@Get({ path: 'health', version: VERSION_NEUTRAL }) // 不随版本变: 探活/公共路由
health() { return { ok: 1 }; }
}
第二步:版本实现的组织——共享 service,只在出口层分叉
// 文件: version-impl.ts
// 反模式: OrdersV2Controller 整个复制一份改字段 —— 双实现从此各自漂移
// 正解: 版本差异收敛在 DTO 映射层, 业务逻辑单份
@Controller({ path: 'orders', version: ['1', '2'] })
export class OrdersController {
constructor(private readonly orders: OrderService) {}
@Get(':id')
@Version('1')
async findV1(@Param('id') id: string) {
return toV1Response(await this.orders.findOne(id)); // 映射函数: 分 → 元
}
@Version('2')
async findV2(@Param('id') id: string) {
return toV2Response(await this.orders.findOne(id));
}
}
// 版本差异大到一个映射函数装不下 → 这是要拆 v2 服务/路由前缀的信号, 而不是继续在 controller 里堆 if
第三步:废弃流程——头声明 + 流量清零才下线
// 文件: deprecate.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { map } from 'rxjs';
@Injectable()
export class V1DeprecationInterceptor implements NestInterceptor {
intercept(ctx: ExecutionContext, next: CallHandler) {
const res = ctx.switchToHttp().getResponse();
res.setHeader('Deprecation', 'true'); // 标准化弃用声明头
res.setHeader('Sunset', 'Wed, 31 Dec 2026 23:59:59 GMT'); // 计划下线时间(RFC 8594)
res.setHeader('Link', '</docs/migration-v2>; rel="deprecation"');
return next.handle().pipe(map((d) => d));
}
}
// 下线纪律: Sunset 到期前监控 v1 流量(按版本打指标, 298 题), 清零(或只剩可联系的白名单)才删代码;
// 客户端监测到 Deprecation 头可提前告警 —— 版本治理是流程问题, 框架只给钩子
总结:版本化选 URI 最省心;版本差异收敛在出口映射层,业务单份;Deprecation/Sunset 头让废弃可被机器感知,流量清零是下线的唯一标准;能用容忍性变更(加可选字段)就别升版本。
追问1:加字段算不算破坏性变更? → 严格客户端(枚举校验)会炸,宽容客户端没事——对外 API 默认当破坏性,先灰度公告 追问2:Header 版本化的优劣? → URL 干净、对 CDN 缓存影响小;缺点是调试稍麻烦、文档工具要配;内部系统常用 追问3:GraphQL 怎么做版本? → 不做 URL 版本:靠字段演进 + @deprecated 指令,客户端按需取字段天然容忍(246 题)
260. GraphQL Subscription:实时推送的落地?
概念 Subscription 是 GraphQL 的第三种操作(query 读、mutation 写、subscription 订阅):客户端声明订阅,服务端在事件发生时推送结果。Nest 落地:@Subscription() 装饰器 + PubSub 实例(单机 EventEmitter 版,多实例必须换 Redis 版);withFilter 做按订阅者过滤;传输层是 WebSocket(graphql-ws 协议)。
典型场景 协作看板(卡片移动全员同步);订单状态变更推给用户;多实例部署下 EventEmitter PubSub 失效(实例 A 的事件推不到连在实例 B 的客户端)。
解决方案 三步:基础订阅 + 过滤 → Redis PubSub 多实例 → 断线恢复语义。
第一步:基础订阅与 withFilter
// 文件: orders.subscription.ts
import { Subscription, Resolver } from '@nestjs/graphql';
import { PubSub } from 'graphql-subscriptions';
import { UseGuards } from '@nestjs/common';
export const pubSub = new PubSub(); // 进程内实现 —— 多实例场景看第二步
@Resolver('Order')
export class OrdersSubscriptionResolver {
@Subscription('orderUpdated', {
filter: (payload, variables, ctx) => // 服务端按订阅参数与身份过滤
payload.orderUpdated.userId === ctx.user.id,
resolve: (payload) => payload.orderUpdated,
})
orderUpdated() {
return pubSub.asyncIterableIterator(['orderUpdated']);
}
}
// 发布侧: pubSub.publish('orderUpdated', { orderUpdated: { id, status, userId, seq } })
第二步:多实例——Redis PubSub
// 文件: graphql-pubsub.ts
import { RedisPubSub } from 'graphql-redis-subscriptions';
import Redis from 'ioredis';
export const pubSub = new RedisPubSub({
publisher: new Redis({ host: 'redis.corp' }),
subscriber: new Redis({ host: 'redis.corp' }), // 订阅连接独立(229 题同款纪律)
});
// 事件经 Redis 广播: 实例 A publish → Redis 扇出 → 所有实例的 subscriber → 各自推给自己的 WS 客户端
// 与 268 题 WS 网关水平扩展同构: 无状态化靠共享消息总线
第三步:断线恢复——订阅不是免费的可靠通道
// 文件: subscription-resume.ts
// graphql-ws 客户端自动重连 + 重新订阅; 但断线期间的事件丢了 —— 补偿设计:
// 事件体带单调 seq, 客户端重连后对比本地 lastSeq:
// 差距小 → 发一个 query 拉增量补洞
// 差距大 → 全量刷新
// 服务端配合: 事件写进带 TTL 的 Redis Stream/列表, 提供 sinceSeq 查询(267 题同款序号思想)
// 原则: 订阅通道只做"通知", 可靠交付靠"通知 + 回查"
总结:Subscription = GraphQL over WebSocket;单机 PubSub 只是玩具,多实例必须 Redis 版;withFilter 做服务端过滤;断线恢复要自己设计(重订阅 + 序号 + 补拉)。
追问1:订阅的鉴权怎么做? → WS 握手/onConnect 阶段验 token(265 题同款问题),把 user 放进 context;过滤器里再校验归属 追问2:Subscription 和 273 题 WS 网关怎么选? → 已有 GraphQL schema 就用 subscription(类型系统一致);纯推送/二进制/超低延迟场景用原生 WS 网关 追问3:大量订阅者广播的瓶颈? → resolve/filter 在每个实例逐订阅者执行,大房间优化:预分组 topic(room 维度 publish)而不是全量事件 + filter
261. 多租户架构:租户解析与数据隔离三档?
概念 SaaS 多租户核心两问:租户从哪来(子域名 tenant.app.com / 请求头 / JWT claim / 路径前缀)与数据怎么隔(三档:共库共表 tenant_id 列、共库独立 schema、独立数据库——隔离性递增、成本递增)。Nest 落地关键:中间件/Guard 解析租户 → ALS 贯穿(236 题)→ ORM 层强制注入租户过滤。
典型场景 ToB SaaS 从单租户私有化走向多租户云版;租户 A 的报表查到租户 B 的数据(重大事故);大客户要求物理隔离。
解决方案 三步:租户解析中间件 → ORM 全局租户过滤 → 独立库的动态 DataSource。
第一步:租户解析——统一入口
// 文件: tenant.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
@Injectable()
export class TenantMiddleware implements NestMiddleware {
use(req: any, res: any, next: () => void) {
const tenantId =
req.headers['x-tenant-id'] ?? // 网关注入(从子域名/JWT 解出)
new URL(`http://${req.headers.host}`).hostname.split('.')[0];
if (!/^[a-z0-9-]{2,20}$/.test(tenantId)) throw new Error('bad tenant');
TenantContext.run(tenantId, next); // ALS: 后续整条异步链可取(254 题)
}
}
// ⚠️ 仅中间件不够: 越过 HTTP 的入口(MQ 消费/定时任务)也要在入口处包 TenantContext.run
第二步:共库共表——ORM 层强制租户过滤
// 文件: tenant-scope.ts
import { Injectable } from '@nestjs/common';
import { DataSource } from 'typeorm';
@Injectable()
export class TenantAwareRepository {
constructor(private readonly ds: DataSource) {}
private get tenantId() { return TenantContext.tenantId; } // ALS 取当前租户
findOrders() {
return this.ds.getRepository(Order).createQueryBuilder('o')
.andWhere('o.tenantId = :tenant', { tenant: this.tenantId }) // 每个查询强制注入
.getMany();
}
// 写侧同理; 双保险: 表上复合唯一键含 tenant_id + 单元测试扫描"忘带租户条件"的查询
// Prisma 路线: client extension 统一 where 注入, 中间层一行都逃不掉
}
第三步:独立库——动态 DataSource 池
// 文件: tenant-datasource.ts
import { DataSource } from 'typeorm';
const pool = new Map<string, DataSource>(); // 租户 → 连接池(带淘汰/心跳, 229 题池管理)
async function dsFor(tenantId: string): Promise<DataSource> {
let ds = pool.get(tenantId);
if (!ds || !ds.isInitialized) {
ds = new DataSource({
type: 'postgres',
url: await resolveTenantUrl(tenantId), // 配置中心查租户库地址(283 题密钥管理)
poolSize: 5,
});
await ds.initialize();
pool.set(tenantId, ds);
}
return ds;
}
// 坑: 迁移要跑 N 个库(灰度滚动)、跨租户聚合查询没有了(改走数据仓库)、池数量上限(租户多时复用中档方案)
总结:解析靠中间件 + ALS,隔离三档按合规与成本选;共表档的命门是”忘带 tenant_id”——靠 ORM 强制注入 + 唯一键 + 测试三重防;独立库档的命门是运维(迁移/连接池);缓存 key 别忘了租户前缀。
追问1:缓存怎么防串租户? → key 强制 t:{tenantId}:... 前缀,封装缓存服务禁止裸拼 key;251 题缓存拦截器的 key 生成同样要接租户
追问2:租户级功能差异(套餐)怎么建模? → 租户 → 套餐 → 特性开关(282 题),判定结果缓存;别在业务代码里 if 租户名
追问3:从共表迁独立库的路径? → 先逻辑隔离(查询层)→ 双写迁移窗口 → 按租户分批切换 + 回滚开关;双写期间以旧为准做对账(281 题)
262. DI 高级:工厂 provider、自定义 token 与初始化顺序?
概念 provider 不只是”类”:useFactory(动态造值,支持 async 与 inject 依赖)、自定义 token(String/Symbol 注入)、useExisting(alias)三种形态解决”值不是 new 出来的”问题。初始化顺序由依赖关系决定:容器先解析 inject 的依赖再跑工厂——异步工厂是官方推荐的”启动期建连”姿势(和 252 题 forRootAsync 同机制)。
典型场景 客户端实例要按环境选实现(云厂商 SDK);一个接口多个实现按配置注入;启动时要从配置中心拉密钥再建连。
解决方案 三步:异步工厂建连 → 自定义 token 多实现选一 → ModuleRef 与 alias。
第一步:异步工厂——启动期建连的标准姿势
// 文件: di-factory.ts
import { Provider } from '@nestjs/common';
export const DB_CLIENT = Symbol('DB_CLIENT');
export const dbClientProvider: Provider = {
provide: DB_CLIENT,
useFactory: async (cfg: ConfigService) => {
const url = await cfg.get('DATABASE_URL'); // 可以 await: 拉配置中心/Vault(283 题)
const client = await connect(url, { poolSize: 20 });
await client.ping(); // fail-fast: 连不上启动就崩, 不带病上线
return client;
},
inject: [ConfigService], // 声明依赖: 容器保证 ConfigService 先就绪
};
// 依赖 DB_CLIENT 的服务拿到的必然是已连接实例 —— 比 onModuleInit 手工赋值更早、更可测(258 题)
第二步:多实现按配置选一(策略注入)
// 文件: sms-provider.ts
export interface SmsSender { send(mobile: string, body: string): Promise<void> }
export const SMS_SENDER = Symbol('SMS_SENDER');
export const smsProvider: Provider = {
provide: SMS_SENDER,
inject: [ConfigService],
useFactory: (cfg: ConfigService): SmsSender => {
const vendor = cfg.getOrThrow('SMS_VENDOR');
switch (vendor) {
case 'aliyun': return new AliyunSms(cfg.get('ALIYUN_KEY'));
case 'tencent': return new TencentSms(cfg.get('TENCENT_KEY'));
default: throw new Error(`unknown vendor: ${vendor}`);
}
},
};
// 业务侧: constructor(@Inject(SMS_SENDER) private readonly sms: SmsSender)
// 多个并存(不是选一)时: factory 返回 Map<vendor, impl>, 或各自命名 token
第三步:ModuleRef 与 useExisting
// 文件: moduleref.ts
import { Injectable, ModuleRef } from '@nestjs/common';
@Injectable()
export class ReportService {
constructor(private readonly moduleRef: ModuleRef) {}
build(kind: 'pdf' | 'excel') {
// get: 取 singleton(257 题边界内的正当用法); resolve: 每次新实例
const renderer = this.moduleRef.get(kind === 'pdf' ? PdfRenderer : ExcelRenderer, { strict: false });
return renderer.render();
}
}
// useExisting(alias): 让旧 token 指到新实现, 迁移期两个名字可用 —— 删旧名分两步走
// { provide: LegacyLogger, useExisting: AppLogger }
总结:工厂 provider 是”非 new 值”的标准答案:异步建连 fail-fast、按配置选实现;token 注入配合接口做策略模式;ModuleRef 只用于运行时动态解析;初始化顺序交给 inject 声明,别手工排。
追问1:两个工厂互相 inject 会怎样? → 形成循环依赖:启动报错(和类循环同源);解法同 253 题——抽第三 provider 或 forwardRef 追问2:工厂抛错进程会怎样? → 启动失败退出(fail-fast);对”可降级”依赖(如缓存)在工厂里 try/catch 返回降级实现,并打指标 追问3:token 字符串和 Symbol 怎么选? → Symbol 防撞且无序列化需求时最稳;字符串利于跨包/调试输出;团队统一即可,导出集中管理
263. Nest 混合应用:HTTP 与微服务监听共存?
概念 一个 Nest 进程同时是 HTTP 服务(REST/GraphQL)和微服务消费者:app.connectMicroservice() 挂载传输器(TCP/RMQ/Kafka),startAllMicroservices() 与 listen() 并行启动。价值:小团队拆不起独立消费者进程时,把异步任务处理和 API 放同一进程;代价:故障域耦合(消费阻塞影响 API)、无法独立伸缩。
典型场景 团队 5 人,要处理 MQ 任务但不想多一套部署;消费逻辑与业务代码同库共享 service;先把架构跑起来,后期再拆(287 题演进起点)。
解决方案 三步:启动骨架 → 消费与 HTTP 的隔离防护 → 拆分演练路径。
第一步:启动骨架
// 文件: main.ts
import { NestFactory } from '@nestjs/core';
import { Transport } from '@nestjs/microservices';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
app.connectMicroservice({
transport: Transport.RMQ,
options: {
urls: [process.env.RMQ_URL],
queue: 'doc-ingest', // 文档解析任务(异步 embedding 的入口, 277 题)
queueOptions: { durable: true },
prefetch: 4, // 限流: 防消费风暴打挂同进程的 HTTP
},
});
await app.startAllMicroservices(); // 先起消费者(不监听端口)
await app.listen(3000); // 再起 HTTP(探针/流量入口)
}
void bootstrap();
// @MessagePattern('doc.parse') 的 handler 与 HTTP controller 共用同一 DI 容器里的 service
第二步:隔离防护——别让消费拖死 HTTP
// 文件: consumer-guard.ts
import { Catch, ArgumentsHost } from '@nestjs/common';
import { BaseRpcExceptionFilter } from '@nestjs/microservices';
// 1) 消费 handler 里的重活丢任务队列(277 题 BullMQ), handler 只做登记 —— 消费入口轻量化
// 2) 消费错误必须接住(否则消息无限重投):
@Catch()
export class ConsumerExceptionFilter extends BaseRpcExceptionFilter {
catch(exception: unknown, host: ArgumentsHost) {
// nack + 死信策略: 重试 N 次进 DLQ(274 题), 别让毒消息循环
return super.catch(exception, host);
}
}
// 3) 资源隔离底线: 消费逻辑用独立的 DB 连接池/信号量, 与 HTTP 池分开(229 题)
// 4) 指标分通道: HTTP 的 RED 指标与消费 lag/耗时分开告警(298 题), 一眼定位哪边出问题
第三步:拆分演练——混合态必须可演进
# 文件: split.txt
演进开关: 消费者独立成进程时, 代码零改动 —— 同一份 AppModule, main 按角色启动:
consumer/main.ts: const app = await NestFactory.createMicroservice(AppModule, rmqOptions)
API 实例: 不再 connectMicroservice; 消费实例: 不 listen
部署期拆分(K8s 两套 Deployment, 同镜像不同启动角色), 好处:
1) 消费可独立扩缩容(按 lag, 276 题)
2) 滚动更新分批: 先滚消费者再滚 API(249 题滚动纪律)
3) 故障域隔离: 消费 OOM 不再连带 API
判断拆分时机: 消费 CPU/内存画像与 API 显著分化、或发布节奏互相拖累
总结:混合应用是”过渡架构”:一份代码两种角色,启动三行;前提纪律是入口轻量化、错误必接住、资源分池、指标分通道;把 main 的启动角色做成开关,拆分就只是部署变化而不是代码重写。
追问1:混合应用停机时消费者怎么办? → shutdown 钩子顺序同样生效(258 题):先停消费拉新,再 drain HTTP 在途——enableShutdownHooks 对两种角色都有效 追问2:@MessagePattern 和 @EventPattern 的区别? → message 期待响应(请求/响应语义);event 是 fire-and-forget(237 题 emit);任务类用 event,同步查证类用 message 追问3:混合应用怎么灰度消费新版本? → 同一 queue 多消费者竞争消费,新版本实例加入即分流(天然灰度);配合幂等(280 题)保证新旧代码都能安全处理
四、WebSocket 与实时通信(264–273)
264. @WebSocketGateway 基础:握手、消息与房间?
概念 Nest 的 WebSocket 网关:@WebSocketGateway() 声明网关类(默认 socket.io 平台,可换 ws 适配器);handleConnection/handleDisconnect 管连接生命周期;@SubscribeMessage(‘event’) 声明消息处理器(返回值即 ack 回执);server.to(room).emit 向房间广播;room 是服务端概念的分组(同房间连接共享消息,无需自建映射表)。
典型场景 实时协作、聊天室、AI 对话推送、后台任务进度通知。
解决方案 三步:最小网关 → 房间与广播姿势 → 与 HTTP 应用的组织关系。
第一步:最小可用网关
// 文件: chat.gateway.ts
import { ConnectedSocket, MessageBody, SubscribeMessage, WebSocketGateway, WebSocketServer, WsException } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';
@WebSocketGateway({ namespace: '/chat', cors: { origin: '*' } })
export class ChatGateway {
@WebSocketServer() server!: Server; // 网关内直接拿 Server 实例
async handleConnection(client: Socket) {
console.log('connected', client.id); // 握手完成: 鉴权见 265 题
}
async handleDisconnect(client: Socket) {
console.log('disconnected', client.id); // 清理在线状态(269 题)
}
@SubscribeMessage('chat:send')
async onSend(@ConnectedSocket() client: Socket, @MessageBody() body: { room: string; text: string }) {
this.server.to(body.room).emit('chat:message', { room: body.room, text: body.text, from: client.id });
return { ok: true }; // 返回值 = ack 回执(客户端回调拿得到)
}
@SubscribeMessage('room:join')
async onJoin(@ConnectedSocket() client: Socket, @MessageBody() { room }: { room: string }) {
if (!(await this.canJoin(client, room))) throw new WsException('forbidden'); // 进房前鉴权
await client.join(room);
}
}
第二步:广播姿势对照
// 文件: broadcast-styles.ts
// this.server.emit(...) 全体
// this.server.to('order:1001').emit(...) 房间(订单页围观者)
// client.emit(...) 只发给自己
// this.server.except('room').emit(...) 除某房间外全体(灰度广播, 272 题降级用)
// 消息命名用域前缀(chat:send / room:join): 事件多了以后, 前缀就是命名空间
第三步:与 HTTP 应用的组织
// 文件: events.module.ts
import { Module } from '@nestjs/common';
@Module({
providers: [ChatGateway, PresenceService],
exports: [PresenceService],
})
export class EventsModule {}
// HTTP 侧触发推送: controller 调 service, service 注入 ChatGateway 调 server.to(...).emit
// ⚠️ 推送入口收敛成一个 NotificationService(业务不直接摸 gateway):
// 换传输层(SSE/WS/推送服务)时业务零改动(270 题选型的前提)
总结:网关 = 连接生命周期 + 消息路由 + 房间广播;消息命名用域前缀;推送统一出口封装;房间管理交给 socket.io,跨实例才需要 Redis adapter(268 题)。
追问1:namespace 和 room 的区别? → namespace 是协议级隔离(不同握手路径,独立中间件/权限模型);room 是运行时分组(动态进出)——多业务线用 namespace,会话分组用 room 追问2:返回值 ack 和主动 emit 怎么选? → ack 用于”这次调用的直接结果”(请求响应语义);服务端主动推送必须 emit——混用会让客户端状态机混乱 追问3:消息体大小有限制吗? → socket.io 单帧受 maxHttpBufferSize 配置(默认 1MB)与内存约束;大负载走 HTTP/对象存储 + WS 只发事件引用(224 题)
265. WebSocket 鉴权:握手 token 与连接级权限?
概念 WS 鉴权与 HTTP 的差异:Guard/Pipe 不直接作用于网关,鉴权要在握手阶段(handleConnection 或 socket.io 的 namespace 中间件)自己做;连接是长活的——token 会过期,要处理”连接活着但凭证死了”;权限是连接级 + 房间级两层(能连上 ≠ 能进任何房间)。
典型场景 聊天连接 24 小时不断,access token 30 分钟过期,之后还能发消息(事故);房间权限只在进房时校验,权限变更后仍能收房间消息。
解决方案 三步:握手验 token → 长连接的 token 续期 → 权限变更生效。
第一步:握手鉴权(两种写法)
// 文件: ws-auth.ts
@WebSocketGateway({ namespace: '/chat' })
export class ChatGateway {
async handleConnection(client: Socket) {
// 方式 A: 在这里验(简单直接)
// token 首选 handshake.auth(握手帧字段, 不进 URL 日志); query 会留在访问日志里
const token = client.handshake.auth?.token ?? client.handshake.query?.token;
try {
client.data.user = await this.jwt.verifyAsync(token); // 双 token 体系见 233 题
} catch {
client.disconnect(true); // 鉴权失败: 拒绝连接
return;
}
}
}
// 方式 B: socket.io namespace 中间件(多网关复用统一鉴权):
// io.use(async (socket, next) => {
// try { socket.data.user = await verify(socket); next(); } catch { next(new Error('unauthorized')); }
// });
第二步:长连接的 token 续期
// 文件: token-refresh.ts
// 模式 1: 主动续 —— 客户端刷新 access token 后, 发一条 ws 消息换凭证
@SubscribeMessage('auth:renew')
async onRenew(@ConnectedSocket() client: Socket, @MessageBody() { token }: { token: string }) {
try {
client.data.user = await this.jwt.verifyAsync(token);
return { ok: true, expireAt: client.data.user.exp };
} catch {
client.disconnect(true);
return { ok: false };
}
}
// 模式 2: 被动查 —— refresh token 轮换时把旧 access 加 Redis 黑名单,
// 每条敏感消息处理前查黑名单(本地缓存 5s 降开销)
// ⚠️ 不做续期的系统 = 长连接权限真空期, 上线前必须二选一
第三步:权限变更生效
// 文件: perm-revoke.ts
// 用户被踢出房间/封禁时, 已建立的连接要立刻生效:
async revokeRoom(userId: string, room: string) {
for (const [, socket] of this.server.of('/chat').sockets) {
if (socket.data.user?.sub === userId) {
await socket.leave(room); // 主动移出房间
socket.emit('room:revoked', { room }); // 通知客户端状态
}
}
}
// 全局封禁(踢下线): socket.disconnect(true) + Redis 黑名单挡住重连(272 题连接治理)
// 权限校验原则: 进房时校验 + 定期重验(房间级 TTL 重查), 别假设权限终身有效
总结:WS 鉴权三件事:握手挡门外、token 过期处理在连接内(renew 消息或黑名单)、权限变更加主动清理;HTTP Guard 的心智搬过来要改造成”连接级 + 房间级 + 时效性”三层。
追问1:token 放 query 还是 auth? → socket.io 的 handshake.auth 优先:不进 URL 日志;query 只适合临时调试场景 追问2:wss 之外还需要应用层加密吗? → 传输已加密;端到端保密(服务端也不可见)才需要应用层加密——一般 IM 不需要,合规聊天另说 追问3:多实例下怎么找用户的所有连接? → 连接注册表进 Redis(userId → 连接列表),268 题 adapter 同款基础设施
266. 心跳与断线重连:ping/pong 与指数退避?
概念 连接存活检测靠心跳:socket.io 服务端默认每 25s 发 ping,超过 pingTimeout 没 pong 判死;TCP half-open(拔网线/NAT 超时)不靠心跳根本发现不了。客户端重连必须指数退避 + 抖动——万人同时断电来电,固定间隔重连会打死服务端(重连风暴)。
典型场景 手机 App 切后台被系统杀连接;地铁进出隧道批量断连恢复;NAT 表项超时导致的”假连接”(发消息才发现不通);LB 空闲超时周期性掐连接。
解决方案 三步:服务端心跳参数 → 客户端退避重连 → 重连后的状态补偿。
第一步:服务端心跳参数(与中间设备对齐)
// 文件: gateway-hb.ts
@WebSocketGateway({
namespace: '/chat',
pingInterval: 20_000, // 服务端 ping 周期: 要比中间设备(NAT/LB)空闲超时短
pingTimeout: 30_000, // 等 pong 上限: 超时判死, 触发 disconnect 清理
})
export class ChatGateway {}
// ⚠️ 中间层对齐: LB 的 idle timeout(如 ALB 默认 60s)必须 > pingInterval,
// 否则 LB 先掐"空闲"连接 —— 症状是周期性掉线且时间点规律
第二步:客户端指数退避 + 抖动
// 文件: client-reconnect.ts
import { io } from 'socket.io-client';
const socket = io('wss://app.corp/chat', {
reconnection: true,
reconnectionAttempts: Infinity,
reconnectionDelay: 1000, // 首次 1s
reconnectionDelayMax: 30_000, // 封顶 30s
randomizationFactor: 0.5, // 抖动: 每次间隔 ±50% —— 防重连风暴的关键参数
});
socket.io.on('reconnect_attempt', () => {
// 重连时可刷新 token(265 题续期钩子)
});
// 应用层再补一个"看起来连着其实死了"的 watchdog:
// 每 30s 发一条 ping 事件, 10s 没 ack 就主动 socket.disconnect() 触发标准重连流程
第三步:重连后的状态补偿
// 文件: resume.ts
// 重连 ≠ 状态恢复: 房间要重进、订阅要重订、错过的消息要补
@SubscribeMessage('sys:hello')
async onHello(@ConnectedSocket() client: Socket) {
// 服务端在连接建立后告诉客户端"你需要恢复什么":
return {
serverTime: Date.now(),
lastSeq: await this.seqStore.lastSeqFor(client.data.user.sub), // 267 题序号
rooms: await this.knownRoomsOf(client.data.user.sub),
};
}
// 客户端: 对比本地 lastSeq → 差距小直接拉增量, 差距大走全量刷新;
// 房间按需重进(恢复最小集, 别盲目全重进)
总结:心跳参数要与中间设备超时对齐(LB idle > pingInterval);重连退避加抖动防风暴;重连后按 lastSeq 做状态补偿——“连接恢复”和”状态恢复”是两件事,后者要显式设计。
追问1:协议层 ping/pong 和应用层心跳选哪个? → 协议层够用就不造轮子;需要业务可见性(客户端 UI 显示”弱连接”)时加应用层心跳,两者不冲突 追问2:服务端要不要限制重连频率? → 要:同 token 短时间高频重连直接拒绝一段(退避惩罚),272 题连接治理的一部分 追问3:手机端的省电与心跳冲突怎么办? → 移动端用系统推送(APNs/FCM)兜底通知,前台才保长连接——纯 WS 方案在移动端不成立,要混合通道
267. 消息可靠性:ack、离线消息与去重?
概念 WS 的默认语义是 at-most-once:断线期间的消息直接丢、发送方不知道对方收没收到。可靠性三件套:ack 回执(至少送到)、离线消息(补上断线窗口)、seq 序号(去重与补洞)。组合后得到 at-least-once + 客户端幂等 = 业务可靠的交付。
典型场景 聊天消息”发了但对方没收到”;下单通知断线丢失;重连补发导致同一消息显示两次。
解决方案 三步:发送方 ack 队列 → 接收方离线补投 → 双端去重。
第一步:发送方——ack + 超时重发
// 文件: sender-ack.ts
import * as crypto from 'node:crypto';
class ReliableSender {
private pending = new Map<string, { payload: unknown; retries: number; timer: NodeJS.Timeout }>();
send(socket: Socket, event: string, payload: unknown, msgId = crypto.randomUUID()) {
socket.emit(event, { msgId, payload });
const timer = setTimeout(() => this.retry(socket, event, msgId), 3_000);
this.pending.set(msgId, { payload, retries: 0, timer });
socket.once(`ack:${msgId}`, () => { // 接收方回执
clearTimeout(this.pending.get(msgId)!.timer);
this.pending.delete(msgId);
});
}
private retry(socket: Socket, event: string, msgId: string) {
const entry = this.pending.get(msgId);
if (!entry || ++entry.retries > 5) return this.deadLetter(msgId, entry); // 进死信(人工/降级)
socket.emit(event, { msgId, payload: entry.payload }); // 幂等重发
entry.timer = setTimeout(() => this.retry(socket, event, msgId), 3_000 * 2 ** entry.retries);
}
}
第二步:接收方——离线消息表 + 上线补投
// 文件: offline-store.ts
// 投递模型: 先落库再推送(顺序不能反 —— 反了就有丢消息窗口)
async deliver(userId: string, message: ChatMessage) {
await this.repo.insert({ ...message, seq: await this.nextSeq(userId) }); // per-user 单调序号
this.push(userId, message); // 在线: 直接推; 失败/离线无所谓, 反正已落库
}
async onReconnect(client: Socket, lastClientSeq: number) { // 266 题 hello 事件触发
const missed = await this.repo.findAfter(client.data.user.sub, lastClientSeq);
for (const m of missed) client.emit('chat:message', m); // 补投
}
第三步:接收方去重——msgId 精确 + seq 单调
// 文件: dedupe.ts
// at-least-once 必然重复(重发 + 补投重叠), 客户端幂等:
class MessageWindow {
private lastSeq = 0;
private seen = new Set<string>();
accept(m: { msgId: string; seq?: number }): boolean {
if (this.seen.has(m.msgId)) return false; // 精确去重(重发场景)
if (m.seq !== undefined && m.seq <= this.lastSeq) return false; // 序号过滤(补投场景)
if (m.seq !== undefined) this.lastSeq = m.seq;
this.seen.add(m.msgId);
if (this.seen.size > 1000) this.seen.clear(); // 窗口滚动, 防泄漏
return true;
}
}
// 服务端对等义务: 消费客户端上行也按 msgId 幂等(280 题同思想, 双向都要)
总结:可靠交付 = 落库先行 + ack 重发 + 离线补投 + 双端幂等;seq 解决”补多少”的账本问题,uuid 解决”重复识别”;只做单向(下行)可靠是常见偷懒,上行同样会丢。
追问1:为什么落库必须在推送前? → 反过来存在”推送成功但落库失败”与”落库前断线”的窗口;先落库最坏情况是多推,交给幂等消化 追问2:seq 用什么生成? → per-user 的 Redis INCR(单调 + 高性能);全局时钟不可靠(多实例回拨/乱序) 追问3:离线消息存多久? → 按产品定(聊天 7~30 天),超期归档冷存;补投窗口超限直接引导走历史消息接口分页拉
268. WebSocket 水平扩展:Redis adapter 与 sticky session?
概念 WS 网关是有状态的(连接绑在实例上),扩容两个问题:跨实例路由(实例 A 上的用户给实例 B 上的用户发消息,B 怎么知道要推)——Redis adapter 把 emit 广播到所有实例,各实例只推自己的连接;握手粘性(升级请求必须路由到同一实例,后续连接才稳定)——sticky session。
典型场景 单实例 5 万连接到顶,要扩到 4 实例;扩容后发现”跨实例消息发不通”;K8s 滚动更新时连接集中断开引发重连风暴。
解决方案 三步:Redis adapter 接入 → sticky session 配置 → 广播放大治理。
第一步:Redis adapter
// 文件: adapter.ts
import { createAdapter } from '@socket.io/redis-adapter';
import { createClient } from 'redis';
import { Server } from 'socket.io';
export function setupAdapter(io: Server) {
const pubClient = createClient({ url: process.env.REDIS_URL });
const subClient = pubClient.duplicate();
await Promise.all([pubClient.connect(), subClient.connect()]);
io.adapter(createAdapter(pubClient, subClient));
// 原理: server.to(room).emit 时, 本实例直推自己的房间成员, 同时向 Redis 发布;
// 其他实例订阅到后各自推自己的成员 —— emit 语义在集群维度成立
}
第二步:sticky session(握手粘性)
# 文件: ingress-sticky.yaml
# HTTP 升级 WS 后连接锚定在实例上, 后续帧不能再漂移 —— 升级请求必须落到同一实例:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
annotations:
nginx.ingress.kubernetes.io/affinity: "cookie" # cookie 粘性
nginx.ingress.kubernetes.io/session-cookie-name: "srv"
spec:
rules:
- http:
paths:
- path: /socket.io
pathType: Prefix
backend:
service:
name: chat-svc
port: { number: 3000 }
# ⚠️ K8s 滚动更新时 sticky 也会重分配: 配合 249 题优雅停机 + 266 题客户端退避, 断连可收敛
第三步:广播放大治理
// 文件: broadcast-budget.ts
// adapter 的代价: 每个 emit 都扇出到全部实例(不管该实例有没有目标连接)——
// 万人在线 + 高频小消息时, Redis 发布带宽与各实例空转都是成本。
// 治理 1: 大房间拆小 —— 万人直播间拆成 N 个分片房间, 服务端分批推
// 治理 2: 按实例定向 —— 自维护 userId → 实例 的注册表(Redis), 只发给目标实例
async pushToUser(userId: string, event: string, payload: unknown) {
const instances = await this.registry.instancesOf(userId); // 连接注册表(265 题同款)
for (const inst of instances) {
await this.redis.publish(`push:${inst}`, JSON.stringify({ userId, event, payload }));
}
}
// 治理 3: 合并碎消息(攒 50ms 批量推), 高频场景能把消息量降一个数量级
总结:WS 扩容 = Redis adapter(消息跨实例)+ sticky(握手粘性)+ 广播治理(拆房间/定向/合并);规模再大,从”广播扇出”演进到”连接注册表 + 定向推送”。
追问1:Redis adapter 挂了会怎样? → 跨实例消息丢(本实例的还能通);adapter 断线重连机制会恢复,期间降级:关键消息走落库 + 客户端拉取(267 题) 追问2:sticky session 和 JWT 鉴权冲突吗? → 不冲突:粘性是路由层(LB cookie),鉴权是应用层;但 cookie 要在 WS 握手前就位(首次 HTTP 请求通过同域种下) 追问3:为什么不用 Redis Stream 做消息通道? → Stream 适合消费语义(离线/回放);实时推送要低延迟扇出,pub/sub 更贴;两者常组合(推送 pub/sub + 补偿 Stream)
269. 房间与在线状态:状态同步怎么做一致?
概念 在线状态的存储分层:单实例可放内存 Map,多实例必须进 Redis(key 带 TTL 由心跳续期,实例崩溃残留靠 TTL 自然过期);一致性难点是”崩溃残留”(disconnect 没跑)与”竞态”(同时进出的乱序)。解法:TTL 兜底 + 序号/版本比较 + 服务端为唯一事实源。
典型场景 显示”在线/离线/最后活跃”;协作房间里”谁在看这个文档”;推送给”所有在线的管理员”。
解决方案 三步:Redis 在线表 → 房间成员一致性 → 状态变更的编排。
第一步:Redis 在线表(TTL 驱动)
// 文件: presence.ts
import { Injectable } from '@nestjs/common';
import type Redis from 'ioredis';
@Injectable()
export class PresenceService {
constructor(private readonly redis: Redis) {}
async heartbeat(userId: string, connId: string) {
// 每个"用户-连接"一个 key, TTL 60s; 客户端每 20s 心跳(266 题对齐)
await this.redis.set(`presence:${userId}:${connId}`, '1', 'EX', 60);
}
async isOnline(userId: string): Promise<boolean> {
// 生产用 SCAN 或维护 userId 索引集合, keys 仅示意
const keys = await this.redis.keys(`presence:${userId}:*`);
return keys.length > 0; // 任一连接活着 = 在线
}
async onDisconnect(userId: string, connId: string) {
await this.redis.del(`presence:${userId}:${connId}`); // 主动清理; 漏了 TTL 兜底
}
}
// 崩溃残留场景: 实例 OOM 死亡, disconnect 没跑 → key 60s 后自动过期 —— 自愈
第二步:房间成员——服务端事实源 + 序号防乱序
// 文件: room-state.ts
async joinRoom(client: Socket, room: string) {
await this.redis.hset(`room:${room}:members`, client.data.user.sub,
JSON.stringify({ connId: client.id, joinedAt: Date.now() }));
const members = await this.listMembers(room);
const roomVer = await this.redis.incr(`room:${room}:ver`); // 房间变更序号
this.server.to(room).emit('room:members', { members, roomVer });
// 客户端用 roomVer 单调性丢弃过期快照: 网络重排到达的旧成员列表不再覆盖新状态
}
// TTL 兜底: room key 设 24h 过期 + 每次访问续期, 无人房间自动消亡, 不用手动扫
第三步:在线状态变更的编排
// 文件: presence-events.ts
async onPresenceChange(userId: string, online: boolean) {
// 1) 好友列表刷新: 查关系表 → 给在线好友推 presence:update
const friends = await this.social.friendIds(userId);
for (const f of friends) this.pushIfOnline(f, 'presence:update', { userId, online });
// 2) 抖动抑制: 30 秒内重复变更合并(地铁进出隧道), 延迟 5s 再广播"稳定态"
// 3) 指标: 在线连接数/房间数进 prom-client(298 题), 容量与成本都靠它
}
总结:在线状态 = Redis TTL 表(崩溃自愈)+ 服务端唯一事实源 + 序号防乱序 + 抖动抑制;内存 Map 只属于单实例玩具期;状态变更当作事件编排,别在连接回调里直接写业务。
追问1:为什么 key 按”用户-连接”而不是按用户? → 多端登录(手机+电脑)各自心跳各自过期;用户级状态由”存在任一连接”推导 追问2:最后活跃时间怎么算? → 心跳顺带 ZADD timestamp;展示”3 分钟前活跃”读排序集合,别为展示做高频写 追问3:万人房间成员列表别全量推? → 全量推是 O(n) 消息体;拆分:只推增量(进/出事件),新进成员拉一次快照——267 题可靠性同样适用
270. SSE、WebSocket 与轮询:实时方案怎么选?
概念 三种服务端推数据姿势:轮询(客户端定时拉,实现最简单,延迟=间隔,浪费在空转);SSE(HTTP 长连接单向推,EventSource 原生自动重连,过 CDN/代理/鉴权头全兼容,文本帧);WebSocket(全双工二进制,需要升级握手与独立网关心智)。选型核心:只需要服务端单向推 → SSE;要双向低延迟交互 → WS;兼容性兜底/极低频 → 轮询。
典型场景 LLM 流式输出(单向,SSE 即可,247 题);协作文档(双向,WS);价格 ticker 每秒推(单向高频,SSE 也够);老企业内网代理不支持升级(轮询兜底)。
解决方案 三步:SSE 极简与限制 → WS 的能力与代价 → 决策清单。
第一步:SSE——单向推送的最短路径
// 文件: sse-quick.ts
import { Controller, Get, Sse } from '@nestjs/common';
import { Observable, interval, map } from 'rxjs';
@Controller('events')
export class EventsController {
@Get('price')
@Sse()
price(): Observable<MessageEvent> {
return interval(1000).pipe(map(() => ({
data: JSON.stringify({ price: nextPrice() }), // 只能文本; 二进制要 base64
})));
}
}
// SSE 白送的能力: 浏览器 EventSource 断线自动重连(带 Last-Event-ID 头做续传);
// HTTP 中间件全兼容(鉴权/压缩/CDN)—— 运维成本几乎为零
// SSE 的限制: 单向、HTTP/1 下同域 6 连接上限(HTTP/2 多路复用解决)、纯文本帧
第二步:WS——双向与低延迟的代价清单
# 文件: ws-cost.txt
WS 换来什么:
客户端主动高频上报(游戏/协作的光标)
二进制帧(音频/protobuf)
单条连接上的请求-响应多路复用(不受 HTTP 并发连接数约束)
付出什么(每一项都是一套工程):
有状态网关 → 268 题水平扩展全套
自定义重连/心跳 → 266 题
可靠性语义自建 → 267 题
鉴权模型独立 → 265 题
连接治理 → 272 题
结论: WS 的"双向"很贵, 先确认真的需要
第三步:决策清单
# 文件: decision.txt
按顺序回答:
1) 数据只从服务端流向客户端? → 是: 候选 SSE; 否: WS
2) 推送频率低于 1 条/秒 且能接受 3~5s 延迟? → 是: 轮询也能交差(监控面板类)
3) 走 SSE 的话: 需要客户端上行控制(如取消生成)?
→ 取消可用普通 POST 叠加(247 题 SSE + POST /cancel), 不必上 WS
4) 选了 WS: 把 265~269 五题清单过一遍, 成本评估后再拍板
常见组合拳: LLM 流式(SSE)+ 会话历史(REST)+ 用户中断(POST)——
三件套覆盖大多数"伪双向"场景
总结:单向推优先 SSE(运维近零、重连原生);真双向/二进制/高频上行才上 WS,并接受一整套网关工程;轮询是低频与兜底;先把”伪双向”需求拆解成 SSE+REST,往往就不需要 WS。
追问1:SSE 的 Last-Event-ID 续传原理? → 服务端给每条消息编 id,断线重连带上最后的 id,服务端从后补发——267 题离线消息的 SSE 版 追问2:HTTP/2 对 SSE 的意义? → 同域名多条 SSE 共享一个 TCP 连接(多路复用),绕开 HTTP/1 的 6 连接上限 追问3:WS 能过 CDN 吗? → 一般不能(CDN 缓存/升级支持差),WS 域名要直连源站或专用 LB;SSE 可以过——这是基础设施成本差异的实例
271. AI 流式对话:WebSocket 通道的工程细节?
概念 AI 对话推送可以走 SSE(247 题),WS 通道的额外价值:多轮状态与连接绑定、用户主动中断(上行控制帧)、多路并发(同一连接里多个会话的 chunk 交错)、打字指示/输入态这类高频双向小消息。核心工程点:会话与连接解耦(taskId 寻址)、chunk 的顺序与成帧(done 语义)、取消传播(226 题)、断线恢复。
典型场景 客服 IM 里嵌 LLM 回复;一个用户开两个对话窗口并行生成;生成中途用户点”停止”。
解决方案 三步:消息协议与多路复用 → 流式转发与取消 → 断线恢复。
第一步:消息协议——多路复用靠 conversationId
// 文件: ai-chat.gateway.ts
import { ConnectedSocket, MessageBody, SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';
import type { Socket } from 'socket.io';
@WebSocketGateway({ namespace: '/ai' })
export class AiChatGateway {
private sessions = new Map<string, AbortController>();
@SubscribeMessage('chat:ask')
async onAsk(@ConnectedSocket() client: Socket, @MessageBody() body: { conversationId: string; text: string }) {
const ac = new AbortController();
this.sessions.set(`${client.id}:${body.conversationId}`, ac); // 会话寻址: 连接内多路并行
const upstream = await this.llm.stream(body.text, { signal: ac.signal });
for await (const chunk of upstream) {
client.emit('chat:chunk', { conversationId: body.conversationId, delta: chunk.text }); // 交错但各自按序
}
client.emit('chat:done', { conversationId: body.conversationId, usage: upstream.usage }); // 成帧结束
}
}
第二步:用户中断——上行控制帧
// 文件: ai-cancel.ts
@SubscribeMessage('chat:stop')
async onStop(@ConnectedSocket() client: Socket, @MessageBody() { conversationId }: { conversationId: string }) {
const ac = this.sessions.get(`${client.id}:${conversationId}`);
ac?.abort('user stopped'); // 226 题: 取消传播到上游, 停止烧 token
this.sessions.delete(`${client.id}:${conversationId}`);
client.emit('chat:stopped', { conversationId });
}
// ⚠️ 停止 ≠ 丢弃: 已生成的部分要不要入库/计费是产品决策 —— 在 AbortError 分支里统一收尾
// 计费按上游返回的 usage 结算(含中断), 别自己数 chunk
第三步:断线恢复——生成不随连接陪葬
// 文件: ai-resume.ts
async handleConnection(client: Socket) {
// 任务句柄落 Redis(状态机: running → done/stopped), 推送只是"投影"
const running = await this.tasks.runningOf(client.data.user.sub);
for (const t of running) {
this.bridge.attach(t.id, client); // 把新连接挂回任务的推送通道(268 题注册表变体)
client.emit('chat:resume', { conversationId: t.conversationId, soFar: t.bufferedChunks });
}
}
// 生成任务与连接解耦: 后台跑(除非策略要求连接断即停);
// chunk 高频不落库(写放大), done 落全文; 进行中缓冲在 Redis(TTL)
总结:AI 对话 WS 三原则:会话与连接解耦(taskId 寻址)、成帧协议明确(chunk/done/stopped)、取消与恢复显式建模;token 计费与入库收尾在服务端 finally,不依赖连接存活。
追问1:为什么 chunk 不落库、done 才落全文? → chunk 高频写放大;done 落全文 + 进行中缓冲在 Redis(TTL),断线恢复拼缓冲即可 追问2:同一用户多设备怎么同步对话? → 任务广播给该用户全部连接(269 题在线表),不是只发发起连接——手机发起电脑能看 追问3:LLM 网关层的重试会不会重复生成? → 上游 5xx 重试要换流(旧流 abort),且同 conversation 幂等键防双跑(280 题)
272. 连接治理:限连、封禁与降级?
概念 WS 网关是稀缺资源(每连接内存 + fd + 心跳成本),必须治理:单用户连接数上限(多端重复登录策略)、全局水位(在线连接数接近容量时的行为)、封禁(黑名单断连 + 挡重连)、大房间降级。原则:所有”拒绝”都要给客户端明确语义(机器可读 code),别静默断。
典型场景 恶意客户端开 500 条连接;大促在线数超容量,新用户连不上;被封用户立刻重连如入无人之境。
解决方案 三步:限连与挤下线 → 封禁链路 → 水位降级。
第一步:单用户限连与挤下线策略
// 文件: conn-limit.ts
async handleConnection(client: Socket) {
const userId = client.data.user.sub;
const conns = await this.presence.connectionsOf(userId); // 269 题在线表
if (conns.length >= 3) {
if (this.policy === 'reject') {
client.emit('sys:error', { code: 'TOO_MANY_CONNECTIONS' }); // 拒绝语义明确
return client.disconnect(true);
}
// 挤下线策略: 踢最老的(策略要显式: 踢最老或按设备优先级, 别随机)
const oldest = [...conns].sort((a, b) => a.joinedAt - b.joinedAt)[0];
const target = (await this.server.of('/chat').fetchSockets()).find((s) => s.id === oldest.connId);
target?.emit('sys:kicked', { reason: 'logged-in-elsewhere' });
target?.disconnect(true);
}
await this.presence.register(userId, client.id);
}
第二步:封禁链路——断得掉也进不来
// 文件: ban.ts
async ban(userId: string, ttlSec: number) {
await this.redis.set(`ban:${userId}`, '1', 'EX', ttlSec);
for (const socket of await this.server.of('/chat').fetchSockets()) {
if (socket.data.user?.sub === userId) {
socket.emit('sys:banned', { until: Date.now() + ttlSec * 1000 });
socket.disconnect(true); // 1) 断现有
}
}
}
// 3) 挡重连: handleConnection 里查 ban key, 命中即拒
// 4) 情报共享: 封禁原因与设备指纹进风控, 同设备换号也命中(配合 245 题限流维度)
第三步:水位降级——接近容量时有序拒新
// 文件: admission.ts
async handleConnection(client: Socket) {
const online = await this.metrics.currentConnections();
const capacity = this.capacityPerInstance; // 压测定出(286 题), 留 20% 余量
if (online > capacity * 0.95) {
// 分级: 95% 拒新免费用户, 98% 全拒 —— 都带 Retry-After 语义
client.emit('sys:error', { code: 'SERVER_BUSY', retryAfterMs: 30_000 });
return client.disconnect(true);
}
// 存量连接的功能降级: 关闭非核心推送(礼物动画/在线状态广播), 保住消息主链路
this.featureFlags.set('presence-broadcast', online < capacity * 0.8); // 282 题开关体系联动
}
// 降级动作前置演练(299 题): 水位降级没演练过 = 上线第一次触发就是事故
总结:连接治理四板斧:限连(拒绝或挤下线,语义明确)、封禁(断存量 + 挡增量)、水位(分级拒新 + 功能降级)、容量红线靠压测;所有拒绝都带机器可读 code 与 retryAfter。
追问1:挤下线踢哪条连接? → 策略显式化:踢最老(移动优先保新设备)或按设备类型优先级;别留随机——客户端无法解释 追问2:连接数容量怎么估? → 单实例压测(内存/fd/心跳 CPU 三条曲线找拐点)× 实例数 × 0.8;观测指标常驻(298 题) 追问3:拒绝语义为什么重要? → 客户端拿到 TOO_MANY_CONNECTIONS 能引导退出旧设备;静默断只会触发疯狂重连(266 题)放大故障
273. socket.io 与原生 ws:协议成本与取舍?
概念 socket.io 在 ws 之上的增值:自动重连(退避策略内建)、事件名与 ack、房间、命名空间;成本:私有协议(EIO 握手 + 帧封装,客户端必须配套 socket.io-client)、每帧额外字节、生态锁死(服务端只能配同主版本的 socket.io 客户端)。原生 ws 是 RFC 6455 标准:任何客户端(浏览器/非 JS)即连即用,但重连/房间/ack 全自建。
典型场景 纯 Web 前后端(客户端版本可控);要对接非 JS 客户端(Go 服务/嵌入式/小程序原生 WebSocket);对帧开销敏感(高频二进制)。
解决方案 三步:成本量化 → 原生 ws 网关 → 决策与混合路线。
第一步:成本看清楚
# 文件: cost.txt
socket.io 每条消息: ["42","event-name",payload] 的封装(事件名 + JSON 数组), ack 再加一层 id 映射
→ 高频小消息场景, 协议开销占比可观; 二进制要额外配置 parser
原生 ws: 发什么是什么(文本/二进制帧), 协议零加成
生态锁定: socket.io 服务端只能配 socket.io 客户端(同主版本) —— 跨语言要找对应实现(有, 但版本坑)
标准性: ws 直连 wss://, 浏览器 new WebSocket() 就能用, wscat 调试友好
第二步:原生 ws 的 Nest 网关
// 文件: raw-ws.gateway.ts
import { ConnectedSocket, MessageBody, SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';
import type { WebSocket } from 'ws';
@WebSocketGateway({ path: '/ws' })
export class RawGateway {
@SubscribeMessage('echo')
async onEcho(@ConnectedSocket() client: WebSocket, @MessageBody() data: unknown) {
client.send(JSON.stringify({ type: 'echo-reply', data })); // 裸协议: 消息格式自己定
}
}
// main.ts: const app = await NestFactory.create(AppModule, new WsAdapter(app));
// 自建清单(把 socket.io 白送的重造一遍): 重连退避(客户端)、心跳、房间表、ack 协议
// —— 工作量约等于 265~269 题各做一遍的简配版
第三步:决策与混合路线
# 文件: decision.txt
选 socket.io: Web 前端 own 全链路、要房间/ack/重连开箱即用、客户端版本可控(自家 App/管理台)
选 ws: 非 JS 客户端、小程序原生 WebSocket、协议要对外公开(第三方接入)、高频二进制
混合路线: 对外开放 ws 端点 + 内部实时用 socket.io —— 两套网关并存, 但消息层统一走
一个 NotificationService(264 题收敛出口), 传输层差异不外溢
降级注意: socket.io 的 polling 降级如今只在古董环境有意义, 反而成为攻击面 ——
生产建议 transports: ['websocket'] 强制纯 ws
总结:socket.io 卖的是工程效率(重连/房间/ack),收的是协议税与生态锁定;原生 ws 卖的是标准与轻,收的是自建工作量;跨语言/开放协议场景 ws 几乎是唯一解;无论选谁,业务代码只依赖统一的消息出口。
追问1:socket.io 的帧为什么是 JSON 数组? → 协议设计:[类型码, …] 前缀区分事件/ack/心跳;也是开销来源——二进制场景可配 msgpack parser 追问2:微信小程序能用 socket.io 吗? → 小程序原生 WebSocket 是标准 ws,socket.io 官方客户端跑不了(需要适配层)——这类场景直接 ws 追问3:两个网关并存会不会双倍连接成本? → 端点分路径(/ws 开放,/socket.io 内部),成本按各自连接数算;真正要防的是业务逻辑写两遍——收敛出口是纪律
五、Nest 微服务与工业化(274–287)
274. RabbitMQ 路由深入:exchange、死信与延迟消息?
概念 RMQ 的路由三层:producer → exchange(分发逻辑)→ binding(routing key 匹配)→ queue。exchange 四型:direct(key 精确)、topic(通配 order.*)、fanout(广播)、headers。可靠性三件套:持久化(durable + persistent 消息)、手动 ack、死信队列(DLX:消费失败/过期/超长的消息转入,人工处理或重试)。延迟消息:队列级 TTL + DLX(死信化实现)或延迟插件。
典型场景 订单 15 分钟未支付自动取消;一批消息消费失败要”稍后重试”而不是无限循环;同一事件多种消费者各自订阅(通知/积分/分析)。
解决方案 三步:topic 路由组织 → 失败重试与死信链 → TTL 延迟队列。
第一步:topic exchange 组织多消费者
// 文件: rmq-topology.ts
// 发布: exchange = 'order.events', routingKey = 'order.created' / 'order.paid' / 'order.cancelled'
// 队列与绑定:
// notify.queue ← order.* (全部订单事件 → 通知)
// points.queue ← order.paid (只有支付 → 积分)
// analytics.queue ← order.# (含多层后缀的全量 → 分析)
await ch.assertExchange('order.events', 'topic', { durable: true });
await ch.assertQueue('points.queue', { durable: true, deadLetterExchange: 'order.dlx' });
await ch.bindQueue('points.queue', 'order.events', 'order.paid');
// ⚠️ 队列归消费者定义(topology 由消费方声明), 新消费者加队列不改生产者 —— 解耦的本质
第二步:失败重试与死信链
// 文件: rmq-retry.ts
await ch.consume('points.queue', async (msg) => {
try {
await handle(msg);
ch.ack(msg);
} catch (err) {
const retry = Number(msg.properties.headers?.['x-retry'] ?? 0);
if (retry < 3) {
// 重试队列: TTL 30s 后死信回主队列(经典"延迟重试"拓扑)
ch.publish('retry.exchange', '', msg.content, {
headers: { 'x-retry': retry + 1 },
expiration: 30_000, // TTL 到期 → DLX → 转回 points.queue
});
} else {
ch.publish('dlq.exchange', '', msg.content, { headers: { 'x-retry': retry, err: String(err) } });
}
ch.ack(msg); // 处理完毕(转投也算处理), 不 ack 会无限重投
}
}, { prefetch: 4 }); // qos: 同时最多 4 条在途(229 题池思想同源)
// DLQ 治理: 死信必须有监控与处理台(重放/丢弃/修复), 只进不出的 DLQ 是伪可靠
第三步:延迟消息(订单超时取消)
// 文件: rmq-delay.ts
// 方案: TTL + DLX —— 延迟队列无消费者, 消息过期死信到真实队列
await ch.assertQueue('order.timeout.15m', {
arguments: {
'x-dead-letter-exchange': 'order.events',
'x-dead-letter-routing-key': 'order.timeout',
'x-message-ttl': 15 * 60 * 1000, // 队列级 TTL 统一延迟
},
});
// 发布侧: 创建订单时 publish 到 order.timeout.15m;
// 15 分钟后消息自动出现在 order.events(routingKey = order.timeout)
// 消费侧判活: 已支付的订单直接忽略 —— 延迟消息是"提醒"不是"事实"
// ⚠️ 消息级 TTL 有队头阻塞坑(前面 30 分钟的挡住后面 1 分钟的), 统一延迟用队列级 TTL 规避;
// 任意延迟上官方延迟插件(rabbitmq_delayed_message_exchange)或 Redis ZSET 方案(277 题 BullMQ)
总结:RMQ 路由记忆点:exchange 定分发策略、队列归消费者声明;可靠链 = durable + 手动 ack + 重试拓扑 + DLQ 治理;延迟消息队列级 TTL 最稳,任意延迟换插件或任务队列;消费幂等永远自己兜(280 题)。
追问1:fanout 和 topic 的选择? → fanout 无条件广播(所有绑定队列全收);topic 要按 key 过滤——“全部 vs 过滤”一句话分清 追问2:prefetch 设多少合适? → 消费快设大(吞吐),慢/重设 1~4(防打挂下游与乱序);目标是让消费者”总有活干但不积压” 追问3:quorum queue 是什么? → 基于 Raft 的仲裁队列(替代经典镜像队列),节点多数派确认才 ack——金融级可靠场景开启
275. gRPC 传输器:proto 契约、死线与拦截器?
概念 gRPC:HTTP/2 + protobuf 二进制的 RPC 协议;Nest 微服务 transporters 之一。proto 是契约:字段编号不可复用(改类型可以改编号不行,兼容性铁律);四种模式 unary/server-stream/client-stream/bidi-stream。工程三件套:deadline(死线,超时显式传播)、retry policy(声明式重试)、interceptor(拦截器,鉴权/日志/tracing 横切)。
典型场景 内部服务高频调用(比 JSON 快数倍);跨语言(Python 算法服务 ↔ Node 网关);强契约团队协作(proto 即文档)。
解决方案 三步:proto 契约与两端接入 → 死线与重试 → 拦截器横切。
第一步:proto 契约
# 文件: embedding.proto
syntax = "proto3";
package embedding.v1;
service Embedding {
rpc Vectorize (VectorizeRequest) returns (VectorizeReply); # unary
rpc StreamCorpus (stream Doc) returns (stream VectorReply); # 双向流: 边传边算
}
message VectorizeRequest {
string text = 1;
# 兼容性铁律: 字段编号一旦发布不可复用/不可改; 弃用加 reserved
reserved 2;
reserved "model_version";
string model = 3;
}
message VectorizeReply {
repeated float vector = 1;
uint32 dim = 2;
}
// 文件: grpc-server.ts
import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';
@Controller()
export class EmbeddingController {
@GrpcMethod('Embedding', 'Vectorize')
vectorize(data: { text: string; model: string }): { vector: number[]; dim: number } {
return { vector: this.model.embed(data.text), dim: 768 };
}
}
// 客户端: clients.register('EMBED', { transport: Transport.GRPC,
// options: { package: 'embedding.v1', protoPath: 'embedding.proto' } })
// const svc = client.getService<EmbeddingClient>('Embedding'); await svc.vectorize(req)
第二步:死线与重试——超时要显式传播
// 文件: grpc-deadline.ts
// 客户端带死线(绝对时间点, 随调用链传播: A→B→C 共享同一个预算, 不是各算各的):
const reply = await svc.vectorize(req, { deadline: Date.now() + 5_000 });
// gRPC 声明式重试(service config, 需服务端/客户端两侧配合开启):
// { retryPolicy: { attempts: 3, initialBackoff: '0.1s', maxBackoff: '1s',
// retryableStatusCodes: ['UNAVAILABLE'] } } // 只重试"可重试"错误
// ⚠️ DEADLINE_EXCEEDED 别重试(预算已耗尽, 重试只会更糟);
// 应用层重试要幂等配合(280 题); 每层都 retry 会指数放大流量(284 题)
第三步:拦截器——横切关注点
// 文件: grpc-interceptor.ts
import * as grpc from '@grpc/grpc-js';
// client interceptor: 注入鉴权与 trace 头
const clientInterceptor: grpc.Interceptor = (options, nextCall) => {
return new grpc.InterceptingCall(nextCall(options), {
start: (metadata, listener, next) => {
metadata.set('authorization', `Bearer ${token()}`);
metadata.set('traceparent', currentTraceContext()); // 279 题 W3C traceparent
next(metadata, listener);
},
});
};
// server 侧: Nest 的 RpcInterceptor 或原生 server interceptor 验 token、打日志、抓异常指标
// 命名纪律: gRPC 状态码语义化(NOT_FOUND/INVALID_ARGUMENT/UNAVAILABLE), 别一律 UNKNOWN ——
// 网关层按状态码决定重试与降级(284 题)
总结:gRPC 的核心资产是 proto 契约(编号纪律)与 HTTP/2 多路复用;死线是”预算传播”不是”各层超时”;重试只打可重试错误;拦截器统一鉴权与 trace;对外网关仍走 REST/GraphQL,gRPC 留给内部。
追问1:protobuf 快在哪? → 二进制紧凑(字段编号代替名字)+ 编解码是生成代码的直线操作(无反射);代价是不可读——调试要 grpcurl 追问2:流式模式什么时候用? → 大 payload 分块(避免单帧内存)、渐进结果(逐条返回)、长会话双向(聊天通道)——unary 解决就别上流 追问3:gRPC 与 REST 怎么共存? → 外部 REST/GraphQL 网关 + 内部 gRPC 的分层最常见;proto 生成 TS 类型(protoc 插件),契约单一事实源
276. Kafka 传输器:分区有序与消费者组?
概念 Kafka 组织:topic 分 partition(并行单位),同 key 的消息进同分区(分区内 FIFO 有序——“按用户有序”靠 key=userId 保证);consumer group 内分摊分区(group 内并发度 ≤ 分区数),rebalance 在成员增减时重新分配。offset 语义:自动提交(可能重复消费)与手动提交(至少一次 + 幂等)。
典型场景 事件流按用户保序(乱序让状态机错乱);消费者扩容到超过分区数白扩;rebalance 期间消费停顿;lag 告警。
解决方案 三步:分区与 key 设计 → 消费组与手动提交 → rebalance 与 lag 治理。
第一步:分区与 key——有序的边界
// 文件: kafka-producer.ts
// 发布: key 决定分区(同 key 同分区 → 有序)
await client.emit('order.events', {
key: orderId, // ✅ 按 orderId 有序: 同一订单的事件不乱序
value: { type: 'ORDER_PAID', orderId, at: Date.now() },
});
// ⚠️ 有序粒度多细, key 就取到多细(订单级有序就 key=orderId, 不必 userId)
// 热点防护: 超大 key(网红店铺)会打满单分区 —— 高热实体加随机后缀拆分(牺牲其有序性换吞吐)
// 分区数规划: 目标吞吐 / 单分区吞吐 × 2 余量; 分区只能加不能减(减会破坏有序)
第二步:消费组与手动提交
// 文件: kafka-consumer.ts
import { Payload, Ctx, KafkaContext, EventPattern } from '@nestjs/microservices';
@EventPattern('order.events')
async onOrderEvent(@Payload() msg: OrderEvent, @Ctx() ctx: KafkaContext) {
const { topic, partition, offset } = ctx.getMessage();
try {
await this.handler.dispatch(msg); // 幂等消费(280 题): at-least-once 必然重复
await ctx.getConsumer().commitOffsets([{ topic, partition, offset }]);
} catch (err) {
// 不提交 → 重启后重消费; 处理不了的毒消息: 记录 + 跳过(提交)进死信表, 别阻塞分区
await this.dlq.record(topic, partition, offset, msg, err);
await ctx.getConsumer().commitOffsets([{ topic, partition, offset }]);
}
}
// ⚠️ 先处理后提交; 反过来(先提交后处理)会丢消息; 自动提交 interval 是吞吐与重复量的折中
第三步:rebalance 与 lag 治理
# 文件: kafka-ops.txt
rebalance 触发: 消费者加入/退出/崩溃, 或订阅变化 —— 期间整组停止消费(Stop-the-World)
治理:
1) cooperative sticky 分配策略: 增量再平衡(只挪必要分区), 避免全组停摆
2) 会话超时调优: 处理慢被误判死亡踢出(处理时长 < max.poll.interval.ms)
3) 部署滚动小步走(249 题思想): 一次只滚一个消费者实例
lag 监控: consumer lag = 分区最新 offset - 组已提交 offset
→ 告警阈值: lag 持续增长(消费不过来)或从 0 跳变(掉组)
→ 处置: 扩消费者(≤分区数)、加分区(注意 key 重分布)、查死信表有没有毒消息风暴
总结:Kafka 心智模型:分区是并行与有序的边界,key 定分区;group 定分摊;offset 定进度,先处理后提交;有序需求粒度 = key 粒度;运维重心在 rebalance 平稳与 lag 告警。
追问1:Kafka 和 RabbitMQ 怎么选? → Kafka:高吞吐事件流、回放、按 key 有序、消费者独立进度;RMQ:复杂路由、任务分派、延迟队列——事件总线选 Kafka,任务队列选 RMQ/BullMQ(277 题) 追问2:重复消费怎么彻底避免? → 做不到”彻底”,只能幂等消化:业务唯一键 + 去重表/Redis(280 题);exactly-once 有严格条件与性能代价 追问3:消息回放怎么做? → 重置组 offset 到历史位置(管理工具),前提:事件处理幂等 + 下游能承受重放流量
277. BullMQ 任务队列:延迟、重试与并发控制?
概念 BullMQ 是 Redis 后端的进程内任务队列(区别于 MQ 中间件:轻、API 亲和、无独立 broker)。能力全景:延迟任务(delay 到点执行)、重复任务(cron)、优先级、并发控制(worker concurrency)、重试(attempts + 指数退避)、进度上报、事件监听。典型落位:异步 embedding 生成、批量导入导出(225 题)、定时巡检。
典型场景 用户上传文档后异步”解析 → 切块 → embedding → 入库”;失败任务自动重试并在多次失败后转人工;批量任务要限速别打挂下游。
解决方案 三步:队列与 worker 基础 → 延迟/重复/优先级/幂等 jobId → 失败治理与事件。
第一步:队列与 Worker
// 文件: ingest.queue.ts
import { Queue, Worker } from 'bullmq';
export const ingestQueue = new Queue('doc-ingest', {
connection: redis,
defaultJobOptions: {
attempts: 3, // 总尝试 3 次
backoff: { type: 'exponential', delay: 2_000 }, // 2s/4s/8s
removeOnComplete: { age: 3600 }, // 完成任务 1h 后清理(别让 Redis 无限涨)
removeOnFail: false, // 失败保留: 治理与重放的依据
},
});
new Worker('doc-ingest', async (job) => {
const { docId } = job.data as { docId: string };
const text = await parse(docId);
const parts = chunks(text);
for (const [i, chunk] of parts.entries()) {
await storeVector(chunk);
await job.updateProgress(Math.round(((i + 1) / parts.length) * 100)); // 进度: 前端可订阅(271 题推送)
}
}, { connection: redis, concurrency: 4 }); // 单 worker 并发 4: 打挂 embedding 服务的护栏
第二步:延迟、重复、优先级与幂等 jobId
// 文件: queue-features.ts
// 延迟任务: 15 分钟后检查订单支付状态(274 题 RMQ TTL 方案的轻量替代)
await ingestQueue.add('check-order', { orderId }, { delay: 15 * 60 * 1000 });
// 重复任务: cron 巡检(238 题 @Cron 的分布式版 —— 多实例只跑一份)
await ingestQueue.add('reindex-stale', {}, {
repeat: { pattern: '0 3 * * *' },
jobId: 'reindex-stale-daily', // jobId 去重: 防重复注册
});
// 优先级: VIP 用户的文档优先解析(数值小先跑)
await ingestQueue.add('doc-ingest', { docId, vip: true }, { priority: 1 });
// 幂等 jobId: 同 docId 的重复上传不重复入队
await ingestQueue.add('doc-ingest', { docId }, { jobId: `ingest:${docId}` });
第三步:失败治理与事件
// 文件: queue-events.ts
worker.on('failed', async (job, err) => {
await this.metrics.counter('queue_failed_total').inc();
if (job && job.attemptsMade >= (job.opts.attempts ?? 1)) {
await this.alerts.warn(`job ${job.id} 终态失败`, { data: job.data, err: err.message });
// 转人工: 写 failed_jobs 表 / 推管理员(264 题网关)—— 与 274 题 DLQ 治理同思想
}
});
worker.on('stalled', (jobId) => { /* worker 崩溃后任务被接管重跑 —— 强调幂等(278 题) */ });
// 运维三板斧: 队列深度/waiting/active 数进指标(298 题); 队列 pause 紧急刹车; drain 清空演练
总结:BullMQ 适合”进程内可靠任务”:延迟/重复/优先级/重试开箱即用;并发与限速保护下游;失败保留 + 事件告警闭环治理;跨服务的事件流仍归 MQ(276 题),别拿任务队列当事件总线。
追问1:BullMQ 和直接用 MQ 的分界? → 任务 = 有完成语义、要重试与进度(单业务内部);事件 = 已发生事实的广播(跨服务)——队列管任务,MQ 管事件 追问2:多实例部署 worker 会重复消费吗? → 不会:Redis 锁语义保证一个 job 同时只被一个 worker 执行;但 stalled 接管会重跑——幂等必须有(278 题) 追问3:任务数千万级还合适吗? → BullMQ 元数据全在 Redis,千万级 pending 会撑爆内存——那是 Kafka/RMQ 场景;队列深度本身也该有告警红线
278. BullMQ 的 stalled 检测与任务幂等:重复执行怎么防?
概念 stalled(失速):worker 执行中崩溃,job 卡在 active 状态;BullMQ 用”锁续期”检测——worker 按锁周期续期,超时未续判死,由其他 worker 接管重跑。这意味着任务至少可能执行两次(执行到一半崩溃 + 接管重跑),幂等不是加分项是必需品。配套:jobId 入队去重、业务状态机二次校验、独立台账追踪。
典型场景 部署滚动时任务被接管,文档被解析入库两次;批量任务执行一半崩溃,重跑把已完成部分重复处理。
解决方案 三步:stalled 机制与参数 → 幂等三板斧 → 结果与状态追踪。
第一步:stalled 机制与参数
// 文件: stalled-config.ts
new Worker('doc-ingest', processor, {
connection: redis,
lockDuration: 30_000, // 锁周期: worker 定期续期; 超时未续 = 疑似失速
stalledInterval: 30_000, // 检查间隔
maxStalledCount: 1, // 失速重跑上限: 超过标 failed —— 防毒任务无限循环
});
worker.on('stalled', (jobId) => {
this.logger.warn({ jobId }, 'job stalled and will be retried by another worker');
});
// 部署配合: 滚动更新前先 worker.close()(等在跑任务收尾)再退出(249 题优雅停机),
// 把"被迫接管"的比例降到最低 —— stalled 是兜底不是常规路径
第二步:幂等三板斧
// 文件: idempotent-processor.ts
async function processor(job: Job<{ docId: string }>) {
const { docId } = job.data;
// 板斧 1: 状态机前置检查 —— 已完成的直接跳过(接管重跑场景)
const state = await db.oneOrNone('SELECT status FROM ingest_state WHERE doc_id = $1', [docId]);
if (state?.status === 'done') return { skipped: true };
// 板斧 2: 处理内分步幂等 —— upsert 代替 insert, 天然可重入
await db.none(
`INSERT INTO chunks (doc_id, seq, content)
VALUES ($1, $2, $3)
ON CONFLICT (doc_id, seq) DO UPDATE SET content = EXCLUDED.content`,
[docId, seq, content],
);
// 板斧 3: 状态推进原子化(带条件) —— 并发重跑只有一方能推进
await db.none(
`UPDATE ingest_state SET status = 'done', finished_at = now()
WHERE doc_id = $1 AND status != 'done'`,
[docId],
);
}
// 入队侧: jobId 去重(277 题)+ 上述三层 —— 全链路"重复无害"
第三步:结果与状态追踪(业务台账)
# 文件: job-tracking.txt
ingest_state 表 = 业务侧的任务台账(队列之外):
字段: doc_id / status / attempt / last_error / result_ref
价值:
1) 用户可见进度: 前端轮询或订阅推送(271 题), 数据源是台账不是队列内部状态
2) 对账: 定时任务扫台账 running 超 1h 的(队列丢了/没入队), 补入队 —— 台账是唯一事实源
3) 幂等的载体: 状态机检查依赖它
⚠️ 写入顺序: 先写台账(pending)再入队; 入队失败靠对账补 ——
反过来(先入队)会丢台账, 处理时状态机检查失效; 更强一致用 outbox(281 题)
总结:stalled 决定了任务可能跑两次,幂等必须做:状态机前置跳过、步骤可重入(upsert)、状态条件推进;业务台账独立于队列存在,进度/对账/补漏都靠它;优雅停机降低接管频率,幂等兜住剩余风险。
追问1:为什么锁续期能判死? → Redis key 带 TTL,worker 定期续;实例死亡无法续 → key 过期 → 检测器发现 → 接管——与 238 题分布式锁看门狗同机制 追问2:任务能取消吗? → job.remove()(未开始)或协作式取消(处理器内检查标志);已在跑的无法强杀(在别的进程里)——226 题 AbortController 只能限本进程 追问3:重复执行的副作用怎么彻底消除? → 外部副作用(发邮件/扣款)单独包:先落”意图表”再执行,意图表唯一键挡重复——280 题幂等全景的一部分
279. OpenTelemetry:分布式追踪接入 Nest?
概念 OTel 三信号:trace(请求在服务间的路径与耗时)、metric(聚合指标)、log(结构化日志,与 trace 关联)。核心概念:trace 由 span 组成,跨服务用 W3C traceparent 头续链;SDK 自动打点(http/express/ioredis/pg 都有 instrumentation)覆盖大部分场景,业务自定义 span 补关键段。Nest 接入基本零侵入。
典型场景 “下单慢”不知道慢在哪个服务;跨 5 个服务的调用链排障要挨个 grep;慢查询归因(DB 慢还是下游慢)。
解决方案 三步:SDK 自动打点接入 → 自定义 span 与日志关联 → 采样与后端对接。
第一步:SDK 自动打点
// 文件: tracing.ts
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
const sdk = new NodeSDK({
serviceName: 'order-api',
traceExporter: new OTLPTraceExporter({ url: 'http://otel-collector:4318/v1/traces' }),
instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();
// ⚠️ 必须在业务代码加载之前执行(模块加载期的 http 补丁要先挂上):
// node --import ./tracing.mjs dist/main.js
// 自动覆盖: 入站/出站 HTTP、DB 驱动、Redis、grpc —— span 属性含 SQL 语句与目标地址
第二步:自定义 span 与日志关联
// 文件: custom-span.ts
import { trace, context } from '@opentelemetry/api';
export class OrderService {
private readonly tracer = trace.getTracer('order');
async placeOrder(cmd: PlaceOrderCommand) {
return this.tracer.startActiveSpan('order.place', async (span) => {
span.setAttribute('order.amount', cmd.amount);
try {
const paid = await this.payment.charge(cmd); // 自动成为子 span(http 出站)
span.setAttribute('payment.txn', paid.txnId);
return paid;
} catch (err) {
span.recordException(err);
span.setStatus({ code: 2 }); // 2 = ERROR
throw err;
} finally {
span.end();
}
});
}
logFields() {
// 日志关联: pino 的 mixin 读 OTel 当前 span(223 题)—— 每条日志自带 trace_id
const sc = trace.getSpan(context.active())?.spanContext();
return { trace_id: sc?.traceId, span_id: sc?.spanId };
}
}
第三步:采样与后端
// 文件: sampling.ts
import { ParentBasedSampler, TraceIdRatioBasedSampler } from '@opentelemetry/core';
// 采样策略: 跟随上游决定(父采样), 根请求按比率 —— 全链路要么都采要么都不采(不会采一半断链)
const sampler = new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(0.1) }); // 10%
// 错误全采: 自定义 shouldSample 读 attributes, 带错误的强制记录
// 采集链路: SDK → OTLP → otel-collector(裁剪/脱敏/再采样)→ Jaeger/Tempo
// 分工: 指标看"面"(298 题), trace 看"线", 日志看"点" —— 排障工作流: 指标发现异常 → trace 定位慢/错段 → 日志看细节
总结:OTel 是可观测的统一语言:自动打点零侵入起步,自定义 span 补业务段,日志混入 trace_id 三方联动;采样跟随父级保证链完整;collector 做脱敏与裁剪防线。
追问1:traceparent 长什么样? → 00-<traceId>-<spanId>-01 四段:版本/traceId/父spanId/采样标志;出站 http 自动注入,对端自动续链
追问2:span 太多存储爆炸? → 采样率 + collector 裁剪(删高基属性如 userId 明文,保留哈希)+ TTL;高基属性只进日志不进 span 标签
追问3:和 Sentry 什么关系? → Sentry 是后端之一(消费 trace 做错误聚合);OTel 是采集标准——换后端不动代码,这正是标准化的价值
280. 幂等设计全景:幂等键、去重表与状态机?
概念 幂等 = 同一操作执行多次效果与一次相同。为什么必须:重试(网络超时但实际成功)、重复投递(at-least-once 的 MQ)、用户双击/重放。设计层次:天然幂等(设值更新、删除)优先;需要设计的:幂等键(客户端生成唯一 ID 随请求携带)+ 服务端双层去重(Redis SETNX 快路径 + DB 唯一约束慢路径)+ 状态机(状态条件推进挡重复流转)。
典型场景 支付回调重复通知(第三方保证 at-least-once);移动端弱网重试导致重复下单;MQ 重平衡引发的重复消费(276 题)。
解决方案 三步:幂等键协议 → 服务端双层去重 → 状态机与响应缓存。
第一步:幂等键协议——客户端负责生成
// 文件: idempotency-client.ts
// 协议: 客户端为"每一次业务意图"生成 uuid, 重试时复用同一个(不是每次重试换新的!)
async function pay(orderId: string) {
const idempotencyKey = localStorageGet(`pay:${orderId}`) ?? crypto.randomUUID();
localStorageSet(`pay:${orderId}`, idempotencyKey); // 重试期间保持不变
const res = await fetch('/api/payments', {
method: 'POST',
headers: { 'Idempotency-Key': idempotencyKey },
body: JSON.stringify({ orderId }),
});
if (res.status === 409) { /* 该 key 已被别的意图使用: 提示用户 */ }
}
// 没有客户端配合的服务端幂等只能靠"业务自然键"(orderId + 动作), 粒度粗但聊胜于无
第二步:服务端双层去重
// 文件: idempotency-server.ts
import { ConflictException, Injectable } from '@nestjs/common';
@Injectable()
export class PaymentService {
async create(key: string, cmd: PayCommand) {
// 第一层: Redis SETNX —— 挡住高并发重复(快, 但可能丢)
const first = await this.redis.set(`idem:${key}`, 'processing', 'EX', 3600, 'NX');
if (first !== 'OK') {
const state = await this.redis.get(`idem:${key}`);
if (state === 'processing') throw new ConflictException('处理中,请勿重复提交');
return JSON.parse(state!); // 已完成: 直接返回上次结果
}
try {
const result = await this.doPay(cmd);
// 第二层: DB 唯一约束 —— Redis 丢数据/过期后的最终防线
// payments 表 UNIQUE(idempotency_key); 插入冲突 = 重复, 查回已有记录返回
await this.redis.set(`idem:${key}`, JSON.stringify(result), 'EX', 3600);
return result;
} catch (err) {
await this.redis.del(`idem:${key}`); // 失败要释放, 允许重试
throw err;
}
}
}
第三步:状态机——业务层的幂等
// 文件: state-machine.ts
// 支付回调场景: 状态流转只允许单向, 重复通知被状态条件挡住
async onPaidCallback(orderId: string, txn: TxnInfo) {
const updated = await db.oneOrNone(
`UPDATE orders SET status = 'paid', paid_at = now(), txn_id = $2
WHERE id = $1 AND status = 'pending_payment' -- 条件推进: 已 paid 的匹配不到行
RETURNING *`,
[orderId, txn.txnId],
);
if (!updated) {
const cur = await db.one('SELECT status FROM orders WHERE id = $1', [orderId]);
if (cur.status === 'paid') return { ok: true, deduped: true }; // 已处理过: 幂等成功
throw new ConflictException(`illegal transition from ${cur.status}`);
}
await this.events.emit('order.paid', { orderId }); // 下游同样要幂等(事件至少一次)
}
总结:幂等是分布式系统的”防御性驾驶”:客户端幂等键定义意图边界;Redis 快挡 + DB 唯一约束兜底;状态机让业务流转天然防重;重复请求返回同结果而不是”第二次报错”。
追问1:幂等键的时效怎么定? → 覆盖”最长重试窗口 + 余量”(支付类 24h);过期后同 key 再来视为新意图——与产品确认语义 追问2:并发同 key 同时到(还没处理完)怎么办? → Redis ‘processing’ 态返回”处理中”让客户端轮询;或分布式锁串行化(238 题)——比直接 409 体验好 追问3:所有接口都做幂等吗? → 有副作用且会被重试的才需要(支付/下单/回调);查询天然幂等,纯记录类可放宽——按成本分级
281. 分布式事务:Saga 补偿与 Outbox 模式?
概念 跨服务事务不能靠 DB 事务(没有全局锁)。2PC 有阻塞与协调者单点问题,互联网实践主流是:Saga(长事务拆本地事务序列,失败走补偿事务回滚已完成步骤)+ Outbox(业务写库与事件发布原子化:事件先写进同库 outbox 表,relay 进程转投 MQ)。核心理念:放弃隔离性,换取可用性与最终一致。
典型场景 下单 = 订单服务 + 库存服务 + 积分服务(三个库);“扣了库存但发 MQ 失败”导致下游永远不知道;补偿设计的坑(不可逆动作)。
解决方案 三步:outbox 保发布 → Saga 编排 → 补偿设计纪律。
第一步:Outbox——消灭”写库成功但事件丢失”
// 文件: outbox.ts
async placeOrder(cmd: PlaceOrderCommand) {
await this.ds.transaction(async (em) => {
await em.insert(Order, { ...cmd, status: 'created' });
await em.insert(Outbox, { // 同一本地事务: 要么都在, 要么都不在
topic: 'order.events',
payload: { type: 'ORDER_CREATED', orderId: cmd.orderId },
status: 'pending',
});
});
// relay(下一步)扫 pending 转投 MQ —— "写库"与"发事件"被本地事务焊死
}
// 文件: outbox-relay.ts
import { Cron } from '@nestjs/schedule';
export class OutboxRelay {
@Cron('* * * * * *') // 秒级; 高吞吐用 LISTEN/NOTIFY 或 binlog(CDC)
async relay() {
const batch = await this.repo.pendingBatch(100); // 单调 ID 游标防漏(225 题)
for (const evt of batch) {
await this.mq.publish(evt.topic, evt.payload); // 至少一次投递 → 消费方幂等(280 题)
await this.repo.markSent(evt.id); // relay 崩溃重启重扫, sent 标记防过度重发
}
}
}
第二步:Saga 编排(中心化)
// 文件: order-saga.ts
export class PlaceOrderSaga {
private readonly steps = [
{ do: reserveStock, undo: releaseStock }, // 每步: 正向 + 补偿
{ do: chargePoints, undo: refundPoints },
{ do: confirmOrder, undo: cancelOrder },
];
async run(ctx: SagaCtx) {
const done: number[] = [];
try {
for (const [i, step] of this.steps.entries()) {
await step.do(ctx);
done.push(i);
}
} catch (err) {
for (const i of done.reverse()) { // 失败: 逆序补偿
await this.retryable(this.steps[i].undo, ctx); // 补偿必须可重试(它失败没有"补偿的补偿")
}
throw err;
}
}
}
// 状态持久化: saga 实例的进度落表(saga_instances), 崩溃恢复从断点继续/补偿 —— 内存跑 = 等事故
第三步:补偿设计纪律
# 文件: compensation.txt
可补偿性分级(设计期逐动作问):
天然可逆: 预扣库存(释放)、冻结积分(解冻) —— Saga 的好朋友
可补偿: 扣款(退款, 有成本)、发通知(撤回, 尴尬)
不可补偿: 发货、发短信、第三方扣款 —— 必须放 Saga 最后一步, 或改成"两阶段":
先创建"待执行"记录(可删) → 全部成功后再真正执行(定时任务扫待执行)
工程纪律:
1. 补偿也要幂等(280 题)与可重试
2. 补偿失败 → 告警 + 人工台(不自动无限重试)
3. 用户沟通: 最终一致的窗口要有 UI 状态(处理中), 别让用户看到"半完成"
总结:跨服务一致性的实用组合:outbox 解决”发布不丢”,Saga 解决”跨服务回滚”,幂等是两者共同的地基;设计期先给每个动作标”可补偿性”,不可逆动作永远排最后;隔离性放弃了,要用状态与对账把中间态管起来。
追问1:协同式(choreography)Saga 呢? → 无中心:服务互相监听事件链式推进;简单场景起步快,链条长后”谁在听谁”成谜——编排式把流程显式化,团队规模大优选 追问2:outbox 表会不会成为瓶颈? → 高吞吐下 relay 批量化 + 分片并行;CDC 方案(debezium 读 binlog)彻底解耦应用与投递 追问3:对账是什么角色? → 兜底巡检:定时比对上下游数据(订单 vs 库存流水),差异报警修复——最终一致系统必须有对账,它是”一致性的体检”
282. 灰度发布与特性开关:feature flags 落地?
概念 两个概念分开:灰度发布 = 新版本的流量渐进(实例级,K8s/网关层,249 题);特性开关 = 代码级的功能开关(请求级,运行时切换)。开关类型:release(灰度放量)、ops(kill switch 紧急关)、experiment(A/B 实验)。落地:集中式开关服务(Unleash/自研)+ Nest 侧注入 FlagService + 上下文(userId/租户/地域)驱动求值。
典型场景 新推荐算法先放 5% 用户;大促前紧急关掉某个非核心模块;新支付渠道 A/B 对比成功率。
解决方案 三步:FlagService 设计 → 求值上下文与规则 → 发布流程整合。
第一步:FlagService——统一求值入口
// 文件: flag.service.ts
import { Injectable } from '@nestjs/common';
@Injectable()
export class FlagService {
private rules = new Map<string, FlagRule>();
private readonly evalCache = new Map<string, boolean>(); // 30s 本地缓存, 开关变更最长延迟 30s
isEnabled(flag: string, ctx: FlagContext): boolean {
const cached = this.readCache(flag, ctx);
if (cached !== undefined) return cached;
const rule = this.rules.get(flag);
const result = rule ? rule.match(ctx) : false; // 未知开关默认关(fail-safe)
this.writeCache(flag, ctx, result);
return result;
}
refresh() { /* 定时/SSE 从开关服务拉最新规则 */ }
}
// 使用: if (this.flags.isEnabled('rec.algo-v2', { userId, tenantId })) { ... }
// ⚠️ 开关判断只收敛在这个服务里 —— 散落的 if(env === '...') 是开关失控的起点
第二步:求值上下文与规则
// 文件: flag-rules.ts
import { createHash } from 'node:crypto';
interface FlagContext { userId: string; tenantId: string; region: string }
function pct(userId: string, salt: string, percent: number): boolean {
const h = createHash('md5').update(`${salt}:${userId}`).digest(); // 稳定 hash: 同用户结果恒定
return (h.readUInt32BE(0) % 100) < percent;
}
const recV2Rule: FlagRule = {
match: (ctx) =>
WHITELIST.includes(ctx.userId) ||
(ctx.tenantId === 'beta' && pct(ctx.userId, 'rec-v2', 37)), // 37% 稳定放量
};
// ⚠️ 百分比必须用稳定 hash(userId): 同一用户每次求值一致, 否则体验抖动 + 实验数据污染
// 开关服务侧(Unleash): 策略 UI + 审计(谁改的什么时候) + 兜底(服务挂了用本地缓存值)
第三步:发布流程整合
# 文件: release-flow.txt
新功能上线标准动作(与 249 题滚动更新配合):
1) 代码带开关合并进主干, 开关默认关 —— trunk-based 的前提(297 题)
2) 部署全量(带关着的开关) —— 部署与发布解耦: 部署是技术动作, 发布是业务动作
3) 开关放量: 0% → 内部账号 → 1% → 10% → 50% → 100%, 每档观察错误率/延迟/业务指标(298 题)
4) 全量后清理: 开关代码与规则下线(排期!开关是债 —— 每个开关存活周期应有上限)
kill switch 演练: 大促前把核心链路的每个 ops 开关真实拨一次(299 题), 确认关得动、关得快
总结:特性开关把”部署”与”发布”解耦:代码先行、放量可控、随时可关;求值要稳定(用户级 hash)与兜底(未知开关默认关、服务挂了用缓存);开关是技术债,全量后必须清理;release/ops/experiment 三类开关不同生命周期。
追问1:开关和配置中心的区别? → 配置是”参数值”(超时时间),开关是”代码路径”(走哪版逻辑);开关要求高频求值 + 秒级生效——基建要求不同(241 题) 追问2:A/B 实验和灰度放量是一个东西吗? → 灰度看稳定性(错误率),实验看效果(转化率,要统计显著性);混用会把”不敢放”和”没效果”搅在一起 追问3:开关判断有性能开销吗? → 本地缓存规则 + O(1) 求值,纳秒级;真正的开销在”代码里到处查开关”的复杂度——每个开关两份路径都要测试
283. 密钥管理:环境变量的局限与 Vault/KMS?
概念 密钥(DB 密码/API key/签名私钥)的生命周期:生成 → 分发 → 轮换 → 吊销。环境变量的问题:落在 CI 配置、进程信息、崩溃转储、镜像层里,且无法细粒度授权与审计。工业方案:Vault(KV 存储 + 动态密钥 + 审计)或云 KMS(信封加密:主密钥不出云,数据密钥被主密钥包裹)。应用侧:启动/运行时从 Vault 拉取,密钥不进代码与环境快照。
典型场景 员工电脑上的 .env 泄漏整站密钥;数据库密码三年没换;新成员入职拿到全部生产密钥。
解决方案 三步:应用侧接入 Vault 读取 → 动态数据库密钥 → 信封加密与轮换。
第一步:应用侧读取(替代 .env)
// 文件: secrets.ts
import { Provider } from '@nestjs/common';
import Vault from 'node-vault';
export const SECRETS = Symbol('SECRETS');
export const secretsProvider: Provider = {
provide: SECRETS,
useFactory: async () => {
const vault = Vault({ endpoint: process.env.VAULT_ADDR, token: await getAppRoleToken() });
// AppRole 认证: role_id 公开 + secret_id 每实例一次性注入(K8s sidecar/CSI 注入更优)
const { data } = await vault.read('secret/data/order-api');
return { dbPassword: data.DB_PASSWORD, llmApiKey: data.LLM_API_KEY };
},
};
// 与 ConfigService 合并(241 题体系): env 管非敏感配置, SECRETS 管敏感配置
// 原则: 密钥只在此处出现一次, 下游统一注入使用, 禁止再落任何变量/日志
第二步:动态数据库密钥
// 文件: dynamic-db.ts
import { DataSource } from 'typeorm';
// Vault 的杀手锏: 按"角色"实时生成短期 DB 账号(默认 TTL 1h), 没有长期密码可泄漏
const { data } = await vault.read('database/creds/order-app');
// data.username = 'v-order-app-9f3k2', data.password = 随机 —— 直接用于建连
const ds = new DataSource({
type: 'postgres',
url: pgUrl(data.username, data.password),
poolSize: 20,
});
// 续期: TTL 到期前 re-read + 平滑重建连接(229 题池的 drain/rebuild)
// 吊销: 直接 revoke 该角色凭证 —— 分钟级全站换密
第三步:信封加密与轮换纪律
// 文件: envelope.ts
import { KMSClient, EncryptCommand } from '@aws-sdk/client-kms';
const kms = new KMSClient({});
// 场景: 身份号等敏感字段要入库加密 —— 不可能每行都过 KMS(慢/贵)
// 信封加密: KMS 主密钥(CMK, 不出 KMS)只加解"数据密钥(DEK)"; DEK 在本地加解海量数据
async function wrapDek(dek: Buffer): Promise<Uint8Array> {
const res = await kms.send(new EncryptCommand({ KeyId: CMK_ARN, Plaintext: dek }));
return res.CiphertextBlob!; // 被主密钥包一层的 DEK 存库
}
// 轮换: 每季轮 CMK(KMS 自动版本化, 旧密文仍可解) + 每年轮 DEK(重加密存量数据, 后台分批)
// 审计: KMS/Vault 的每次调用有日志 —— "谁在何时动了哪个密钥"可回答, 这是合规的底线
总结:密钥管理的成熟度 = 从 .env 走向:集中存储(Vault)+ 动态短密(免轮换焦虑)+ 信封加密(性能与安全兼得);应用侧密钥只出现一次、随取随用不落盘;轮换常态化,审计可回溯。
追问1:开发环境的密钥怎么办? → 本地 Vault dev 模式或 docker 假数据;原则:开发永远摸不到生产密钥的影子 追问2:JWT 签名密钥怎么轮换? → 双密钥并存:新签用 kid 标注新密钥,验证按 kid 路由,旧 token 自然过期后撤旧钥——在线业务零中断 追问3:密钥泄漏应急动作? → 先吊销(让密钥立即失效)再排查;顺序反了(先查后吊)会给攻击者留窗口——演练要包含这个决策压力(299 题)
284. 熔断与降级:circuit breaker 怎么落地?
概念 级联失效的机制:依赖变慢 → 调用方线程/连接被占满 → 调用方自己也挂 → 逐级向上传染。熔断器三态:closed(正常,统计失败)→ open(失败率超阈值,直接快速失败不再调用)→ half-open(冷却后放探测流量验证恢复)。降级是熔断的”之后怎么办”:缓存兜底、默认值、功能砍除。与重试的关系:重试放大流量,熔断优先级高于重试。
典型场景 支付通道 P99 从 200ms 涨到 30s,下单链路被拖死;推荐服务挂了想保住”能下单”;弱依赖挂掉不能影响核心路径。
解决方案 三步:opossum 熔断器接入 → 分级降级策略 → 组合纪律。
第一步:opossum 熔断器
// 文件: breaker.ts
import { CircuitBreaker } from 'opossum';
const breaker = new CircuitBreaker((cmd: ChargeCmd) => payment.charge(cmd), {
timeout: 3_000, // 单次调用超时: 慢 = 失败(不拖线程)
errorThresholdPercentage: 50, // 失败率阈值
rollingCountTimeout: 10_000, // 统计窗口 10s
rollingCountBuckets: 10, // 窗口分 10 桶
resetTimeout: 30_000, // open → half-open 冷却 30s
volumeThreshold: 20, // 窗口内至少 20 次调用才开始判定(防小样本误判)
});
breaker.on('open', () => this.metrics.inc('breaker_open', { dep: 'payment' }));
const result = await breaker.fire(cmd).catch(() => this.fallbackPayment(cmd));
第二步:分级降级策略
// 文件: fallbacks.ts
// 依赖分级(设计期完成):
// 强依赖(支付): 不可降级 —— 熔断后直接"支付暂不可用", 保住数据一致性, 用户可重试
// 弱依赖(推荐/评论): 降级不熔断体验 —— 兜底策略逐级:
async function getProductPage(productId: string) {
return {
info: await productRepo.findOne(productId), // 核心: 本地 DB, 不受远端影响
recommend: await recoBreaker.fire(productId)
.catch(() => cache.get(`reco:${productId}`)) // 一级: 上次缓存
.catch(() => DEFAULT_RECO), // 二级: 静态默认(热门榜)
reviews: await reviewBreaker.fire(productId)
.catch(() => ({ items: [], degraded: true })), // UI 明示降级, 不假装正常
};
}
// ⚠️ 降级数据要打标: 缓存兜底的推荐是旧数据, 展示端要知道, 别当正常数据卖
第三步:组合纪律
# 文件: discipline.txt
超时 / 重试 / 熔断的层叠纪律:
1) 每层超时预算化(275 题死线思想): 网关 5s = 支付 3s + 余量; 内层超时必须 < 外层
2) 重试只在一层做(防放大): 消费端重试了, 生产端就别重试; 重试次数 × 并发 = 瞬时放大倍数
3) 熔断判定用"失败率"不用"失败数": 小流量服务失败 3 次就熔断会抖动(volumeThreshold 的意义)
4) half-open 探测流量要小(1 qps 量级): 恢复验证不等于全量放行
5) open 状态的调用"立即失败"要快: 返回预设降级, 别抛异常一路 500(那是另一种故障)
总结:熔断的本质是”放弃治疗换自保”:依赖病了先切断,冷却后试探;降级方案设计期分级(强依赖保一致、弱依赖保体验);超时预算 + 单层重试 + 失败率熔断三条纪律防叠加放大。
追问1:熔断和限流的区别? → 限流保自己不被打爆(入口维度,245 题);熔断保自己不被拖死(出口维度)——一个防”进得多”,一个防”出得慢”,通常都要 追问2:half-open 探测失败怎么办? → 回 open 重置冷却计时;连续数轮失败拉长冷却(指数),并告警人工介入 追问3:熔断状态要不要跨实例共享? → 不要:各实例独立统计独立熔断(局部视角足够);共享状态反而造成”一刀切”与状态服务依赖
285. 审计日志与合规留痕:谁在何时改了什么?
概念 审计日志 ≠ 应用日志:记录”主体(谁)在何时对什么对象做了什么变更(前/后值)“,用于追责与合规,要求不可篡改、可查询、留存期合规(等保/SOX/GDPR 各有要求)。技术要点:Interceptor 捕获写操作、实体 diff、敏感字段处理、独立存储与归档。
典型场景 “这个订单的收货地址被谁改了”;等保三级检查操作留痕;批量删数据的事后追查。
解决方案 三步:声明式捕获 → diff 与敏感处理 → 存储与查询。
第一步:声明式捕获(装饰器 + 拦截器)
// 文件: audit.decorator.ts
import { SetMetadata } from '@nestjs/common';
export const AUDIT_KEY = 'audit:rule';
export function Audit(resource: string, action: string) {
return SetMetadata(AUDIT_KEY, { resource, action });
}
// 使用: @Audit('order', 'update_address') @Patch('orders/:id/address')
// 文件: audit.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { tap } from 'rxjs';
@Injectable()
export class AuditInterceptor implements NestInterceptor {
constructor(private readonly reflector: Reflector, private readonly audit: AuditService) {}
intercept(ctx: ExecutionContext, next: CallHandler) {
const rule = this.reflector.get(AUDIT_KEY, ctx.getHandler());
if (!rule) return next.handle();
const req = ctx.switchToHttp().getRequest();
const entry = {
at: new Date(), actor: req.user?.sub ?? 'anonymous', ip: req.ip,
resource: rule.resource, action: rule.action,
target: req.params?.id, after: req.body, requestId: req.id,
};
return next.handle().pipe(tap(() => void this.audit.record(entry))); // 成功后异步落, 不阻塞响应
}
}
// ⚠️ 漏标 = 覆盖率漏洞: 关键域的写操作清单用测试守护(289 题 E2E 断言审计行已生成)
第二步:diff 与敏感字段
// 文件: audit-diff.ts
async record(entry: AuditEntry) {
if (entry.action.startsWith('update')) {
const before = await this.repo.rawSnapshot(entry.resource, entry.target);
entry.diff = diffObjects(before, entry.after); // 只存变化: { address: { old, new } }
}
// 敏感字段双向处理: 展示层脱敏(手机号打码), 取证需要原值 → 加密存储(283 题信封加密)
entry.diff = maskDeep(entry.diff, ['phone', 'idCard']);
await this.auditRepo.insert(entry); // 独立表/库: 与业务库分离
}
// 只记 diff 不记全量的理由: 存储省一个数量级 + 审计查询直接看变化
第三步:存储与查询
# 文件: audit-store.txt
表结构要点: (at, actor, resource, target, action, diff jsonb, requestId, prev_hash, hash)
链式哈希: hash = sha256(prev_hash + entry) —— 防篡改: 改任何一条, 后续链校验不过(合规加分项)
查询场景: "这个对象的时间线" —— where resource + target order by at desc
归档: 热数据 90 天(库内)→ 冷数据转对象存储(压缩+索引), 留存期按合规定(常见 179d~3y)
⚠️ 告警联动: 高危操作(批量删除/权限变更)实时推送安全群 —— 审计不止是"事后能查"
总结:审计三要素:声明式捕获(装饰器标注 + 测试守护覆盖率)、diff 最小化 + 敏感处理、独立存储 + 链式防篡改;查询按”对象的时间线”设计;高危操作实时告警让审计从事后走向事中。
追问1:应用日志和审计日志能合并吗? → 不建议:生命周期(天 vs 年)、写入方(散在代码 vs 拦截器)、合规要求(可丢 vs 不可丢)都不同——分开是架构不是浪费 追问2:GraphQL 的写操作怎么审计? → mutation 解析器层统一拦截(全局 interceptor 或 field resolver 元数据),按 mutation 名映射 resource/action 追问3:内部系统的”系统操作”记吗? → 记:定时任务/迁移/自动扩容都以系统身份落审计——actor: system:cron-reindex 比”不知道谁干的”强一万倍
286. SLA 与容量规划:压测与限流配额怎么联动?
概念 指标层级:SLI(测什么:P99 延迟/错误率)→ SLO(目标:P99 < 300ms)→ SLA(对外合同与赔付)。错误预算 = 1 − SLO 目标,是”还能坏多少”的额度,花完就冻结发布保稳定。容量规划链路:单机压测极限 → 峰值流量 × 冗余系数 → 副本数,并与限流(245 题)联动:限流阈值 = 容量 × 安全水位,超容量流量在入口挡住而不是拖垮全员。
典型场景 大促容量评估;新接口上线要不要扩容;P99 毛刺归因(容量不足还是慢查询)。
解决方案 三步:单机压测找拐点 → 容量推算 → 水位预案联动。
第一步:单机压测(找拐点)
// 文件: k6-load.js
import http from 'k6/http';
import { check } from 'k6';
export const options = {
stages: [
{ duration: '2m', target: 200 }, // 阶梯爬压: 每档稳定后再加
{ duration: '2m', target: 400 },
{ duration: '2m', target: 800 },
],
thresholds: { http_req_duration: ['p(99)<300'] },
};
export default function () {
const res = http.get('http://api.corp/orders?page=1');
check(res, { 'status 200': (r) => r.status === 200 });
}
// 拐点判定(压测时同步看): CPU%(>70% 曲线弯折)、事件循环延迟(214 题)、DB 池等待(229 题)
// 结论形如: 单实例 500 QPS 时 P99 开始劣化 → 单机安全容量 = 500 × 0.7 ≈ 350
第二步:容量推算
# 文件: capacity.txt
副本数 = 峰值 QPS ÷ 单机安全容量 × 冗余系数
示例: 峰值 5000 QPS, 单机 350, 冗余 1.5(挂一台 + 滚动更新期间 + 突发)
→ 5000 / 350 × 1.5 ≈ 21.4 → 22 副本
细化维度(别只算总量):
1) 按接口画像拆: 混合场景压测(读:写 = 真实比例), 写路径通常先到瓶颈(DB)
2) 依赖侧容量: 应用扩了 DB 没扩 = 白扩 —— 每层都要有容量数字
3) 长连接类(WS 网关): 容量单位是连接数 + 消息速率, 不是 QPS(272 题压测法)
4) HPA: min = 平峰副本, max = 容量上限对应副本 —— max 不能超过压测过的安全范围
第三步:水位预案联动
# 文件: playbook.txt
水位分层动作(提前演练, 299 题):
70% 容量: 观察(QPS/CPU/P99 面板), 确认 HPA 正常扩容
85%: 限流收紧 —— 245 题限流阈值动态下调(砍非核心接口配额), 保核心交易
95%: 降级启动 —— 284 题预案: 弱依赖熔断 + 功能砍除(评论/推荐)
100%+: 入口排队/静态兜底页 —— 宁可部分用户慢, 不可全员 500
事后: 错误预算复盘 —— 本月 SLO 99.9% = 43 分钟可坏额度;用完 → 冻结 feature 发布只修稳定性
总结:容量规划是”用数字管恐惧”:单机压测找拐点、按真实流量画像推副本、每层(应用/DB/网关)都有容量数;限流阈值 = 容量 × 安全水位;水位分层预案把”超载”变成编排好的降级序列。
追问1:压测环境怎么逼近生产? → 生产影子流量回放或同规格独立环境;数据量级一致(百万行的表和空表压测结果毫无关系) 追问2:P99 毛刺先查什么? → 顺序:GC 停顿(219 题)→ 慢 SQL/锁 → 连接池排队 → 网络重传;单次毛刺看 trace(279 题)定位请求,别急着扩容 追问3:错误预算怎么影响日常发布? → 预算充足正常发;低于 30% 降频;耗尽冻结——用数据回答”这个月还能不能上新功能”
287. 单体到微服务:演进路径与拆分标准?
概念 微服务不是目标而是结果:团队规模、部署耦合、故障隔离需求到了,单体痛了才拆。拆分标准:按业务域(DDD 限界上下文)+ 数据所有权(每个服务独占自己的库)优先于技术分层。演进路径:模块化单体(257 题边界纪律)→ 绞杀者模式逐步迁移(新功能新服务 + 路由层分流)→ 老功能逐块搬出。拆完后要还的债:分布式事务(281 题)、追踪(279 题)、幂等(280 题)。
典型场景 发布互相踩(订单小改动牵连推荐全回归);一个模块的内存泄漏拖死整个单体;三团队在同一个仓库互相等 code review。
解决方案 三步:拆分前评估 → 拆分动作(数据先行)→ 绞杀者迁移。
第一步:拆分前评估——先确认真的需要
# 文件: split-checklist.txt
值得拆的信号(满足 2 条以上再立项):
1) 部署耦合痛: 高频模块被低频模块的发布节奏拖累
2) 故障域: 单一模块的问题(内存/连接)拖死全局
3) 团队协作: 3+ 团队在同一代码库持续互相阻塞
4) 扩容画像分化: A 模块要 CPU、B 模块要内存, 单体只能一起扩
不该拆的理由(都不成立):
"技术栈想换" / "微服务更高级" / "大厂都拆了"
第一原则: 先做模块化单体(模块边界 + 独立数据 schema), 边界稳定了"拆"只是部署动作
第二步:拆分动作——数据所有权先行
# 文件: split-order-domain.txt
拆分单位: 订单域(orders + order_items + 订单相关 Redis key 全归它)
第一步不是拆代码, 是拆数据访问:
反模式(伪拆分): OrderService(独立进程)直连推荐库表 —— 库没拆等于没拆
正确: OrderRepository 只允许订单服务进程访问; 跨域要数据走 API/事件
跨域联表怎么办: 要么调用聚合(服务间 API), 要么 CQRS 读模型(256 题投影)
第二步: 消灭跨库外键与共享表 —— 共享的 user 表拆: 订单服务存 userId 快照(冗余字段),
用户信息变更靠事件同步(281 题 outbox)—— "冗余换解耦"是微服务的日常
第三步:绞杀者模式迁移
// 文件: strangler-routes.ts
// 流量入口加路由层(网关规则或 BFF), 新旧实现并存按规则分流:
const ROUTES = [
{ match: '/orders/*', target: 'order-svc', canary: { header: 'x-user-hash', pct: 10 } },
{ match: '*', target: 'legacy-monolith' }, // 默认仍走单体
];
// 迁移节奏(以域为单位):
// 1) 新域服务上线, 按百分比切流量(282 题放量), 双写对账(281 题)验证一致性
// 2) 全量切完后单体里的老代码下线(能删的删, 不能删的标 deprecated)
// 3) 一次只迁一个域 —— 并行迁三个域 = 事故率 × 3
// ⚠️ 迁移期的双写/对账是成本大头, 排期按 40% 算; 图快跳过对账的迁移都在赌命
总结:微服务演进的正确姿势:模块化单体先行(边界 = 未来切面)、数据所有权优先于代码切分、绞杀者按域渐进迁移 + 对账护航;拆分解决三个真痛点:部署独立、故障隔离、独立扩缩;为拆而拆只会收获分布式系统的全部缺点。
追问1:数据库怎么真正拆开? → 先逻辑隔离(账号权限)→ 停跨库 join(改调用/投影)→ 数据迁移(双写窗口 + 对账)→ 切读 → 切写 → 下线旧库——每步可回滚 追问2:拆完发现拆错了能合回来吗? → 能且应该(业务认知深化后边界重画很正常);合并成本 < 维护两个错误边界的成本时就合——别为了面子硬撑 追问3:服务间调用用同步还是异步? → 查询走同步(gRPC,275 题),状态变更广播走事件(MQ,276 题);用同步做状态变更就要接受一致性与可用性的代价(284 题熔断护体)
六、测试与工程化(288–299)
288. vitest 单元测试:mock 策略与 test doubles?
概念 vitest:ESM 原生、esbuild 转译(快)、兼容 jest API、与 vite 共享配置。单测的 test doubles 三件套:stub(替身给固定值)、spy(记录调用不改变行为)、mock(替身验证交互)。原则:mock 边界(只 mock 进程外的依赖:DB/HTTP/时钟),不 mock 被测单元的内部协作者;模块级 vi.mock 与方法级 vi.spyOn 分场景。
典型场景 service 单测要不要连库;时间相关逻辑(过期/幂等窗口)怎么测;mock 太深导致”测试在测 mock”。
解决方案 三步:模块级 mock 隔离边界 → spy 与 fake 时钟 → 反模式识别。
第一步:模块级 mock——隔离进程外依赖
// 文件: order.service.spec.ts
import { vi, describe, it, expect } from 'vitest';
vi.mock('./payment.client', () => ({
PaymentClient: vi.fn().mockImplementation(() => ({
charge: vi.fn().mockResolvedValue({ txnId: 'txn_1', status: 'ok' }),
})),
}));
describe('OrderService.placeOrder', () => {
it('支付成功后订单转 paid', async () => {
const repo = { save: vi.fn().mockResolvedValue(undefined) };
const svc = new OrderService(new PaymentClient(), repo as any);
const order = await svc.placeOrder({ userId: 'u1', amount: 100 });
expect(order.status).toBe('paid');
expect(repo.save).toHaveBeenCalledWith(expect.objectContaining({ status: 'paid' }));
});
});
第二步:spy 与 fake 时钟
// 文件: time-sensitive.spec.ts
import { vi, it, expect } from 'vitest';
it('幂等键过期后允许新意图', async () => {
vi.useFakeTimers(); // 时间可控: 不用真等(280 题语义)
const svc = makeService();
await svc.create('key-1', cmd);
vi.advanceTimersByTime(24 * 3600 * 1000); // 快进 24h
const again = await svc.create('key-1', cmd);
expect(again.isNew).toBe(true);
vi.useRealTimers();
});
// spy: 不替换行为, 只观察(对"失败时打了告警"这类副作用断言)
it('失败路径必须告警', async () => {
const warn = vi.spyOn(logger, 'warn').mockImplementation(() => {});
await expect(svc.risky()).rejects.toThrow();
expect(warn).toHaveBeenCalledTimes(1);
});
第三步:反模式识别
# 文件: antipatterns.txt
1) mock 内部实现: service 里 new 出来的 helper 被 vi.mock —— 重构即红, 测试护的是实现不是行为
→ 只 mock 边界(网络/DB/时间/随机); 内部协作留给真实代码
2) 断言 mock 的调用而不是结果: expect(save).toHaveBeenCalled() 写了一堆, 行为没验证
→ 断言优先落在返回值/状态变化, 交互断言只补关键协议(如"失败时没调用 save")
3) 快照滥用: toMatchSnapshot() 大对象 —— 变更即红但没人 review diff
→ 快照只用于真正稳定的结构(错误码表), 业务输出用显式断言
4) 追求 100% 覆盖率: getter/胶水代码凑数
→ 覆盖率门槛设在增量(diff coverage ≥ 80%), 全量数字只观察(293 题)
总结:vitest 单测的核心纪律:mock 只打在边界(DB/HTTP/时钟),被测单元的内部逻辑真实跑;时间用 fake timers;断言行为而非实现;覆盖率看增量不看总量。
追问1:vi.mock 的提升(hoist)是什么坑? → 它被提升到文件顶部,引用的外部变量还没初始化会报错——用 vi.hoisted 或工厂内自建数据 追问2:私有方法怎么测? → 不测:私有是设计信号,想测说明它该提取成独立单元(公共函数/类) 追问3:测试彼此依赖(顺序敏感)怎么排查? → vitest 默认按文件并行、文件内串行;同文件内共享状态是主因——每测试重建被测对象,共享只读 fixture(292 题)
289. supertest 集成测试:E2E 与测试数据库怎么搭?
概念 Nest E2E:TestingModule 复刻应用(真实管道/守卫/拦截器),supertest 发真 HTTP 请求打到 app.getHttpServer()(init 不监听端口,内存级快)。核心抉择是数据库策略:内存库(sqlite/pg-mem,快但方言差异)vs testcontainers(真 PG,慢但保真)。数据隔离三法:事务回滚(快)、truncate(中)、独立 schema(隔离最好)。
典型场景 “单测全绿但路由 404”(管道/前缀没测到);校验逻辑过不了 E2E;E2E 跑 15 分钟没人愿意跑。
解决方案 三步:E2E 骨架 → 数据库选择与隔离 → E2E 边界纪律。
第一步:E2E 骨架
// 文件: orders.e2e-spec.ts
import { Test } from '@nestjs/testing';
import { INestApplication, ValidationPipe } from '@nestjs/common';
import request from 'supertest';
describe('Orders (e2e)', () => {
let app: INestApplication;
beforeAll(async () => {
const moduleRef = await Test.createTestingModule({
imports: [AppModule], // 尽量完整: 真实管道/守卫都要在场
})
.overrideProvider(PaymentClient) // 只替换进程外依赖(288 题同纪律)
.useValue({ charge: async () => ({ txnId: 't', status: 'ok' }) })
.compile();
app = moduleRef.createNestApplication();
app.useGlobalPipes(new ValidationPipe({ whitelist: true })); // 与 main.ts 一致(抽公共 bootstrap)
await app.init(); // init 不 listen: supertest 直连, 快
});
afterAll(async () => { await app.close(); });
it('POST /orders 非法入参 → 400 且带错误详情', () =>
request(app.getHttpServer())
.post('/orders')
.send({ amount: -1 })
.expect(400)
.expect((res) => { expect(res.body.message).toBeDefined(); }));
});
第二步:数据库策略与隔离
// 文件: test-db.ts
// 推荐: testcontainers —— 每个任务起一次性真 PG(与生产同方言):
import { PostgreSqlContainer } from '@testcontainers/postgresql';
beforeAll(async () => {
const pg = await new PostgreSqlContainer().start(); // 随机端口, 任务结束销毁
process.env.DATABASE_URL = pg.getConnectionUri();
await runMigrations(pg.getConnectionUri()); // 迁移也被测试覆盖(发布前最后一道)
});
// 隔离策略(每测试之间):
// 方案 A 事务回滚: 每测试包 transaction, 结尾 rollback —— 快, 但测不到提交行为(触发器/约束延迟)
// 方案 B truncate: 用例间清表 —— 简单, 测试间有隐性依赖风险
// 方案 C schema-per-worker: 并行 worker 各自 schema —— 速度与隔离兼得(推荐 CI)
// ⚠️ sqlite 快但方言差异(JSONB/锁行为)会造成"测试过生产挂" —— 生产 PG 就用 PG 测
第三步:E2E 边界纪律
# 文件: e2e-scope.txt
E2E 只测"装配与协议":
✅ 路由/状态码/错误体结构、鉴权放行与拒绝、管道校验、中间件顺序
✅ 关键用户旅程 3~5 条(下单到支付、登录到登出)—— 冒烟级
❌ 业务分支细节(单测的事, 288 题)
❌ 第三方真实调用(mock 或 contract 测试, 291 题)
时长预算: E2E 套件 < 5 分钟(并行 + 分片), 超 10 分钟必然被跳过 —— 时长是存活的生命线
总结:E2E 的价值在”单测看不见的装配层”:管道、守卫、路由、错误协议;数据库宁慢求真(testcontainers + 同方言);边界纪律防 E2E 变成慢性全套回归;时长控制在 5 分钟内它才会被天天跑。
追问1:app.init() 和 app.listen() 的区别? → init 起容器不监听端口(supertest 直连内存 server,快);listen 才绑真端口——E2E 用 init 追问2:守卫依赖请求上下文(ALS)怎么测? → supertest 请求真实走中间件链,ALS 天然生效——这正是 E2E 比单测强的地方 追问3:Flaky(偶发失败)测试怎么治? → 隔离违规(共享状态/真实时间/端口冲突)三连排查;修不了的标记 skip 建账跟踪,别 retry 掩盖——flaky 测试比没有测试更危险
290. 测试金字塔:70/20/10 的全栈分配与反模式?
概念 测试金字塔:大量快单测(毫秒级,测逻辑)+ 适量集成测试(测装配)+ 少量 E2E(测旅程)。比例参考 70/20/10,本质是成本-速度-保真的权衡:越往上越慢越脆越保真。反模式是”冰淇淋筒”(倒金字塔:靠手工/少量 E2E 撑质量)和”沙漏”(单测很多、E2E 很多、集成缺失)。
典型场景 团队说”写测试太慢”于是全靠手工点;每次改数据库字段 200 个 E2E 红;上线前手工回归三天。
解决方案 三步:分层定位 → 判断题往哪层放 → 覆盖率与门禁。
第一步:分层定位
# 文件: pyramid.txt
/E2E\ 10% | 旅程级: 登录→下单→支付全链路; 慢(分钟) 脆(环境) 少而精
/集成 \ 20% | 装配级: 模块+真实DB/管道; 中速 中稳
/ 单测 \ 70% | 逻辑级: service/纯函数; 快(毫秒) 稳 多
分配的本质: 一个行为尽量在最低可行的层验证 —— 下移降成本, 上移求保真
新代码起步: 先给纯逻辑补单测(性价比之王), 旅程补 1 条 E2E, 集成按模块补
第二步:判断题放哪层
# 文件: which-layer.txt
"金额计算含退款分摊" → 单测: 纯逻辑, 边界(0/负/精度)全扫
"ValidationPipe 拒绝多余字段" → 集成: 装配行为(管道真挂上才有效, 232 题)
"JWT 过期返回 401 且错误体规范" → 集成: 守卫+过滤器协作(250 题)
"下单流程含库存扣减与回调" → E2E: 跨模块旅程, 只断言关键节点
"CSV 转义" → 单测; "导出接口能下载" → 集成; "导出→下载→打开" → 手工冒烟
拿不准时的默认: 先写单测; 单测模拟不了装配(注入/中间件顺序)时升级集成
第三步:覆盖率与门禁
// 文件: vitest-config.json —— 覆盖率只作为门禁的"下限", 不作为 KPI
{
"coverageThreshold": { "global": { "lines": 60 } },
"comment": "全量 60 是地板; 关键域(order/payment)单列 85; 增量(diff)覆盖率才是团队指标(293 题)"
}
// 门禁语义: 新 PR 的改动行覆盖率 < 80% 挡合并 —— 老 legacy 不追溯, 新账不欠
总结:金字塔是成本模型不是教条:逻辑下沉单测、装配居中集成、旅程顶端 E2E;比例 70/20/10 起步按实际调;覆盖率管增量不管存量;防倒金字塔的关键是让单测”写得快”(288 题纪律)。
追问1:什么测试不值得写? → 框架胶水(纯转发的 controller)、getter/setter、只为覆盖率的空洞断言——增加维护成本零收益 追问2:TDD 必须吗? → 不是教条:逻辑复杂/边界多的适合先写测试(设计压力);CRUD 类事后补关键路径即可——测试是工具不是仪式 追问3:契约测试(291 题)算哪层? → 独立的第四类:替代”跨服务 E2E”——服务间交互在消费者侧闭环验证,避免为了测一个调用拉起整条链路
291. 契约测试:Pact 与 openapi-typescript 两条路?
概念 跨端/跨服务的兼容性验证两条路:schema 契约(OpenAPI 为事实源,openapi-typescript 生成前端类型 + CI 校验漂移,240 题的深化)与消费者驱动契约(Pact:消费者声明”我期望这样调你”,提供者跑同一套期望验证)。解决的问题:后端改字段,前端/下游编译期毫无感知,上线才炸。
典型场景 响应体删了个字段,三个下游两个挂;移动端老版本还在用两年前的字段;微服务 A 改 DTO,不知道 B 依赖什么。
解决方案 三步:OpenAPI 类型生成流水线 → Pact 消费者/提供者 → can-i-deploy 发布门禁。
第一步:OpenAPI 契约流水线(前后端)
# 文件: contract-ci.yml
jobs:
schema:
steps:
- run: npm run build # nest 构建时 @nestjs/swagger 产出 openapi.json
- run: npx openapi-typescript openapi.json -o schema.d.ts
- run: npx openapi-zod-client openapi.json -o schema.zod.ts # 可选: 校验器同步生成
- uses: actions/upload-artifact@v4
with: { name: schema, path: schema.d.ts }
# 前端消费: import { paths } from './schema.d.ts'
# axios.get<paths['/orders']['get']['responses']['200']['schema']>('/orders')
# 破坏性变更(删字段/改类型) → 前端类型错误 → CI 红 —— 在编译期而不是上线后暴露
第二步:Pact 消费者驱动(服务间)
// 文件: order-consumer.pact.spec.ts
import { PactV3, MatchersV3 } from '@pact-foundation/pact';
const provider = new PactV3({ consumer: 'web-bff', provider: 'order-api' });
it('查询订单期望含支付状态字段', async () => {
await provider
.given('订单 o1 存在且已支付')
.uponReceiving('GET /orders/o1')
.withRequest({ method: 'GET', path: '/orders/o1', headers: { authorization: MatchersV3.like('Bearer x') } })
.willRespondWith({
status: 200,
body: {
id: MatchersV3.string('o1'),
status: MatchersV3.string('paid'),
paidAt: MatchersV3.iso8601DateTime(),
},
})
.executeTest(async (mockServer) => {
const client = new OrderClient(mockServer.url);
const order = await client.get('o1');
expect(order.status).toBe('paid');
});
});
// 跑完产出 pact 文件(web-bff → order-api 的契约)推 broker;
// order-api 的 CI 拉取所有"指向自己的契约"逐一验证 —— 提供者改动是否破坏消费者, 编译期知道
第三步:can-i-deploy 发布门禁
# 文件: can-i-deploy.sh
# 部署前问 broker: "web-bff@v2.3 与 order-api 当前版本兼容吗?"
pact-broker can-i-deploy --pacticipant web-bff --version 2.3.0 \
--to-environment production --broker-base-url=https://broker.corp
# 不兼容(exit 1)则 CI 挡发布 —— 把"上线才发现不兼容"变成"发布前就知道"
# 与 249 题滚动更新配合: 新旧版本共存期间都要满足在跑契约
总结:契约测试把兼容性从”运气”变”门禁”:前后端用 OpenAPI 生成类型(schema 是唯一事实源);服务间用 Pact(消费者期望驱动提供者验证);broker 的 can-i-deploy 接进发布流水线。它替代的是脆弱的全链路 E2E。
追问1:契约测试和集成测试的区别? → 集成测”真实两方现在合不合”;契约测”改动会不会破坏对方期望”——前者验证当下,后者防守未来,且不需要拉起对方 追问2:GraphQL 的契约怎么管? → schema 本身就是契约:CI 跑 schema diff(破坏性检查)+ 客户端 query 校验(codegen)——机制不同思想相同 追问3:pact 文件谁维护? → 消费者写(声明期望),提供者被动满足——“谁依赖谁定义”倒置了话语权,这正是 CDC 的精髓
292. 测试数据管理:factory、seed 与清理策略?
概念 三类数据三种管法:测试内数据(factory 现造,随用随建——默认)、全局 seed(基础字典数据,一次性灌入,测试不改它)、外部夹具(大样本/回放数据,文件或快照)。清理策略与隔离策略配套(事务回滚/truncate/schema 隔离,289 题)。目标:测试不依赖执行顺序、不依赖”上次跑剩下的数据”。
典型场景 测试本地过 CI 挂(本地库有脏数据);造数代码在每个测试里复制粘贴两百行;删了某个 seed 测试集体变红。
解决方案 三步:factory 模式 → seed 管理 → 清理与确定性。
第一步:factory 模式
// 文件: factories.ts
import { faker } from '@faker-js/faker/locale/zh_CN';
export function orderFactory(overrides: Partial<Order> = {}): Order {
return {
id: faker.string.uuid(),
userId: faker.string.uuid(),
amount: faker.number.int({ min: 1, max: 10_000 }),
status: 'pending_payment',
createdAt: new Date(),
...overrides, // 测试只声明"我关心的差异" —— 意图清晰
} as Order;
}
// 用法: orderFactory({ status: 'paid', amount: 0 }) —— 测"已支付订单金额为 0"这个边界
// 关联数据: makeUserWithOrder() 这类组合 factory 封装"成套关系", 别在测试里手搓外键链
第二步:seed 管理
// 文件: seed.ts
import { DataSource } from 'typeorm';
// 只放"环境性数据": 字典(支付渠道列表)、权限角色、测试账号 —— 特征: 测试不改它
export async function seedBase(ds: DataSource) {
await ds.createQueryBuilder()
.insert()
.into(PayChannel)
.values([{ code: 'wechat', name: '微信' }, { code: 'alipay', name: '支付宝' }])
.orIgnore() // 幂等: 重复执行无害
.execute();
}
// 执行时机: 迁移后、测试套件前(全局 beforeAll); E2E 与本地环境共用同一 seed 脚本
// ⚠️ seed 里绝不放"业务性数据"(某个具体订单)—— 那是 factory 的事; 混放 = 依赖地狱的起点
第三步:清理与确定性
// 文件: deterministic.ts
// 清理三选一(与 289 题隔离策略对应): 每测试事务回滚(首选) / afterAll truncate / schema-per-worker
// 确定性: 时间与随机都固定 —— 同一提交跑一万次结果一致
beforeAll(() => {
faker.seed(42); // 随机数据可复现(失败重跑同数据)
vi.setSystemTime(new Date('2026-10-17T08:00:00Z')); // 时间冻结(288 题)
});
// 反模式: 测试之间"接力"(A 创建的数据 B 用)—— 顺序依赖让失败像多米诺;
// 需要"存在的数据"就在自己的测试里造, 造不了(外部系统)才用共享 fixture 并标注只读
总结:测试数据的黄金律:默认现造(factory + overrides 表达意图)、seed 只放环境性数据、清理与隔离配套、时间随机全固定;测试顺序无关性是可维护性的分水岭。
追问1:大样本性能测试数据怎么来? → 脚本批量生成(100 万订单)落独立环境,不进常规测试库;从不”用生产数据拷贝”做开发测试(合规红线) 追问2:factory 放哪一层? → 测试工具目录(tests/factories),不进 src——它是测试代码;跨包共享抽成 @corp/test-fixtures(294 题) 追问3:测试里直接写 SQL 造数可以吗? → 可以但要封进 factory:裸 SQL 散落 = schema 一改全红;factory 是数据构造的唯一出口
293. CI 流水线:lint→typecheck→test→build 门禁怎么设计?
概念 流水线的使命:合并前挡住可自动发现的问题,且要快(开发者不会等 20 分钟)。标准阶段:lint(秒级)→ typecheck(秒级)→ 单测(分钟)→ build(产物)→ 镜像。门禁哲学:快速失败(便宜的检查先跑)、增量优先(只测受影响部分)、缓存复用(node_modules/turbo 缓存)。
典型场景 PR 排队 40 分钟大家开始合并后再看;CI 绿但生产挂(门禁漏了关键检查);流水线里 npm install 每次全量下载。
解决方案 三步:阶段设计与门禁 → 缓存与增量 → 分层流水线。
第一步:阶段与门禁
# 文件: ci.yml
name: ci
on: [pull_request]
jobs:
quality:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with: { fetch-depth: 0 } # 增量计算需要完整历史
- uses: actions/setup-node@v4
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile # 222 题: 锁定安装
- name: lint # 1. 最便宜的先跑: 秒级, 挡格式/明显错误
run: pnpm lint
- name: typecheck # 2. 类型门禁: 零容忍
run: pnpm typecheck
- name: audit # 3. 供应链门禁(222 题)
run: npx audit-ci --high
- name: test # 4. 单测 + 增量覆盖率 80% 门禁(290 题)
run: pnpm test -- --coverage
- name: build # 5. 能构建(类型/循环依赖的最后防线)
run: pnpm build
第二步:缓存与增量
# 文件: ci-cache.yml
# pnpm store 缓存(setup-node 的 cache: pnpm 已处理)+ turbo 远程缓存(294 题):
- name: turbo-cache
uses: rharkor/caching-for-turbo@v1.2
# 只跑受影响的包(monorepo):
- run: pnpm turbo lint typecheck test build --filter=...[origin/main]
# 测试分片: 大套件拆 4 份并行跑(shard 后合并覆盖率)
- run: pnpm test -- --shard=${{ matrix.shard }}/4
strategy:
matrix: { shard: [1, 2, 3, 4] }
第三步:分层流水线(快慢分离)
# 文件: pipeline-layers.txt
PR 流水线(< 10 分钟目标, 开发体验生命线):
lint / typecheck / 单测 / build / 契约验证(291 题)
合并后流水线(主干质量, 可慢):
E2E 全量(289 题) / 集成矩阵(多 Node 版本, 228 题) / 镜像构建与扫描(trivy)
发布流水线(手动/自动触发):
can-i-deploy 契约门禁(291 题) → 镜像签名 → 灰度部署(249/282 题)
原则: PR 等 10 分钟是上限; 慢检查全部后置到合并后 —— "合并前的每分钟都在向团队收税"
总结:CI 门禁 = 便宜先跑 + 增量计算 + 缓存复用;PR 层保速度(10 分钟红线),慢检查后置合并后;供应链/契约/镜像扫描各归其位;门禁的意义是自动化地挡住”人会忘的事”。
追问1:CI 绿但生产挂,门禁还缺什么? → 常缺:迁移可执行(E2E 里跑)、配置校验(241 题 schema)、镜像扫描、契约门禁——按”上次事故”反向补 追问2:flaky 测试把 CI 搞红怎么办? → 隔离修复优先(289 题);短期 quarantine 标记(单独 job 跑不挡合并)+ 建账——别全局 retry 掩盖 追问3:merge queue 是什么? → PR 依次真实合并到临时主干再验证——防止”各自绿,合一起红”的竞态;团队并行度高时值得开
294. monorepo:pnpm workspace 与 turbo 任务编排?
概念 pnpm workspace:workspace:* 协议管理包间依赖(链接不拷贝)、严格 node_modules(幽灵依赖隔离——没声明的包 import 不到)。turbo:任务图编排 + 内容寻址缓存(输入 hash 命中直接回放输出)+ —filter 增量(只跑受影响包)。结构惯例:apps(部署单元)+ packages(共享库)。
典型场景 前台/管理台/服务端三应用共享类型与工具库;CI 全量构建 30 分钟;某个包偷偷用了没声明的依赖,单仓拆走就挂。
解决方案 三步:workspace 骨架 → turbo 任务与缓存 → 增量与边界纪律。
第一步:workspace 骨架
# 文件: pnpm-workspace.yaml
packages:
- apps/*
- packages/*
// 文件: apps/api/package.json
{
"name": "@corp/api",
"dependencies": {
"@corp/shared-types": "workspace:*",
"@corp/logger": "workspace:^"
}
}
// workspace:* 语义: 本地链接 + 发布时替换为真实 semver(* → 匹配); packages 放纯库(无运行时入口)
// 严格性: pnpm 默认隔离 node_modules —— apps/api 里 import 'lodash'(未声明)直接报错,
// 逼迫依赖显式化(222 题供应链友好的副作用)
第二步:turbo 任务与缓存
// 文件: turbo.json
{
"$schema": "https://turbo.build/schema.json",
"tasks": {
"build": {
"dependsOn": ["^build"], // 先构建依赖的包(拓扑序自动排)
"inputs": ["src/**", "tsconfig.json"], // 内容寻址: 这些输入没变 → 缓存命中
"outputs": ["dist/**"]
},
"test": { "dependsOn": ["build"], "inputs": ["src/**", "test/**"] },
"lint": {}
}
}
// 效果: 改了 packages/logger → 依赖它的所有包重 build/test; 只改 apps/web 文案 →
// api 的 build/test 全部缓存命中, 秒级跳过 —— CI 时长与变更半径成正比(293 题)
第三步:增量与边界纪律
# 文件: turbo-commands.sh
# 只跑受影响的包(PR 场景, 与 293 题流水线配合):
pnpm turbo test build lint --filter=...[origin/main]
# 缓存验证: 故意重跑, 输出带 ">>> cache hit" 即生效
# 远程缓存: 团队共享(Vercel remote cache 或自托管), 同事之间也复用
# 边界纪律(静态强制, 253/257 题同源):
# apps 可依赖 packages, packages 不依赖 apps, packages 之间单向
# eslint-plugin-boundaries(296 题)在 CI 挡下违反边界的 import
总结:monorepo 的收益公式:workspace 协议(链接 + 严格依赖)+ turbo(任务图 + 缓存 + 增量);结构上 apps/packages 分层、依赖单向;变更半径决定 CI 时长——这就是”monorepo 不慢”的全部秘密。
追问1:什么时候该拆仓? → 团队边界稳定且要独立发布节奏/权限隔离时;拆之前先问:现在的边界(包)是否已经清晰——模糊边界拆出去只是把耦合换成网络调用(287 题) 追问2:包的版本策略? → 内部消费用 workspace:*(实时联动);对外发布用 changesets(295 题)统一版本管理——两套语义别混 追问3:turbo 缓存会缓存”错”结果吗? → inputs 声明漏了(如隐式依赖环境变量)会;排查:turbo 会打印 hash 输入,补齐 inputs 或声明 env 依赖
295. changesets:包版本与发布流程管理?
概念 语义化版本(semver):major(破坏)/minor(功能)/patch(修复)。changesets 流程:改代码的 PR 附带一个 .changeset/*.md(声明哪些包、什么级别、变更描述)→ 合并后自动累积 → 定期触发 version PR(消费 changesets 改版本号 + 生成 CHANGELOG)→ merge 后发布。monorepo 联动:被依赖的包升版本,依赖它的包自动 bump。
典型场景 共享库发版靠手改 package.json 版本号,经常漏;CHANGELOG 三个月没人写,积累到写不动;monorepo 里 A 库升 patch,引用它的 B 忘了动。
解决方案 三步:changeset 日常 → version 与发布 → 与 conventional commits 的选型对比。
第一步:日常——PR 附 changeset
<!-- 文件: .changeset/spotty-pandas-run.md(Changesets CLI 生成随机名) -->
---
'@corp/logger': minor
---
新增 traceId 自动注入(223 题的 child logger 现在开箱即用)
# 文件: changeset-flow.sh
pnpm changeset # 交互式: 选包/选级别/写描述 —— 30 秒的事, 附在功能 PR 里
# CI 校验: 动了 packages/** 又没有 changeset 的 PR 挡下(除非标签 skip-release)
第二步:version 与发布
# 文件: release.sh
pnpm changeset version # 消费全部 changeset: bump 版本 + 更新各包 CHANGELOG.md + 清空 changeset
# 产生的变更走一个 "Version Packages" PR —— 评审的是"这批要发什么", 发布变成显式决策
git checkout -b release/2026-10-17 && git commit -am 'version packages' && gh pr create
# merge 后:
pnpm changeset publish # 发布到 registry; monorepo 联动: workspace:* 已被替换为真实 semver
第三步:与 conventional commits 的选型对比
# 文件: versioning-choice.txt
changesets(显式声明):
✅ 变更意图明确(minor 就是 minor, 不靠 commit message 猜)
✅ monorepo 联动成熟(依赖图 bump)
❌ 每个功能 PR 多一步
conventional commits + 自动推导(standard-version/semantic-release):
✅ 零额外步骤(feat → minor, fix → patch)
❌ commit message 即版本: 写错类型 = 发错版本; 破坏性变更藏在 body 里容易被漏
选型: 库(尤其 monorepo 多包)选 changesets; 小型单包 + commit 纪律强的团队可用自动化推导(297 题)
共同底线: 发布是显式动作(Version PR / release tag), 拒绝"merge 即发布"的黑盒
总结:changesets 把版本管理变成流程:功能 PR 声明变更 → version PR 汇总决策 → publish 发布;monorepo 依赖联动自动化;发布永远显式可评审;与 commit 自动推导相比,它把”版本判断”从事后猜测变成事前声明。
追问1:private app 要不要进 changesets? → 不用:apps 不发布,只有 packages 进版本管理(changesets config 的 ignore 配置) 追问2:发出去发现坏了怎么办? → semver 没有”撤回”:立即发 patch 修复;真破坏(major 误发)可 deprecated + 重新发正确版本——这也是版本纪律值钱的原因 追问3:预发布(pre-release)怎么管? → changesets 的 pre mode:进入预发布通道(2.0.0-beta.x),正式版退出合并——大版本重构的标配流程
296. 代码规范工程化:eslint、prettier 与 husky 怎么串起来?
概念 分工:prettier 管格式(无争论,纯机器审美);eslint 管质量(未使用变量/类型边界/依赖方向);husky 提供 git hooks(提交前触发),lint-staged 只检查暂存文件(全量 lint 十秒,暂存检查一秒)。Nest 项目的关键增强:typescript-eslint 严格集 + 边界规则(模块依赖方向)。
典型场景 code review 里一半评论是格式问题;有人提交没过 lint 的代码;模块间依赖逐渐腐化没人发现。
解决方案 三步:eslint flat config → git hooks 链 → 规则引入节奏。
第一步:eslint flat config
// 文件: eslint.config.mjs
import eslint from '@eslint/js';
import tseslint from 'typescript-eslint';
export default tseslint.config(
eslint.configs.recommended,
...tseslint.configs.strictTypeChecked, // 类型感知规则: 更严但更值
{
languageOptions: { parserOptions: { projectService: true } },
rules: {
'@typescript-eslint/no-floating-promises': 'error', // 漏 await 直接红 —— Node 最值钱规则
'@typescript-eslint/no-misused-promises': 'error',
'@typescript-eslint/consistent-type-imports': 'error',
},
},
);
// 模块边界(单向依赖)用 eslint-plugin-boundaries 按目录元素声明:
// domain 只允许依赖 shared/infra, app 可依赖全部(257 题分层的静态强制)
// prettier 不进 eslint 规则(两者分工): .prettierrc 独立存在, format 单独跑
第二步:git hooks 链
// 文件: package.json(片段)
{
"lint-staged": {
"*.{ts,tsx}": ["eslint --fix", "prettier --write"],
"*.{json,md}": ["prettier --write"]
}
}
# 文件: husky-setup.sh
pnpm dlx husky init
echo "pnpm lint-staged" > .husky/pre-commit # 提交前: 只查暂存文件, 1~2 秒
echo "pnpm dlx commitlint --edit \$1" > .husky/commit-msg # 297 题提交信息规范
# ⚠️ hooks 是体验优化不是门禁: --no-verify 可绕过 —— 所以 CI 必须全量再跑一遍(293 题)
第三步:规则引入的团队节奏
# 文件: rollout.txt
新规则上线姿势(直接全量 error 会淹没团队):
1) 先 warn 跑两周, 输出热点文件清单
2) 对存量豁免: 文件级 eslint-disable(带原因与清理 issue 号), 新文件立即 error
3) no-floating-promises 这类高价值规则优先 —— 它挡的是真事故(未处理 rejection, 217 题同源)
规则要少而狠: 每条规则团队都能说出"它挡过什么" —— 说不出的规则删掉
总结:规范工程化的串联:prettier 消灭格式讨论、eslint(strictTypeChecked + boundaries)守住质量与架构边界、husky+lint-staged 让检查在提交瞬间发生、CI 全量兜底;规则宁少勿滥,每条都要有”挡过事故”的战绩。
追问1:为什么 no-floating-promises 最值钱? → Node 事故大类的根因:忘 await 的 rejection 静默丢失(217 题同源);类型感知规则能在编译期抓住它 追问2:lint-staged 和 CI 重复吗? → 不重复:前者是”快速反馈体验”(可绕),后者是”不可绕的门禁”——定位不同,都要 追问3:eslint 与编译器(tsc)的规则重叠? → tsc 管”类型是否成立”,eslint 管”写法是否危险”(any 滥用/浮 promise);noUnusedLocals 这类开 tsc 即可,别两边配
297. 提交规范与分支策略:conventional commits 与 trunk-based?
概念 conventional commits:提交信息结构化(type(scope): subject)——feat/fix/chore/refactor,机器可解析(changelog 自动生成、版本推导)。trunk-based:短命分支(小时/天级)+ 高频合并主干,与 git-flow(长命 develop/release 分支)相对;半成品代码靠特性开关(282 题)藏进主干,而不是靠分支隔离。
典型场景 大功能分支活了三周,合并冲突改到怀疑人生;release 分支的 hotfix 忘了合回主干;changelog 靠人肉回忆两个月前的改动。
解决方案 三步:提交规范落地 → trunk-based 工作流 → 与发布的配合。
第一步:提交规范落地
# 文件: commit-format.txt
<type>(<scope>): <subject>
feat(order): 支持部分退款
fix(auth): refresh token 轮换竞态导致偶发登出
refactor!(payment): 迁移新网关 API ← ! 标记破坏性(changelog 抓取)
BREAKING CHANGE: 响应字段 amount 单位改为元
type 速查: feat/fix/perf/refactor/test/docs/build/ci/chore
落地: commitlint(config-conventional)+ husky 的 commit-msg hook(296 题串联)
价值: git log 变成可查询数据库 —— git log --grep '^fix(order)' 找某模块全部修复
第二步:trunk-based 工作流
# 文件: trunk-flow.sh
# 小步提交 + 短命分支:
git checkout -b feat/partial-refund
# ... 每天(至少)rebase 主干保持新鲜, 冲突早暴露:
git fetch origin && git rebase origin/main
# 完成前: 开关守护(新代码默认关, 282 题), 未完成功能也能安全进主干
git push -u origin feat/partial-refund && gh pr create
# 合并策略: squash(一个 PR 一个提交, 历史干净)—— 团队约定统一即可
# 主干永远可发布: merge queue 串行验证(293 题), 合进去的就是验证过的
第三步:与发布的配合
# 文件: release-cadence.txt
trunk-based 的发布 = 从主干打 tag(或 release train 定期切):
持续部署(内部服务主流): 主干绿 → 自动发布 → 灰度放量(282 题)
定期发布(对外产品): 每周二 release train, 冻结窗口极短
hotfix: 从 tag 拉分支修 → cherry-pick 回主干(顺序别反)—— tag 只出不养
与 git-flow 的对照(为什么不用它):
develop/release 长命分支 = 合并冲突与"哪个分支包含修复"的心智税;
现代答案: 主干 + 开关 + 环境晋升(deploy to staging/prod), 用部署流水线替代分支隔离
总结:提交规范让历史可机器消费(changelog/版本/检索);trunk-based 用短命分支 + 特性开关 + merge queue 实现”主干永远可发布”;分支策略的现代化本质:从”分支隔离变化”转向”开关隔离变化 + 流水线保证质量”。
追问1:squash merge 会不会丢历史? → 丢的是过程提交(草稿史),保留的是 PR 粒度语义——需要考古时 PR 页面还在,别为”保留每一个 typo 修复”抗拒 squash 追问2:功能要两周怎么办? → 拆:每个可独立合并的增量(开关关着)陆续进主干;真拆不动的大重构走 branch-by-abstraction(新旧并存,开关切换) 追问3:commit message 用中文还是英文? → 团队语言优先(可读性第一),但 type/scope 保持英文枚举——机器解析与人类阅读各取所需
298. 监控告警落地:prom-client 指标与告警规则怎么设计?
概念 指标四类型:counter(只增,请求数/错误数)、gauge(可增减,在线连接/队列深度)、histogram(分桶,延迟分布 → P99)、summary(客户端分位,少用)。Nest 采集三板斧:RED 指标(Rate/Errors/Duration 中间件)、业务指标(订单量/队列积压)、运行时指标(事件循环延迟/堆,214 题)。告警规则设计:基于症状(用户受影响)而非原因(CPU 高),带 for 防抖,分级路由。
典型场景 上线三个月没有任何告警,出事靠用户反馈;告警 500 条没人看(狼来了);P99 面板有了但不知道多少算异常。
解决方案 三步:指标采集 → PromQL 告警规则 → 告警分级与治理。
第一步:指标采集(RED + 业务)
// 文件: metrics.ts
import { Counter, Gauge, Histogram, collectDefaultMetrics } from 'prom-client';
collectDefaultMetrics({ prefix: 'node_' }); // 运行时: 堆/GC/事件循环(214 题)
export const httpRequests = new Counter({
name: 'http_requests_total', labelNames: ['method', 'route', 'status'],
help: '总请求',
});
export const httpDuration = new Histogram({
name: 'http_request_duration_seconds',
labelNames: ['method', 'route'],
buckets: [0.01, 0.05, 0.1, 0.3, 0.5, 1, 3, 5], // 桶设计贴业务: >1s 的细分没意义
help: '请求延迟',
});
export const queueDepth = new Gauge({ name: 'queue_depth', labelNames: ['queue'], help: '队列积压' });
// 中间件埋点: route 用路由模板(/orders/:id)而不是真实路径 —— 否则 label 基数爆炸
第二步:PromQL 告警规则
# 文件: alerts.yml
groups:
- name: order-api
rules:
- alert: HighErrorRate
expr: |
sum(rate(http_requests_total{status=~"5.."}[5m])) by (route)
/ sum(rate(http_requests_total[5m])) by (route) > 0.02
for: 5m # 持续 5 分钟才报(防毛刺)
labels: { severity: page }
annotations: { summary: '{{ $labels.route }} 错误率 >2% 持续 5m' }
- alert: P99LatencyHigh
expr: histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, route)) > 1
for: 10m
labels: { severity: ticket }
- alert: QueueBacklog
expr: queue_depth > 1000
for: 15m
labels: { severity: page }
第三步:告警分级与治理
# 文件: alerting-rules.txt
分级(按"响应动作"定义, 不是按严重词):
page(电话/即时群): 用户可见影响 —— 错误率/可用性/队列积压到损害级
ticket(工单, 工作时间处理): 趋势异常 —— P99 抬升/磁盘增长
silent(只记录): 原因类指标 —— CPU/内存(它们是症状的候选解释, 不是症状本身)
治理纪律:
1) 每条 page 值得叫醒一个人吗?不值得降级 —— 告警疲劳是监控的头号杀手
2) 告警必须带 runbook 链接(299 题): 收到告警的人知道下一步点哪里
3) 月度复盘: 30 天 0 触发的 page 降级/删除; 事故没告警的补新规则
4) SLO 对齐: 基于错误预算消耗速率告警(286 题)比单点阈值更贴近"用户痛苦"
总结:监控落地闭环:RED + 业务 + 运行时三层指标 → 症状导向的 PromQL 规则(for 防抖)→ 按响应动作分级;label 基数纪律(路由模板化);告警的生命线是”每条都值得被叫醒 + 都有 runbook”。
追问1:histogram 和 summary 选哪个? → histogram(可聚合:多实例桶相加再算分位);summary 的分位不能跨实例聚合——分布式系统选 histogram 追问2:指标和日志的预算怎么分? → 指标便宜常驻(计数/分布),日志贵按需(DEBUG 打开,223 题分级);trace 抽样补全链路(279 题)——三支柱各司其职 追问3:Prometheus 拉模式有延迟吗? → 抓取间隔(15~30s)决定最低告警延迟;更快的用 push 网关或错误突增即时事件告警
299. 故障演练与 runbook:应急预案怎么工程化?
概念 runbook:面向特定故障的可执行手册(症状画像 → 判断步骤 → 处置动作 → 升级路径),标准是”凌晨三点被叫醒的人照着做能活下来”。演练:主动注入故障验证预案(依赖延迟/实例 kill/资源耗尽),暴露”文档里写的是理想,系统跑的是现实”的差距。复盘(blameless):事故后产出行动项回归到 284/286/298 题的体系。
典型场景 大促前的可用性保障;预案文档一年没人看,真出事发现命令都跑不通;每次事故后”下次注意”然后重演。
解决方案 三步:runbook 编写 → 演练场景库 → 复盘闭环。
第一步:runbook 编写
<!-- 文件: runbooks/db-primary-down.md -->
# 故障:订单库主库不可用(症状: 下单 5xx 突增 + 连接超时)
## 快速判断(< 2 分钟)
1. 确认症状: Grafana 面板 "Order API"(链接)错误率 > 50%?
2. 区分主库挂 vs 网络抖: `kubectl exec pg-check -- pg_isready -h db-primary.corp`
3. 看切换是否已自动发生: `patronictl list`(自动故障转移通常 30s 内完成)
## 处置
- 场景 A(已自动切换, 应用未恢复): 重启 order-api 滚动(连接池旧地址失效)
`kubectl rollout restart deploy/order-api` # 预计 3 分钟, 观察 P99 恢复
- 场景 B(未自动切换, 手动): `patronictl switchover pg-cluster --leader db-primary`
⚠️ 先确认 replica lag < 5s, 带着大延迟切换 = 丢数据
## 升级
10 分钟未恢复 → 呼叫 DBA 值班(电话在顶部); 30 分钟 → 拉事故频道, 启动对外公告流程
## 关联
- 依赖: 284 题熔断应已挡住雪崩(验证 breaker_open 指标有值)
- 事后: outbox 积压检查与数据一致性对账(281 题)
第二步:演练场景库
# 文件: drill-scenarios.txt
场景设计(每个都对应一个高频真实故障):
D1 依赖变慢: tc netem 给支付通道加 3s 延迟 → 验证熔断打开 + 下单仍可用(284 题)
D2 实例猝死: kubectl delete pod --wait=false → 验证滚动自愈 + 在途请求表现
D3 DB 切换: 主库维护窗口强制 switchover → 验证 runbook 场景 B 全流程
D4 依赖故障: 断网到 LLM 供应商 → 验证降级文案 + 恢复后自动回正(247/271 题)
D5 流量翻倍: 压测打到 2× 峰值 → 验证 286 题水位预案逐级触发
D6 密钥过期: 动态 DB 密钥 TTL 到期不续 → 验证 283 题重建链路
节奏: 季度一轮(每轮 2~3 场景, 生产低峰); 新人入职第一月参与一次(读十遍不如跑一遍)
产出: 每场演练后 runbook 修订 + 新发现的监控盲区补指标(298 题)
第三步:复盘闭环(blameless)
# 文件: postmortem-template.txt
事故复盘模板(24h 内初稿, 一周内终稿):
影响面: 持续时长/用户受损(SLO 预算消耗, 286 题)
时间线: 检测(告警 or 用户报告? 后者 = 监控盲区)/ 决策 / 恢复各节点
根因: 技术根因 + 流程根因(为什么没拦在前面)
行动项: 每条带 owner 与 deadline, 分类到体系 ——
代码(熔断/重试) → 284 | 监控(新告警) → 298 | 预案(runbook) → 本题 | 容量 → 286
blameless 纪律: 只问"系统为什么允许人为失误造成事故", 不问"谁搞的" ——
惩罚文化得到的只有隐瞒和下次更大的事故
行动项跟踪: 上季度未完成项 = 下季度演练的必测场景(欠账要还)
总结:应急预案工程化 = 写得出(凌晨可执行的 runbook)+ 练得到(季度场景化演练)+ 闭环掉(blameless 复盘行动项归体系);预案没演练过就等于没有;监控盲区、预案失效、体系缺口,全都靠演练暴露。
追问1:混沌工程和演练是一回事吗? → 演练是混沌工程的子集:有预案地注入故障;混沌工程更进一步——持续自动化随机注入(Chaos Mesh),成熟团队的目标形态 追问2:演练把生产打挂了怎么办? → 演练也要爆炸半径控制:低峰 + 灰度实例 + 随时可停的注入开关——和上线一个标准 追问3:怎么推动团队认真做? → 用事故说话:每次复盘把”如果演练过 D 场景”写进根因;把 runbook 可执行性变成上线检查项——让它成为交付的一部分而不是额外负担
第三批完(扩充版):Node.js 深入 30 题(200–229)+ NestJS 核心 20 题(230–249)+ NestJS 进阶 14 题(250–263)+ WebSocket 与实时通信 10 题(264–273)+ Nest 微服务与工业化 14 题(274–287)+ 测试与工程化 12 题(288–299),共 100 题,题号 200–299。其中 200–215 为原 Node.js 深入(重编号)、230–249 为原 NestJS(重编号),其余为扩充新增。AI 深度工程部分(Prompt/评测/RAG/Agent/多模态/前端交互/综合场景/LangChain 基础)已拆分至 04-AI深度工程100题.md。