面试题库
TypeScript 与 NestJS 面试题总汇
TS 语言基础、Node/事件循环、NestJS 核心、TypeORM/Prisma、类型体操,加上 15 道技术方案设计题与 25 道考官口试题,加上 12 道整体系统方案设计题,总汇共 116 题。
- Node.js
- Nest
- TypeScript
- 面试
TypeScript 与 NestJS 面试题总汇
Redis、RabbitMQ、Kafka、ElasticSearch、MySQL、网络、Docker 等题目与语言无关,直接沿用
backend/03和backend/04文档,本文不重复。
由原《TypeScript 与 NestJS 面试题》《NestJS 技术方案面试题精讲》两篇合并而成:知识问答按主题重组,15 道方案设计题与 25 道考官口试题整章保留,全文连续编号(共 104 题),末附题型×坑速查表。
一、TypeScript 语言基础
1、TypeScript 是什么?和 JavaScript 的关系
- TypeScript = JavaScript + 静态类型系统,是 JS 的超集,最终编译成 JS 运行。
- 两个核心理解点:
- 结构类型(Structural Typing):TS 只看”形状”不看”名字”。两个结构相同的类型即使没有继承关系也互相兼容。
- 类型擦除:TS 的类型只在编译期存在,编译后完全消失(装饰器元数据除外)。
- 动态逃逸口:TS 有
any、类型断言,逃逸很自由,也容易滥用。
2、TS 有哪些基础类型
| 分类 | 类型 | 说明 |
|---|---|---|
| 原始类型 | number / string / boolean / null / undefined / symbol / bigint | 只有一种数字类型(双精度浮点) |
| 二进制 | Buffer / Uint8Array | |
| 空值/无返回 | void | |
| 任意 | any / unknown | 见下一题 |
| 数组 | T[] / Array<T> | |
| 键值 | Map<K,V> / Record<K,V> | |
| 集合 | Set<T> | |
| 枚举 | enum / union 字面量类型 | 更推荐 type Status = 'A' | 'B' |
3、any、unknown、never 的区别(必考)
any:放弃类型检查,任何操作都允许,会”污染”传播——相当于关闭 TS。unknown:安全的 any。可以接收任何值,但使用前必须收窄(typeof、instanceof、断言),否则编译报错。推荐优先 unknown。never:不可能存在的类型。函数永远抛错/死循环返回 never;never 是所有类型的子类型,常用于穷尽检查:
type Shape = Circle | Square;
function area(s: Shape) {
switch (s.kind) {
case 'circle': return ...;
case 'square': return ...;
default:
const _exhaustive: never = s; // 漏分支时这里编译报错
}
}
4、什么是类型推断?什么时候需要显式标注
let x = 1自动推断为 number;函数返回值通常也能推断。- 需要显式标注的场景:函数参数、空数组(
[]会被推断为any[])、想用父类型接收多种子类型、公共 API 的导出函数(返回值显式标注可防止实现变化破坏调用方)。
5、联合类型和交叉类型
- 联合
A | B:取值可以是 A 或 B,使用时需要收窄(判别联合 + switch 是最常用模式)。 - 交叉
A & B:同时具备两者所有属性,类似”接口多继承”。 - 联合类型 + 判别联合是 TS 表达力的核心:用一个字符串字面量字段区分分支,配合 never 穷尽检查既安全又好读。
6、interface 和 type 的区别(必考)
| 维度 | interface | type |
|---|---|---|
| 对象/函数类型 | ✅ | ✅ |
| 联合、交叉、条件、映射类型 | ❌ | ✅ |
| 声明合并(同名自动合并) | ✅(扩展第三方声明时有用) | ❌ 重复声明直接报错 |
| extends | ✅ 也可 extends type | 通过 & 交叉实现 |
| 原始类型起别名 | ❌ | ✅ type ID = string | number |
结论:给对象/类定形状优先 interface,需要类型运算时用 type。
7、TS 的类有哪些特性
- 单继承(
extends)。 - 属性参数简写:
constructor(private readonly name: string)一行完成声明+赋值。 - 访问修饰符:public(默认)/ protected / private(只编译期检查,运行时无效)/#private(真私有字段)。
readonly修饰只读属性。- 抽象类 abstract:抽象方法必须由子类实现。
- 类既是”类型”也是”值”:
const u: User = ...中类名可直接当类型用;但 interface 只是类型,运行时不存在。
8、TS 如何处理异常
- TS/JS 没有 checked 异常,所有抛出的值都可以是任何类型(
throw 'error'甚至合法)。 - 最佳实践:永远
throw new Error('...')或其子类;catch (e)中 e 是unknown,需要收窄:
try {
await risky();
} catch (e) {
if (e instanceof HttpException) ...
const msg = e instanceof Error ? e.message : String(e);
}
- 自定义异常:
class BusinessException extends Error {}。注意编译到 ES5 目标时 instanceof 会失效(原型链问题),需Object.setPrototypeOf(this, BusinessException.prototype)。
9、泛型及泛型约束
function first<T>(arr: T[]): T | undefined { return arr[0]; }
// 泛型约束:限制 T 必须有 length 属性
function getLen<T extends { length: number }>(x: T): number { return x.length; }
- 泛型在编译期擦除。TS 可以用
keyof、条件类型、infer在类型层面做”计算”,见补全篇的类型体操。
10、常用内置工具类型(必考)
Partial<T>/Required<T>:所有属性变可选/必填。Pick<T, K>/Omit<T, K>:挑取/剔除部分属性。Record<K, V>:键值映射对象。ReturnType<T>/Parameters<T>:取函数返回值/参数类型。Readonly<T>:全只读。- 手写
Partial体现映射类型功底:
type MyPartial<T> = { [K in keyof T]?: T[K] };
11、枚举:enum、const enum、union 该用哪个
enum:编译成双向映射对象,运行时占体积。const enum:编译期内联,产物干净。- 更主流的做法是字面量联合:
type Role = 'admin' | 'user'——零运行时开销、穷尽检查友好。需要反向映射或迭代时才用 enum。
二、Node.js 与 Web 基础
HTTP 协议类题目(无状态、请求/响应报文、状态码、GET/POST 区别、HTTPS)与语言无关,答案见通用文档,此处只列 Node 侧的题目。
12、单线程事件循环(必考)
- Node 主线程单线程执行 JS,IO(网络、文件、DNS)由 libuv 线程池异步完成,CPU 密集型任务会阻塞整个进程。
- 事件循环阶段:timers → pending → poll → check(setImmediate)→ close。
- 宏任务 vs 微任务:每执行完一个宏任务,清空全部微任务队列;
Promise.then是微任务,setTimeout是宏任务,微任务优先。
console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
// 输出 1 3 2
13、async/await 和 Promise
async函数返回 Promise;await是 then 的语法糖;async/await以同步书写风格表达异步流程。- 并发执行多个异步:
await Promise.all([a(), b()])(一个失败全部 reject)、allSettled(互不影响)、race、any。常见错误:顺序 await 两个独立请求,白白串行。 - 高并发限流:用
p-limit等库控制并发数。 - “线程安全”问题:单线程内不存在竞态;但 await 之间会让出执行权,
if (!cache[key]) { cache[key] = await load(); }这种 check-then-act 依然可能重复加载(并发请求各自通过检查),需要用cache[key] ??= load()缓存 Promise 本身来解决。
14、Stream 和 Buffer
- Buffer:固定长度的二进制缓冲区,Node 特有。
- Stream:分 Readable / Writable / Duplex / Transform,避免大文件一次性读入内存:
import { createReadStream, createWriteStream } from 'fs';
import { pipeline } from 'stream/promises';
await pipeline(createReadStream('in.zip'), createWriteStream('out.zip'));
- 背压(backpressure):写入速度跟不上读取速度时
pipe/pipeline会自动暂停读取。
15、Reflect Metadata(Nest 的根基)
- TS 类型编译后擦除,传统上只能用
Object.keys、instanceof等弱反射。 - 装饰器 +
reflect-metadata弥补了这一点:Nest 依赖它实现依赖注入和路由参数解析:
import 'reflect-metadata';
function Entity(name: string): ClassDecorator {
return (target) => {
Reflect.defineMetadata('entityName', name, target);
};
}
@Entity('user')
class User {}
Reflect.getMetadata('entityName', User); // 'user'
- Nest 中
@Injectable()把类注册为 Provider,@Body()等参数装饰器把元数据写进方法签名,框架启动时通过Reflect.getMetadata('design:paramtypes', ...)读出构造参数类型完成自动注入——没有装饰器元数据就没有 Nest 的 IoC。
16、V8 与内存管理
- V8 执行管线:Ignition 字节码解释执行 + TurboFan 热点优化编译。
- GC:V8 分新生代(Scavenge 半空间复制)和老生代(标记清除 + 标记整理),STW 时间很短。
- 常见内存泄漏:全局变量、遗忘的 setInterval、闭包持有大对象、未销毁的事件监听器、无上限的 Map 缓存(用 WeakMap / LRU 缓存规避)。排查:
process.memoryUsage()、heap snapshot(node --inspect+ Chrome DevTools)。
17、模块体系
- ES Module 是官方标准:
import / export;CommonJS(require)是历史包袱,两者互操作有坑(ESM 导入 CJS 默认值语义)。 package.json中"type": "module"决定 .js 文件按哪种解析;TS 里由module编译选项控制。- 一个文件就是一个模块,依赖解析基于 node_modules 查找。
18、相等判断的坑
==会隐式类型转换('1' == 1为 true),永远用===/!==。NaN !== NaN,判断用Number.isNaN。- 对象比较的是引用,深比较用
lodash.isEqual或自己实现;Object.is可区分 +0/-0 和 NaN。
19、Node 如何充当 HTTP 服务器
- Node 内置
http模块,运行时本身就是 HTTP 服务器,不需要外部容器:
import { createServer } from 'http';
createServer((req, res) => res.end('ok')).listen(3000);
- 实际开发不裸用 http 模块,而是用 Express / Fastify / NestJS。没有连接线程池模型——单线程事件循环处理所有连接,IO 异步非阻塞。
20、请求处理端点在 Nest/Express 体系里是什么
- Express 里是路由回调
(req, res, next),Nest 里是@Controller中的处理方法。 - 经典陷阱:Controller 也是单例,但单线程串行执行,普通属性不会有竞态;真正的坑是
await期间共享状态被其他请求修改,以及不要在 Controller 上存请求级数据(Nest 用 Request 作用域 Provider 或AsyncLocalStorage/ClsModule解决)。
21、中间件与生命周期钩子
- 统一编码、鉴权、日志等横切逻辑 → Express/Nest 中间件、Nest Guard/Interceptor。
- 应用启停监听 → Nest 的
OnModuleInit/OnApplicationBootstrap/OnModuleDestroy/enableShutdownHooks();进程级事件process.on('SIGTERM')用于优雅停机(K8s 滚动更新必考)。
22、转发 vs 重定向在 Node 里怎么写
- 转发(服务器内部):“重写 req.path 后 next()“,Nest 中可结合
@Req()修改后放行,更常见的是直接调用内部 Service 方法;模板渲染体系(SSR 框架如 Next.js)才有真正的 forward 概念。 - 重定向:Express
res.redirect(302, '/login');Nest@Res() res或res.status(302).redirect()。语义:转发一次请求地址栏不变,重定向两次请求地址栏改变。
23、Cookie 和 Session 在 Nest 里的实现
- Cookie:
cookie-parser中间件 +res.cookie()。 - Session:
express-session(生产配 Redis store,多实例共享)。 - 前后端分离下主流是 JWT:无状态、水平扩展不需要共享存储;缺点是无法主动失效(配 Redis 黑名单)。对比 Session 的优缺点是高频题。
- “浏览器禁用 Cookie 怎么办”:URL 传 session id(不安全)或改用 token 放 Authorization 头——JWT 天然不受影响。
24、单线程的 Node 如何利用多核
cluster模块 fork 多个 worker 共享端口(master 分发连接),或用pm2/容器编排多实例 + 负载均衡。- CPU 密集任务:
worker_threads(真正的线程,共享内存需 transfer 或 SharedArrayBuffer)或拆成独立进程/消息队列。“Node 适不适合做 CPU 密集型服务”的标准答案:不适合,扬长避短。
25、Node 的全局对象和进程相关
globalThis(统一全局对象)、process(argv/env/exit)、Buffer、setTimeout家族。- 环境变量:
process.env.NODE_ENV,配合@nestjs/config的ConfigModule.forRoot({ isGlobal: true })使用。
三、NestJS
26、什么是 Nest 的 IoC 容器?
- Nest 借鉴 Angular 的 IoC 设计:
@Module()划分模块并登记 providers,框架负责实例化和装配,业务代码只声明依赖:
@Injectable()
export class UsersService {
findAll() { return []; }
}
@Module({
controllers: [UsersController],
providers: [UsersService], // 注册到容器
})
export class UsersModule {}
@Controller('users')
export class UsersController {
// 构造器注入,容器自动解析 UsersService
constructor(private readonly usersService: UsersService) {}
}
- 好处:解耦、可测试(测试时用
Test.createTestingModule换成 mock provider)、统一生命周期管理。
27、依赖注入有哪几种方式?
- 构造器注入(官方推荐):
constructor(private readonly svc: UsersService),依赖不可变、必填,测试时容易替换。 - 属性注入:
@Inject(UsersService) private svc,需要装饰器,依赖可能为 undefined。 - 基于 token 的注入:接口编译后擦除,无法直接当 token,需要
InjectionToken:
export interface LoggerService { log(msg: string): void; }
export const LOGGER = Symbol('LOGGER');
providers: [{ provide: LOGGER, useClass: ConsoleLogger }]
constructor(@Inject(LOGGER) private logger: LoggerService) {}
- 另外支持
useValue(常量/配置对象)、useFactory(工厂,可注入依赖 async 工厂)、useExisting(别名)四种提供方式。
28、Provider 的作用域
| 作用域 | 说明 |
|---|---|
| DEFAULT(默认) | 全应用单例 |
| Scope.TRANSIENT | 每次注入新实例 |
| Scope.REQUEST | 每个请求独立实例(注入链上所有依赖都会升级为 request 作用域) |
- REQUEST 作用域的性能代价:每请求都要实例化一条依赖链,Nest 官方建议用
AsyncLocalStorage(ClsModule)替代来传递请求上下文。
29、Provider 的生命周期
- 实例化(构造器)→ 属性注入完成 → 钩子按序触发:
onModuleInit()OnApplicationBootstrap的onApplicationBootstrap()(此时所有模块就绪,可安全互相调用)- 服务运行
onModuleDestroy()→onApplicationShutdown()(需app.enableShutdownHooks(),用于 SIGTERM 优雅停机:关闭连接、ack 完在途消息)
30、将类声明为可注入要注意什么
- 类上
@Injectable();Controller 上@Controller()(同时也可被注入)。 - 注意:光加 @Injectable() 不够,必须注册到某个 Module 的 providers 里才会被容器管理——这是最常踩的坑(没有包扫描式自动注册,必须显式登记或用
DiscoveryModule)。
31、同名 Provider / 模块冲突怎么办?
- 每个 Module 有独立的注入上下文:默认 providers 是模块私有的;
exports后被 import 才进入全局可见范围。 @Global()模块导出的 provider 全局唯一;同 token 重复注册时后注册的覆盖(overrideProvider也基于此)。- 跨模块注入的规则:A 想注入 B 模块的 provider,B 必须 exports 且 A import B。
32、循环依赖怎么解决?
- Nest 不自动解决循环依赖,必须开发者显式打破环:
// module 级
@Module({ imports: [forwardRef(() => BModule)] })
// provider 级
constructor(@Inject(forwardRef(() => BService)) private b: BService) {}
- 更好的方案:抽公共逻辑到第三个 Service、事件解耦(EventEmitter2)、或改用接口 + token 注入。函数参数
forwardRef(() => ...)是因为类声明时对方还未定义(TS 的 hoisting 问题),不是运行时特性。
33、单例 Provider 的并发安全问题
- 单线程串行,纯同步代码无竞态;风险来自:
await期间的共享可变状态(见一.13);- worker_threads / cluster 各进程内存独立,本身不共享。
- 结论题答法:Controller/Service 保持无状态或只放不可变配置,请求级数据走 REQUEST 作用域或 AsyncLocalStorage。
34、Nest 的 AOP 体系——必考
Nest 用五种组件实现横切关注点,执行顺序是高频考点:
请求 → Middleware → Guard → Interceptor(前置) → Pipe → Controller
↘ Handler 抛异常 → ExceptionFilter
Controller 返回 → Interceptor(后置, 可改写响应/包装 Result) → 响应
| 组件 | 典型用途 |
|---|---|
| Middleware | 日志、原始 body 处理 |
| Guard | 认证鉴权(返回 bool 或抛 ForbiddenException) |
| Interceptor | 响应包装、缓存、耗时统计、map RxJS 流 |
| Pipe | 参数转换(ParseIntPipe)、DTO 校验(ValidationPipe + class-validator) |
| ExceptionFilter | 全局异常 → 统一响应体 |
- 自定义 Guard 示例:
@Injectable()
export class RolesGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(ctx: ExecutionContext): boolean {
const roles = this.reflector.get<string[]>('roles', ctx.getHandler());
const user = ctx.switchToHttp().getRequest().user;
return roles.includes(user.role);
}
}
35、Nest 常用装饰器对照表(必背)
| 需求 | 装饰器 |
|---|---|
| 控制器 | @Controller(‘users’) |
| 路由方法 | @Get() @Post() @Put() @Delete() @Patch() |
| 查询参数 ?a=1 | @Query() |
| 路径参数 /users/:id | @Param() |
| 请求体 | @Body() |
| 请求头 | @Headers() |
| 返回 JSON | 直接返回对象即可(自动序列化) |
| 全局异常 | @Catch() + ExceptionFilter |
| 参数校验 | @UsePipes(ValidationPipe) 或全局 ValidationPipe |
| 跨域 | @EnableCors / app.enableCors() |
| 响应拦截 | NestInterceptor |
36、统一返回体和全局异常处理
// 统一响应包装:Interceptor
@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, R<T>> {
intercept(ctx: ExecutionContext, next: CallHandler): Observable<R<T>> {
return next.handle().pipe(map(data => ({ code: 0, data, message: 'ok' })));
}
}
// 全局异常:Filter
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
catch(exception: unknown, host: ArgumentsHost) {
const res = host.switchToHttp().getResponse<Response>();
const status = exception instanceof HttpException ? exception.getStatus() : 500;
res.status(status).json({ code: status, message: exception instanceof Error ? exception.message : 'error' });
}
}
// main.ts 全局注册
app.useGlobalFilters(new AllExceptionsFilter());
app.useGlobalInterceptors(new TransformInterceptor());
37、事务怎么做?
- 两种做法:
- 显式编程式(TypeORM):
dataSource.transaction(async (em) => { ... }),em 上所有操作同事务。 - 声明式:引入
typeorm-transactional(基于 AsyncLocalStorage + CLS),然后在 Service 方法上用@Transactional()装饰器,事务上下文自动透传。
- 显式编程式(TypeORM):
- 隔离级别:数据库层面设置(
SET TRANSACTION ISOLATION LEVEL/ typeormtransaction(isolation)),隔离级别的概念题沿用数据库文档;嵌套事务行为靠手动控制事务边界/嵌套策略实现,没有自动传播机制。 - 事务失效场景:自调用(同类方法内部调用不走装饰器逻辑)、异常被 try/catch 吞掉、非事务连接上的操作、async 错误未 await 传播。
38、动态模块与配置体系
- 动态模块让库模块按使用方配置装配:
ConfigModule.forRoot({ isGlobal: true, load: [() => require('./config')] }),
TypeOrmModule.forRootAsync({
inject: [ConfigService],
useFactory: (config: ConfigService) => ({
type: 'postgres',
url: config.get('DATABASE_URL'),
autoLoadEntities: true,
}),
}),
JwtModule.register({ secret: process.env.JWT_SECRET, signOptions: { expiresIn: '1h' } }),
forRootvsforRootAsync:同步配置 vs 依赖注入 + 异步取配置(如从配置中心拉取)。@nestjs/config+.env+ ConfigService 类型安全取值;多环境用.env.development/.env.production+NODE_ENV切换。- 官方生态包:
@nestjs/typeorm、@nestjs/jwt、@nestjs/swagger、@nestjs/bull、@nestjs/microservices等。
39、Nest 目录约定
- CLI
nest g resource user生成 module/controller/service/dto/entity 标准结构;main.ts 引导NestFactory.create(AppModule)。 - 模块组织建议:按业务域(feature module)拆分 + AppModule 聚合导入 + 公共能力(config、logger、guards)做成 @Global 模块。
40、Nest 微服务怎么做?
- 通信抽象:
@nestjs/microservices,同一个 Service 可以暴露 HTTP/TCP/MQTT/Kafka/gRPC 多种传输层:
const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.KAFKA,
options: { client: { brokers: ['localhost:9092'] } },
});
@MessagePattern('user.created') // 消息处理器
@EventPattern('user.created') // 事件(fire-and-forget)
- 组件生态:
| 能力 | Node/Nest 方案 |
|---|---|
| 注册发现 | Consul(官方 @nestjs/terminus 集成)、Kubernetes Service DNS、Nacos 社区 SDK |
| 负载均衡 | 客户端负载均衡:@nestjs/microservices 内置 + BullMQ/Kafka 消费组;网关层 Nginx/Kong/APISIX |
| 熔断 | @nestjs/circuit-breaker(基于 opossum)、自定义 Interceptor + opossum |
| 配置中心 | @nestjs/config + Consul/Vault/Apollo |
| 网关 | Nest 自建网关 / Kong / APISIX / Traefik |
| 链路追踪 | OpenTelemetry(@opentelemetry/auto-instrumentations-node)+ Jaeger |
| 事件总线 | EventEmitter2(进程内)、Kafka/RabbitMQ(跨服务) |
- 熔断 vs 降级:熔断是”连续失败后直接快速失败一段时间”(opossum 的 closed→open→half-open 三态),降级是”失败/超限时走兜底逻辑”,通常熔断触发降级。示例:
@Injectable()
export class PaymentService {
private breaker = new CircuitBreaker(this.callBank.bind(this), {
timeout: 3000, errorThresholdPercentage: 50, resetTimeout: 10000,
});
async pay(dto: PayDto) {
try {
return await this.breaker.fire(dto);
} catch {
return this.fallback(dto); // 降级:记录待补偿队列,稍后重试
}
}
}
41、Nest 的请求日志和耗时统计
- 全局 Middleware 记录入站,Interceptor
tap/计时不侵入业务:
intercept(ctx, next) {
const start = Date.now();
const req = ctx.switchToHttp().getRequest();
return next.handle().pipe(
tap(() => console.log(`${req.method} ${req.url} ${Date.now() - start}ms`)),
);
}
- 生产日志库:
nest-pino(结构化 JSON 日志 + 请求 ID)。
42、Nest 里用到的设计模式
- 单例:默认 Provider。
- 工厂:
useFactory、NestFactory。 - 装饰器:一切 @ 装饰器。
- 观察者:EventEmitter2、RxJS Observable(Interceptor 的
next.handle()就是 Observable 流)。 - 代理/适配器:
@nestjs/microservices各 transport 的 ClientProxy、HttpService适配 axios。 - 策略:Passport 的多个 Strategy(jwt/local/oauth2)、Guard 内按角色分派。
- 模板方法:生命周期钩子 OnModuleInit 等。
- 责任链:Middleware → Guard → Pipe → Interceptor 链。
四、数据访问层
43、参数绑定与 SQL 注入防范
// TypeORM:永远用参数占位,框架自动预编译
userRepo.createQueryBuilder('u')
.where('u.name = :name', { name: input }) // ✅ 预编译参数
// .where(`u.name = '${input}'`) // ❌ 字符串拼接,注入!
// 原生查询
dataSource.query('SELECT * FROM users WHERE id = $1', [id]); // PostgreSQL $1
44、TypeORM vs Prisma 选型(高频)
| 维度 | TypeORM | Prisma |
|---|---|---|
| 范式 | 传统 ORM(实体/装饰器) | Schema-first + 生成客户端 |
| 类型安全 | 装饰器实体,深度查询类型较弱 | 极强(schema 自动生成类型) |
| 复杂 SQL | QueryBuilder 较强 | 复杂查询要 $queryRaw |
| 迁移 | 自动 migration | migrate diff 友好 |
| Nest 集成 | 官方 @nestjs/typeorm | PrismaService 封装 |
答法:重业务轻 SQL 用 Prisma(类型安全 + DX),复杂报表/查询调优多则 TypeORM QueryBuilder 或保留 SQL。
45、应用层缓存策略
- 默认每次查询都打到数据库,缓存要自己做:
- 方案 A:Interceptor + Redis 缓存响应(cache-manager-redis-store)。
- 方案 B:Repository 层包缓存(cache aside:先查缓存,miss 查库回填,写时删缓存——缓存一致性的延迟双删/Canal 答案沿用 Redis 文档)。
46、insert 返回自增主键
// TypeORM:save 后实体自动回填 id
const user = await repo.save(new User(...)); // user.id 已有值
// Prisma
const user = await prisma.user.create({ data: {...} }); // 返回完整记录含 id
// 原生(PostgreSQL)RETURNING
await dataSource.query('INSERT INTO users(name) VALUES ($1) RETURNING id', [name]);
47、分页查询
const [items, total] = await repo.findAndCount({
skip: (page - 1) * size,
take: size,
order: { createdAt: 'DESC' },
});
深分页优化(游标分页 WHERE id < :cursor LIMIT n)沿用 ES/MySQL 文档思路。
五、补全篇(TS/Nest 特有、必考)
48、类型体操三板斧:keyof / typeof / infer
// keyof:取对象类型的所有键组成联合
type UserKeys = keyof { id: number; name: string }; // 'id' | 'name'
// typeof:从值反推类型(配置对象常用)
const config = { host: 'localhost', port: 3000 } as const;
type Config = typeof config; // { readonly host: 'localhost'; readonly port: 3000 }
// infer:在条件类型中"提取"类型变量
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type R = Unwrap<Promise<string>>; // string
// 内置 ReturnType / Parameters 的实现原理就是 infer
type MyReturnType<T> = T extends (...args: never[]) => infer R ? R : never;
49、条件类型与映射类型
// 条件类型 + 分发特性(传入联合类型会逐个计算再合并)
type NonNullable<T> = T extends null | undefined ? never : T;
// 映射类型 + as 重映射(实现 Pick)
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
// 模板字面量类型
type EventName = `on${Capitalize<'click' | 'input'>}`; // 'onClick' | 'onInput'
50、as const、satisfies、类型断言
as const:把字面量锁定为最窄类型且全只读,是元组/配置对象类型推断的关键。as T:强制断言(编译期,无运行时检查),滥用会掩盖 bug;unknown as T双重断言是明确危险的信号。satisfies T(TS 4.9+):校验值满足类型但保留更精确的字面量推断——比: T声明更好用:
const themes = {
dark: { bg: '#000', color: '#fff' },
} satisfies Record<string, { bg: string; color: string }>;
51、函数重载、可选/默认/剩余参数
function combine(a: string, b: string): string; // 重载签名
function combine(a: number, b: number): number;
function combine(a: any, b: any): any { return a + b; } // 实现签名对外不可见
- 可选参数
b?: string(=string | undefined)、默认参数b = 'x'会自动收窄类型、剩余参数...rest: string[]。
52、声明文件与 @types
- 用到无类型的 JS 库时:
declare module 'xxx'或写.d.ts;社区类型在@types/xxx(DefinitelyTyped)。 declare只描述类型不产生代码;tsconfig的typeRoots/types控制加载范围。
53、tsconfig 关键配置(必考)
strict: true总开关(含 strictNullChecks 等,务必开)。target:输出 JS 语法版本(ES2020+);module:模块体系(Node 用 commonjs 或 NodeNext/ESM);moduleResolution: bundler / node16。esModuleInterop:让 CJS 的import x from 'cjs'正常工作。skipLibCheck: true跳过依赖包类型检查(提速);paths/baseUrl路径别名;declaration、sourceMap、experimentalDecorators + emitDecoratorMetadata(Nest 必需,元数据注入依赖它)。
54、Nest 的参数校验:class-validator + class-transformer
// main.ts 全局开启
app.useGlobalPipes(new ValidationPipe({
whitelist: true, // 剥离未定义字段
forbidNonWhitelisted: true, // 多传字段直接报错
transform: true, // payload 转 DTO 类实例
}));
// DTO
export class CreateUserDto {
@IsString() @IsNotEmpty() name: string;
@IsEmail() email: string;
@IsInt() @Min(0) age: number;
}
- DTO 模式 + 类型即文档是 TS 全栈的核心优势。
55、认证方案:Passport + JWT 完整链路
// 策略
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
constructor(config: ConfigService) {
super({ jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
secretOrKey: config.get('JWT_SECRET') });
}
validate(payload: { sub: number; role: string }) { return payload; } // 挂到 req.user
}
// 使用
@UseGuards(AuthGuard('jwt'), RolesGuard)
@Roles('admin')
@Delete('users/:id')
remove(@Param('id', ParseIntPipe) id: number) { ... }
- Guard 负责认证与授权,Strategy 负责令牌校验,校验结果挂到 req.user 供后续 Guard 使用。
56、Nest 事件与 RxJS
- Interceptor 返回的是
Observable,可用map/tap/catchError/timeout/retry操作符做响应变换、重试、超时——理解”Interceptor 是流”是区分初级/中级的分水岭。 - 进程内事件:
@nestjs/event-emitter,@OnEvent('user.created');跨服务事件走 MQ(沿用 MQ 章节题目)。
57、Swagger / OpenAPI 文档
// main.ts
const config = new DocumentBuilder()
.setTitle('API').setBearerAuth().build();
SwaggerModule.setup('docs', app, SwaggerModule.createDocument(app, config));
// Controller 上
@ApiTags('users') @ApiOperation({ summary: '创建用户' })
@ApiResponse({ status: 201, type: UserVo })
- DTO 类即 Schema,天然同步。
58、限流
@nestjs/throttler:
ThrottlerModule.forRoot([{ ttl: 60000, limit: 10 }]); // 全局:1 分钟 10 次
@Throttle({ default: { limit: 3, ttl: 60000 } }) // 单接口覆盖
@SkipThrottle() // 跳过
- 分布式多实例场景改用 Redis 存储(自定义 ThrottlerStorage)或网关层限流(Kong/APISIX)。
59、优雅停机与健康检查
app.enableShutdownHooks(); // SIGTERM → onModuleDestroy 顺序执行
// 健康检查:@nestjs/terminus
@Get('health')
health() { return this.health.check([() => this.db.pingCheck('database')]); }
- K8s 滚动更新流程:readinessProbe 失败摘流量 → SIGTERM → 处理完在途请求 → 关闭 DB/Redis/Kafka 连接 → 退出。Nest 优雅停机是微服务”发布如何不停服”的标准答案。
60、测试
// Nest 内置 Jest + Supertest
const moduleRef = await Test.createTestingModule({
controllers: [UsersController],
providers: [{ provide: UsersService, useValue: { findAll: jest.fn().mockResolvedValue([]) } }],
}).compile();
it('GET /users', () =>
request(app.getHttpServer()).get('/users').expect(200).expect([]));
- e2e:起完整 AppModule + Supertest 打真实 HTTP;单测:Test.createTestingModule + overrideProvider mock 依赖。
61、构建与部署
- 运行:
nest start(开发);生产nest build(tsc)或 SWC 编译器(nest build -b swc,快 20 倍)。dev 热重载:nest start --watch。 - 生产镜像用多阶段构建(builder 安装依赖编译 → runner 只拷 dist + 生产依赖)。
- 进程守护:
pm2 start dist/main.js -i max(cluster 多核);或 Docker + K8s。
62、Node 性能排查
- 慢在哪:
clinic doctor/autocannon压测。 - CPU 热点 / 阻塞事件循环:
--inspect+ Chrome CPU Profile;blocked-at检测同步长任务。 - 内存:heap snapshot 对比找增长对象;
--max-old-space-size=2048调整堆上限。 - 事件循环延迟:
monitorEventLoopDelay()指标接入 Prometheus。 - 常见事故:正则回溯爆炸、JSON.parse 大 payload 同步阻塞、误用
*同步 fs API。
63、Monorepo 与 Nx(加分项)
nest new -p npm monorepo原生 monorepo 或用 Nx/turbo 管理多 app + 共享 libs(shared dto/types);CI 只构建受影响的项目(nx affected)。
64、TS 后端优劣势一句话速答
- 优势:类型即文档、前后端同构共享 DTO、结构类型+联合类型表达力、JSON 原生亲和、开发迭代速度。
- 劣势:运行时无类型(校验需 class-validator 兜底)、生态重前端轻后端、单线程 CPU 密集弱、装饰器元数据依赖 legacy decorators 特性。
六、NestJS 技术方案设计题(15 题,四段式精讲)
本文 15 道题全部是「方案设计 / 场景题」——面试官给一个真实需求,看你能不能给出完整方案、说出落地时会踩的坑、并给出修补手段。每题按四段展开:问题类型 → 怎么解决 → 有哪些坑 → 怎么修补。坑与修补均来自可复现的实验项目(认证、RBAC、日志、拦截器、版本控制、循环依赖、动态模块、WebSocket、SSE 等,NestJS 12 语义),不是概念罗列。
65、前后端分离项目,JWT 双 token 无感刷新怎么设计?accessToken 过期了怎么做到用户无感知?
问题类型:认证鉴权设计类。考察点:对 JWT「无状态」的边界认知(无法主动失效)、token 生命周期的工程化拆分、前后端配合的完整闭环,以及刷新过程的并发安全。这是认证类题里区分度最高的一道——只会「登录发 token」算初级,能讲清旋转、重放检测、竞态才是中级以上。
怎么解决:
- 双 token 分工:accessToken 短时效(15 分钟
2 小时),每次请求带在14 天),只用来换新 accessToken,不参与业务请求。短 accessToken 把「token 泄漏」的暴露窗口压到最小。Authorization: Bearer xxx;refreshToken 长时效(7 - 签发:
JwtModule注册双配置(两个 secret 分开,泄漏 access secret 不影响 refresh 校验),登录成功签发一对:
// 文件场景:src/auth/auth.module.ts —— accessToken 走全局默认配置
JwtModule.registerAsync({
useFactory: (config: ConfigService) => ({
secret: config.get('JWT_ACCESS_SECRET'),
signOptions: { expiresIn: '2h' },
}),
inject: [ConfigService],
}),
// 文件场景:src/auth/auth.service.ts —— 登录签发双 token,refreshToken 落 Redis
const accessToken = this.jwtService.sign(
{ sub: user.id, username: user.username, jti: randomUUID() },
{ expiresIn: '2h' },
);
const refreshToken = this.jwtService.sign(
{ sub: user.id, jti: randomUUID() },
{ secret: this.config.get('JWT_REFRESH_SECRET'), expiresIn: '14d' },
);
// 只存哈希:Redis 泄漏也伪造不出 refreshToken
await this.redis.set(`refresh:${user.id}`, sha256(refreshToken), 'EX', 14 * 24 * 3600);
return { accessToken, refreshToken };
- accessToken 校验:自定义 Guard(或 Passport JwtStrategy)里
jwtService.verify()验签 + 过期检查,通过后把 payload 挂到request.user,失败统一抛UnauthorizedException。 - 刷新端点 + 旋转(rotation):
POST /auth/refresh验 refreshToken 签名后,还要和 Redis 里存的哈希比对;通过则签发新的双 token,并使旧 refreshToken 作废——这就是旋转。
// 文件场景:src/auth/auth.controller.ts —— 刷新:验签 + 对库 + 旋转
@Post('refresh')
async refresh(@Body() dto: RefreshTokenDto) {
const payload = this.jwtService.verify(dto.refreshToken, {
secret: this.config.get('JWT_REFRESH_SECRET'),
});
const stored = await this.redis.get(`refresh:${payload.sub}`);
if (stored !== sha256(dto.refreshToken)) {
await this.redis.del(`refresh:${payload.sub}`); // 旧 token 二次使用,疑似泄漏
throw new UnauthorizedException('登录已失效,请重新登录');
}
return this.authService.rotate(payload.sub); // 签发新双 token,旧 refreshToken 作废
}
- 前端无感刷新:响应拦截器捕获 401 → 暂存失败请求 → 调
/auth/refresh→ 用新 token 重放;refreshToken 也过期(刷新接口返回 401)才跳登录页。 - 主动失效通道(JWT 天生缺失的能力):改密码、踢人、封号时,更新 Redis 里该用户的
tokenVersion(或把旧 accessToken 的 jti 加黑名单,TTL 设为它的剩余有效期),Guard 校验时多查一次。
有哪些坑:
- accessToken 还有效但用户已经改密码 / 被封号:JWT 无状态,
verify()只看签名和过期,业务侧怎么「作废」它做不到——上线后被安全团队第一个 challenge 的就是这一点。 - JWT 401 的三大来源混在一起:header 少了
Bearer前缀(authorization.split(' ')[1]取到 undefined 或错误段)、签发和校验的 secret 不一致(比如本地注册了两个不同配置的 JwtModule)、token 真过期——三种原因前端拿到的都是同一个 401,排查时分不清。 - refreshToken 也做成纯无状态:不带 Redis 比对,只验签名。泄漏的 refreshToken 在 14 天内可以无限重放,「旋转」更是无从谈起。
- 并发刷新竞态:页面同时发 5 个请求,accessToken 过期后 5 个 401 同时触发刷新;第一个成功后 refreshToken 已旋转,其余 4 个拿旧 token 去换全部失败,用户被「莫名登出」。
- payload 越塞越大、越塞越敏感:把角色、手机号甚至密码哈希放进 JWT——JWT 只是 Base64 编码不是加密,谁拿到都能读;且每个请求都带全量状态,白白增大流量。
怎么修补:
- accessToken 短时效(泄漏窗口小)+ Redis 黑名单(jti → 剩余 TTL)或用户级
tokenVersion字段:签发时写进 payload,Guard 校验时比对,改密码/踢人时 version + 1,旧 token 全部失效。 - 用
^Bearer (.+)$严格解析并区分错误码:401 响应体返回token_missing / token_invalid / token_expired,前端只在token_expired时走刷新逻辑,其余直接登出;secret 统一从 ConfigService 取,禁止散落硬编码。 - refreshToken 必须服务端有档:Redis 存哈希,每次刷新旋转;发现「已旋转的旧 token 被再次使用」视为泄漏信号,直接清掉该用户全部会话(重放检测)。
- 前端对刷新加互斥锁(single-flight):第一个 401 触发刷新,其余请求进队列等新 token 后统一重放;后端可再给旧 refreshToken 一个 30~60 秒宽限期,双保险。
- payload 只放
sub / username / jti / tokenVersion;角色这类可变信息不放 token,鉴权时查缓存/库,权限变更即时生效。
66、后台管理系统要一套 RBAC 权限体系,怎么用 Guard + 自定义装饰器落到 Nest 上,而不是每个接口抄 if?
问题类型:认证鉴权 + AOP 落地类。考察点:声明式编程意识(声明与执行分离)、对 metadata 机制(SetMetadata/Reflector)的理解、全局 Guard 的正确注册方式,以及「两层 Guard(认证→鉴权)」的职责划分。手写 if 能跑,但「新增接口忘了抄 = 静默裸奔」——面试官要看你怎么从机制上堵住这个洞。
怎么解决:
- 模型层:RBAC0 三张表(用户-角色、角色-权限),Service 提供「把用户所有角色的权限合并成一个数组」的方法。
- 声明层:
SetMetadata封装自定义装饰器,把「需要登录」「需要什么权限」声明在 controller 或 handler 上,handler 里一行校验代码都不写:
// 文件场景:src/common/decorators/require.decorator.ts
export const RequireLogin = () => SetMetadata('require-login', true);
export const RequirePermission = (...permissions: string[]) =>
SetMetadata('require-permission', permissions);
- 执行层:LoginGuard(认证:验 token、挂
request.user)+ PermissionGuard(鉴权:比对声明权限与用户权限),Guard 里用Reflector.getAllAndOverride同时读 handler 和 class 两级 metadata:
// 文件场景:src/common/guards/login.guard.ts —— 构造器注入 Reflector
@Injectable()
export class LoginGuard implements CanActivate {
constructor(private readonly reflector: Reflector, private readonly userService: UserService) {}
canActivate(context: ExecutionContext): boolean {
const requireLogin = this.reflector.getAllAndOverride<boolean>('require-login', [
context.getHandler(), // handler 优先
context.getClass(), // 再查 controller 级
]);
if (!requireLogin) return true; // 未声明需要登录的接口(如登录本身)直接放行
const request = context.switchToHttp().getRequest<Request>();
const authorization = request.headers.authorization;
if (!authorization) throw new UnauthorizedException('用户未登录');
const token = authorization.split(' ')[1];
const user = token && this.userService.findUserByToken(token);
if (!user) throw new UnauthorizedException('token 失效,请重新登录');
request.user = { username: user.username }; // 挂给后续的 PermissionGuard 用
return true;
}
}
- 全局注册:用
APP_GUARDtoken 声明为 provider(而不是app.useGlobalGuards),这样 Guard 走 IoC 容器、能注入依赖;声明顺序即执行顺序:
// 文件场景:src/app.module.ts —— 两个全局 Guard,顺序不能反
providers: [
UserService,
{ provide: APP_GUARD, useClass: LoginGuard }, // 先:认证
{ provide: APP_GUARD, useClass: PermissionGuard }, // 后:鉴权
],
- 业务侧变成纯声明:controller 上
@RequireLogin()+@RequirePermission('query_aaa'),类级声明对新方法默认生效;个别接口再单独@RequirePermission('create_aaa')。 - 性能:权限集用 Redis 缓存(key 形如
user_${username}_permissions,30 分钟过期),改角色/权限时主动删 key。
有哪些坑:
app.useGlobalGuards(new LoginGuard())手动 new:Guard 注入不了 UserService、Reflector——启动直接报Nest can't resolve dependencies,或者有人图省事在 Guard 里new Reflector(),拿到的不是容器里那个实例,读 metadata 行为诡异。- 两个 Guard 声明顺序写反:PermissionGuard 在前时
request.user还没挂上,而 PermissionGuard 里写了if (!request.user) return true——鉴权被静默跳过,所有接口裸奔,比报错可怕得多。 - 忘写
@RequireLogin()时 Guard 是放行的:getAllAndOverride返回 undefined →if (!requireLogin) return true。遗漏的表现恰好和预期相反(该拦的没拦),编译不报错、测试不报错,只有攻击者会发现——手写 if 时代「忘抄 = 裸奔」的问题被原样继承了下来。 - 装饰器是工厂函数,忘了带括号:
@RequireLogin不加()不会报编译错误,但 SetMetadata 根本没挂上;还有getAllAndOverride只传了getHandler()忘传getClass(),controller 级声明全部失效。 - 每个请求都实时查库合并角色权限:3 张表 join 一遍,热门接口把数据库打出慢查询。
怎么修补:
- 全局 Guard 一律走
{ provide: APP_GUARD, useClass: X }注册(IoC 容器创建,支持依赖注入);Reflector 一律构造器注入。 - 严格保证 LoginGuard 在前;并把 PermissionGuard 的兜底逻辑改为「声明了权限要求但没有 user → 直接拒绝」而不是放行,让顺序写反时至少是「全拒」而不是「全放」。
- 反转默认:全局默认需要登录,提供
@Public()装饰器(SetMetadata 白名单)显式放行登录、健康检查等接口——新增接口默认受保护,遗漏不再是漏洞。 - 自定义装饰器统一
@RequireLogin()带括号调用(团队 lint 约定);getAllAndOverride的目标数组固定写[context.getHandler(), context.getClass()]。 - 权限集进 Redis 缓存 + 变更时删 key;或登录时把权限快照写进 token/session,容忍分钟级延迟。
67、全站接口要统一 {code, message, data} 响应格式,并且任何异常都返回统一结构,怎么设计?
问题类型:AOP 架构类。考察点:对 Nest 横切组件分工的理解(响应包装归 Interceptor、异常归 Exception Filter)、RxJS 操作符(map/tap/catchError)的正确使用、全局组件的注册方式,以及「统一格式」对特殊响应(文件流、SSE)的兼容处理。能把这道题讲圆满的,基本已经具备中型项目的骨架设计能力。
怎么解决:
- 成功路径:TransformInterceptor +
map包装响应信封,APP_INTERCEPTOR全局注册,一处生效全站自动包装,新增接口不可能忘:
// 文件场景:src/common/interceptors/transform.interceptor.ts
@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, R<T>> {
intercept(context: ExecutionContext, next: CallHandler): Observable<R<T>> {
return next.handle().pipe(
map((data) => ({ code: 0, message: 'success', data })),
);
}
}
// 文件场景:src/app.module.ts —— 全局注册(走 IoC,可注入依赖)
providers: [{ provide: APP_INTERCEPTOR, useClass: TransformInterceptor }],
- 失败路径:全局 Exception Filter。
@Catch()捕获一切异常:HttpException 取出状态码与getResponse();未知异常统一 500、不透内部信息;错误响应也包成同一个信封,前端只写一套解析:
// 文件场景:src/common/filters/all-exceptions.filter.ts
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
catch(exception: unknown, host: ArgumentsHost) {
const res = host.switchToHttp().getResponse();
const status = exception instanceof HttpException ? exception.getStatus() : 500;
const message =
exception instanceof HttpException
? (exception.getResponse() as any).message ?? exception.message
: '服务器繁忙,请稍后重试'; // 未知异常不透 message,防泄露 SQL/堆栈
res.status(status).json({ code: status, message, data: null });
}
}
- 业务异常体系:自定义
BusinessException extends HttpException,HTTP 状态码与业务 code 分离(code: 40001之类),Filter 统一翻译。 - 耗时与访问日志顺手用
tap在同一个拦截器体系里做:next.handle().pipe(tap(() => log耗时)),比在 handler 里Date.now()量得更准(handler 内部量不到序列化和响应发送)。 - 超时保护可选叠加:
timeout(3000)+catchError把TimeoutError转成RequestTimeoutException(408)。
有哪些坑:
@Res()注入原生 response 后忘了{ passthrough: true }:Nest 检测到注入了 response 对象就默认「返回值不再作为响应体」——这类接口需要手动res.json();挂了全局信封后,这些接口的返回值被悄悄忽略,表现为「接口返回空」。- 全局信封把 SSE / 文件下载接口也包了:
@Sse()返回的 Observable、文件流被map当成普通data塞进信封,流式语义直接坏掉(EventSource 收到的是一个 JSON 信封而不是 event-stream)。 - 全局拦截器用
app.useGlobalInterceptors(new Xxx())注册:手动 new 的实例注入不了依赖(要打日志、查配置的拦截器直接没法写),和 Guard 的坑同源。 - 异常 message 一刀切:要么把未知异常的
err.message原样透给客户端(数据库报错、堆栈片段泄露);要么业务代码全用普通throw new Error(),前端只拿到Internal server error,线上排查全靠猜。 - 错误响应和成功响应结构不一致:成功是
{code:0, message, data},校验失败却是 Nest 默认的{statusCode, message: string[]}——前端被迫写两套解析,「统一格式」只统一了一半。 - 双层包装:路由级已经有一个包装拦截器,再上全局信封,返回变成
{code:0, data: {code:200, message:'success', data:{...}}}——嵌套信封,前端逐层剥。
怎么修补:
- 注入
@Res的地方统一写@Res({ passthrough: true }),保留返回值自动序列化;真要完全接管的接口(重定向、下载)在 code review 里单独把关。 - 给信封拦截器加白名单:自定义
@SkipTransform()(本质还是 SetMetadata),拦截器里用 Reflector 判断该路由跳过包装;SSE、Swagger、导出下载都打上。 - 全局组件一律
APP_INTERCEPTOR / APP_FILTERtoken 注册,需要依赖注入的组件不进 main.ts。 - 分级处理:HttpException → 按
getResponse()透出业务信息;未知异常 → 固定话术给前端、完整堆栈进日志(winston error 级);业务错误强制用 HttpException 子类抛出。 - Filter 里对错误响应也包统一信封
{code, message, data: null},与成功结构对齐;ValidationPipe的错误数组在 Filter 里格式化成字符串。 - 全站只保留一层包装(全局信封),路由级 TransformInterceptor 删除;e2e 断言响应结构,双层嵌套立刻爆红。
68、线上接口要做破坏性升级(返回结构都变了),但老版本 App 还在流通,多版本共存与灰度发布怎么设计?
问题类型:API 治理 / 兼容性设计类。考察点:对「路由匹配增加版本维度」的理解、四种版本携带方式的取舍、新旧 controller 并存的组织方式,以及灰度发布的落地路径。核心矛盾:服务端一个字段变更,不能逼所有客户端同一天发版。
怎么解决:
- 开启版本维度:
main.ts里app.enableVersioning(...),路由匹配从「路径 + 方法」变成「路径 + 方法 + 版本」。四种携带方式按需选:URI(/v2/aaa,网关友好)、HEADER(自定义 header,路径干净)、MEDIA_TYPE(Accept 头)、CUSTOM(自定义 extractor,可做灰度分流):
// 文件场景:src/main.ts —— HEADER 方式 + 默认版本兜底
app.enableVersioning({
type: VersioningType.HEADER,
header: 'version',
defaultVersion: '1', // 不带 header 的旧客户端按 v1 处理
});
- 新旧 controller 并存:老 controller 标
VERSION_NEUTRAL兜底一切旧版本;新版本单独一个AaaV2Controller标version: '2',两者共用同一个 Service——版本控制只管路由层:
// 文件场景:src/aaa/aaa.controller.ts —— 老版本兜底
@Controller({ path: 'aaa', version: VERSION_NEUTRAL })
export class AaaController { /* 返回老格式 */ }
// 文件场景:src/aaa/aaa-v2.controller.ts —— 新版本
@Controller({ path: 'aaa', version: '2' })
export class AaaV2Controller { /* 返回新格式 */ }
- 注册顺序很关键:更具体的版本(
AaaV2Controller)注册在前面,VERSION_NEUTRAL兜底的放后面——controller 按注册顺序从上到下匹配。 - 个别接口升级不必整个 controller 搬家:handler 上单独
@Version('2'),优先级高于 controller 级声明。 - 灰度发布:CUSTOM extractor 从请求里(租户 header、用户灰度标)提取版本号,配合配置中心开关动态调整放量比例;v1 流量归零(监控有数据)再下线 v1 controller。
有哪些坑:
- URI 版本方式下
VERSION_NEUTRAL失效:URI 方式不支持版本中立——VERSION_NEUTRAL的 controller 只匹配不带版本前缀的裸路径(/aaa),/v1/aaa直接 404。从 HEADER 切到 URI 时「controller 一行不改」是不成立的。 - controller 注册顺序反了:
VERSION_NEUTRAL的 AaaController 写在 AaaV2Controller 前面,NEUTRAL 先到先得拦住一切,version: 2的请求永远拿到老格式,还以为是前端 header 没带对。 - 忘了
enableVersioning:所有版本声明全部被无视,两个 controller 只剩注册顺序在起作用,行为「看起来随机」,且没有任何报错。 - HEADER 方式的死角:没配
defaultVersion时,不带 header 的旧客户端 404;浏览器地址栏直接访问永远拿不到 v2(浏览器不会带自定义 header)。 - 版本只在应用层路由,网关不感知:想按版本限流、回滚、分流,v2 出问题想快速切回 v1,应用层的 HEADER 版本对网关是黑盒,做不到。
怎么修补:
- 切 URI 方式时,把 NEUTRAL 改成明确的
version: '1'(此后裸路径/aaa反而 404,版本前缀成为路径必要部分);把这条写进切换清单。 - 注册顺序固定「具体版本在前、兜底在后」,并用 e2e 用例锁住「
version: 2必须命中 V2」。 enableVersioning放进 main.ts 的启动检查清单;CI 里跑一条最小版本的冒烟请求。- 必配
defaultVersion: '1'兜住存量客户端;浏览器调试改用 URI 方式或浏览器插件注入 header。 - 灰度需求重的系统选 URI 方式让版本进路径,网关按
/v1/*、/v2/*分组做限流与回滚;HEADER/CUSTOM 方式则把灰度规则收敛到配置中心,由应用层读取。
69、用户模块要调通知模块,通知模块又要查用户信息,Module/Provider 循环依赖怎么解?
问题类型:模块设计类。考察点:Nest 递归创建依赖的机制理解(为什么环会死锁成 undefined)、forwardRef 的正确用法(两边都包 + @Inject)、以及「重构消环优先、forwardRef 兜底、ModuleRef 单方面绕环」三条路的取舍。能讲清两段著名报错的真正死因,而不是照报错提示盲改,是这道题的加分点。
怎么解决:
- 首选重构消环:把互相调用的逻辑抽到第三个 Service,或用事件解耦(EventEmitter2,用户模块发事件、通知模块监听),环直接消失。
- Module 环:两边都用
forwardRef包 imports。原理是「先创建、后转发引用」——创建阶段互不等待,双方都实例化完成后再把真实引用转发过去:
// 文件场景:src/aaa/aaa.module.ts —— 环的两边都要包
@Module({ imports: [forwardRef(() => BbbModule)] })
export class AaaModule {}
// bbb.module.ts 对称地写 imports: [forwardRef(() => AaaModule)]
- Provider 环:
@Inject(forwardRef(() => XxxService))。用了 forwardRef 之后不能按类型自动注入,必须手动指定 token:
// 文件场景:src/ddd/ddd.service.ts —— 与 ccc.service.ts 对称
@Injectable()
export class DddService {
constructor(
@Inject(forwardRef(() => CccService))
private cccService: CccService,
) {}
}
- ModuleRef 运行时取:注入
ModuleRef(IoC 容器句柄),真正调用时再this.moduleRef.get(CccService, { strict: false })——引用在运行时才去容器拿,天然不参与初始化竞赛,且不要求对方改任何代码。 - 不要扩大化:没参与环的普通注入保持原样,不要预防性地到处包 forwardRef。
有哪些坑:
- 只改一边:给 aaa.module 包了 forwardRef、bbb.module 还是直接引用——报错原样回来。环必须两边都处理,缺一不可。
- Provider 环用了 forwardRef 却忘加
@Inject(或属性注入的@Inject(forwardRef(...))整行写漏):应用能启动,但引用没被转发,调用this.xxxService.yyy()时拿到 undefined——启动成功不等于环已解决,坑到第一次运行时才爆。 - 看不懂报错、误判原因:
The module at index [0] of the AaaModule "imports" array is undefined——TS 层面 import 环是合法的、编译通过,死在 Nest 运行时的递归创建;新人常误以为是自己文件路径写错,改半天路径。 - 到处乱包 forwardRef:不参与环的注入也包,类型推断变弱、可读性下降,还把「环存在」这个坏消息藏在代码里。
ModuleRef.get()默认strict: true:只在当前模块作用域找,拿不到其他模块未导入的 provider,运行时抛错。
怎么修补:
- 认定规则「环的两边都要包」,code review 用模块依赖图(或 lint 规则)检查环的两端是否对称处理。
- forwardRef 必须与
@Inject成对出现;上线前用 e2e 实际调用环路径上的方法验证返回值里没有 undefined(启动冒烟测不出来)。 - 熟记两段报错原文与死因(
imports array is undefined= Module 环;Nest can't resolve dependencies= Provider 环),报错信息里其实直接提示了Use forwardRef() to avoid it。 - 重构优先:抽公共 Service / 事件总线;forwardRef 是迫不得已的兜底,引入时在注释里说明环从哪来、何时消。
- 跨模块查找显式写
get(Token, { strict: false })。
70、要给团队写一个可复用的配置模块(像 @nestjs/config 那样),动态模块怎么设计?
问题类型:模块设计 / 可复用组件类。考察点:对动态模块本质的理解(「把模块定义从静态数据变成函数返回值,让配置在 import 那一刻流进模块」)、register/forRoot/forFeature 的语义约定、以及 ConfigurableModuleBuilder 的使用。这是「会用 Nest」和「能写 Nest 生态组件」的分水岭。
怎么解决:
- 静态方法返回 DynamicModule:给模块加
static register(options),返回值和@Module参数几乎一样,只多一个module属性;imports数组里放「函数调用的结果」,参数就这样传进去了:
// 文件场景:src/bbb/bbb.module.ts —— 手写版:看清 DynamicModule 的本质
@Module({})
export class BbbModule {
static register(options: Record<string, any>): DynamicModule {
return {
module: BbbModule,
controllers: [BbbController],
providers: [{ provide: 'CONFIG_OPTIONS', useValue: options }],
exports: ['CONFIG_OPTIONS'],
};
}
}
// 使用方:imports: [BbbModule.register({ aaa: 1 })] —— 括号出现了,配置进来了
- 模块内部注入 options:Service/Controller 里
@Inject('CONFIG_OPTIONS')拿到使用方传的配置,基于它做初始化。 - 用
ConfigurableModuleBuilder免去样板代码:链式配置生成自带register/registerAsync的基类、唯一的 options token 和参数类型:
// 文件场景:src/config/config-options.ts —— builder 生成基类
export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } =
new ConfigurableModuleBuilder<ConfigModuleOptions>()
.setClassMethodName('forRoot')
.setExtras({ isGlobal: true }, (definition, extras) => ({
...definition,
global: extras.isGlobal, // isGlobal 字段决定模块是否全局
}))
.build();
// 文件场景:src/config/config.module.ts —— 继承基类,覆写并追加自己的 provider
export class ConfigModule extends ConfigurableModuleClass {
static forRoot(options: typeof OPTIONS_TYPE): DynamicModule {
const base = super.forRoot(options);
return {
...base,
providers: [...(base.providers ?? []), ConfigService],
exports: [...(base.exports ?? []), ConfigService],
};
}
}
- 异步配置走
forRootAsync:options 要从配置中心/密钥服务异步拉时,传useFactory(可配inject声明工厂依赖)。 - 遵守命名约定:
register(用一次传一次,可多份)、forRoot(配置一次全局用)、forFeature(forRoot 后的局部注册,如TypeOrmModule.forFeature([实体]))。
有哪些坑:
- 字符串 token 冲突:手写版用
'CONFIG_OPTIONS'做 token,两个模块(或同一模块 register 两次连两个库)都用了这个字符串,后注册的覆盖先注册的——配置静默串库,极难排查。 - isGlobal 语义没吃透:
isGlobal: false时其他模块没 import 就注入 ConfigService,启动报Nest can't resolve dependencies;反过来以为设了 global 就没生效,多半是setExtras的处理函数没把global: extras.isGlobal写进模块定义。 forRootAsync的useFactory里抛错/超时(配置中心连不上):错误混在一大团模块初始化日志里,看不出根因是配置拉取失败。- 模块内部直接读
process.env:替使用方做了决定(变量叫什么、从哪读),换环境要改模块源码,「复用」名存实亡。 - 覆写 forRoot 时弄丢基类的内容:忘了
...base展开,把基类注册的 options provider 或 exports 覆盖掉,模块行为残缺。
怎么修补:
- token 用 builder 生成的
MODULE_OPTIONS_TOKEN(天然带模块唯一前缀);手写时给 token 加模块名前缀(BBB_CONFIG_OPTIONS)。 setExtras第二个参数务必返回{ ...definition, global: extras.isGlobal };文档写清「非全局必须 import,全局才能免 import」,并在 README 里给出两种用法的示例。useFactory里 try/catch 包装,抛出带语义的错误(ConfigCenter unreachable: timeout after 3s),并给配置中心客户端设置超时,别让启动无限挂起。- 读什么、从哪读由 forRoot 的 options 决定(envPath、前缀等参数化),模块内部只消费注入进来的 options。
- 覆写时始终
...base展开再追加:providers: [...(base.providers ?? []), ConfigService]。
71、生产环境的请求日志与链路追踪怎么做?console.log 直接上生产差在哪?
问题类型:可观测性设计类。考察点:日志框架的核心能力(级别、多目的地、结构化)、Nest 框架日志与业务日志的统一接管、请求轨迹(traceId)的贯穿方案,以及多进程部署下的日志治理。这道题答得好坏,直接反映候选人有没有真正运维过线上服务。
怎么解决:
- winston + nest-winston 统一接管:
WinstonModule.forRoot配置level(最低输出级别,一个配置全局开关)和transports(控制台彩色 + 文件 JSON 双写),main.ts里替换应用 Logger,框架启动日志和业务new Logger()输出走同一套:
// 文件场景:src/main.ts —— bufferLogs 让初始化日志先进缓冲,替换完成后再输出
const app = await NestFactory.create(AppModule, { bufferLogs: true });
app.useLogger(app.get(WINSTON_MODULE_NEST_PROVIDER));
// 文件场景:src/app.module.ts —— 控制台好看,文件好采
WinstonModule.forRoot({
level: 'debug',
transports: [
new winston.transports.Console({
format: winston.format.combine(colorize(), timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
printf(({ level, message, context, timestamp }) =>
`[NEST] ${timestamp} ${level} [${context || 'App'}] ${message}`)),
}),
new winston.transports.File({
format: winston.format.combine(timestamp(), json()), // 每行一个 JSON,ELK/Loki 直接采
filename: 'app.log', dirname: 'log',
}),
],
}),
- 请求日志用 Interceptor:进入时打 method/path/ip/user-agent/目标 class+handler,响应时用
tap打状态码、耗时、响应——middleware 拿不到响应、Filter 只有异常才走,Interceptor 是唯一前后都能拿到的位置。 - 链路追踪:中间件里取/生成
x-request-id,写回响应头;用 AsyncLocalStorage(ClsModule)把它变成全链路可取的上下文,日志 format 自动带上 traceId,多实例再注入全局 traceId。 - 错误单独落盘:再加一个
Filetransport,level: 'error',error 级别单独一个文件,告警系统只盯这个文件。 - 业务代码统一
new Logger(ClassName):五个级别(verbose/debug/log/warn/error)按场景用,context 标识来源。
有哪些坑:
request.ip经过 nginx 拿到的是代理 IP:线上看到的「客户端 IP」全是网关内网地址,风控/审计数据作废;真实 IP 在X-Forwarded-For里。- 级别一调,请求日志全消失:请求日志用的是
logger.debug,level从 debug 调成 warn 后所有请求日志静默关闭——运维以为「服务没流量了」,其实是自己关的灯。 - useLogger 没写/写在
app.listen之后、或没开bufferLogs:启动期的框架日志走的还是默认 Logger,和 winston 格式两套;app.get(WINSTON_MODULE_NEST_PROVIDER)还要求 WinstonModule 必须已注册,顺序错了直接报 UNKNOWN_TOKEN。 - 多进程写同一个文件:PM2 cluster 4 个进程/K8s 多副本同写
log/app.log,日志行交错、互相覆盖,拼不出一次请求的完整轨迹;没有 traceId 时更是无从下手。 - 响应体全量
JSON.stringify进日志:大响应体拖慢请求主线程,密码、token、手机号等敏感字段原样进日志被采集系统留存——合规事故预定。 - console.log 直上生产:没有级别开关、不能落文件、多进程交错、没有结构,ELK 只能靠正则猜。
怎么修补:
- IP 取
request.headers['x-forwarded-for'] || request.ip(或统一用 request-ip 类库);nginx 侧配好X-Forwarded-For传递。 - 团队约定「请求日志用 info 级」或把「调级别会关掉 debug 级请求日志」写进值班手册;error 告警只依赖独立的 error transport。
- 固定写法:
NestFactory.create(AppModule, { bufferLogs: true })+useLogger在listen之前;启动冒烟检查日志格式统一。 - 容器化部署改为 stdout 输出、由采集器统一收集(File transport 意义不大);traceId 用 AsyncLocalStorage 贯穿每条日志,响应头回传方便前后端对账。
- 日志 format 层统一脱敏(password/token/phone 置为
***)并截断超长字段(如响应体只留前 500 字符)。 - 生产禁用 console(lint 规则 no-console),统一走 Logger 体系。
72、用户要传几百 MB 的视频文件,大文件上传方案怎么设计?小的头像上传和它有什么不同?
问题类型:性能与可靠性设计类。考察点:multipart 解析机制(multer 在 Nest 里的位置)、文件校验的正确姿势(内容而非扩展名)、路径与存储安全,以及大文件「不经过应用服务器」的架构升级(直传对象存储/分片)。考的是从「能上传」到「上传不把服务搞挂」的完整思考。
怎么解决:
- 普通上传(头像等小文件):Nest 把 multer 封装成 Interceptor(文件解析发生在进入 handler 之前),
FileInterceptor('file')+@UploadedFile()取文件,ParseFilePipe挂校验器:
// 文件场景:src/upload/upload.controller.ts —— 小文件标准姿势
@Post('avatar')
@UseInterceptors(FileInterceptor('file', {
storage: multer.diskStorage({
destination: (req, file, cb) => { fs.mkdirSync('uploads', { recursive: true }); cb(null, 'uploads'); },
filename: (req, file, cb) => cb(null, randomUUID() + extname(file.originalname)), // 随机名防重防穿越
}),
limits: { fileSize: 5 * 1024 * 1024 },
}))
upload(@UploadedFile(
new ParseFilePipe({
validators: [
new MaxFileSizeValidator({ maxSize: 5 * 1024 * 1024 }),
new FileTypeValidator({ fileType: 'image/' }), // 按文件内容判断
],
}),
) file: Express.Multer.File) {
return { filename: file.filename, size: file.size };
}
- 多文件场景选对拦截器:
FilesInterceptor(同字段多文件)、FileFieldsInterceptor(多字段)、AnyFilesInterceptor。 - 大文件(百 MB 级视频)走对象存储直传:服务端只签发预签名 URL(presigned URL),前端直传 OSS/S3,传完回调确认——应用服务器不过文件流,带宽、内存、慢客户端占用全部转移。
- 需要自己管大文件时用分片:前端按 hash 切片上传,服务端提供「查询已传分片」(秒传/断点续传)与「合并」接口;上传前先查 hash 实现秒传。
- 流式落盘:服务端必须写文件时用 Stream +
pipeline(自带背压,写入跟不上会暂停读取),不要一次性Buffer.concat进内存。
有哪些坑:
@Body()拿不到文件:multipart 请求里文件部分被默认 body 解析器直接丢弃,文件在请求体里但永远到不了 handler;以及FileInterceptor('file')的字段名和前端表单字段名对不上,file是 undefined——上传接口第一坑。- 大小限制分两层,先死在网关:应用层
limits.fileSize超限时 multer 抛错往往不是友好的 400;而 nginxclient_max_body_size默认 1M,比应用限制还小,请求先在网关被 413 掉,排查的人却在看应用代码。 - 拿
originalname拼保存路径:中文/特殊字符文件名引发路径问题之外,../../etc/passwd式的原始文件名是路径穿越攻击面;同名文件互相覆盖。 - 按扩展名/mimetype 字段校验类型:把
shell.php改名成avatar.jpg轻松绕过;上传目录一旦被当静态资源伺服,等于送出一个可执行文件入口。 - 大文件全部经过应用服务器:Node 单线程,multer 缓冲 + 慢速客户端长时间占用连接,几十个并发上传就能把整个 API 服务拖到无响应——不止上传挂,全站挂。
怎么修补:
- 文件接口一律走四种文件拦截器 +
@UploadedFile/@UploadedFiles;字段名是前后端契约,写进文档并用 e2e 锁定。 ParseFilePipe+ validator 让应用层返回语义化 400;nginxclient_max_body_size与应用limits对齐成同一数值,网关 413 也统一页面处理。- 文件名永远服务端生成:
randomUUID()+ 扩展名白名单(从 originalname 里只取白名单内的扩展名);存储目录按日期/用户分桶。 - 用
FileTypeValidator按文件内容(魔数)判断真实类型;扩展名白名单;上传目录与静态资源目录物理分离并禁执行权限。 - 大文件改预签名 URL 直传对象存储,应用只做签发/回调/落库;自建场景用分片 + 断点续传,服务端流式处理并开启背压。
73、实时推送场景:构建日志滚动、AI 流式回答、聊天室,SSE 和 WebSocket 怎么选?各自落地要注意什么?
问题类型:实时通信选型类。考察点:单向推 vs 双工的判断力、SSE 在 Nest 的正确写法(@Sse + Observable 生命周期管理)、WebSocket 网关(room/ack/生命周期)的组织方式,以及两类方案各自的经典生产事故。选错方向的代价是「用全双工的成本做单工的事」或反之。
怎么解决:
- 先做方向判断:客户端只需要「听」(日志、进度、行情、AI 流式回答、站内信)→ SSE,它就是一条不关闭的 HTTP 响应流,普通 HTTP 基础设施全兼容、浏览器原生
EventSource自动重连 +Last-Event-ID续传;双向高频(聊天、协同编辑、游戏)→ WebSocket,HTTP Upgrade 握手后全双工。 - SSE 落地:
@Sse()装饰器代替 @Get,handler 返回Observable<MessageEvent>,observer.next()推一条、observer.complete()结束流;消息信封data(对象自动 JSON 序列化)、id(断点续传书签)、type(命名事件)、retry(重连间隔)、comment(心跳注释行)。广播场景用 service 里的Subject+asObservable(),业务代码notify()一调、所有在线客户端秒收。 - WebSocket 落地:
@WebSocketGateway({ cors: {...} })+ 生命周期钩子(handleConnection/handleDisconnect管上下线与状态清理)+@SubscribeMessage('事件名')/@MessageBody()/@ConnectedSocket()做消息路由 +@WebSocketServer()注入 Server 做广播;群聊用client.join(room)进房、server.to(room).emit(...)定向广播。 - SSE 的资源纪律:Observable 构造函数 return 的清理函数(teardown)或
finalize,在 complete/error/客户端断开三种情况下都会执行——interval 一律在这里清。 - 降级兜底:低频状态查询用轮询就够,别为了「实时」两个字硬上长连接。
有哪些坑:
- SSE 命名事件用
onmessage收不到:带了type字段的消息只进addEventListener('名字'),onmessage只收没有event:行的默认消息——「服务端明明在推、客户端一条都收不到」的第一大坑。 - SSE 流不清理:teardown/finalize 里忘了
clearInterval,客户端断开后 interval 还在跑——连接越断越多、定时器越积越多,典型内存泄漏,而且是慢慢渗漏那种。 - EventSource 不能设置自定义请求头:带不了
Authorization,JWT 鉴权直接失效;跨域场景下想用 cookie 还得withCredentials,此时 CORS 的 origin 不能写*。 - 代理层把流「攒着」:nginx 默认缓冲响应,SSE 消息攒一堆才到客户端,「实时」变成「批量迟到」;对 event-stream 开 gzip 同样破坏流;HTTP/1.1 下浏览器同域名只有 6 条连接,一个页面开多个 SSE 直接占满。
- 流推过数据后再抛异常改不了状态码:200 响应头已经发出去了,
observer.error()只能结束流;校验(如任务是否存在)必须放在流开始之前。 - WebSocket 侧:socket.io 有自有协议,裸 WebSocket 客户端/wscat 连不上 socket.io 服务端,客户端必须配对(且大版本一致);
@SubscribeMessage方法的返回值不是广播,是 ack 回执只回发送者——想广播却 return,全场安静。
怎么修补:
- 客户端按事件名
addEventListener;业界[DONE]结束约定不带 type、走onmessage,老客户端只挂 onmessage 也能收到。 - 每个 SSE handler 的 Observable 都写 teardown(或链式写法挂
finalize)清理定时器/订阅;客户端收到结束标志后主动es.close(),别让 EventSource 把正常结束当断线去自动重连。 - SSE 鉴权改用 cookie +
withCredentials(origin 指定具体域名),或连接时一次性 query token 换会话。 - 保留 Nest 12 自动携带的
X-Accel-Buffering: no响应头,nginx 再显式proxy_buffering off,event-stream 不开 gzip;上 HTTP/2 多路复用解除 6 连接限制。 - 参数校验、鉴权都放流开始前抛(404/401 正常返回);需要中途传错就用约定事件(
type:'error')推给客户端。 - 客户端统一 socket.io-client 且与服务端大版本对齐;广播用
server.emit/server.to(room).emit;多实例部署给 socket.io 配 Redis adapter,否则广播只到达本进程的连接。
74、每天凌晨跑对账任务,服务部署了 3 个实例,定时任务的分布式问题怎么解?
问题类型:任务调度 / 分布式一致性类。考察点:对 @nestjs/schedule 机制的了解、多实例重复执行的根治手段(分布式锁/单副本/队列)、任务幂等设计,以及「任务执行到一半实例重启」的恢复策略。答不出分布式视角的,基本只在单机玩过 demo。
怎么解决:
- 先把任务搬进代码:
ScheduleModule.forRoot()注册 +@Cron/@Interval/@Timeout装饰器,任务跟着应用走、可版本管理,取代「服务器 crontab curl 接口」的外挂方案:
// 文件场景:src/report/task.service.ts
@Injectable()
export class TaskService {
@Cron(CronExpression.EVERY_DAY_AT_4AM, { name: 'daily-report' })
async dailyReport() { /* 分布式锁 + 幂等,见下 */ }
}
- 多实例重复执行的解法按成本递增选:(a) 任务专用单副本 Deployment(调度与业务分离部署);(b) Redis 分布式锁——同一时刻只有一个实例真正执行;(c) 任务改造成消息进队列(BullMQ/Kafka),单 worker 消费,天然只有一份。
- Redis 锁的标准姿势:值写实例唯一 ID,
SET key instanceId NX EX ttl抢锁;释放前校验「锁还属于自己」(Lua 保证原子);TTL 略大于任务最大时长,任务内可心跳续期:
// 文件场景:src/report/task.service.ts —— 抢不到锁说明别的实例在跑
const acquired = await this.redis.set(`lock:daily-report:${today}`, instanceId, 'EX', 600, 'NX');
if (!acquired) return;
try {
await this.generateDailyReport();
} finally {
await this.releaseIfOwner(`lock:daily-report:${today}`, instanceId);
}
- 幂等兜底:任务内部按「日期 + 业务键」去重(做过就跳过),就算锁失效重复触发也不产生重复数据。
- 动态管理:
SchedulerRegistry支持运行时增删查任务(按 name 定位),配合管理接口手动触发/禁用。 - 错过补偿:记录任务最后成功执行时间,启动时(cron 停机窗口)判断是否需要补跑。
有哪些坑:
ScheduleModule.forRoot()没注册:所有任务装饰器静默不生效,控制台安静如鸡;TaskService 没放进 providers 同样不跑——「任务没执行」排查看半天,其实是根本没装配。- K8s 滚动更新/多副本裸跑:每个实例都到点触发,日报发 3 份、对账跑 3 次;滚动发布瞬间新旧实例并存,同一分钟双跑。
- 外挂 crontab curl 方案:任务逻辑与调度配置分离在两处,换机器/改端口就悄悄断;实例扩容后同样重复触发;「昨晚忘了配」= 昨天没有数据且无人知晓。
- 装饰器参数写错不报错:
@Interval(name, ms)参数顺序颠倒、装饰器名拼错,只有部分任务不跑,没有任何日志提示;任务没有 name,想查都不知道查谁。 - 任务执行到一半实例重启(SIGTERM/驱逐):锁没释放(TTL 内任务不敢再跑,漏跑一次);或锁先过期被第二实例抢到,同一任务双跑各一半;没有执行记录表,「跑没跑过、跑到哪」全靠猜。
怎么修补:
- forRoot 必须在根模块注册;启动时用
SchedulerRegistry.getCronJobs()打印任务注册清单进日志,一眼确认装配成功。 - 按成本选型:能拆就单副本任务 Deployment;不便拆就 Redis 锁;强可靠就上队列。
- 任务进代码跟应用走;确需外部触发,收敛到一个带鉴权的任务管理接口并记录触发来源。
- 用
CronExpression常量与 TS 类型约束参数;所有任务强制{ name }命名,运维可按名操作。 - 锁 TTL > 任务最大时长 + 心跳续期;任务表记录执行状态(running/done/failed + 业务键唯一约束),启动时扫「running 但持有者已死」的任务做恢复;优雅停机等待在途任务完成(见 Q78)。
75、入参校验怎么做才不把畸形数据放进业务层?CreateDto 和 UpdateDto 又该怎么复用?
问题类型:数据校验 / DTO 设计类。考察点:ValidationPipe 全局配置各开关的真实含义、class-validator 装饰器的正确组合、mapped-types 的 DTO 复用,以及「校验静默失效」的几种形态。这题答得细不细,直接暴露有没有维护过被脏数据淹过的库。
怎么解决:
- 全局启用 ValidationPipe,三个关键开关全开:
// 文件场景:src/main.ts
app.useGlobalPipes(new ValidationPipe({
whitelist: true, // 剥离 DTO 未定义的字段
forbidNonWhitelisted: true, // 多传未定义字段直接 400(内部接口建议开)
transform: true, // payload 转成 DTO 类实例,query 类型转换生效
}));
- DTO 类即契约:字段上用 class-validator 装饰器声明规则,可传
{ message }定制中文错误信息;错误默认一次性报全(不是碰到第一个错就停)。 - DTO 复用用 @nestjs/mapped-types:
PartialType(CreateXxxDto)做 PATCH(全部字段变可选)、PickType/OmitType挑选或剔除字段、IntersectionType组合多个 DTO——告别复制粘贴两个 DTO 各改各的。 - 复杂校验:条件校验用
@ValidateIf;自定义校验器实现 ValidatorConstraintInterface,再用applyDecorators封装成组合装饰器。 - 参数级转换:路由参数配
ParseIntPipe/ParseBoolPipe/ParseUUIDPipe,query 里配合 transform 的@Type(() => Date)做类型转换。
有哪些坑:
- 装饰器加了、脏请求依然 200 通过:没在 main.ts 全局启用 ValidationPipe(或忘了保存重启)——本校验方案最高频的坑,DTO 写得再漂亮也是摆设。
whitelist: true静默剥离未知字段:前端把emial拼错,服务端悄悄把字段丢掉,落库缺数据但不报任何错,排查到天亮;反过来forbidNonWhitelisted一开,微信回调这类「人家说啥你收啥」的第三方接口直接被多字段 400 拒掉。transform: true没开:@Query('page')拿到的是 string,page + 1变成字符串拼接;@Type(() => Date)完全不生效;dto instanceof CreateXxxDto是 false(拿到的是普通对象)。- PartialType 做 PATCH 的边界:字段全变可选后,空字符串
""不是 undefined,@IsEmail()对空串照样报错(想「不传就跳过」必须显式@IsOptional());嵌套对象只写了类型标注、没加@ValidateNested()+@Type(() => SubDto),内层校验整个被跳过。 - 构建换 SWC 后校验/DI 行为异常:SWC 不支持
emitDecoratorMetadata,依赖「按设计类型自动注入」的构造器参数与 DTO 的隐式类型元数据会丢,启动报 can’t resolve 或转换失效。
怎么修补:
- 全局管道进 main.ts,并在 e2e 里放一条「脏请求必须 400」的冒烟用例,谁改配置谁爆红。
- 内部接口开
forbidNonWhitelisted快速暴露拼写错误;第三方回调路由单独放行(该路由不挂全局严格管道,或用管道白名单 options),别让安全开关误伤回调。 - 必开
transform: true;对 query 参数再显式挂ParseIntPipe等转换管道双保险。 - 可选字段显式
@IsOptional()(它的语义是 undefined/null 时跳过校验);嵌套对象固定写@ValidateNested() @Type(() => SubDto)两个装饰器;PATCH 需要「传了才校验、不传跳过」时配合@ValidateIf((o) => o.field !== undefined)。 - SWC 构建的项目显式写
@Inject(Token),或对 DTO/Provider 密集的模块保持 tsc 构建;升级构建链路时全量回归校验相关用例。
76、拆微服务时,服务间通信怎么在 HTTP / gRPC / 消息队列之间选?Nest 里怎么落地?
问题类型:架构选型类。考察点:同步 vs 异步的通信语义判断、@nestjs/microservices 的抽象(transport 无关 + MessagePattern/EventPattern 两种语义)、ClientProxy 的正确触发方式,以及熔断降级的配套。选型说不清「什么时候不该用 MQ」的,一般是背了很多名词。
怎么解决:
- 按语义选型:同步请求-响应(下单要立刻知道结果)→ HTTP(简单通用、调试方便)或 gRPC(多语言契约、高性能、强类型 proto);异步解耦/削峰/广播(订单创建后通知积分、短信)→ MQ(Kafka/RabbitMQ),生产方不等消费方;进程内事件 → EventEmitter2,别啥都跨网络。
- Nest 落地:客户端
ClientsModule.register([{ name, transport, options }])或ClientProxyFactory,服务端@MessagePattern('user.created')(请求-响应语义,等回执)与@EventPattern('user.created')(事件语义,fire-and-forget)分开用;同一个 Service 可换 transport 而业务代码不动。 - 调用姿势:
clientProxy.send(pattern, payload)触发请求-响应;emit()发事件。注意显式消费:firstValueFrom(this.client.send(...))。 - 可靠性三件套:超时(Interceptor
timeout+ catchError 转 408/504)、重试(只重试幂等操作)、熔断降级(opossum:closed → open → half-open三态,连续失败直接快速失败一段时间,触发降级逻辑走兜底)。
// 文件场景:src/payment/payment.service.ts —— 熔断 + 降级
private breaker = new CircuitBreaker(this.callBank.bind(this), {
timeout: 3000, errorThresholdPercentage: 50, resetTimeout: 10000,
});
async pay(dto: PayDto) {
try {
return await this.breaker.fire(dto);
} catch {
return this.fallback(dto); // 降级:进补偿队列稍后重试
}
}
- 可观测配套:OpenTelemetry 自动埋点 + traceId 贯穿(见 Q71),微服务一多没有链路追踪等于盲飞。
有哪些坑:
- MessagePattern 和 EventPattern 语义混用:把「发通知」这类不需要回执的逻辑写在
@MessagePattern上,消费方一慢,生产方全部阻塞等回执——异步场景被写成了同步,削峰变成添堵。 clientProxy.send()返回的是冷 Observable:不订阅(不toPromise/firstValueFrom)根本不会发送——代码看着调了远程,实际上什么都没发出去,也没有任何报错。- transport 各自的 ack 语义没配:Kafka/RabbitMQ 下 handler 抛异常,消息按默认行为重入队,毒消息无限循环消费,日志刷爆、队列堵死。
- gRPC 的 proto 与 TS 代码手工同步:加了字段忘了重新生成客户端,运行时字段 undefined、序列化错位,编译期毫无提示。
- 没有熔断的直连:下游数据库慢查询 → 下游服务变慢 → 上游全部请求堆在等响应,一条链路拖死整棵服务树(单线程事件循环被拖住,连健康检查都超时,被 K8s 误杀)。
怎么修补:
- 需要回执用
@MessagePattern,事件用@EventPattern;topic 命名「资源.动作」统一管理,把语义写进团队规范。 send()结果一律显式消费(firstValueFrom),并对 client 配置超时;关键事件改走持久化 MQ + 死信队列,emit丢失可追溯。- 每种 transport 显式配置 ack/重试策略:handler 内 catch 住业务异常走死信,只让可重试的瞬时错误重入队,并限制最大重试次数。
- proto 文件进仓库,CI 里自动生成 + 契约测试,生成物与代码不同步直接构建失败。
- 出网调用统一套 opossum 熔断 + 超时 + 降级(返回兜底值/进补偿队列);网关层再兜一层限流(Q79)。
77、列表接口太慢想加缓存,缓存放哪一层、一致性怎么保、并发回源怎么防?
问题类型:数据一致性 / 缓存架构类。考察点:缓存位置的选择(响应级 vs 数据访问级)、cache-aside 模式的正确写法、写后一致性(删缓存时机)、以及高并发下的击穿防护。这题的坑全部来自「看起来简单的 if (cache) return」——单线程 Node 里 await 一样有竞态。
怎么解决:
- 位置选型:(a) Interceptor 按 URL 缓存整个响应(适合公开、无个性化内容,如配置、公告);(b) Repository/Service 层 cache-aside(按数据键缓存,粒度细、可控性强)——多数业务场景选 b。
- cache-aside 标准流程:读——先查缓存,miss 查库回填(带 TTL);写——先更新数据库,再删缓存(不是更新缓存);key 设计带命名空间和版本(
user:v2:{id}),TTL 兜底最终一致。 - 并发回源防护(单飞):缓存 Promise 本身而不是值——
check-then-act在 await 之间会让出执行权,并发请求各自通过if (!cache[key])检查、重复回源:
// 文件场景:src/user/user.service.ts —— 缓存 Promise,防并发重复回源
private readonly inflight = new Map<string, Promise<User>>();
async getUser(id: number): Promise<User> {
const cached = await this.redis.get(`user:${id}`);
if (cached) return JSON.parse(cached);
let p = this.inflight.get(`user:${id}`);
if (!p) {
p = this.repo.findOne({ where: { id } })
.then((user) => this.redis.set(`user:${id}`, JSON.stringify(user), 'EX', 300).then(() => user))
.finally(() => this.inflight.delete(`user:${id}`));
this.inflight.set(`user:${id}`, p);
}
return p; // 并发请求共享同一次回源
}
- 一致性加强:写路径做延迟双删(更新后删一次,延迟几百毫秒再删一次);强一致要求高的订阅 binlog(Canal)刷缓存;接受不了旧数据的读走库。
- 穿透/雪崩:查不到的数据缓存空值(短 TTL);TTL 加随机抖动错峰;热点 key 提前预热。
有哪些坑:
- 响应级缓存按 URL 做 key,但接口带登录态:A 用户的个性化数据被缓存到 URL 维度,B 用户请求同一个 URL 拿到 A 的数据——缓存越高效,泄漏越彻底;query 参数顺序不同还导致 key 膨胀、命中率虚低。
- check-then-act 竞态:
if (!cache[key]) { cache[key] = await load(); }缓存的是值,await 期间并发的 N 个请求都通过了检查,一起打到数据库——缓存失效瞬间的高并发击穿,DB QPS 不降反升。 - 先删缓存后写库(或删缓存失败):删完缓存到事务提交之间,别的请求 miss 后把旧值查出来回填,脏数据一直活到 TTL 结束;删缓存那一步失败则更是常见(网络抖动),旧数据继续服务。
- Nest 内置 CacheModule 默认内存存储:多实例各缓存各的,改完数据一部分实例是新的、一部分是旧的,表现「时好时坏」,而且重启全丢。
- 缓存无 TTL 或同时过期:无 TTL 的 key 靠写时删除保一致,一旦删除失败脏数据永生;批量设置的相同 TTL 在同一时刻集体失效,流量尖刺打穿到 DB(雪崩)。
怎么修补:
- 带用户态的接口不做响应级缓存,或 key 里拼入用户维度并规范化 query 参数(排序后再拼 key);响应级缓存只用于无个性化内容。
- 缓存 Promise 本身(单飞),或回源加分布式互斥锁;集群内也可以用「逻辑过期」——过期后返回旧值并异步刷新。
- 写路径固定「先更新库,再删缓存」,删除失败进重试队列;强一致场景延迟双删 + binlog 订阅兜底;所有 key 都带 TTL 作为最后防线。
- 集中缓存:
cache-manager换 Redis store(cache-manager-redis-yet 等),多实例一份缓存。 - 一律设置 TTL 且加随机抖动(基础值 ± 20%),空值缓存 30~60 秒防穿透,大对象压缩或拆 key。
78、K8s 滚动更新时怎么做到发布不停服?Nest 的生命周期钩子怎么配合优雅停机?
问题类型:可靠性设计类。考察点:Nest 启动/停机钩子的正确启用(enableShutdownHooks)、K8s 滚动更新的完整时序(readiness 摘流量 → SIGTERM → 排空 → 退出)、外部连接(DB/MQ/Redis)的关闭顺序,以及宽限期与实际排空时间的匹配。这是「发布如何不停服」的标准答案,也是背概念最容易露馅的题。
怎么解决:
- 启用停机钩子:
app.enableShutdownHooks()——没有这一行,SIGTERM 到来时 Nest 的onModuleDestroy/onApplicationShutdown一个都不会触发。钩子顺序:onModuleDestroy() → beforeApplicationShutdown(signal) → onApplicationShutdown()。 - 停机时序对齐 K8s:readinessProbe 失败摘流量 → 容器收到 SIGTERM → 应用停止接收新请求(HTTP server 停收新连接)→ 等在途请求处理完 → 关闭 DB/Redis/Kafka 连接 →
process.exit(0);terminationGracePeriodSeconds(默认 30s)是硬上限,超时直接 SIGKILL。 - 连接关闭顺序:先停消息消费者(不再拉新消息、ack 完在途),再关数据库连接池、Redis,最后退出——顺序反了会造成消息重复消费或连接风暴。
- 健康检查:
@nestjs/terminus暴露/health(含 db pingCheck 等就绪依赖),readiness 挂它;发布时先让 readiness 失败(如收到 SIGTERM 即返回 not ready)再等排空。 - 超时兜底:停机流程整体设一个软超时(如 10 秒后强制
process.exit),防止某个在途请求/未 ack 消息把退出流程挂死。
有哪些坑:
- 忘了
app.enableShutdownHooks():所有 onModuleDestroy/onApplicationShutdown 静默不触发,连接不关、消费者不停,SIGTERM 走 Node 默认行为直接退出——发布瞬间在途请求半途而废、MQ 消息没 ack 全部重投。 - 注册了
process.on('SIGTERM')后忘了process.exit():一旦你监听了信号,Node 的默认退出行为就被接管,处理完不显式退出,进程一直挂着,直到宽限期被 SIGKILL——表现为「发布巨慢,每次都卡满 30 秒」。 - 停机时不关消费者和连接池:Kafka 消费者没先停,在途消息处理一半被杀,重启后重复消费(没做幂等就是重复扣款);数十个实例同时滚动,旧实例 DB 连接不释放,新实例连接池瞬间打满数据库。
terminationGracePeriodSeconds小于实际排空时间:大请求/大消息处理需要 40 秒,宽限期默认 30 秒——宽限期一到 SIGKILL,前面优雅停机全白做。onModuleInit里调用其他模块的 provider 或做重活:onModuleInit 阶段别的模块可能还没初始化完(调用直接出错);在 init 里做慢 IO(预热连库、拉配置)会拖住整个启动,K8s 反复探活失败触发重启循环。
怎么修补:
- main.ts 固定写
app.enableShutdownHooks(),onModuleDestroy/onApplicationShutdown 里按顺序关消费者、连接池;启动清单检查。 - 停机 handler 里加
setTimeout(() => process.exit(0), 10_000).unref()软超时兜底,保证一定能退出。 - 关闭顺序固化:先 stop 消费 → ack 在途 → close server → close DB/Redis;消费逻辑做幂等(消息带唯一键),重复投递不产生重复副作用。
- 压测得出最坏排空时长,把
terminationGracePeriodSeconds设为「排空时长 + 余量」;HTTP server 用close()等连接排空而不是立刻销毁。 - 跨模块调用放到
onApplicationBootstrap(所有模块就绪后再触发);慢初始化挪到useFactory异步工厂或懒加载,启动只做「能对外服务」的最小集合。
79、接口要防刷,限流方案怎么设计?单机限流和多实例部署差在哪?
问题类型:稳定性 / 安全防护类。考察点:@nestjs/throttler 的正确配置(v5+ 语法)、限流 key 维度的选择(IP/用户/接口)、内存存储在分布式下的失效,以及和网关层限流的分层配合。「装个 throttler 就完事」的回答在多实例场景下是不及格的。
怎么解决:
- 应用层用 @nestjs/throttler:全局默认限流 + 装饰器按接口覆盖:
// 文件场景:src/app.module.ts —— v5+ 写法:命名 throttler 数组
ThrottlerModule.forRoot([{ name: 'default', ttl: 60_000, limit: 60 }]),
// 文件场景:src/auth/auth.controller.ts —— 登录接口单独收紧
@Throttle({ default: { limit: 5, ttl: 60_000 } }) // 1 分钟 5 次
@SkipThrottle({ default: true }) // 需要跳过的接口显式指定
全局 Guard 用 APP_GUARD 注册 ThrottlerGuard(和 Q66 同一个坑:手动 new 注册注入不了依赖)。
2. key 维度按接口性质选:公开接口按 IP;登录/验证码按 IP + 账号双维度(任一超限即拒),防止攻击者换 IP 撞库,也防止 NAT 出口下一个公司共享一个桶。
3. 多实例必须换存储:默认内存存储是「每实例各算各的」,3 个实例限 60 次/分实际放行 180 次/分——注入 Redis 版 ThrottlerStorage,或把全局限流上移网关(nginx limit_req / Kong / APISIX)。
4. 分层限流:网关做粗粒度(IP/路由级总量),应用做细粒度(用户/业务维度);超限时返回 429 + Retry-After,前端做友好提示。
5. 配套:限流命中打 warn 日志并接告警——突增的 429 往往是攻击或前端 bug 的第一信号。
有哪些坑:
- 多实例内存存储:以为限了 10 次/分,副本越多放行越多,「限流形同虚设」;更糟的是部分请求打到不同实例,计数分散,攻击者实测发现「偶尔能多刷几次」,更难定位。
- 按 IP 限流在代理后失真:服务在 nginx/SLB 后面,
req.ip拿到的一直是代理地址——全站用户共享一个桶,一个人触发全站 429;反过来无脑信任X-Forwarded-For,攻击者伪造该头每次换一个「IP」,单 IP 限流被绕过。 - throttler 大版本升级配置静默失效:v4 的对象写法
forRoot({ ttl, limit })升到 v5 后应改为「命名 throttler 数组」,@Throttle参数也从元组改成对象——老代码不报错,但限流规则对不上,线上行为悄悄变。 - 登录/短信接口只按 IP 限:公司 NAT 出口几百人共用一个 IP,一个同事狂点验证码,全公司被锁;攻击者换 IP 池则完全不受约束。
@SkipThrottle()作用域失控:想给健康检查放行,把@SkipThrottle()加在了 controller 类上——整个控制器所有接口全部免限流;或者只想跳过一个命名规则却跳过了全部。
怎么修补:
- 注入 Redis 存储(
ThrottlerStorageRedis等),计数全局唯一;或全局限流交网关,应用只做业务细粒度。 - 正确配置
app.set('trust proxy', 1)只信任固定一跳,req.ip取 XFF 的第一个不可信地址之前一跳;关键接口在 IP 之外叠加 userId/账号维度。 - 升级 throttler 时按 v5+ 语法迁移(
forRoot([{ name, ttl, limit }])、@Throttle({ default: {...} })),并用 e2e 验证「第 N+1 次请求必须 429」。 - 登录/验证码接口双桶:IP 桶 + 账号桶,任一超限即拒;失败计数进 Redis 滑动窗口,连错锁定走独立逻辑(与限流解耦)。
@SkipThrottle精确到 handler 并指定要跳过的规则名({ default: true });code review 检查类级 SkipThrottle 的必要性。
七、NestJS 考官口试题(25 题,分层答案 + 追问链)
用途:给学生做口试 / 模拟面试。每题给「分层参考答案要点」和一条追问链(每个追问附期望回答),便于面试官逐层加码与判读。
80、Nest 和 Express 是什么关系?Nest 到底抽象了什么?
参考答案:Nest 不是 Express 的替代,而是架在它之上的框架——默认 HTTP 适配器就是 Express(可换 Fastify),Express 负责真正的 HTTP 收发,Nest 在上面加了模块化、依赖注入、装饰器路由、AOP 组件、微服务抽象这一整套工程结构。价值口径:小服务用 Express 直接写很快;业务复杂、团队协作时,Nest 提供的是”约定和结构”,让代码往一个方向长。
追问
- 追问①:换 Fastify 的动机? → 期望:性能(HTTP 处理更快),Nest 的 API 层面几乎无感,因为适配器隔离了差异。
- 追问②:Nest 里还能拿到底层 req/res 吗? → 能,
@Req()/@Res()或透传,但依赖了平台抽象之外的东西,可移植性下降。
81、什么是 IoC?为什么需要依赖注入?
参考答案:控制反转——类的实例化和装配交给框架,业务代码只声明”我需要什么”。@Module 登记 providers,容器负责 new、负责把 UsersService 塞进 UsersController 的构造器。三收益:解耦(上层依赖声明而非自己创建)、可测试(测试时把 Service 换成 mock 注入进去)、统一生命周期(单例、销毁钩子由容器管)。
追问
- 追问①:不用 DI,自己 new 有什么问题? → 期望:依赖链要手动层层传递装配、测试要改代码才能换实现、单例和生命周期散落各处。
- 追问②:Nest 的 IoC 借鉴了谁? → Angular(装饰器 + 模块的设计同源)。
82、类上加了 @Injectable() 却报”找不到依赖”,最常见的原因?
参考答案:光加装饰器不注册——必须把类登记到某个 Module 的 providers 里,容器才会管理它(Nest 没有包扫描式自动注册)。第二个高频坑是模块边界:A 模块想注入 B 模块的 provider,B 必须 exports 它、且 A 要 import B——providers 默认是模块私有的。
追问
- 追问①:@Global() 模块解决什么? → 导出的 provider 全局可用,典型放 config、logger、公共 guard,免得每个模块都 import。
- 追问②:overrideProvider 是什么原理? → 同 token 后注册覆盖先注册——测试里换 mock 的官方通道。
83、依赖注入有哪几种方式?为什么接口不能直接当注入类型?
参考答案:① 构造器注入(官方推荐:依赖必填不可变、易替换);② 属性注入(@Inject(),可能 undefined,少用);③ token 注入——TS 接口编译后类型擦除,运行时不存在,没法当查找凭证,所以用 Symbol 或字符串做 InjectionToken,provide 端 useClass/useValue/useFactory,注入端 @Inject(LOGGER)。四种提供方式:useClass / useValue(配置常量)/ useFactory(异步工厂)/ useExisting(别名)。
追问
- 追问①:配置对象怎么注入? → useValue 或 useFactory + ConfigService,别在业务里散落读 process.env。
- 追问②:useFactory 典型场景? → 依赖其它 provider 才能构造的对象,如”从配置中心拉连接串再建数据库连接”。
84、Provider 的作用域有哪几种?REQUEST 作用域的代价?
参考答案:DEFAULT(全应用单例,默认)、TRANSIENT(每次注入新实例)、REQUEST(每个请求独立实例)。REQUEST 的两个坑:整条注入链都会被连坐升级为 request 作用域;每请求重建依赖链,性能开销真实存在。官方建议:要传递请求级上下文(traceId、当前用户)用 AsyncLocalStorage(ClsModule) 替代。
追问
- 追问①:单例 Service 里存请求级数据会怎样? → 串请求——A 用户的数据被 B 看到,这是必修级 bug。
- 追问②:TRANSIENT 用在哪? → 有内部状态的辅助类(如每次要独立计数器的限流器)。
85、生命周期钩子的顺序?优雅停机怎么做?
参考答案:实例化 → onModuleInit → onApplicationBootstrap(所有模块就绪,可安全互相调用)→ 服务运行 → onModuleDestroy → onApplicationShutdown。注意最后两个要 app.enableShutdownHooks() 才会触发。优雅停机链路:K8s 发 SIGTERM → readiness 摘流量 → 处理完在途请求 → 关闭 DB/Redis/Kafka 连接(ack 完消息)→ 退出——这是”发版不停服”的标准答案。
追问
- 追问①:为什么销毁钩子默认不生效? → 避免误解生命周期成本,需要显式开启。
- 追问②:onModuleInit 里能调别的模块的 service 吗? → 有风险(对方可能没初始化完),要调就放 onApplicationBootstrap。
86、Nest 的 AOP 五件套是什么?执行顺序?(必考)
参考答案:Middleware → Guard → Interceptor(前置)→ Pipe → Controller;异常走 ExceptionFilter;返回值过 Interceptor(后置)再出去。职责分工:Middleware(日志、原始 body)、Guard(认证鉴权,能否进)、Interceptor(包装响应、缓存、耗时——操作的是”流”)、Pipe(参数转换与校验)、Filter(异常兜底转统一响应体)。
追问
- 追问①:为什么 Guard 在 Interceptor 前? → 鉴权都没过,没有必要执行包装逻辑;顺序是”先门禁后装修”。
- 追问②:全局注册和局部使用的差别? → APP_* 注入模块(能注入依赖)优于 app.useGlobal*(new 出来的拿不到 DI);局部用装饰器挂。
87、鉴权放 Guard 还是 Middleware?
参考答案:Guard。三个理由:能拿到执行上下文(目标 Controller/方法、元数据如 @Roles('admin'))做细粒度判断;能在依赖注入体系里用 Reflector/用户 Service;语义清晰(就是”能否激活路由”)。Middleware 定位是通用预处理,看不到将路由到哪。实现要点:canActivate 返回 boolean/抛 ForbiddenException;SetMetadata + Reflector.get 读角色元数据。
追问
- 追问①:认证和授权怎么拆? → 认证(你是谁,JWT 校验挂 req.user)一个 Guard;授权(你能干嘛,比对角色)另一个 Guard,链式
@UseGuards(AuthGuard('jwt'), RolesGuard)。 - 追问②:Guard 里抛异常会被谁接住? → ExceptionFilter——顺带验证第 7 题的链路。
88、参数校验怎么做?ValidationPipe 的三个关键开关?
参考答案:路由参数用内置 Pipe(ParseIntPipe 转数字并校验);请求体用全局 ValidationPipe + DTO 类,DTO 字段挂 class-validator 装饰器(@IsEmail/@Min)。三开关:whitelist(剥离未声明的字段,防夹带)、forbidNonWhitelisted(多传直接报错)、transform(payload 变成 DTO 类实例 + 类型转换)。原则:入口处一次性校验,业务代码信任 DTO 类型。
追问
- 追问①:为什么前端校验了后端还要校验? → 前端校验是体验,后端校验是安全(接口可被直接调用);“前端校验防君子,后端校验防小人”。
- 追问②:DTO 和实体类为什么分开? → 实体映射表结构,DTO 定义接口契约,混用会暴露表结构且字段生命周期完全不同。
89、统一响应体和全局异常怎么做?
参考答案:响应体用全局 Interceptor,next.handle().pipe(map(data => ({ code: 0, data, message: 'ok' })));异常用全局 ExceptionFilter(@Catch() 兜底):HttpException 取其状态码,未知异常按 500 处理并打日志上报,统一格式返回 {code, message}。注意:区分”业务异常(主动抛,给用户看 message)“和”系统异常(不泄露堆栈,只给通用提示)”。
追问
- 追问①:为什么不用一个 Middleware 包所有? → 响应包装要处理”流”(Interceptor 在正确时机),异常处理要区分异常类型(Filter 专职),中间件做不了这两件事。
- 追问②:业务错误码体系放哪? → 自定义 BusinessHttpException(带 code),Filter 里识别透出。
90、动态模块是什么?forRoot 和 forRootAsync 的区别?
参考答案:让库模块按使用方的配置装配:TypeOrmModule.forRoot({连接配置})、ConfigModule.forRoot({isGlobal})。区别:forRoot 同步传配置;forRootAsync 依赖注入 + 异步取配置(inject: [ConfigService],useFactory 里从配置中心拉),并注意 async 工厂会延迟应用启动(等待完成)。
追问
- 追问①:JwtModule、ThrottlerModule 属于哪种? → 都有 forRoot/register 形态;register 用于可重复注册的无状态配置,forRoot 通常单例共享——答出”命名约定暗示生命周期”是加分。
- 追问②:.env 多环境怎么管? → .env.development/.env.production + NODE_ENV 切换,ConfigService 类型化读取,禁止散落 process.env。
91、循环依赖怎么解决?更好的方案是什么?
参考答案:症状:AService 注入 BService、B 又注入 A,实例化死锁。兜底方案是 forwardRef(模块级和注入级都要,() => BService 用函数延迟求值,原因纯粹是声明时对方类还没定义)。更优解:抽公共逻辑到第三个 Service、或用事件解耦(EventEmitter2,一方只发事件不管谁听)、或接口 + token 注入。
追问
- 追问①:为什么函数包一层? → TS 类声明的提升问题,不是运行时特性。
- 追问②:事件解耦的代价? → 流程变成隐式的,排错要追事件名——工程权衡题,能说出来说明不是背 API。
92、单例 Service 的并发安全问题?(check-then-act 竞态)
参考答案:单线程串行,纯同步代码无竞态;风险全部来自 await 的间隙——if (!cache[key]) { cache[key] = await load(); } 两个请求同时通过 if,重复加载(甚至互相覆盖)。标准解法:缓存 Promise 本身 cache[key] ??= load(),后来的请求 await 同一个 Promise;天然去重。原则:Controller/Service 保持无状态,请求级数据走 AsyncLocalStorage。
追问
- 追问①:为什么缓存 Promise 就安全? → 同步赋值表达式之间不会被切换,第一个 await 前缓存已就位,后来者直接命中。
- 追问②:cluster 多进程下这个缓存还有效吗? → 无效,各进程内存独立——要共享上 Redis。
93、事务怎么做?哪些场景会失效?
参考答案:两种:编程式 dataSource.transaction(async em => {...})(em 上的操作同事务);声明式 @Transactional()(typeorm-transactional,基于 AsyncLocalStorage 透传事务上下文,嵌套调用自动同事务)。失效场景必背:同类自调用(不经过代理,装饰器不生效)、异常被 try/catch 吞掉、操作跑在事务连接之外、async 错误没 await 传播。
追问
- 追问①:跨两个 Service 的事务怎么办? → 声明式方案的事务上下文随 AsyncLocalStorage 传递,调用链上的 Repository 自动同事务;或显式把 em 传下去。
- 追问②:长事务的风险? → 连接池被占满、锁持有时间长——大事务拆小、非必要操作(发通知)移出事务。
94、TypeORM 和 Prisma 怎么选?SQL 注入怎么防?
参考答案:TypeORM:传统 ORM,装饰器实体,QueryBuilder 应对复杂查询强,迁移自动生成;Prisma:Schema-first,类型安全极强(schema 自动生成类型),复杂查询走 $queryRaw。口径:重业务轻 SQL、要 DX 和类型安全 → Prisma;复杂报表、查询调优多 → TypeORM 或保留 SQL。注入防范:永远参数占位——where('u.name = :name', {name})、原生查询 $1 占位;任何字符串拼接进 SQL 都是事故。
追问
- 追问①:为什么占位符能防注入? → 参数与 SQL 结构分离传输,驱动预编译,输入永远被当数据不当代码。
- 追问②:save 之后怎么拿自增 id? → TypeORM save 后实体自动回填;Prisma create 返回完整记录;原生用 RETURNING。
95、JWT 认证的完整链路?(Passport + 双 Token)
参考答案:登录:校验账密 → 签发 Access(短,如 1h)+ Refresh(长,如 7d,存库可吊销,下发 HttpOnly Cookie)。请求:AuthGuard(‘jwt’) → JwtStrategy 用密钥验签 → validate(payload) 的返回挂到 req.user → 后续 Guard/业务从这里拿身份。刷新:专门接口验 Refresh 换新 Access(可做”旋转”:每次刷新同时换新 Refresh)。要点:Access 无状态不查库(快)、Refresh 有状态可吊销(安全),黑白名单和强制下线都打在 Refresh 上。
追问
- 追问①:登出怎么做? → 前端删 Access;Refresh 服务端作废(白名单删除/黑名单记录)——“JWT 无法主动失效,用 Refresh 补”。
- 追问②:Strategy 里的 secret 放哪? → ConfigService 注入,环境变量,绝不硬编码。
96、限流怎么做?多实例部署要注意什么?
参考答案:官方 @nestjs/throttler:全局 ThrottlerModule.forRoot([{ttl, limit}])(如 1 分钟 10 次),单路由 @Throttle 覆盖、@SkipThrottle 豁免。默认存储在内存——多实例各算各的,阈值等于乘以实例数;分布式要自定义 ThrottlerStorage 换 Redis 计数,或直接在网关(Kong/APISIX/Nginx)做限流。
追问
- 追问①:限流维度怎么选? → 按 IP(防爬)还是按用户(防刷)还是按接口(保护慢接口),维度决定 key 设计。
- 追问②:限流和熔断的区别? → 限流保护自己不被打垮(入口节流);熔断防止下游拖垮自己(连续失败快速失败)——两个方向。
97、Nest 微服务怎么做?熔断和降级的区别?
参考答案:@nestjs/microservices 把”通信方式”抽象出来:同一个 Service 可暴露 HTTP/TCP/MQTT/Kafka/gRPC;@MessagePattern(请求响应)vs @EventPattern(fire-and-forget)。生态位:注册发现(Consul/K8s DNS)、链路追踪(OpenTelemetry)。熔断:连续失败后”跳闸”,一段时间内直接快速失败不再调用下游(opossum 三态 closed→open→half-open);降级:失败/超限时走兜底逻辑(返回缓存、进补偿队列)——通常熔断触发降级。
追问
- 追问①:@MessagePattern 和 @EventPattern 怎么选? → 需要结果用 Message(同步语义);通知型用 Event,解耦且不怕消费方挂。
- 追问②:事件跨服务用什么? → Kafka/RabbitMQ;进程内才用 EventEmitter2——层次要分清。
98、为什么说 Reflect Metadata 是 Nest 的根基?
参考答案:TS 类型编译后擦除,运行时”不知道”构造器参数是什么类型——IoC 就没法自动装配。出路:装饰器 + reflect-metadata——@Injectable()、@Body() 等把元数据写进类/方法签名,框架启动时用 Reflect.getMetadata('design:paramtypes', ...) 读回类型信息完成注入和参数解析。两个配套前提:tsconfig 开 experimentalDecorators + emitDecoratorMetadata,入口 import ‘reflect-metadata’。一句话:没有装饰器元数据就没有 Nest 的 IoC。
追问
- 追问①:没有装饰器的普通 TS 类,Nest 能注入吗? → 不能,缺元数据来源——这就是为什么 Nest 的代码风格全是装饰器。
- 追问②:Nest 里还能见到哪些设计模式? → 单例(默认 Provider)、工厂(useFactory)、观察者(EventEmitter2/Interceptor 的 Observable 流)、策略(Passport 多 Strategy)、责任链(Middleware→Guard→Pipe→Interceptor)、代理(ClientProxy)——报得出对应位置才算活学。
99、请求日志和耗时统计怎么做?
参考答案:入站日志用全局 Middleware(method/url/traceId),耗时统计用 Interceptor + tap 操作符(Date.now() 差值,响应后记录,不侵入业务),生产用 nest-pino(结构化 JSON + 请求 ID 关联)。要点:日志要有 traceId 串起一次请求的所有日志;错误日志在 ExceptionFilter 里统一记。
追问
- 追问①:为什么耗时放 Interceptor 不放 Middleware? → Middleware 看不到响应完成时机,Interceptor 的 tap 在流发出时触发,天然覆盖异步响应。
- 追问②:日志级别怎么用? → dev 用 debug、生产 info 起,error 必须带堆栈和 traceId;不要在循环里打 info。
100、Nest 的测试怎么做?
参考答案:两层。单元测试:Test.createTestingModule({controllers, providers}) 组装迷你容器,用 useValue 把依赖换成 jest.fn() mock,测 Controller/Service 逻辑;overrideProvider 替换真实的库依赖(TypeORM/HttpService)。e2e 测试:起完整 AppModule,用 Supertest 打真实 HTTP(request(app.getHttpServer()).get('/users').expect(200)),验证整条链路(路由、校验、Guard、DB)。
追问
- 追问①:单测里要不要连真数据库? → 尽量不要(慢、不稳定),mock Repository;要测真实 SQL 走 e2e + 测试库/事务回滚。
- 追问②:e2e 和联调的区别? → e2e 是自动化、可重复、进 CI;联调是人工验证——能否进 CI 是分界线。
101、生产部署要注意什么?性能从哪查起?
参考答案:构建:nest build(生产用 SWC 编译器,快一个量级);镜像用多阶段构建(builder 装依赖编译 → runner 只带 dist + 生产依赖);进程:pm2 cluster 或 K8s 多副本。性能排查路径:压测(autocannon)定位瓶颈 → CPU 热点/事件循环阻塞(node —inspect + CPU Profile、blocked-at)→ 内存(heap snapshot 对比)→ 事件循环延迟(monitorEventLoopDelay);常见事故:大 JSON.parse 同步阻塞、误用同步 fs、正则回溯。
追问
- 追问①:为什么强调”不要阻塞事件循环”? → 单线程模型:一段同步长计算卡住的是整个进程所有请求,连健康检查都超时,K8s 会杀实例。
- 追问②:Dev 依赖会进生产镜像吗? → 不应——多阶段 +
npm ci --omit=dev,答得出镜像体积意识。
102、SSE 和 WebSocket 在 Nest 里分别怎么实现?
参考答案:SSE:普通 Controller 就能做——@Sse() 装饰器返回 RxJS Observable(或用原生 res 写 text/event-stream 头,按 data: 格式推),注意返回的必须是 MessageEvent 结构、连接断开要 complete 清理防泄漏;适合 AI token 流、进度推送。WebSocket:@WebSocketGateway() 网关类,@SubscribeMessage('事件名') 收消息,handleConnection/Disconnect 管生命周期,server.to(room).emit() 定向广播(socket.io 体系)。
追问
- 追问①:SSE 要配 Nginx 时注意什么? → 关 proxy_buffering,否则流被代理攒着,打字机变卡带。
- 追问②:为什么 AI 接口倾向 SSE/流而不是 WS? → 单向、就是 HTTP(过网关/鉴权简单)、自动重连;WS 的双向能力在这里用不上。
103、版本化、全局前缀、CORS——前后端联调三件事怎么配?
参考答案:全局前缀 app.setGlobalPrefix('api');版本化三种模式:URI(/v1/users,最直观)、HEADER、MEDIA_TYPE,enableVersioning({type: VersioningType.URI}) + @Version('1'),默认版本兜底未标注的路由;CORS 用 app.enableCors({origin, credentials}),生产白名单域名 + 携带凭证必须指定具体 Origin(不能 *)。
追问
- 追问①:URI 版本化下,未标注 @Version 的路由去哪了? → 默认版本控制(配 defaultVersion 则对应版本命中;不配则只有裸路径)。
- 追问②:带 cookie 跨域,前端还要配什么? → fetch credentials: ‘include’/axios withCredentials,后端 origin 不能是 *。
104、Swagger 文档怎么接?怎么保持不腐烂?
参考答案:main.ts 里 DocumentBuilder 定义标题/鉴权方式,SwaggerModule.setup('docs', app, createDocument(...)) 即挂 /docs;Controller 上 @ApiTags/@ApiOperation,DTO 类本身就是 Schema(class 装饰器即文档),配 @ApiResponse 标注响应类型。防腐烂的关键:文档注解贴着代码走,代码评审时连带审注解;DTO 改了文档自动变,这是 TS 全栈”类型即文档”的优势。
追问
- 追问①:Swagger 对前后端协作的实际价值? → 契约先行:前端 mock、联调、自测对照同一份文档,减少口头对表结构。
- 追问②:不想手写注解的偷懒方案? → DTO + ValidationPipe 的装饰器已经能推断大半,补最小注解;先跑通再补文档是常态,但别不补。
题型 × 坑速查表
| 题号 | 题目 | 题型 | 最典型的坑 | 修补关键词 |
|---|---|---|---|---|
| Q65 | JWT 双 token 无感刷新 | 认证鉴权 | token 还有效但人已改密;并发刷新竞态;Bearer 前缀/secret/过期三种 401 分不清 | 短 accessToken + tokenVersion 黑名单;前端刷新单飞;401 错误码细分 |
| Q66 | RBAC 落到 Guard + 装饰器 | 认证鉴权 + AOP | useGlobalGuards(new X()) 注入不了;Guard 顺序反了鉴权被静默跳过;忘写 @RequireLogin 是放行 | APP_GUARD 注册;认证在前鉴权在后;默认全拒 + @Public 白名单 |
| Q67 | 统一响应格式与全局异常 | AOP 架构 | @Res 忘 passthrough 返回值被忽略;全局信封包坏 SSE;错误响应与成功响应两套结构 | passthrough:true;@SkipTransform 白名单;Filter 也包统一信封 |
| Q68 | 多版本共存与灰度发布 | API 治理 | URI 方式下 VERSION_NEUTRAL 失效(/v1/aaa 404);注册顺序反了 v2 永不生效;忘 enableVersioning | NEUTRAL 改明确版本;具体版本注册在前;defaultVersion 兜底 |
| Q69 | 循环依赖 | 模块设计 | 只改一边 forwardRef;忘配 @Inject 运行时 undefined;报错被误判为路径写错 | 两边都包 + @Inject 成对;e2e 调用环路径;重构/事件优先 |
| Q70 | 动态模块设计配置模块 | 模块设计 | 字符串 token 全局冲突;isGlobal 没生效;覆写 forRoot 弄丢基类 provider | builder 唯一 token;setExtras 写 global;…base 展开再追加 |
| Q71 | 请求日志与链路追踪 | 可观测性 | request.ip 是代理 IP;level 调高请求日志全消失;多进程同写一个文件 | X-Forwarded-For;请求日志级别约定;stdout 采集 + ALS traceId |
| Q72 | 大文件上传 | 性能与可靠性 | @Body 拿不到文件/字段名不匹配;nginx 1M 先拒;originalname 路径穿越;大文件拖垮单线程 | 四种文件拦截器;网关应用限制对齐;随机文件名;预签名 URL 直传 |
| Q73 | SSE vs WebSocket 选型 | 实时通信 | 命名事件 onmessage 收不到;SSE 不清 interval 内存泄漏;EventSource 带不了 header;nginx 攒消息;socket.io 客户端必须配对 | addEventListener;teardown/finalize;cookie 鉴权;X-Accel-Buffering;版本对齐 |
| Q74 | 定时任务分布式问题 | 任务调度 | forRoot 没注册任务静默不跑;多实例重复执行;任务跑一半实例重启锁未释放 | 注册清单日志;Redis 锁 + 幂等;TTL>任务时长 + 执行记录表 |
| Q75 | ValidationPipe 与 DTO 复用 | 数据校验 | 没全局启用校验形同虚设;whitelist 静默丢字段;transform 没开 query 是 string;嵌套校验被跳过 | e2e 脏请求冒烟;内部开 forbid;transform:true;@ValidateNested + @Type |
| Q76 | 微服务通信选型 | 架构选型 | MessagePattern/EventPattern 语义混用;send() 冷 Observable 不订阅不发送;毒消息无限重入队 | 事件用 EventPattern;firstValueFrom 显式消费;死信 + 重试上限 |
| Q77 | 缓存方案与一致性 | 数据一致性 | 响应缓存把 A 的数据给 B;check-then-act 并发回源;先删缓存旧值回填;内存缓存多实例不一致 | key 加用户维度;缓存 Promise 单飞;先更库再删 + 延迟双删;Redis store |
| Q78 | 优雅停机与生命周期 | 可靠性设计 | 忘 enableShutdownHooks 钩子全不触发;监听 SIGTERM 后不 exit 进程挂住;宽限期小于排空时间;onModuleInit 跨模块调用 | enableShutdownHooks + 软超时 exit;宽限期=排空+余量;跨模块调用放 onApplicationBootstrap |
| Q79 | 限流方案 | 稳定性 | 内存存储多实例各算各的;代理后全站共享一个 IP 桶;v5 语法迁移静默失效;类级 @SkipThrottle 全放行 | Redis ThrottlerStorage;trust proxy + 双维度桶;e2e 断言 429;SkipThrottle 精确到 handler |
八、整体技术方案设计题(12 题,四段式精讲)
系统设计题和背概念题最大的区别:面试官要的不是名词堆砌,而是分层展开的完整链路 + 每一层的取舍论证 + 踩过坑之后的修补。
一个成熟的回答顺序永远是:
- 先问清楚量级——多少 QPS、多少数据、容忍多久不一致;
- 分层给方案——请求进来 → 限流 → 缓存 → DB → 异步 → 补偿;
- 主动说出方案的坑——能把坑讲出来,才证明真的做过;
- 给出生产级的修补——坑与修补一一对应。
只会画架构图和能把”坑”主动讲出来的候选人,不是一个档次。本文 12 道题全部按「问题类型 → 怎么解决 → 有哪些坑 → 怎么修补」四段拆解,文末附「题型 × 坑速查表」,面试前扫一遍即可。
六大题型速览
12 道题背后其实只有六类通用问题,先记住每类的”核心矛盾”,遇到没见过的题也能往框架里套:
| 题型 | 对应题目 | 核心矛盾 | 答题主线 |
|---|---|---|---|
| 高并发吞吐 | Q1 秒杀、Q7 计数排行 | 性能 vs 正确性(快还不能错) | 分层削减流量:CDN → 限流 → 缓存原子操作 → MQ 异步 → DB 兜底 |
| 数据一致性 | Q2 缓存一致性、Q3 幂等 | 性能 vs 正确性(允许多久不一致) | 最终一致 + 收敛窗口:延迟双删 / binlog 订阅 / 原子状态迁移 |
| 互斥正确性 | Q4 分布式锁 | AP 系统做 CP 事 | 原子加锁 + 超时防死锁 + 只删自己的锁 + 强一致组件或 DB 兜底 |
| 可靠性容错 | Q5 MQ 不丢、Q6 超时重试风暴 | 可用性 vs 级联故障 | 分段保证(at-least-once)+ 幂等消化重复;超时 / 重试 / 熔断 / 限流 / 降级组合拳 |
| 存储与查询 | Q8 附近的人、Q10 深分页、Q11 分库分表 | 数据量 vs 单点极限 | 换数据结构(GEO / 游标)、换查询视图(ES 异构)、拆分 + 迁移 |
| 可用性稳定性 | Q9 登录态、Q12 缓存三件套 | 无状态便利 vs 主动控制 | 取舍论证 + 组合方案(双 token / 黑名单;多级缓存 / 逻辑过期) |
通用答题框架
不管题目多花哨,按这五步走,结构分就拿到了:
- 反问量级:QPS 多少、数据量多少、能容忍多久不一致——需求不清就给方案是减分项;
- 给基线方案:最朴素的能跑版本(直接写 DB、直接 LIMIT 分页);
- 指出瓶颈:基线在量级下哪里先死(单表 2000 万、单 key 单分片、offset 深扫);
- 分层演进:每一层给选型理由和取舍,而不是直接甩终态架构图;
- 主动讲坑与修补:坑讲得越具体(带时序、带现象),可信度越高。
Q16. 让你设计一个秒杀系统,10 万人抢 1000 件商品,整体方案怎么做?
问题类型:高并发吞吐类。核心矛盾是性能与正确性:既要在毫秒级返回,又绝不能超卖。考察点是把”瞬时百万请求”层层削减到数据库能承受的量级,通用范式是”层层拦截、动静分离、缓存优先、异步下单、限流兜底、数据库最终一致”。
怎么解决:
- 先算账,再设计。
- 10 万人在开抢瞬间点击,峰值 QPS 约 10 万+,而真正能成交的只有 1000 单;
- 方案的本质:每一层把流量削减一个数量级,最后落到 DB 的请求只有几千。
- 前端 / 接入层削流。
- 秒杀页全静态化,商品详情、倒计时、图片全部走 CDN,动态数据(库存余量)单独一个接口;
- 按钮点击后置灰 + loading 防重复提交;
- 开抢时间用服务端时间校准,防止改本地时间提前刷。
- 网关层拦截。
- Nginx 按 IP / URI 限流(
limit_req),同一用户、同一 IP 高频请求直接拉黑; - 验证码或答题:既防脚本刷单,又把”同一秒的洪峰”打散成几秒内的平滑流量。
- Nginx 按 IP / URI 限流(
- 应用层限流 + 校验。
- 单机限流(令牌桶)+ 分布式限流(Redis + Lua),超出容量的请求快速返回”系统繁忙”,绝不让它们往后走;
- 校验登录态、活动时间、该用户是否已参与。
- Redis 原子预扣库存。
- 活动开始前把库存预热进 Redis;
- 扣减用 Lua 脚本一次性完成”判重复 + 判库存 + 扣减”(而不是先 get 再 decr);
- 扣减成功的请求才算”抢到资格”,10 万 QPS 到这一层后只剩 1000 个成功请求。
- MQ 异步削峰下单。
- Redis 扣减成功后发一条消息到 MQ(RabbitMQ/Kafka),立即向用户返回”排队中”;
- 消费者异步落库生成订单、扣 DB 库存,DB 写入压力从 10 万 QPS 降到可控的匀速写。
- 数据库层最终兜底。
- 订单落库用乐观锁绝对防超卖:
UPDATE stock SET num = num - 1 WHERE id = ? AND num > 0; - 影响行数为 0 说明 Redis 与 DB 出现过偏差,拒绝并走补偿。
- 订单落库用乐观锁绝对防超卖:
- 超时关单与对账。
- 15 分钟未支付自动关单回滚库存:RabbitMQ 死信队列实现延迟,定时任务兜底(classic/22 的 @Cron 就是这个角色);
- 每天定时对账 Redis 剩余库存与 DB,发现漂移自动修正。
- 结果通知。
- 用户端轮询订单状态(2~3 秒一次,带退避);
- 或用 SSE(classic/28)由服务端把”抢购成功/失败”推给前端,一条连接推到底,天然适合”排队结果”这种单向通知,比轮询省得多。
有哪些坑:
- Redis 扣减写成”先 GET 判断库存、再 DECR”两步——并发下两个请求都读到库存 1,各自 DECR,库存变 -1,超卖;或者判重(是否已抢过)和扣库存分开做,同一用户的两个并发请求都通过判重,重复下单。
- Redis 扣成功、MQ 消息发送失败——用户收到”排队中”却永远没有订单,库存被占着不放,少卖。
- 只信 Redis,DB 层没有
num > 0条件——一旦 Redis 与 DB 短暂不一致,DB 库存被扣穿,这才是真正的超卖。 - 没有验证码 / 随机丢弃,10 万请求在同一毫秒打进来——Redis 单分片网卡和 CPU 被打满,连正常商品的下单接口也被拖挂。
- 秒杀链接提前泄露——脚本提前拿直链,开抢瞬间精确刷请求,真人用户毫无机会。
怎么修补:
- 判重 + 判库存 + 扣减合并成一段 Lua 脚本原子执行(Redis 单线程执行 Lua 期间不会插入其他命令);扣减结果同时 SADD 进”已购集合”,判重就靠它。
- MQ 发送采用本地消息表 + 发送重试:Redis 扣减与”待发消息记录”在同一事务边界内落库,由后台任务保证消息最终发出;再加定时对账兜底——扫描”Redis 已扣但无订单”的单子,超时自动回滚库存。
- DB 侧永远保留
WHERE num > 0(或 version 乐观锁)作为最后一道防线:即使上游全错,数据库物理上不可能超卖。 - 上验证码 / 答题错峰 + 网关容量外请求直接 503,把毫秒级尖峰摊成秒级平峰;秒杀服务与主站隔离部署(独立集群、独立 Redis/DB),秒杀挂了不影响主流程。
- 秒杀 URL 动态生成:开抢前才下发加密签名 URL(URL 带时间戳 + HMAC),服务端验签,提前拿到的直链无效。
Q17. 缓存和数据库的双写一致性怎么保证?先更新库还是先删缓存?
问题类型:数据一致性类。考察点是在 CAP 之间做取舍——缓存一致性的现实答案是”最终一致 + 一个收敛时间窗口”,强一致就得放弃缓存的性能价值。面试官想听的是:你知道每种写序的脏数据窗口在哪,以及怎么把窗口缩到业务可接受。
怎么解决:
- 先定基调。
- 绝大多数业务(商品详情、用户资料)允许秒级不一致,目标是最终一致;
- 资金、库存等强敏感数据不直接走缓存,或缓存只读 + 显式版本校验。
- 基础模式选 Cache Aside(旁路缓存)。
- 读:先读缓存,未命中读 DB 并回填;
- 写:先更新 DB,再删除缓存——删而不是更新,因为并发写下的”更新缓存”可能乱序覆盖,删除让下一次读自然回填最新值。
- 为什么不是”先删缓存再更新 DB”。
- 删完缓存到 DB 提交之间,并发读会把旧值从 DB 读出来重新回填;
- 之后缓存里长期是旧数据,不一致窗口不可控;
- “先更库后删缓存”的不一致只出现在”读请求在 DB 更新前读了旧值、在删除后才回填”这个极小概率时序里(要求读比写还慢,且同一条数据恰好被并发读写)——概率低几个数量级,所以选它。
- 延迟双删。
- 写操作:更新 DB → 删缓存 → 异步延迟几百毫秒(覆盖主从同步窗口)→ 再删一次;
- 把读旧值回填的那部分脏数据清掉;
- 延迟取多少?主从延迟 P99 的 1
2 倍,一般 500ms1s,延迟期间的数据由 TTL 和对账兜底。
- binlog 订阅做终极兜底。
- 用 Canal / Debezium 订阅 MySQL binlog,凡是 DB 有变更,由订阅端统一发删除消息(可发到 MQ 广播给所有实例);
- 删除动作从业务代码里彻底解耦——业务只管写库,失效缓存交给数据管道;
- 不可能漏删:只要 DB 写成功,变更事件就一定在 binlog 里。
- TTL 兜底:所有缓存 key 必须设置过期时间,即使上述全失败,不一致窗口也被 TTL 封顶。
- 极端强一致场景。
- 读写加分布式锁,或干脆穿透式只读 DB;
- 主动说出”这方案性能损失巨大,只在资金类场景用”——这句话本身就是加分项。
有哪些坑:
- “先更新 DB 再删缓存”的删除失败了(Redis 抖动 / 超时)——缓存里一直是旧值直到 TTL 过期,用户看到降价前的价格。
- 先删缓存再更新 DB,并发读把旧值回填——窗口虽小但真实存在;尤其搭配读写分离时:删缓存后读请求走了从库,从库还没同步到新值,回填的就是旧数据。
- 业务代码里手写删除散落各处——一个商品信息被订单服务、商品服务、营销服务三处更新,有一处忘了删缓存,一致性方案形同虚设。
- 删除后瞬间大量读未命中,一起打向 DB(缓存击穿)——热门商品缓存刚失效,几千个并发同时回源。
怎么修补:
- 删除失败进重试队列:删失败把 key 扔进 MQ 延迟重试;更彻底的是 binlog 订阅统一失效——删除从”业务代码尽力而为”变成”数据管道保证最终执行”。
- 延迟双删应对回填旧值:第二次删除安排在主从同步完成之后(延迟取主从延迟 P99 的 1
2 倍,通常 500ms1s);从库回填场景,回填前校验数据版本或只由主库读路径回填。 - 缓存失效逻辑收敛成统一的注解 / AOP 或统一的领域事件(进程内可参考 classic/23 的 event-emitter 广播失效,跨服务走 binlog + MQ),代码评审只看一个地方。
- 回填加互斥锁:同一个 key 只允许一个请求回源 DB 重建缓存,其余等待或返回旧值(详见 Q12 缓存击穿)。
Q18. 接口幂等怎么保证?用户重复点击、MQ 重复消费、支付重复回调,分别怎么防?
问题类型:数据一致性 / 可靠性类。考察点:理解”重复不可避免”(网络重试、用户重放、MQ at-least-once 都会带来重复),幂等是服务端的自我保护,核心手段是把”查重 + 执行”做成原子,而不是查完再执行。
怎么解决:
- 分层设防,存储层兜底。四板斧:
- 前端按钮置灰防抖——挡掉 90%,但只是体验优化,不能作为正确性依据(请求可以直接绕过前端);
- 防重 token——挡并发重复;
- 数据库唯一索引——终极兜底;
- 分布式锁——串行化同一业务键。
- 防重 token 机制。
- 进入表单页时服务端下发一次性 token(存 Redis);
- 提交时携带,服务端原子地校验并删除 token(
GETDEL或 Lua); - token 只能被消费一次,重复提交自然被挡。
- 唯一索引兜底。
- 订单表对
(user_id, activity_id)、支付流水表对out_trade_no建唯一索引; - 重复插入报
DuplicateKeyException,捕获后转为返回第一次的结果(而不是抛 500)。
- 订单表对
- 状态机。
- 只允许合法的状态迁移:
UPDATE orders SET status = 'PAID' WHERE id = ? AND status = 'WAIT_PAY'; - 影响行数为 0 说明已处理过,天然幂等;
- 订单超时关单与支付成功的竞态也靠它:支付先迁移状态,关单线程再来时 update 影响行数为 0,直接退出——支付优先,绝不误关。
- 只允许合法的状态迁移:
- MQ 消费端幂等。
- 消息表 / 去重表记录已处理的
msgId或业务键; - 消费前先原子插入去重表(唯一索引),插入失败说明处理过,直接 ack;
- 或用 Redis
SETNX key msgId EX 24h快速判重。
- 消息表 / 去重表记录已处理的
- 支付回调。
- 以渠道流水号为幂等键 + 状态机 + 唯一索引三重防护;
- 重复回调返回 success 即可——返回失败渠道会按退避策略无限重试,反而自己制造重试风暴。
有哪些坑:
- token 校验写成”先 GET 判断存在、再 DEL”两步——两个并发请求都 GET 到 token 存在,都通过校验,幂等失效,回到原点。
- 唯一索引冲突没被捕获——重复请求触发
DuplicateKeyException直接向用户抛 500,用户以为下单失败再点一次,forever 500。 - token 被消费后,用户的”正常重试”也被拒绝——网络超时用户重发请求,token 已被第一次消费,重试被判为重复,但第一次可能还没建成功订单,用户体验极差。
- 状态判断与更新分离——先
SELECT status再UPDATE,两个请求同时 select 到”待支付”,都执行更新,状态机被击穿。 - 只做了 HTTP 接口幂等,MQ 消费端裸奔——生产者重发、消费者 rebalance 时的重复投递,导致积分加了两遍。
怎么修补:
- 校验与删除必须原子:Redis 6.2+ 用
GETDEL一条命令;低版本用 Lua(if GET==v then DEL; return 1)。 - 捕获唯一索引冲突,转成查询已有记录并返回原结果——幂等的语义是”重复请求拿到和第一次相同的结果”,不是报错。
- 幂等键改用客户端生成的 requestId(每次业务操作一个,重试时不变)而不是一次性 token:重试携带同一个 requestId,第一次成功则返回缓存结果,未成功则允许再执行。
- 状态迁移用带条件的原子 UPDATE(判影响行数),不要 select-then-update;需要更多前置校验时升级为乐观锁(version 字段)。
- 消费端按 msgId / 业务键建去重表(唯一索引),插入成功才执行业务;去重记录设 TTL 或定期清理,避免无限膨胀。
Q19. 分布式锁怎么实现?Redis 锁在主从切换时为什么会出问题,怎么办?
问题类型:互斥正确性类。考察点是”用 AP 系统做 CP 事”的典型冲突——Redis 性能高但故障切换时可能丢锁,etcd/ZooKeeper 强一致但性能低。要能讲清锁的三要素:原子加锁、超时防死锁、只能释放自己的锁。
怎么解决:
- 先说锁的用途分层。
- 抢任务调度、防重复构建——“锁偶尔失效只造成重复执行”,Redis 锁够用;
- 扣库存、转账——“锁失效就是资损”,要么 etcd/ZooKeeper 强一致锁,要么锁 + DB 乐观锁双重保险(锁做性能优化,DB 条件更新做正确性兜底)。
- Redis 单机锁的标准姿势。
SET lock_key unique_value NX PX 30000——一条命令完成”不存在才设置 + 过期时间”;- NX 保证互斥,PX 保证持有者宕机后锁自动释放;
unique_value是每次加锁生成的唯一标识(UUID + 线程 ID)。
- 释放锁必须 Lua。
- 先
GET比对 value 是自己的,再DEL,两步必须原子; - 否则可能删掉别人的锁(时序:自己的锁过期 → B 加锁成功 → 自己的 DEL 到了 → 把 B 的锁删了)。
- 先
- 看门狗续期。
- 业务执行时间不可预知:锁 30s 过期但业务要跑 60s,就会并发进入;
- Redisson watchdog 在持锁期间每 10s(过期时间的 1/3)自动续期,业务执行完停止续期;
- 兼顾”宕机自动释放”与”长任务不失效”。
- Redis 集群的锁安全。
- 主从异步复制:主节点写入锁后还没同步给从节点就宕机,从切换为主,锁丢了;
- B 在新主上加锁成功,A 还以为自己在持锁——互斥被打破;
- 高正确性场景用 RedLock(多数派写,存在争议,可主动提 Martin Kleppmann 与 antirez 的论战)或 etcd。
- etcd 锁(learnhub 的 docker compose 里就带 etcd)。
- 基于 Raft 强一致,租约(lease)TTL + keepalive 续约,持有者宕机租约到期锁自动释放;
- 把”锁存在”这件事变成集群共识,不依赖单点数据不丢;
- 性能低于 Redis(共识要走多数派),但正确性敏感场景值得这个代价。
- 永远用 tryLock(带超时)而不是无限阻塞等锁,拿不到快速失败返回”操作太频繁”,避免线程堆积。
有哪些坑:
- 加锁拆成 SETNX + EXPIRE 两步——SETNX 成功后、EXPIRE 执行前客户端宕机,锁永不过期,所有后续请求永远拿不到锁,业务死锁。
- 锁不设过期时间,持有者宕机死锁;反过来,过期时间拍脑袋设太短——业务没跑完锁先过期,第二个请求并发进来,库存扣了两遍。
- 释放锁直接 DEL——锁提前过期后被 B 拿到,A 的 DEL 会把 B 的锁删掉,C 又能加锁,B、C 并发执行。
- 主从切换锁丢失——Redis 异步复制,锁还没同步到从节点主就挂了,互斥被打破(这坑压力不大时根本测不出来,半夜故障切换时爆雷)。
- 锁粒度太粗:全商品一把锁,所有秒杀请求串行,吞吐还不如不用锁。
怎么修补:
- 加锁只用
SET ... NX PX ...单命令原子操作(或 Lua),任何”先加锁再设过期”的写法直接打回。 - 过期时间必设,且配合看门狗动态续期:默认 30s,后台线程按 1/3 周期续满,进程宕机续期停止、锁到期自动释放——两个方向的安全都覆盖。
- 释放用 Lua 比对 value 再删;更进一步配 fencing token(单调递增版本号,etcd 的 revision 天然适合),下游存储(DB 乐观锁 version)校验 token——即使锁失效造成并发,旧持有者的写入也会被拒绝。
- 正确性敏感场景:换 etcd / ZooKeeper(Raft / ZAB 多数派提交,写入即共识);或保留 Redis 锁做第一道闸 + DB 条件更新(
WHERE num>0/WHERE version=?)做最终裁判。 - 锁粒度细化到具体资源(
lock:stock:{skuId});单 key 依旧过热时按 Q1 用”Redis 原子扣减”替代锁模式——能用原子命令的就别上锁。
Q20. 消息队列怎么选型?怎么保证消息一条都不丢?
问题类型:可靠性容错类。考察点:把”不丢”拆成生产者 → broker → 消费者三段分别论证,并理解 at-least-once 与幂等的配合——不丢的代价就是可能重复,重复要靠 Q3 的幂等消化。
怎么解决:
-
选型先给对比再给结论:
维度 Kafka RabbitMQ RocketMQ 吞吐 百万级,最高 万~十万级 十万级 路由能力 弱(topic/partition) 强(exchange/direct/topic) 中(tag 过滤) 延迟消息 不支持 插件支持(死信 TTL) 原生支持(18 个级别) 事务消息 弱(Kafka 事务偏流语义) 无 原生支持 适合 日志 / 大数据管道 中小团队业务解耦 电商交易链路 - 结论按”团队技术栈 + 场景”选:learnhub 的 docker compose 里 RabbitMQ 和 MySQL/Redis/ES 并列作为标准件,就是中小团队业务解耦的典型选择。
-
生产者段不丢。
- 开启发送确认:Kafka
acks=all+ 重试,RabbitMQ publisher confirm; - broker 确认落盘才算成功,确认失败指数退避重试有限次数;
- 关键业务用本地消息表:业务数据和消息记录同一事务落库,后台任务扫表发送,发送成功才标记——“发送”这个动作本身也有了兜底。
- 开启发送确认:Kafka
-
broker 段不丢。
- 队列 / 消息 / 交换器全部持久化:Kafka 副本数 ≥3、
min.insync.replicas=2;RabbitMQ 队列 durable + 消息 deliveryMode=2 + 镜像 / 仲裁队列; - 单机 broker 存内存里的消息重启即丢,这一段必须显式配置。
- 队列 / 消息 / 交换器全部持久化:Kafka 副本数 ≥3、
-
消费者段不丢。
- 关闭自动 ack,业务处理成功后再手动 ack;
- 处理失败 nack 重回队列重试有限次数,超限进死信队列(DLQ)+ 告警人工处理,而不是无限重投。
-
重复怎么办。
- 三段都保证”至少一次”后,重复不可避免(最典型:消费者处理完、ack 还没发出去就宕机,重启后消息重投);
- 消费端按 Q3 做幂等(去重表 / 唯一索引 / 状态机),重复消息消费多次结果一致。
-
堆积怎么办。
- 加消费者实例(Kafka 消费者数 ≤ 分区数)、批量拉取批量提交、非核心逻辑再拆一级异步;
- 堆积量、消费延迟接入监控告警(classic/21 的结构化日志 + 指标是排障基础)。
-
顺序性。
- 全局有序代价极高(单分区),一般只做分区有序;
- 同一订单的消息按 orderId hash 到同一分区,单线程消费,乱序只发生在跨分区之间;
- 追问”消费失败会不会乱序”:同分区重试会阻塞后续消息(或超限进死信后跳过),顺序与可用性又是一对取舍——能主动讲到这层,这题就到位了。
有哪些坑:
- 生产者”发后即忘”——
send()不等确认,网络抖动静默丢消息;本地环境正常、生产环境跨机房丢,更隐蔽。 - RabbitMQ 队列没声明 durable、消息没持久化——broker 重启,堆积的几万条消息全没了,而且开发阶段永远发现不了。
- 消费者自动 ack——消息一到就确认,业务代码抛异常时消息已被确认,丢了;反过来”处理成功但 ack 前宕机”会重投,没做幂等就重复下单。
- 失败无限重回队列——一条毒消息(反序列化失败)被消费、失败、重投、再消费……死循环,消费延迟打满,后面的正常消息全部堆积,下游还被高频重试打挂(和 Q6 的重试风暴同源)。
- 跨服务的进程内事件当 MQ 用——用 classic/23 那种 event-emitter 发”订单已创建”,进程一重启事件就没了:进程内事件是”发完就忘”,可靠性投递必须上真正的 MQ。
怎么修补:
- 生产者开 confirm / acks,确认超时指数退避重试,最终失败落补偿表人工介入;关键业务用本地消息表把”业务落库”与”消息必达”绑成一个事务。
- 上线检查清单固化:队列 / 消息持久化、镜像或副本、
min.insync.replicas——配置做成 IaC(docker compose / helm)里显式声明,不依赖控制台手点。 - 手动 ack,处理成功才确认;重投的重复用消费端幂等消化(去重表 + 唯一索引),幂等键用业务键而非 msgId(生产者重发时 msgId 会变)。
- 重试有限次数(如 3 次)+ 指数退避,超限进死信队列并告警;毒消息(反序列化失败这类永久性错误)第一次就直接进 DLQ,不参与重试。
- 明确边界:进程内 event-emitter 用于同进程模块解耦(下单后发通知),跨服务 / 可靠性投递一律上 MQ——两者不是替代关系,是作用域不同。
Q21. 下游服务变慢,调用方重试把整条链路打挂了,怎么办?说说超时、重试、熔断、限流、降级。
问题类型:可靠性容错类(级联故障)。考察点:故障传播的力学——一个依赖变慢 → 线程 / 连接被占满 → 上游线程池耗尽 → 逐级向上蔓延,雪崩。反制手段是一套组合拳,每一拳都要有时间参数和数量参数,不能只报名词。
怎么解决:
- 超时是一切的前提。
- 每个外部调用(HTTP / RPC / Redis / DB)必须设连接超时 + 读超时;
- 上游超时 > 下游处理时间之和(入口 3s、中间层 1.5s、DB 500ms 的漏斗形),否则上层还在等、下层早就放弃,线程白占;
- 默认不设超时的客户端库等于埋雷。
- 重试要克制。
- 只重试幂等接口;次数 ≤2~3;
- 指数退避 + 随机抖动(backoff + jitter),避免失败后所有请求在同一毫秒齐刷刷重试;
- 只重试超时和明确可重试的错误码,业务错误(余额不足)不重试。
- 熔断器三态。
- closed(正常)→ 错误率 / 慢调用率超阈值 → open(直接快速失败,不再发请求,给下游喘息);
- 冷却期后 half-open(放一小撮探测请求)→ 成功率恢复则回 closed,仍失败则回 open;
- 熔断的意义是把”等超时”变成”毫秒级失败”,保住自己的线程。
- 限流做容量保险。
- 单机令牌桶保进程,集群限流(Redis + Lua 滑动窗口)保全局;
- 入口层(Nginx / 网关)限总量,服务层限关键接口;
- 阈值按压测容量定,超出的请求快速返回”系统繁忙”——宁可部分拒绝,不可全部雪崩;
- 算法取舍一句话:固定窗口有临界突刺(两窗口边界可放过 2 倍流量)、滑动窗口平滑、漏桶恒速但无法应对突发、令牌桶允许攒令牌应对合理突发,网关层最常用。
- 降级预案。
- 熔断 / 限流触发后要有退路:推荐列表返回缓存里的昨日热榜、评价数返回”10 万+“、非核心标签直接隐藏;
- 降级开关放配置中心,可一键手动触发。
- 舱壁隔离(线程池 / 信号量)。
- 不同依赖用独立线程池,第三方接口的池打满只影响自己,不传染主流程;
- learnhub 这类同时依赖 MySQL/Redis/MQ/ES 多个中间件的服务尤其要隔离。
- 可观测兜底。
- 结构化日志 + traceId 串联链路(classic/21 的 winston 请求日志就是这个用途);
- 熔断 / 限流事件打指标告警,故障时 3 分钟定位是哪个依赖。
有哪些坑:
- 不设超时——下游 GC 停顿 10s,调用方线程也挂 10s,线程池 200 个线程瞬间耗尽,整个服务(包括不相关接口)全部无响应。
- 多层都配 3 次重试——网关 × 服务 × 客户端,一个失败请求放大成 27 个,下游本来就过载,重试流量直接补刀打死,再也无法恢复。
- 重试无退避——失败后立刻重发,所有失败请求在同一时刻集中重试,形成周期性脉冲,下游刚缓一口气又被打下去。
- 熔断恢复太猛——half-open 直接全量放行,下游还没真正恢复,瞬间又被打开,熔断器在 open / half-open 之间抖动,期间所有用户请求都在失败。
- 只有熔断没有降级——熔断打开后接口直接抛异常,用户白屏;或降级逻辑从没演练过,真触发时降级接口自己也 500。
怎么修补:
- 全链路超时预算:入口超时 = 各层耗时总和 × 1.5,配置中心统一管理;新依赖接入必须带超时配置,代码评审硬卡。
- 重试只在一层做(通常是最靠近故障点的调用方),并确认接口幂等;重试预算全局收敛,配额用尽就放弃转异步补偿。
- 退避公式
delay = base * 2^n + random(jitter),把重试在时间轴上摊开。 - half-open 小流量探测(放 5%~10% 或个位数请求),连续 N 次成功再逐步放量;恢复期叠加限流,爬坡式回切。
- 降级逻辑随主流程一起上线、定期演练(混沌工程),兜底数据(降级缓存)有后台任务持续刷新;降级入口做成开关,运营可干预。
Q22. 站内要做一个”点赞数实时统计 + 热门内容排行榜”,分数相同时按时间先后来排,怎么设计?
问题类型:高并发读写 + 数据结构选型类。考察点:计数场景”读多写多”的特征决定了 DB 扛不住,要在 Redis 里选对结构,并且解决”内存数据与 DB 的最终一致”。
怎么解决:
- 点赞计数 + 去重用 Set。
moment:like:{id}存 userId,SADD / SREM / SISMEMBER / SCARD四个原语正好对应点赞 / 取消 / 查状态 / 查总数;- Set 天然去重,一个人重复点赞不会使计数增加;
- 高频的点赞数展示读 SCARD,或单独用 Hash field
HINCRBY维护计数列。
- 排行榜用 ZSET。
ZADD / ZINCRBY更新分数,ZREVRANGE取 TopN,ZREVRANK查自己的名次;- O(logN) 的更新和范围查询,DB 的
ORDER BY做不到这个量级。
- 同分按时间排,靠 score 复合编码。
- ZSET 同分数默认按成员字典序,不符合需求;
- 做法:score 双字段拼接——
score = 分数 * 2^32 + (MAX_TS - timestamp); - 高位放业务分,低位放反向时间戳(先到的值大、排前面);
- 读出来按位拆解(右移 32 位得分数,取低 32 位用 MAX_TS 反减得时间);
- 给得出这个公式,基本能证明你真做过而不是背的。
- 写链路。
- 点赞请求 → Set 判重 + 计数增减 + ZSET 分数更新(合并进 Lua 保证原子)→ 发 MQ → 消费者批量落 DB(点赞明细表 + 计数汇总表)。
- 读链路。
- 计数走 Redis,榜单 TopN 走 ZSET,点进详情再查 DB;
- 榜单页可加短 TTL 缓存(几秒)进一步挡读。
- 持久化与对账。
- Redis 只做热数据,DB 是事实源;
- 每小时定时任务把 Redis 计数刷回 DB 并对账(classic/22 的 @Cron 就是这个角色);
- Redis 故障后从 DB 重建预热。
有哪些坑:
- 判重(SISMEMBER)和 ZADD / HINCRBY 分开执行——取消点赞和重新点赞并发到达:判重通过后对方取消,计数被多减 / 多加,计数与 Set 不一致,永远差 1。
- 只写 Redis 不落 DB——Redis 宕机(尤其 AOF everysec 丢 1 秒),几小时点赞数据蒸发,用户发现自己刚点的赞不见了。
- ZSET 同分按字典序——默认行为不是时间序;不做 score 编码,同分内容的排名按 member 字符串大小排,排行榜看着”乱序”。
- 明星微博式热点——某条内容百万 QPS 点赞,全部压在单个 Redis key 上,单分片 CPU / 网卡打满,整个集群其他 key 跟着受影响。
ZREVRANGE 0 -1拉全量——百万成员的榜单一次拉回,网络和内存双爆。
怎么修补:
- 判重 + 计数 + ZSET 更新合并成一段 Lua 原子执行;或者以 Set 为唯一事实源,计数每次从 SCARD 派生(写少读多时可行),从根本上消除两结构不一致。
- MQ 异步落库 + 定时对账双保险:消息携带完整事件(点赞 / 取消、用户、时间),消费端落明细表,汇总可由明细重算;对账发现偏差超阈值告警并以 DB 为准修正。
- score 复合编码(分数 << 32 | (MAX_TS - ts)),读出来按位拆解还原;业务分用减法 / 反转保证”分高在前、同分先到在前”。
- 热点 key 拆分:计数拆 N 个子 key(
like:{id}:{0..9})随机写、读时 SUM;或点赞先在应用内存合并批量刷 Redis;云 Redis 开读写分离,读走从节点。 - 榜单一律分页拉取(
ZREVRANGE start end,单页 ≤100);超大榜改用”只维护 TopN + 落榜即删”的截断策略,ZSET 成员数封顶。
Q23. 社交 App 要做”查找附近的人”,亿级用户,怎么设计?
问题类型:空间索引 + 数据结构选型类。考察点:地理位置检索不能对全表算距离,要理解 geohash 编码原理和它的边界问题,以及”亿级”带来的分片与冷热数据治理。
怎么解决:
- 选 Redis GEO。
- 底层是 ZSET + geohash:
GEOADD people 121.4894 31.2466 user1001把经纬度编码成 52 位整数作为 ZSET 的 score; GEOSEARCH people FROMLONLAT 121.48 31.24 BYRADIUS 1 km ASC WITHDIST一次拿到半径内按距离排序的用户;- 内存计算、毫秒级返回,是社交类 App 的事实标准。
- 底层是 ZSET + geohash:
- geohash 原理要能讲两句。
- 经纬度各自二分(维度区间对半砍、经度区间对半砍),交替编码成 bit 串,再 base32 编码;
- 前缀越长格子越小;相邻格子共享前缀,于是”附近”检索退化成”前缀范围扫描”;
- 这正是 ZSET(score 有序)能高效范围查的原因——GEOSEARCH 本质是一次 ZRANGEBYSCORE + 距离精筛。
- 上报策略。
- 客户端不能每秒上报:按”移动距离超过 50m 或间隔超过 30s”才上报一次;
- 服务端
GEOADD幂等覆盖更新(member 就是 userId)。
- 查询链路。
- GEOSEARCH 拿到 (userId, distance) 列表 → 业务过滤(性别 / 年龄 / 拉黑名单)→ 批量查 DB / 缓存补全资料 → 返回;
- 一次 50 个,分页用 cursor 存上批距离。
- 亿级分片。
- 单个 key 装不下也不该装全国:按城市 / 网格拆 key(
geo:shanghai、geo:beijing),归属由上报时反解城市; - 查询只查用户所在城市的 key——跨城的”附近”没有业务意义,天然隔离。
- 单个 key 装不下也不该装全国:按城市 / 网格拆 key(
- 冷数据清理。
- GEO 没有 per-member TTL;
- 用”双 ZSET”技巧:GEO 底层就是 ZSET,再维护一个
geo:city:ts(userId → 上报时间戳),定时任务把 30 天未上报的用户从两个结构里删掉(ZREMRANGEBYSCORE 按时间清理)。
有哪些坑:
- 客户端每次定位变化都上报——GPS 抖动 1m 也触发,写 QPS 直接乘 10,Redis 和客户端电量双输。
- geohash 边界问题——两个人隔一条街,恰好分属相邻两个格子,互查不到;半径查询只扫一个格子必漏边界。
- 一个 key 存全量用户——亿级 member 的 ZSET 单分片几十 GB,读写全打一台机器,还和热点 key 问题叠加。
- 隐私与位置残留——用户关掉”附近的人”后位置还在库里,仍可被检索到;恶意用户用脚本遍历全城位置(隐私合规事故)。
- GEO 命令版本坑——
GEORADIUS / GEORADIUSBYMEMBER在 Redis 6.2 起被标记废弃,新代码应使用GEOSEARCH / GEOSEARCHBYMEMBER,老资料里的命令直接抄会踩兼容性问题。
怎么修补:
- 上报节流合并:距离阈值 + 最短时间间隔双条件;服务端再兜一层去抖(两次上报距离 < 50m 丢弃)。
- 查询扩大一圈再过滤:先取目标格子,同时取 8 个相邻格子(geohash 相邻可计算),合并后按真实球面距离(Haversine)精筛排序——牺牲一点计算换不漏人;用 Redis 时 BYRADIUS 本身按中心点圆查,但格子原理是回答追问的底气。
- 按城市 / 网格拆 key + 大城市二级拆分(按区县),member 数控制在百万级以内,配合读写分离扛读。
- 用户关闭功能即
ZREM立即移除;上报接口鉴权 + 频控 + 位置模糊化(经纬度截到 geohash 5~6 位,精度百米级);对”禁止被发现”的用户过滤查询结果。 - 统一用
GEOSEARCH(Redis ≥6.2),并主动讲一句版本差异 + 底层结构(ZSET + 52bit geohash score)——把这题的原理分拿满。
Q24. 集群部署后登录态怎么共享?Session 和 JWT 怎么选?JWT 怎么实现”退出立即失效”?
问题类型:架构取舍类(有状态 vs 无状态)。考察点:不是背 JWT 结构,而是论证”无状态的收益(水平扩展、跨服务)与代价(无法主动失效)“之间的矛盾,并给出生产可用的组合方案。
怎么解决:
-
先摆两条路线。
Session 集中存储 JWT 状态位置 服务端(Redis) 客户端(token 内) 水平扩展 依赖共享存储 天然友好 主动失效 / 踢人 天然支持 原生做不到,需黑名单 / 版本号 每次请求开销 查一次 Redis 只验签(无 IO) 适合 后台管理、强管控 开放 API、微服务网关 -
Session 共享方案。
- Session 不存本地内存,集中存 Redis(express-session + connect-redis,Nest 同理),Cookie 只放 sessionId;
- 任意实例都能读到登录态,扩容 / 重启无感;
- 单点退出、改密踢人天然支持——这是有状态路线的标准答案。
-
JWT 结构。
- header(算法).payload(claims:uid、exp、iss).signature(HMAC / RSA 签名);
- 签名保证不可篡改,但 payload 只是 base64,不是加密,不能放敏感信息。
-
JWT 的正确用法是双 token。
- accessToken 短期(15 分钟,放内存变量,不落 localStorage);
- refreshToken 长期(7~30 天,放 HttpOnly Cookie),只用来换新 accessToken;
- 短 token 把”泄露后可作恶窗口”压到分钟级。
-
JWT 退出立即失效的三个方案。
- 黑名单:注销时把 token 的 jti 写入 Redis 黑名单,校验时先查黑名单,TTL 设为 token 剩余有效期——无状态退化为”轻量有状态”,但只在登出 / 踢人这类低频动作查一次,成本可控;
- 版本号:用户表加 tokenVersion,改密 / 踢人时 +1,JWT 里携带签发时版本,不匹配即失效——一次改废该用户全部历史 token;
- refresh 旋转校验:换新 accessToken 时校验旧 refresh 是否已被使用过。
-
选型结论。
- 后台管理系统(要踢人、强管控)→ Redis Session 或 JWT + 黑名单;
- 开放 API / 微服务网关(无状态、跨域)→ 双 token JWT;
- App 端长登录 → 双 token + 设备管理;
- 真实系统常见混合形态:JWT 携带轻量身份 + Redis 存可变状态(权限、封禁)。
-
微服务下的传递。
- 网关统一鉴权,验证后把用户信息透传下游(X-User-Id header 或继续传 token);
- 下游不再各自查库解析——认证收敛在入口。
有哪些坑:
- Session 存本机内存 + Nginx 轮询负载均衡——登录请求落在 A 实例,下一个请求落到 B,登录态丢失,用户”一会儿登录一会儿没登录”,经典现象题。
- JWT 无法主动失效被当成小问题,干脆发长有效期 accessToken——直接发 7 天,泄露后攻击者用 7 天,注销、改密全都拦不住。
- payload 里放手机号、角色权限等敏感信息——payload 只做 base64,任何人拿到 token 解开就能看;权限变更后旧 token 里的角色还是老的,越权持续到过期。
- refresh token 不旋转——泄露后永久可用,攻击者拿它无限换新 access,业务方毫无感知。
- 退出登录只删了前端存储——token 本身仍然有效,抓包重放照样通过校验,“退出”是假的。
怎么修补:
- Session 集中上 Redis(集群 / 哨兵保证可用),Cookie 配 HttpOnly + Secure + SameSite 防 CSRF 和窃取;实例本地不再存任何登录态。
- 短 access + 长 refresh 双 token,泄露窗口从”天”压到”分钟”;网关侧加异常检测(同一 token 多 IP 使用告警)。
- payload 只放 uid、jti、exp 这类非敏感标识;角色权限每次从缓存(Redis / 本地短 TTL)读取——token 只做”身份认证”,不做”权限授权”(认证与授权分离)。
- refresh token 一次性旋转:每次刷新发新 refresh、旧作废(写入已用列表);检测到旧 refresh 被重放 → 判定泄露,作废该用户全部 token 强制重登。
- 注销 / 踢人走 jti 黑名单或 tokenVersion 版本号,把”立即失效”从不可能变成低频操作;这两者只需在登出、改密节点写一次 Redis,无状态的性能收益基本不损失。
Q25. 订单列表 5000 万数据,翻到第 10 万页接口直接超时,深分页怎么优化?
问题类型:数据库性能类。考察点:理解 LIMIT offset, size 的真实代价——offset 之前的数据要全部扫描并丢弃;并且”随机跳页”和”顺序翻页”必须分而治之,游标分页是后者的解法。
怎么解决:
-
先定位原因。
LIMIT 999990, 10让 MySQL 通过二级索引定位到起点后,逐行回表读出前 100 万行,再丢掉 999990 行;- offset 越深扫描越多,RT 随页码线性恶化,最终大量回表把 CPU 和 IO 打满;
- 验证方式:
EXPLAIN看 rows 扫描量,慢查询日志里典型的”rows 百万级、using where”深分页画像。
-
子查询 / 延迟关联优化(保随机跳页)。
- 先在覆盖索引上把目标页的主键找出来,再回表:
SELECT * FROM orders t JOIN (SELECT id FROM orders WHERE user_id = ? ORDER BY id DESC LIMIT 999990, 10) tmp ON t.id = tmp.id;- 子查询只扫索引不回表,回表只发生 10 次,深分页从秒级降到几十毫秒。
-
游标 / 键集分页(顺序翻页首选)。
- 记住上一页最后一条的排序值,下一页
WHERE user_id = ? AND id < #{lastId} ORDER BY id DESC LIMIT 10; - 永远只扫 10 行,第 1 页和第 10 万页一样快;
- 把 lastId(及次排序字段)编码成不透明 cursor(base64)返给前端,防爬虫猜测页码结构。
- 记住上一页最后一条的排序值,下一页
-
业务上限制跳页。
- 信息流、订单列表只提供”下一页 / 上一页”;
- 管理后台允许跳页但限制最大页码(如 1000 页内),超过强制输入条件缩小范围;
- 搜索引擎也只给几十页,这是行业共识不是偷懒。
-
count 的优化。
- 千万级表上
COUNT(*)同样昂贵:总数走 Redis 缓存定时更新、或展示”约 1.2 万条”近似值; - 只在第一页请求 count,翻页过程复用。
- 千万级表上
-
数据架构级方案。
- 订单列表查询走 ElasticSearch(learnhub 里 MySQL 与 ES 并列部署,就是为这种场景),search_after 天然就是游标分页;MySQL 只做交易事实源,binlog / MQ 同步,ES 做查询视图;
- ORM 侧注意:TypeORM 的
skip/take生成 offset 模式,Prisma 的take + cursor是游标模式(classic/25、26),深分页必须显式用 cursor。
-
兜底:冷热分离。
- 历史订单归档表,线上库只留近 3~6 个月;
- 单表量级从 5000 万降到几百万,所有查询自然变快。
有哪些坑:
- ORM 默认的 skip / take 生成的就是 LIMIT offset 模式——平时前几页没感觉,运营导出 / 爬虫翻到深页直接把 DB 打满,慢查询雪崩。
- 游标分页要求排序列唯一且稳定——只用
create_time排序,同一秒多条记录时边界记录会被跳过或重复;带筛选条件时条件列不在索引里,WHERE status=? AND id < lastId走不了索引还是要扫。 - 随机跳页硬套游标——用户点”第 50 页”,游标方案给不出(不知道第 49 页的最后一条),产品需求和方案能力错配。
- 每页都执行精确
COUNT(*)——列表页本身 50ms,count 跑了 2s,优化了半天分页,count 才是真正的慢点。
怎么修补:
- 深翻页场景把 ORM 改成游标模式(Prisma
cursor: { id },TypeORM 手写where id > :lastId),并加页码上限兜底;后台导出走异步任务 + 流式查询,不走 HTTP 分页。 - 排序列做成复合且唯一:排序键
(create_time, id)双列,游标条件(create_time, id) < (lastTime, lastId)(MySQL 行值比较或等价展开);建立联合索引(user_id, create_time, id),保证筛选 + 排序 + 游标全程走索引。 - 跳页需求单独用子查询延迟关联方案或引 ES(from/size 限制上限 + search_after 深翻页),两套方案按产品形态并存。
- 总数改缓存 + 定时刷新(计数服务 / Redis)或 ES 近似值;只在第一页 count,后续翻页复用。
Q26. 单表 5000 万订单要做分库分表,分片键怎么选?在线迁移怎么做才能不停机、不丢数据?
问题类型:存储容量与扩展性类 + 在线迁移。考察点:两段独立的能力——前半段考分片键与全局 ID 设计(写扩散与查询路由),后半段考双写迁移的灰度与回滚,是高级岗最常见的”方案完备性”考题。
怎么解决:
- 先判断要不要拆。
- B+ 树单表经验值 2000 万左右:树高从 3 层变 4 层,索引热点页装不进 buffer pool,磁盘 IO 放大;
- 但先穷尽垂直优化(索引、SQL、归档冷数据、读写分离),拆分是最后手段——一旦拆了几乎不可逆。
- 垂直拆先于水平拆。
- 按业务域拆库(订单库 / 库存库 / 用户库,与微服务边界对齐);
- 单库压力下来后,再对订单表水平拆。
- 分片键选择(灵魂)。
- 按最高频、最核心的查询维度选:电商订单 90% 的查询是”买家查我的订单” → 按
user_idhash 分 16 库 × 32 表; - 卖家维度的查询用异构:binlog 同步一份按
seller_id分片的索引表(或同步到 ES——learnhub 的 ES 就承担这种第二查询视图),查到 order_id 再回主表; - 取舍一句话:用数据冗余换查询路由能力。
- 按最高频、最核心的查询维度选:电商订单 90% 的查询是”买家查我的订单” → 按
- 路由算法。
user_id % 64简单但扩容要迁数据;- 一致性哈希 / 翻倍扩容(16 → 32 库只迁移一半数据);
- 基因法:分库数固定,订单号里嵌入 user_id 后缀的分片基因(如 user_id 后 6 位拼进订单号),通过订单号也能直接路由,免二级索引表——电商”买家查 + 客服按单号查”两个维度都 O(1) 定位。
- 全局 ID。
- 自增 ID 跨表会重复,用雪花算法:41 位时间戳 + 10 位机器 + 12 位序列,趋势递增利于 B+ 树插入(顺序写,不触发频繁页分裂);
- 时钟回拨三连:等待时间追平(最常用)/ 备用序列位 / 独立时间源;或号段模式(Leaf)预取号段做高可用兜底。
- 跨分片查询与事务。
- 分页 / 排序:各分片并发查 + 内存归并(优先队列);
- 跨库事务避免 2PC,用本地消息表 + MQ 最终一致(与 Q5 打通);
- 统计类走异构后的 ES / 数仓,不在 64 个分片上跑聚合。
- 在线迁移五步法(不停机核心)。
- a. 双写开闸:应用写老库(主)+ 异步写新库(从),老库仍是事实源;新库写失败只记日志不影响主流程;
- b. 存量同步:全量把老库 5000 万导入新库(按主键区间分批、限流);
- c. 增量追平 + 校验:binlog 订阅(Debezium / Canal)补齐双写期间的增量;对账工具逐区间比对(数量 + 内容抽样),一致率 100% 才进下一步;
- d. 灰度切读:按 1% → 10% → 50% → 100% 把读流量切到新库,每档观察 RT / 错误率,随时可回切(读回滚零成本);
- e. 切写 + 收尾:读写全切新库,双写保留一段时间作为回滚保险,观察一两周后下线老库、删除双写代码。
- 回滚预案贯穿全程:切读可回滚(改配置)、切写前老库始终最新(双写以老库为主)——任何一步发现问题都能退回上一个稳定态。
有哪些坑:
- 分片键选错——按订单号分片,结果”买家查订单列表”每次广播 64 个分片再归并,DB 集群整体被单接口拖垮;这是分库分表失败的头号原因,事后换分片键 ≈ 推倒重来。
- 双写阶段新库写失败被忽略——“反正老库是主,新库失败无所谓”的侥幸,导致存量同步完成后校验永远对不平,切读一拖再拖。
- 切读瞬间数据不一致——增量 binlog 有延迟,切流量那一刻新库还差几秒数据,用户看到”刚下的订单消失”;更严重的是切读期间老库还在被写,某条更新只落了老库。
- 跨分片分页归并错乱——每片
LIMIT 100直接取前 100 合并,第 2 页的数据可能混在第 1 页里(各分片数据分布不均),翻页出现重复 / 遗漏。 - 迁移脚本一把梭——5000 万单线程全量同步跑了三天,增量越积越多追平遥遥无期;或同步把老库读挂了,影响线上交易。
怎么修补:
- 分片键以查询流量 TOP1 的维度为准(拿埋点 / 日志统计说话,不拍脑袋);第二维度一律异构(索引表 / ES / 数仓),主表只服务主维度——为最热的查询路径做物理设计。
- 双写新库失败落补偿表 + 定时任务重放(classic/22 的定时任务正是这种补偿角色),并接入对账:不一致自动修复 + 告警,不带病进入切读阶段。
- 切读前置条件硬卡:binlog 延迟 < 1s 持续 30 分钟 + 对账一致率 100%;切读期间保持双写且以老库为准,新库只是影子;灰度按用户维度切,同一用户要么全读老要么全读新,避免读到中间态。
- 跨分片分页用归并正确的方法:每片多取(page_size + 已归并跳过数)或禁止跳页改游标(与 Q10 呼应);TopN 每片取 N 再归并没问题,深度跳页直接限制或走 ES。
- 全量同步按主键区间分片并发 + 限流(每批 5000 行,QPS 压在老库可承受范围),优先从从库导数据;增量以 binlog 为唯一来源(双写只是兜底),保证追平有终点。
Q27. 缓存雪崩、击穿、穿透分别是什么?大促时某个热点 key 每秒几十万请求,怎么扛?
问题类型:可用性 / 稳定性类。三件套是缓存体系的”必考默写题”,区分度在于能不能把三者的触发条件和对策一一对应,以及热点 key 这种”单点物理极限”问题的组合拳解法。
怎么解决:
- 先把三个概念一句话钉死。
- 穿透:查的 key 在缓存和 DB 里都不存在(恶意遍历 id / 恶意攻击),每次都打穿到 DB;
- 击穿:某个热点 key 在某个瞬间过期,万级并发同时回源重建,DB 被瞬时打挂(一 key 定生死);
- 雪崩:大量 key 同一时刻集体过期(或 Redis 整体宕机),请求洪峰整体砸向 DB。
- 穿透的对策。
- 缓存空值:DB 查不到也回填空标记(短 TTL,30s~5min),同一个非法 id 只打一次 DB;
- 布隆过滤器前置:所有合法 id 预先入过滤器,请求先问布隆,“不存在”直接返回,连 Redis 都不用查;
- 入口参数校验(id 格式、范围),非法请求挡在最外层。
- 击穿的对策。
- 互斥锁重建:缓存失效时只放一个请求去查 DB 重建,其余等待 / 自旋重读缓存(锁粒度是这个 key);
- 逻辑过期:key 不设物理 TTL,value 里带过期时间,发现”逻辑过期”返回旧值并异步触发重建,读请求永不回源。
- 雪崩的对策。
- TTL 加随机抖动(
TTL = base + random(0, 300s)),把过期时间摊开,消灭”同一时刻集体失效”; - Redis 集群 / 哨兵保住缓存本身的高可用;
- DB 侧限流熔断兜底(Q6 组合拳)——即使缓存整体挂了,DB 也只接过载阈值内的请求,系统”降速”而不”雪崩”。
- TTL 加随机抖动(
- 热点 key(单 key 几十万 QPS)——单 key 物理上只能落在一个分片,网卡 / CPU 有极限,方案是组合拳:
- 本地缓存 L1:应用进程内缓存(Caffeine / lru-cache,1~5s 超短 TTL),几十万 QPS 里 90% 在进程内消化,Redis 只兜 miss——经典多级缓存(浏览器 → CDN → 本地 → Redis → DB);
- key 副本拆分:热点 key 复制 N 份(
hot:key:0~hot:key:9),写时同步 N 份,读时随机挑一份,单 key QPS 直接除以 N; - 读写分离:读走从节点;
- 热点探测 + 预热:大促前把爆品清单提前预热进缓存和本地缓存,不靠第一次请求冷启动。
- 只存热点数据。
- “Redis 20 万容量 vs DB 2000 万数据”的答案:
allkeys-lru淘汰策略 + 懒加载(被访问才入缓存)+ 已知热点主动预热; - 不做全量加载,避免冷数据污染缓存、挤掉真热点;
- 让有限内存里永远是最热的 20 万。
- “Redis 20 万容量 vs DB 2000 万数据”的答案:
有哪些坑:
- 缓存空值不设 TTL 或 TTL 太长——恶意遍历几百万个不存在 id,每个都存一条空值,Redis 内存被”空值攻击”打爆;TTL 太短又挡不住持续攻击。
- 布隆过滤器被当成万能——它有误判率(说”存在”可能不存在,还是打 DB)且删除困难(标准布隆不支持删除,下架商品一直在过滤器里”存在”);全量重建期间服务抖动。
- 互斥锁重建做成全局锁——一个热点 key 失效,锁的是”整个缓存模块”,所有 key 的重建全串行,RT 整体飙升;或锁没设超时,重建线程异常后死锁,所有请求永远在等锁。
- 同一批数据同一时刻过期——运营凌晨批量导入 10 万个 key,TTL 统一 24h,第二天凌晨 10 万 key 齐刷刷失效,雪崩每天准时上演。
- 本地缓存与 Redis 不一致且无法收敛——N 个实例各自的 L1 内容不同步,更新消息只通知到部分实例,不同机器用户看到的数据不同,而且”哪个实例旧了”都无法定位。
- 逻辑过期返回旧数据的业务接受度没确认——技术侧上线了”永远不阻塞”的逻辑过期,业务侧(价格!库存!)不接受旧值,直接资损事故。
怎么修补:
- 空值 TTL 设短(30s~几分钟)且空值也计入内存预算;攻击场景前置布隆过滤器 + 网关风控(IP / UA 频控),双层过滤。
- 承认布隆的边界并主动讲:误判率 p 与容量 n 一起规划(调到 1% 以下,漏进来的少量请求由空值缓存兜住);需要删除用计数布隆 / 布谷鸟过滤器;重建用”双过滤器交替 + 原子切换”,不中断服务。
- 锁粒度细化到 key 级(
lock:rebuild:{key}),tryLock 带超时快速失败,拿不到锁的请求短暂自旋重读缓存(重建一般几十毫秒);配合逻辑过期双保险:优先返回旧值,重建异步进行。 - TTL = base + random,批量导入场景尤其要加;热点数据 TTL 反而设长甚至不设物理 TTL(用逻辑过期管理),物理上消灭击穿。
- 多级缓存更新用 MQ / binlog 广播失效(所有实例订阅同一失效消息,收到即清本地),本地 TTL(1~5s)保底最坏收敛时间;本地缓存加”实例 + key + 版本”监控,不一致可观测。
- 逻辑过期上线前和业务白纸黑字确认容忍度(容忍几秒旧值?哪些字段不能旧?),不能容忍的字段(价格、库存)不走缓存或走”读时校验版本”。
面试常用量级锚点
方案论证要有数字支撑。背下这一组”锚点”,答题时随口报出量级,和只说”很多""很大”的候选人立刻拉开差距:
| 对象 | 经验量级 | 用在哪道题 |
|---|---|---|
| MySQL 单表 | ~2000 万行(B+ 树 3 层变 4 层) | Q10 / Q11 何时优化、何时拆表 |
| MySQL 单机 QPS | 读几千 / 写一两千(与行大小、索引相关) | 读写分离、加缓存的理由 |
| Redis 单机 QPS | 10 万级(纯内存 + IO 多路复用) | Q1 秒杀为什么敢全量过 Redis |
| Redis 单 key | 单分片物理极限,几十万 QPS 就要警惕 | Q7 / Q12 热点 key 拆分时机 |
| 限流阈值 | 压测容量的 70%~80%,留余量抗突发 | Q6 限流参数怎么定 |
| 雪花算法 | 41 位时间戳可用 69 年,单机每毫秒 4096 个 | Q11 全局 ID 容量论证 |
| Kafka / RabbitMQ 吞吐 | Kafka 单集群百万级,RabbitMQ 十万级 | Q5 选型对比的数字支撑 |
| accessToken 有效期 | 15 分钟;refreshToken 7~30 天 | Q9 双 token 的参数 |
| 延迟双删的延迟 | 主从延迟 P99 的 1 | Q2 的时间参数 |
| 缓存空值 TTL | 30 秒~5 分钟 | Q12 穿透对策 |
| 深分页临界 | offset 过万明显劣化,十万级到秒级 | Q10 何时必须换游标 |
题型 × 坑速查表
面试前 5 分钟扫这张表:每道题最容易踩的坑 + 对应的修补关键词,足够在追问里稳住。
| # | 题目 | 题型 | 最高频的坑 | 修补关键词 |
|---|---|---|---|---|
| Q1 | 秒杀系统 | 高并发吞吐 | 判重与扣减两步非原子超卖;Redis 扣成功 MQ 丢失少卖;DB 无 num>0 兜底 | Lua 原子扣减;本地消息表 + 对账回滚;DB 条件更新最后防线 |
| Q2 | 缓存一致性 | 数据一致性 | 先更库后删缓存删除失败;先删缓存旧值被回填;从库延迟读到旧数据 | binlog 订阅统一失效;延迟双删;TTL 兜底 |
| Q3 | 接口幂等 | 数据一致性 | token 先查再删非原子;唯一索引冲突抛 500;select-then-update 状态击穿 | GETDEL / Lua 原子消费;冲突转返回原结果;条件 UPDATE 判影响行数 |
| Q4 | 分布式锁 | 互斥正确性 | SETNX+EXPIRE 两步死锁;删了别人的锁;主从切换锁丢失;业务超时锁提前过期 | SET NX PX 单命令;唯一 value + Lua 释放;etcd 强一致;看门狗续期 + fencing token |
| Q5 | MQ 不丢 | 可靠性容错 | 发后即忘;broker 内存存储;自动 ack;毒消息无限重投堆积 | confirm/acks + 本地消息表;持久化 + 副本;手动 ack + 死信队列 + 有限退避 |
| Q6 | 超时重试风暴 | 可靠性容错 | 不设超时线程耗尽;多层重试放大 27 倍;无退避集中重试;熔断恢复抖动 | 全链路超时预算;重试只做一层 + 指数退避 + jitter;half-open 小流量探测 + 降级预案 |
| Q7 | 计数 / 排行榜 | 高并发读写 | ZSET 同分按字典序;判重与计数不原子;只写 Redis 宕机丢数据;单 key 热点 | score 复合编码(分数 + 反向时间戳);Lua 原子化;MQ 落库 + 定时对账;子 key 拆分 |
| Q8 | 附近的人 | 空间索引 | 高频上报写放大;geohash 边界漏人;单 key 亿级成员;隐私残留 | 距离阈值节流;相邻格子 + 距离精筛;按城市拆 key + 时间清理;关闭即 ZREM + 位置模糊化 |
| Q9 | Session / JWT | 架构取舍 | Session 本地存 + 轮询负载失衡;长 access 泄露;payload 放敏感信息;refresh 不旋转被重放 | Redis 集中 Session;双 token 短 access;jti 黑名单 / tokenVersion;refresh 一次性旋转 |
| Q10 | 深分页 | 数据库性能 | ORM skip/take 生成 LIMIT offset;排序键不唯一游标错乱;每页精确 COUNT | 游标分页 + 复合索引 (lastTime, id);子查询延迟关联保跳页;count 缓存 / 近似 |
| Q11 | 分库分表迁移 | 存储扩展 | 分片键选错全广播;双写失败被忽略;切读时增量未追平;跨分片归并错乱 | 按最热查询选键 + ES 异构;补偿表 + 对账达标才切;binlog 延迟 <1s 前置条件;深跳页走游标 |
| Q12 | 雪崩 / 击穿 / 穿透 | 可用性 | 空值无 TTL 被打爆;全局锁重建;批量导入同一 TTL 集体过期;L1 多实例不收敛 | 短 TTL 空值 + 布隆前置;key 级锁 + 逻辑过期;TTL 加随机抖动;MQ 广播失效 + 本地 TTL 保底 |
最后一条通用心法:所有”坑”本质上分三类——
- 非原子:两步操作之间插进了并发(Q1 扣减、Q3 token、Q4 释放锁、Q7 判重计数);
- 无兜底:单点成功就当全部成功,失败路径没人管(Q2 删除失败、Q5 发后即忘、Q11 双写失败);
- 无边界:重试无限、TTL 统一、集合无上限、锁无超时(Q6 重试风暴、Q8 全量成员、Q12 雪崩)。
设计方案时把每一层都问一遍”并发插进来会怎样?失败了谁兜底?会不会无限增长?“,坑就提前消灭在纸上;面试时把这话说出来,就是系统设计高分的分水岭。