1
┌───────────────────────────────────┐
2
│  JS 代码（业务逻辑）              │
3
├───────────────────────────────────┤
4
│  Node.js 标准库                   │
5
│  (http/fs/net/stream/events...)  │
6
├───────────────────────────────────┤
7
│  C++ Bindings（JS ↔ C++ 桥接）    │
8
├──────────────────┬────────────────┤
9
│   V8 引擎        │    libuv       │
10
│  （执行 JS）      │ （异步 I/O）    │
11
└──────────────────┴────────────────┘

1
传统多线程模型（Apache 老版本）：
2
每个请求 → 创建一个线程 → 阻塞等待 I/O → 返回响应
3
问题：
4
- 线程创建/切换开销大
5
- 内存占用高（每线程 ~1MB 栈）
6
- C10K 问题（万级连接就撑不住）
7

8
Node.js 事件驱动模型：
9
每个请求 → 注册回调 → 立即返回 → 主线程处理下一个请求
10
       ↓ I/O 完成
11
    libuv 线程池处理 → 事件循环触发回调 → 返回响应
12

13
关键点：
14
1. 主线程不阻塞：I/O 交给操作系统 / libuv 线程池
15
2. 单线程避免了锁竞争和上下文切换
16
3. 内存占用低：每连接 ~几 KB
17
4. libuv 默认线程池 4 个（可调 UV_THREADPOOL_SIZE 至 1024）
18

19
真实数据：
20
- Node.js 单进程可支持 5万+ 并发连接
21
- 传统 Apache 每线程模型：几千连接就 OOM

1
require('xxx') 查找顺序：
2

3
1. 核心模块（http/fs/path 等）→ 直接返回
4
2. 路径模块（./ ../ /）→ 按路径查找
5
3. 非路径模块（lodash）→ node_modules 查找
6
   从当前目录逐级向上查找 node_modules
7
   找到后：
8
   a. 有 package.json 且声明 main → 加载 main
9
   b. 无 package.json 或无 main → 依次尝试
10
      index.js → index.json → index.node
11

12
文件扩展名解析顺序：
13
.js → .json → .node（C++ 插件）→ .mjs（ESM）
14

15
模块缓存：
16
- 加载过的模块缓存在 require.cache
17
- 同一模块多次 require 只执行一次
18
- 可通过 delete require.cache[路径] 强制重载（测试常用）

1
Node.js 事件循环（基于 libuv）分 6 个阶段：
2

3
   ┌───────────────────────────┐
4
┌─>│           timers          │  执行 setTimeout/setInterval 回调
5
│  ├───────────────────────────┤
6
│  │     pending callbacks     │  执行延迟到下一轮的 I/O 回调
7
│  ├───────────────────────────┤
8
│  │       idle, prepare       │  内部使用
9
│  ├───────────────────────────┤
10
│  │           poll            │  ★ 最重要：获取新的 I/O 事件
11
│  │                           │  执行 I/O 回调（文件、网络）
12
│  │                           │  适当时阻塞等待
13
│  ├───────────────────────────┤
14
│  │           check           │  执行 setImmediate 回调
15
│  ├───────────────────────────┤
16
│  │      close callbacks      │  执行 close 事件回调
17
│  └───────────────────────────┘
18

19
与浏览器的差异：
20

21
1. 微任务清空时机
22
   浏览器：每次宏任务后清空
23
   Node 11 前：每【阶段】结束后清空
24
   Node 11+：与浏览器对齐（每个宏任务后清空）
25

26
2. 独有 API
27
   process.nextTick：优先级最高，当前操作完成后立即执行
28
   setImmediate：check 阶段执行
29

30
3. 优先级顺序：
31
   process.nextTick > Promise.then > setTimeout ≈ setImmediate

1
// 经典输出题
2
setTimeout(() => console.log('timeout'), 0);
3
setImmediate(() => console.log('immediate'));
4
// 主模块中：顺序不确定（取决于进程启动耗时）
5
// 若在 I/O 回调中：immediate 总是先执行
6

7
// process.nextTick vs Promise
8
Promise.resolve().then(() => console.log('promise'));
9
process.nextTick(() => console.log('nextTick'));
10
// 输出：nextTick → promise
11

12
// nextTick 递归会阻塞事件循环！
13
function recursive() {
14
  process.nextTick(recursive);   // 永远轮不到 I/O
15
}
16
// 应该用 setImmediate 递归
17

18
// 综合题
19
async function async1() {
20
  console.log('async1 start');
21
  await async2();
22
  console.log('async1 end');
23
}
24
async function async2() { console.log('async2'); }
25
console.log('script start');
26
setTimeout(() => console.log('setTimeout'), 0);
27
async1();
28
new Promise(resolve => {
29
  console.log('promise1');
30
  resolve();
31
}).then(() => console.log('promise2'));
32
console.log('script end');
33

34
// 输出顺序：
35
// script start
36
// async1 start
37
// async2
38
// promise1
39
// script end
40
// async1 end
41
// promise2
42
// setTimeout

1
// Buffer：Node.js 提供的二进制数据容器
2
// JS 原生只有字符串和数组，无法高效处理 TCP 流、文件、图片等二进制数据
3

4
// 创建 Buffer
5
const buf1 = Buffer.alloc(10);              // 10 字节，初始化为 0
6
const buf2 = Buffer.allocUnsafe(10);        // 10 字节，未初始化（快但可能泄漏旧数据）
7
const buf3 = Buffer.from([1, 2, 3]);        // 从数组
8
const buf4 = Buffer.from('hello');          // 从字符串（默认 utf-8）
9
const buf5 = Buffer.from('hello', 'base64');// 指定编码
10

11
// 编码转换
12
buf4.toString('utf8');      // 'hello'
13
buf4.toString('base64');    // 'aGVsbG8='
14
buf4.toString('hex');       // '68656c6c6f'
15

16
// 常见操作
17
Buffer.concat([buf1, buf2]);       // 拼接
18
buf1.write('abc', 0);              // 写入
19
buf1.slice(0, 5);                  // 切片（共享内存，不是拷贝！）
20
buf1.equals(buf2);                 // 比较
21
buf1.length;                       // 字节长度（不是字符长度）
22

23
// Buffer vs Uint8Array
24
// Buffer 是 Uint8Array 的子类，Node.js API 都接受两者
25
// 但 Buffer 有更多便捷方法（toString/alloc 等）
26

27
// 内存管理：
28
// Buffer 分配在 V8 堆外（不受 GC 精确管理）
29
// 大量小 Buffer 建议用 Buffer.allocUnsafe + 手动清零
30
// 或用 Buffer pool（Node 内部有 8KB pool）

1
Stream（流）：处理流式数据的抽象接口
2
适用于：大文件、实时数据、网络传输
3

4
核心优势：
5
- 内存友好：不用一次性加载全部数据
6
- 时间友好：边读边处理，不用等全部就绪
7

8
四种 Stream 类型：
9
┌──────────────┬─────────────────────────────┐
10
│ Readable     │ 可读流（数据源）             │
11
│              │ 例：fs.createReadStream      │
12
│              │     process.stdin            │
13
│              │     http 请求 body           │
14
├──────────────┼─────────────────────────────┤
15
│ Writable     │ 可写流（数据目的地）         │
16
│              │ 例：fs.createWriteStream     │
17
│              │     process.stdout           │
18
│              │     http 响应                │
19
├──────────────┼─────────────────────────────┤
20
│ Duplex       │ 双向流（既可读又可写）       │
21
│              │ 例：net.Socket               │
22
│              │     WebSocket                │
23
├──────────────┼─────────────────────────────┤
24
│ Transform    │ 转换流（读写并转换数据）     │
25
│              │ 例：zlib.createGzip          │
26
│              │     crypto.createCipheriv     │
27
└──────────────┴─────────────────────────────┘

1
// 大文件复制（错误做法：内存爆炸）
2
const data = fs.readFileSync('huge.mp4');      // 4GB 内存！
3
fs.writeFileSync('copy.mp4', data);
4

5
// 正确做法：Stream
6
fs.createReadStream('huge.mp4')
7
  .pipe(fs.createWriteStream('copy.mp4'));     // 分块传输，内存占用小
8

9
// pipe 的进阶用法（gzip 压缩）
10
fs.createReadStream('data.txt')
11
  .pipe(zlib.createGzip())
12
  .pipe(fs.createWriteStream('data.txt.gz'));
13

14
// Stream 三大事件
15
const rs = fs.createReadStream('data.txt');
16
rs.on('data', chunk => console.log('收到 chunk', chunk.length));
17
rs.on('end', () => console.log('读取完成'));
18
rs.on('error', err => console.error('出错', err));
19

20
// 背压（Backpressure）
21
// 问题：读得快、写得慢 → 数据积压在内存
22
// pipe 自动处理背压
23
// 手动处理：
24
const rs = fs.createReadStream('in.txt');
25
const ws = fs.createWriteStream('out.txt');
26
rs.on('data', chunk => {
27
  const ok = ws.write(chunk);
28
  if (!ok) {
29
    rs.pause();                                  // 暂停读
30
    ws.once('drain', () => rs.resume());         // 排空后恢复
31
  }
32
});
33

34
// Stream 组合（pipeline，Node 10+，推荐替代 pipe）
35
const { pipeline } = require('stream/promises');
36
await pipeline(
37
  fs.createReadStream('in.txt'),
38
  zlib.createGzip(),
39
  fs.createWriteStream('in.txt.gz')
40
);
41
// pipeline 优势：自动清理、错误传播、支持 Promise
42

43
// Stream 在 Web 标准中的对应
44
// Node.js Stream ↔ Web Streams API（ReadableStream/WritableStream）
45
// Node 18+ 两者可互转：Readable.toWeb() / Readable.fromWeb()

1
// 1. child_process —— 创建子进程
2
const { spawn, exec, fork, execFile } = require('child_process');
3

4
// spawn：流式输出，适合长时间运行、大数据量
5
const child = spawn('ls', ['-la']);
6
child.stdout.on('data', d => console.log(d.toString()));
7
child.on('close', code => console.log('退出码', code));
8

9
// exec：缓冲输出，适合短命令
10
exec('ls -la', (err, stdout, stderr) => console.log(stdout));
11

12
// fork：spawn 的特例，创建 Node 子进程 + IPC 通道
13
const worker = fork('./worker.js');
14
worker.send({ task: 'compute' });
15
worker.on('message', result => console.log(result));
16

17
// 2. cluster —— 多进程共享端口（利用多核 CPU）
18
const cluster = require('cluster');
19
const os = require('os');
20

21
if (cluster.isPrimary) {
22
  const numCPUs = os.cpus().length;
23
  for (let i = 0; i < numCPUs; i++) cluster.fork();
24

25
  cluster.on('exit', (worker) => {
26
    console.log(`Worker ${worker.process.pid} 挂了，重启`);
27
    cluster.fork();                              // 自动重启
28
  });
29
} else {
30
  require('./server.js');                        // 每个 Worker 运行 HTTP 服务
31
  // 内核负责负载均衡（Linux 上由内核分发，Windows 由 primary 轮询）
32
}
33

34
// 3. worker_threads —— 线程（Node 12+）
35
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
36

37
if (isMainThread) {
38
  const worker = new Worker(__filename, { workerData: { num: 42 } });
39
  worker.on('message', result => console.log('计算结果', result));
40
  worker.on('error', err => console.error(err));
41
} else {
42
  // 在 worker 线程中执行 CPU 密集任务
43
  const result = heavyCompute(workerData.num);
44
  parentPort.postMessage(result);
45
}
46

47
// worker_threads vs child_process：
48
// - 线程共享内存（SharedArrayBuffer），通信更快
49
// - 内存开销小（进程 ~30MB，线程 ~5MB）
50
// - 但隔离性弱，一个线程崩溃可能影响主线程
51

52
// 选型建议：
53
// - Web 服务多核负载均衡 → cluster（生产用 PM2 cluster 模式）
54
// - CPU 密集计算（图片处理、加密）→ worker_threads
55
// - 调用外部命令 / 独立子任务 → child_process

1
1. stdio 管道（child_process.spawn 默认）
2
   父进程 ← stdin/stdout/stderr → 子进程
3

4
2. IPC 通道（child_process.fork / cluster）
5
   process.send() / process.on('message')
6
   基于 socket / named pipe
7

8
3. 信号（Signal）
9
   process.kill(pid, 'SIGTERM')
10
   process.on('SIGTERM', () => cleanup())
11

12
4. 共享内存（worker_threads）
13
   SharedArrayBuffer + Atomics
14

15
5. 网络通信（跨机器）
16
   HTTP / WebSocket / gRPC / TCP
17

18
6. 消息队列（跨服务）
19
   Redis Pub/Sub / RabbitMQ / Kafka
20

21
7. 文件锁 / 命名管道
22
   适合无亲缘关系进程
23

24
Node.js 常用：
25
- fork() 自带 IPC 通道，最简单
26
- cluster 内部用 IPC 做进程管理
27
- PM2 通过 IPC 实现进程监控和零停机重启

1
const http = require('http');
2
const url = require('url');
3

4
const server = http.createServer((req, res) => {
5
  const { pathname, query } = url.parse(req.url, true);
6

7
  // 设置 CORS
8
  res.setHeader('Access-Control-Allow-Origin', '*');
9
  res.setHeader('Content-Type', 'application/json; charset=utf-8');
10

11
  // 路由分发
12
  if (req.method === 'GET' && pathname === '/api/users') {
13
    res.writeHead(200);
14
    res.end(JSON.stringify({ users: [] }));
15
  } else if (req.method === 'POST' && pathname === '/api/users') {
16
    // 读取请求 body（Stream）
17
    let body = '';
18
    req.on('data', chunk => body += chunk);
19
    req.on('end', () => {
20
      const data = JSON.parse(body);
21
      res.writeHead(201);
22
      res.end(JSON.stringify({ id: 1, ...data }));
23
    });
24
  } else {
25
    res.writeHead(404);
26
    res.end(JSON.stringify({ error: 'Not Found' }));
27
  }
28
});
29

30
server.listen(3000, () => console.log('Server on :3000'));
31

32
// 原生 HTTP 的痛点：
33
// 1. 路由分发要手写 if/else
34
// 2. body 解析要手动收集 Stream
35
// 3. 中间件（日志、鉴权、错误处理）没有统一机制
36
// 4. 静态文件服务要自己实现
37
// → 所以有 Express / Koa / Fastify / NestJS

1
// Express：最主流，回调风格
2
const express = require('express');
3
const app = express();
4
app.use(express.json());                        // 中间件
5
app.get('/users/:id', (req, res) => {
6
  res.json({ id: req.params.id });
7
});
8
app.use((err, req, res, next) => {              // 错误处理中间件
9
  res.status(500).json({ error: err.message });
10
});
11
app.listen(3000);
12

13
// Koa：洋葱模型（async/await）
14
const Koa = require('koa');
15
const app = new Koa();
16
app.use(async (ctx, next) => {
17
  const start = Date.now();
18
  await next();                                  // 执行下游
19
  ctx.set('X-Response-Time', `${Date.now() - start}ms`);
20
});
21
app.use(async ctx => { ctx.body = 'Hello'; });
22
app.listen(3000);
23

24
// Fastify：高性能 + Schema 校验
25
const fastify = require('fastify')();
26
fastify.get('/users/:id', {
27
  schema: {
28
    params: { type: 'object', properties: { id: { type: 'string' } } },
29
    response: { 200: { type: 'object', properties: { id: { type: 'string' } } } }
30
  }
31
}, async (req, reply) => ({ id: req.params.id }));
32
fastify.listen({ port: 3000 });
33

34
// NestJS：装饰器 + 依赖注入 + 模块化
35
@Controller('users')
36
export class UserController {
37
  constructor(private readonly userService: UserService) {}
38

39
  @Get(':id')
40
  async findOne(@Param('id') id: string) {
41
    return this.userService.findOne(id);
42
  }
43
}
44
// NestJS 底层默认用 Express，可切换到 Fastify

1
// 中间件像洋葱，请求进入时顺序执行，响应返回时逆序执行
2
app.use(async (ctx, next) => {
3
  console.log('1 进入');
4
  await next();
5
  console.log('6 返回');
6
});
7
app.use(async (ctx, next) => {
8
  console.log('2 进入');
9
  await next();
10
  console.log('5 返回');
11
});
12
app.use(async (ctx) => {
13
  console.log('3 处理');
14
  ctx.body = 'hello';
15
  console.log('4 处理完');
16
});
17

18
// 输出：1进入 → 2进入 → 3处理 → 4处理完 → 5返回 → 6返回
19

20
// 洋葱模型的价值：
21
// - 日志统计耗时（await next() 前后）
22
// - 事务管理（await next() 前开启，后提交/回滚）
23
// - 响应统一包装
24
// - 错误捕获（try/catch await next()）

1
// MySQL
2
const mysql = require('mysql2/promise');
3
const pool = mysql.createPool({
4
  host: 'localhost', user: 'root', password: 'xxx',
5
  database: 'test', waitForConnections: true,
6
  connectionLimit: 10,                           // 连接池大小
7
  queueLimit: 0,
8
});
9
const [rows] = await pool.execute('SELECT * FROM users WHERE id = ?', [1]);
10

11
// Redis
12
const Redis = require('ioredis');
13
const redis = new Redis({ host: 'localhost', port: 6379, db: 0 });
14
await redis.set('key', 'value', 'EX', 3600);     // 1 小时过期
15
const val = await redis.get('key');
16

17
// MongoDB
18
const { MongoClient } = require('mongodb');
19
const client = new MongoClient('mongodb://localhost:27017');
20
await client.connect();
21
const db = client.db('test');
22
const users = await db.collection('users').find({}).toArray();
23

24
// ORM 方案
25
// 1. Prisma（现代、TS 友好、DX 最好）
26
const { PrismaClient } = require('@prisma/client');
27
const prisma = new PrismaClient();
28
const user = await prisma.user.findUnique({ where: { id: 1 } });
29

30
// 2. TypeORM（装饰器风格，NestJS 默认）
31
@Entity()
32
class User {
33
  @PrimaryGeneratedColumn() id: number;
34
  @Column() name: string;
35
}
36
const user = await repo.findOne({ where: { id: 1 } });
37

38
// 3. Sequelize（老牌，功能全）
39
const User = sequelize.define('User', { name: DataTypes.STRING });
40
const user = await User.findByPk(1);
41

42
// 4. Mongoose（MongoDB ODM）
43
const User = mongoose.model('User', new Schema({ name: String }));
44
const user = await User.findById(id);
45

46
// 选型建议：
47
// - 新项目、TypeScript → Prisma（首推）
48
// - NestJS 项目 → TypeORM
49
// - 复杂 SQL、多数据库 → Sequelize
50
// - MongoDB → Mongoose

1
问题：每次请求都创建/销毁数据库连接
2
- TCP 三次握手 + 认证 → 每次开销 ~50-100ms
3
- 数据库连接数有限（MySQL 默认 151）
4
- 高并发下连接数暴涨 → 数据库崩溃
5

6
连接池：预先创建 N 个连接，复用
7
┌──────────────────────────────┐
8
│      连接池（Connection Pool）│
9
│  ┌────┐┌────┐┌────┐┌────┐    │
10
│  │ C1 ││ C2 ││ C3 ││ C4 │ …  │
11
│  └────┘└────┘└────┘└────┘    │
12
└──────────────────────────────┘
13
       ↑       ↓
14
   请求获取  用完归还
15

16
关键配置：
17
- connectionLimit：最大连接数（一般 = CPU 核数 × 2 + 磁盘数）
18
- queueLimit：等待队列长度
19
- idleTimeout：空闲连接超时回收
20
- acquireTimeout：获取连接超时
21

22
Node.js 各库默认都有连接池：
23
- mysql2: createPool()
24
- pg: new Pool()
25
- Redis: ioredis 内置
26
- Mongoose: 内置
27

28
连接池监控：
29
- 活跃连接数 / 空闲连接数 / 等待队列长度
30
- 连接泄漏检测（长时间未归还）

1
1. CPU 密集任务处理
2
   - Worker Threads（首选）
3
   - 任务队列（Bull / BullMQ + Redis）
4
   - 微服务拆分（专门的服务处理计算任务）
5

6
2. I/O 优化
7
   - 使用异步 API（fs.promises 而非 fs sync）
8
   - 连接池（数据库、Redis、HTTP Agent）
9
   - HTTP Keep-Alive（复用 TCP 连接）
10
   - 批处理（bulk insert、pipeline）
11

12
3. 缓存策略
13
   - 内存缓存：LRU-Cache / node-cache（进程内，最快）
14
   - 分布式缓存：Redis（多实例共享）
15
   - HTTP 缓存：ETag / Last-Modified / Cache-Control
16
   - 多级缓存：内存 → Redis → 数据库
17

18
4. 内存管理
19
   - 避免大对象（用 Stream 处理大文件）
20
   - 及时释放引用（避免闭包持有大数据）
21
   - 监控 V8 堆：process.memoryUsage()
22
   - 排查内存泄漏：--inspect + Chrome DevTools 拍堆快照
23

24
5. 代码层面
25
   - 避免同步 API（fs.readFileSync 阻塞事件循环）
26
   - JSON 大对象序列化用 fast-json-stringify（基于 Schema）
27
   - 正则避免灾难性回溯（用 safe-regex 检查）
28
   - 减少闭包和函数创建（V8 优化）
29

30
6. 部署层面
31
   - Cluster / PM2 多进程利用多核
32
   - Docker 容器化 + K8s 水平扩展
33
   - Nginx 反向代理 + 负载均衡 + 静态资源
34
   - CDN 加速静态资源
35
   - Gzip / Brotli 压缩
36

37
7. 监控工具
38
   - clinic.js（诊断 Node.js 性能问题）
39
   - 0x（火焰图）
40
   - node --prof（V8 profiler）
41
   - Prometheus + Grafana（生产监控）
42
   - APM：New Relic / DataDog / 阿里 ARMS

1
// 性能分析工具 clinic.js
2
// 安装：npm i -g clinic
3
// 使用：
4
clinic doctor -- node server.js       // 综合诊断
5
clinic flame -- node server.js        // 火焰图
6
clinic bubbleprof -- node server.js   // 异步操作分析
7

8
// 内存泄漏排查
9
const v8 = require('v8');
10
const heapStats = v8.getHeapStatistics();
11
console.log(heapStats);
12
// {
13
//   total_heap_size: 20971520,
14
//   used_heap_size: 15728640,
15
//   heap_size_limit: 2197815296,   // 默认 ~2GB（64位）
16
// }
17

18
// 手动触发 GC（需启动参数 --expose-gc）
19
global.gc();
20

21
// HTTP Keep-Alive Agent（复用 TCP 连接）
22
const http = require('http');
23
const agent = new http.Agent({ keepAlive: true, maxSockets: 100 });
24
http.get({ host: 'api.example.com', agent });

1
PM2（Process Manager 2）：Node.js 生产环境进程管理器
2

3
核心功能：
4
1. 守护进程（崩溃自动重启）
5
2. 集群模式（多核负载均衡）
6
3. 零停机重启（reload）
7
4. 日志管理（合并、切割）
8
5. 监控（CPU、内存、重启次数）
9
6. 开机自启
10

11
常用命令：
12
pm2 start app.js --name myapp         # 启动
13
pm2 start app.js -i max               # 集群模式（max = CPU 核数）
14
pm2 list                              # 查看所有进程
15
pm2 logs myapp                        # 查看日志
16
pm2 monit                             # 实时监控面板
17
pm2 restart myapp                     # 重启（有短暂中断）
18
pm2 reload myapp                      # 零停机重启（滚动更新）
19
pm2 stop myapp                        # 停止
20
pm2 delete myapp                      # 删除
21
pm2 save                              # 保存进程列表
22
pm2 startup                           # 生成开机自启脚本
23

24
配置文件（ecosystem.config.js）：

1
module.exports = {
2
  apps: [{
3
    name: 'myapp',
4
    script: './dist/main.js',
5
    instances: 'max',                    // 集群数（max = CPU 核数）
6
    exec_mode: 'cluster',                // 集群模式
7
    env: {
8
      NODE_ENV: 'production',
9
      PORT: 3000,
10
    },
11
    max_memory_restart: '1G',            // 内存超限自动重启
12
    error_file: './logs/err.log',
13
    out_file: './logs/out.log',
14
    merge_logs: true,
15
    log_date_format: 'YYYY-MM-DD HH:mm:ss',
16
    // 优雅关闭
17
    kill_timeout: 5000,
18
    wait_ready: true,                    // 等待 process.send('ready')
19
    listen_timeout: 10000,
20
  }],
21
};
22

23
// 应用中：
24
process.send('ready');                   // 通知 PM2 应用就绪
25
process.on('SIGINT', () => {             // 优雅关闭
26
  server.close(() => process.exit(0));
27
});

1
# 多阶段构建（镜像最小化）
2

3
# 阶段 1：构建
4
FROM node:20-alpine AS builder
5
WORKDIR /app
6
COPY package*.json ./
7
RUN npm ci --only=production              # 只装生产依赖
8
COPY . .
9
RUN npm run build                         # TS 编译 / 打包
10

11
# 阶段 2：运行
12
FROM node:20-alpine
13
WORKDIR /app
14

15
# 安全：不用 root 用户
16
RUN addgroup -g 1001 -S nodejs && \
17
    adduser -S nodejs -u 1001
18

19
# 只复制构建产物和生产依赖
20
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
21
COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
22
COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
23

24
USER nodejs
25
EXPOSE 3000
26

27
# 健康检查
28
HEALTHCHECK --interval=30s --timeout=3s \
29
  CMD wget --quiet --tries=1 --spider http://localhost:3000/health || exit 1
30

31
# 用 node 直接启动（不用 npm start，让 Node 成为 PID 1，接收 SIGTERM）
32
CMD ["node", "dist/main.js"]

1
1. 依赖漏洞
2
   - npm audit / snyk / socket.dev 扫描
3
   - 定期更新（npm-check-updates）
4
   - lock 文件提交，防止 CI 装到不同版本
5

6
2. XSS（服务端渲染场景）
7
   - 转义用户输入（用模板引擎默认转义，别关闭）
8
   - CSP 响应头（helmet.contentSecurityPolicy）
9
   - 富文本用 sanitize-html / DOMPurify
10

11
3. SQL 注入
12
   - 参数化查询（?占位符），永远别拼字符串
13
   - 用 ORM（Prisma/TypeORM 默认参数化）
14

15
4. CSRF
16
   - SameSite Cookie
17
   - CSRF Token（csurf 中间件）
18
   - 验证 Origin / Referer
19

20
5. 敏感信息泄漏
21
   - 生产环境不返回 stack trace
22
   - .env 文件不进 Git（.gitignore）
23
   - 日志脱敏（手机号、身份证、密码）
24
   - 错误响应不暴露内部信息
25

26
6. HTTP 安全头（helmet 一键搞定）
27
   const helmet = require('helmet');
28
   app.use(helmet());
29
   // 自动设置：
30
   // - X-Content-Type-Options: nosniff
31
   // - X-Frame-Options: SAMEORIGIN
32
   // - Strict-Transport-Security
33
   // - Content-Security-Policy
34
   // - X-XSS-Protection
35

36
7. 速率限制（防 DDoS / 暴力破解）
37
   const rateLimit = require('express-rate-limit');
38
   app.use('/api/', rateLimit({ windowMs: 15*60*1000, max: 100 }));
39

40
8. 请求体大小限制（防内存耗尽）
41
   app.use(express.json({ limit: '1mb' }));
42

43
9. 原型污染
44
   - 避免直接 Object.assign({}, JSON.parse(userInput))
45
   - 用 lodash.merge 前先看 CVE，或换 defu / merge-deep
46
   - 校验 __proto__ / constructor / prototype 键
47

48
10. SSRF（服务端请求伪造）
49
    - 用户传入 URL 时白名单校验
50
    - 禁止内网 IP（10.x / 192.168.x / 127.x）

1
HTTP 客户端：
2
- axios（最流行，Promise API）
3
- node-fetch（fetch API 兼容）
4
- got（功能强大，重试、hooks）
5
- undici（Node 官方，最快，fetch 内置实现）
6

7
参数校验：
8
- zod（TS 友好，运行时校验 + 类型推断）
9
- joi（功能全，Schema 声明式）
10
- yup（前端也用，Formik 搭配）
11
- class-validator（NestJS 默认，装饰器风格）
12

13
日志：
14
- pino（性能最好，JSON 格式）
15
- winston（灵活，多 transport）
16
- consola（美观，Nuxt 默认）
17

18
任务队列：
19
- bull / bullmq（Redis 后端，最流行）
20
- agenda（MongoDB 后端）
21
- bee-queue（轻量 Redis）
22

23
定时任务：
24
- node-cron（Cron 表达式）
25
- node-schedule（更灵活）
26

27
工具库：
28
- lodash（工具函数）
29
- dayjs（日期，moment 替代品）
30
- uuid（生成唯一 ID）
31
- dotenv（.env 加载）
32

33
TypeScript 支持：
34
- ts-node（直接运行 TS）
35
- tsx（更快，基于 esbuild）
36
- @types/node（Node API 类型）
37

38
打包与发布：
39
- esbuild（极快，打包 CLI 工具）
40
- tsup（基于 esbuild 的库打包）
41
- pkg / nexe（打包成单文件可执行）
42
- ncc（@vercel/ncc，打包成单文件）

1
BFF（Backend For Frontend）价值：
2
- 接口聚合（多微服务 → 一个前端接口）
3
- 数据裁剪（只返回前端需要的字段）
4
- 适配多端（Web / App / 小程序不同结构）
5
- 缓冲层（后端变更时 BFF 消化差异）
6
- SSR（服务端渲染）
7

8
NestJS 实现 BFF：

1
// 最简单的 SSR（原生 HTTP + Vue）
2
const { createSSRApp } = require('vue');
3
const { renderToString } = require('vue/server-renderer');
4
const http = require('http');
5

6
http.createServer(async (req, res) => {
7
  const app = createSSRApp({
8
    data: () => ({ message: 'Hello SSR' }),
9
    template: '<div>{{ message }}</div>',
10
  });
11
  const html = await renderToString(app);
12
  res.end(`
13
    <!DOCTYPE html>
14
    <html>
15
      <body>
16
        <div id="app">${html}</div>
17
        <script src="/client.js"></script>
18
      </body>
19
    </html>
20
  `);
21
}).listen(3000);
22

23
// 现代 SSR 框架：
24
// - Next.js（React）：文件路由 + SSR/SSG/ISR + API Routes
25
// - Nuxt 3（Vue）：文件路由 + SSR/SSG + Server API
26
// - Astro：SSG 为主 + 岛屿架构（局部 hydration）
27
// - Remix：SSR + Web 标准 + 嵌套路由
28

29
// SSR 关键问题：
30
// 1. 数据获取：服务端预取（getServerSideProps / useFetch）
31
// 2. 状态脱水/注水：服务端 state → HTML → 客户端 hydration
32
// 3. 环境判断：typeof window === 'undefined' 区分服务端
33
// 4. 内存泄漏：服务端不能持有请求级数据到全局
34
// 5. 性能：缓存渲染结果、流式 SSR、部分 hydration