【NestJS】17 MongoDB 性能优化与生产环境最佳实践

深入掌握 Mongoose 中间件、索引优化、性能调优，构建生产级的数据库应用。

前言 ✨#

在上篇文章中，我们学习了 MongoDB 的基础概念、Mongoose ODM 的使用、Schema 设计以及基本的查询操作。

但在实际项目中，我们还会遇到这些问题：

🤔 如何在保存用户时自动加密密码？
🤔 为什么我的查询这么慢？
🤔 如何优化数据库性能？
🤔 生产环境应该注意什么？

这篇文章将为你解答这些问题。我们将学习：

🎯 中间件与钩子：自动化数据处理
📊 索引设计：让查询快如闪电
⚡ 性能优化：从慢查询到高性能
🛡️ 最佳实践：构建生产级应用
🔍 问题排查：常见问题与解决方案

让我们开始吧！

一、中间件与钩子#

什么是钩子？#

钩子在特定时刻自动执行逻辑，类似生命周期函数。

执行时机：

1
操作触发 → Pre 钩子 → 实际操作 → Post 钩子 → 完成

常用钩子：

pre('save')：保存前
post('save')：保存后
pre('findOneAndUpdate')：更新前
pre('deleteOne')：删除前

实战：密码自动加密#

1
pnpm add bcryptjs
2
pnpm add -D @types/bcryptjs

1
import * as bcrypt from 'bcryptjs';
2

3
@Schema({ timestamps: true })
4
export class User extends Document {
5
  @Prop({ required: true, unique: true })
6
  username: string;
7

8
  @Prop({ required: true, unique: true })
9
  email: string;
10

11
  @Prop({ required: true, minlength: 6 })
12
  password: string;
13
}
14

15
export const UserSchema = SchemaFactory.createForClass(User);
16

17
// ========== Pre Save 钩子：加密密码 ==========
18
UserSchema.pre('save', async function(next) {
19
  // 1. 检查密码是否被修改
20
  if (!this.isModified('password')) {
21
    return next();  // 没修改，跳过
22
  }
23

24
  try {
25
    // 2. 生成盐并加密
26
    const salt = await bcrypt.genSalt(10);
27
    this.password = await bcrypt.hash(this.password, salt);
28
    next();
29
  } catch (error) {
30
    next(error);
31
  }
32
});
33

34
// ========== Post Save 钩子：记录日志 ==========
35
UserSchema.post('save', function(doc) {
36
  console.log(`✅ 用户 ${doc.username} 已保存`);
37
});
38

39
// ========== 实例方法：比对密码 ==========
40
UserSchema.methods.comparePassword = async function(
41
  candidatePassword: string,
42
): Promise<boolean> {
43
  return bcrypt.compare(candidatePassword, this.password);
44
};
45

46
// ========== 实例方法：隐藏敏感字段 ==========
47
UserSchema.methods.toJSON = function() {
48
  const obj = this.toObject();
49
  delete obj.password;
50
  return obj;
51
};

在 Service 中使用：

1
@Injectable()
2
export class UserService {
3
  constructor(
4
    @InjectModel(User.name) private userModel: Model<User>,
5
  ) {}
6

7
  // 注册：密码自动加密
8
  async register(dto: CreateUserDto) {
9
    return this.userModel.create(dto);  // 钩子自动加密
10
  }
11

12
  // 登录：验证密码
13
  async login(email: string, password: string) {
14
    const user = await this.userModel
15
      .findOne({ email })
16
      .select('+password')  // 显式包含密码
17
      .exec();
18

19
    if (!user) {
20
      throw new UnauthorizedException('用户不存在');
21
    }
22

23
    const isValid = await user.comparePassword(password);
24
    if (!isValid) {
25
      throw new UnauthorizedException('密码错误');
26
    }
27

28
    return user;  // 返回时密码已隐藏
29
  }
30
}

工作流程：

1
1. 注册：{ username: 'alice', password: 'password123' }
2
   ↓
3
2. Pre Save 钩子检测到 password 被修改
4
   ↓
5
3. 加密：'password123' → '$2a$10$N9qo8uLO...'
6
   ↓
7
4. 保存到数据库
8
   ↓
9
5. Post Save 钩子打印日志
10
   ↓
11
6. 返回：{ username: 'alice' }（密码已隐藏）

其他常用钩子#

自动更新时间戳：

1
UserSchema.pre('findOneAndUpdate', function(next) {
2
  this.set({ updatedAt: new Date() });
3
  next();
4
});

数据验证：

1
UserSchema.pre('save', async function(next) {
2
  // 检查用户名是否包含敏感词
3
  const bannedWords = ['admin', 'root', 'system'];
4
  if (bannedWords.some(w => this.username.toLowerCase().includes(w))) {
5
    return next(new Error('用户名包含被禁止的词汇'));
6
  }
7
  next();
8
});

钩子注意事项#

1. 必须检查 isModified()：

1
// ✅ 正确
2
UserSchema.pre('save', async function(next) {
3
  if (!this.isModified('password')) return next();
4
  // 加密逻辑...
5
});
6

7
// ❌ 错误：每次保存都加密，会重复加密
8
UserSchema.pre('save', async function(next) {
9
  this.password = await bcrypt.hash(this.password, 10);
10
});

2. 使用普通函数，不用箭头函数：

1
// ✅ 正确：this 指向文档
2
UserSchema.pre('save', async function(next) {
3
  console.log(this.username);
4
});
5

6
// ❌ 错误：this 是 undefined
7
UserSchema.pre('save', async (next) => {
8
  console.log(this.username);  // undefined!
9
});

二、索引设计与性能#

索引的本质#

无索引：扫描所有数据

1
查询 username='alice'
2
扫描 100,000 条 → 平均 50,000 次比较

有索引：B-tree 快速定位

1
查询 username='alice'
2
通过索引 → 只需 3-4 次查找

性能对比：

数据量	无索引	有索引
100	50 次	7 次
10,000	5,000 次	14 次
1,000,000	500,000 次	20 次

索引类型#

1. 单字段索引：

1
@Prop({ index: true })
2
username: string;
3

4
@Prop({ unique: true })  // 唯一索引
5
email: string;
6

7
// 或
8
UserSchema.index({ username: 1 });  // 1=升序, -1=降序

2. 复合索引：

1
// 经常这样查询？
2
find({ status: 'active' }).sort({ createdAt: -1 })
3

4
// 创建复合索引
5
UserSchema.index({ status: 1, createdAt: -1 });
6

7
// ✅ 可以使用的查询
8
find({ status: 'active' })
9
find({ status: 'active' }).sort({ createdAt: -1 })
10

11
// ❌ 不能使用的查询
12
find({ createdAt: { $gte: date } })  // 跳过了第一个字段

3. 唯一索引：

1
UserSchema.index({ email: 1 }, { unique: true });
2
// 确保字段值唯一 + 提高查询性能

4. 稀疏索引：

1
UserSchema.index({ phone: 1 }, { sparse: true });
2
// 允许多个文档该字段为 null
3
// 如果存在，必须唯一

5. 文本索引：

1
UserSchema.index({ bio: 'text', username: 'text' });
2

3
// 全文搜索
4
await this.userModel.find({
5
  $text: { $search: 'developer nodejs' }
6
});

6. TTL 索引：

1
// 验证码 Schema
2
@Schema()
3
export class VerificationCode extends Document {
4
  @Prop() code: string;
5
  @Prop({ type: Date, default: Date.now })
6
  createdAt: Date;
7
}
8

9
// 1 小时后自动删除
10
VerificationCodeSchema.index(
11
  { createdAt: 1 },
12
  { expireAfterSeconds: 3600 }
13
);

查询性能分析#

使用 explain() 分析：

1
const explanation = await this.userModel
2
  .find({ status: 'active' })
3
  .explain('executionStats');

关键指标：

1
{
2
  executionStats: {
3
    nReturned: 5000,           // 返回 5000 条
4
    totalDocsExamined: 5000,   // 检查 5000 条
5
    executionTimeMillis: 15,   // 耗时 15ms
6
    executionStages: {
7
      stage: 'IXSCAN'          // 索引扫描（好）
8
      // stage: 'COLLSCAN'     // 全表扫描（坏）
9
    }
10
  }
11
}

性能判断：

1
// ✅ 好：使用索引，只检查需要的文档
2
nReturned: 100
3
totalDocsExamined: 100
4
stage: 'IXSCAN'
5

6
// ❌ 坏：全表扫描
7
nReturned: 100
8
totalDocsExamined: 1000000
9
stage: 'COLLSCAN'

索引设计最佳实践#

1. ESR 规则（Equality, Sort, Range）：

1
// 查询
2
find({
3
  status: 'active',           // Equality（等值）
4
  age: { $gte: 18, $lte: 30 } // Range（范围）
5
}).sort({ createdAt: -1 });   // Sort（排序）
6

7
// 索引顺序：E → S → R
8
UserSchema.index({
9
  status: 1,      // 1. Equality
10
  createdAt: -1,  // 2. Sort
11
  age: 1,         // 3. Range
12
});

2. 选择性原则：

1
// ✅ 好：选择性高的字段优先
2
UserSchema.index({ email: 1, status: 1 });
3
// email 选择性高（每个用户不同）
4
// status 选择性低（只有 3 个值）
5

6
// ❌ 不好
7
UserSchema.index({ status: 1, email: 1 });

3. 避免过多索引：

1
// ❌ 不好：索引太多
2
UserSchema.index({ username: 1 });
3
UserSchema.index({ email: 1 });
4
UserSchema.index({ status: 1 });
5
UserSchema.index({ age: 1 });
6
UserSchema.index({ createdAt: 1 });
7
// 问题：占内存、写入慢
8

9
// ✅ 好：只为常用查询建索引
10
UserSchema.index({ email: 1 }, { unique: true });
11
UserSchema.index({ status: 1, createdAt: -1 });

三、性能优化实战#

常见问题与解决方案#

问题 1：N+1 查询

1
// ❌ 错误：11 次查询（1 + 10）
2
async getUsersWithInterviews() {
3
  const users = await this.userModel.find().limit(10);  // 1 次
4

5
  for (const user of users) {
6
    user.interviews = await this.interviewModel.find({ userId: user._id });  // 10 次
7
  }
8

9
  return users;
10
}
11

12
// ✅ 正确：2 次查询
13
async getUsersWithInterviews() {
14
  return this.userModel
15
    .find()
16
    .limit(10)
17
    .populate('interviews')  // 自动关联
18
    .exec();
19
}
20

21
// ✅ 更好：1 次查询（聚合）
22
async getUsersWithInterviews() {
23
  return this.userModel.aggregate([
24
    { $limit: 10 },
25
    {
26
      $lookup: {
27
        from: 'interviews',
28
        localField: '_id',
29
        foreignField: 'userId',
30
        as: 'interviews'
31
      }
32
    }
33
  ]);
34
}

问题 2：返回过多字段

1
// ❌ 错误：返回所有字段（包括大字段）
2
async getUsers() {
3
  return this.userModel.find();
4
}
5

6
// ✅ 正确：只返回需要的字段
7
async getUsers() {
8
  return this.userModel
9
    .find()
10
    .select('username email status')
11
    .exec();
12
}
13

14
// ✅ 或排除大字段
15
async getUsers() {
16
  return this.userModel
17
    .find()
18
    .select('-password -bio -avatar')
19
    .exec();
20
}

问题 3：没有分页

1
// ❌ 错误：一次返回所有（可能 100 万条）
2
async getAllUsers() {
3
  return this.userModel.find();
4
}
5

6
// ✅ 正确：分页
7
async getUsers(page = 1, pageSize = 20) {
8
  const skip = (page - 1) * pageSize;
9

10
  const [data, total] = await Promise.all([
11
    this.userModel.find().skip(skip).limit(pageSize).exec(),
12
    this.userModel.countDocuments(),
13
  ]);
14

15
  return { data, total, page, pageSize };
16
}

问题 4：低效查询条件

1
// ❌ 避免 NOT 查询
2
find({ status: { $ne: 'banned' } })
3

4
// ✅ 使用 IN
5
find({ status: { $in: ['active', 'inactive'] } })
6

7
// ❌ 避免正则开头通配符
8
find({ username: /.*alice.*/i })
9

10
// ✅ 使用前缀匹配
11
find({ username: /^alice/i })

问题 5：并发写入冲突

1
// ❌ 错误：可能丢失更新
2
async incrementScore(userId: string) {
3
  const user = await this.userModel.findById(userId);
4
  user.score += 10;  // 并发时会丢失
5
  await user.save();
6
}
7

8
// ✅ 正确：原子操作
9
async incrementScore(userId: string) {
10
  return this.userModel.findByIdAndUpdate(
11
    userId,
12
    { $inc: { score: 10 } },  // 原子操作
13
    { new: true }
14
  );
15
}

问题 6：内存溢出

1
// ❌ 错误：一次加载所有
2
async processAllUsers() {
3
  const users = await this.userModel.find();  // 可能几百万条
4
  for (const user of users) {
5
    await this.processUser(user);
6
  }
7
}
8

9
// ✅ 正确：使用流
10
async processAllUsers() {
11
  const stream = this.userModel.find().cursor();
12

13
  for await (const user of stream) {
14
    await this.processUser(user);
15
  }
16
}
17

18
// ✅ 或批处理
19
async processAllUsers() {
20
  const batchSize = 100;
21
  let skip = 0;
22

23
  while (true) {
24
    const users = await this.userModel
25
      .find()
26
      .skip(skip)
27
      .limit(batchSize);
28

29
    if (users.length === 0) break;
30

31
    await Promise.all(users.map(u => this.processUser(u)));
32
    skip += batchSize;
33
  }
34
}

异步优化#

1
// ❌ 串行：总时间 = 时间1 + 时间2 + 时间3
2
async getUserData(userId: string) {
3
  const user = await this.userModel.findById(userId);
4
  const interviews = await this.interviewModel.find({ userId });
5
  const comments = await this.commentModel.find({ userId });
6
  return { user, interviews, comments };
7
}
8

9
// ✅ 并行：总时间 = max(时间1, 时间2, 时间3)
10
async getUserData(userId: string) {
11
  const [user, interviews, comments] = await Promise.all([
12
    this.userModel.findById(userId),
13
    this.interviewModel.find({ userId }),
14
    this.commentModel.find({ userId }),
15
  ]);
16
  return { user, interviews, comments };
17
}

聚合优化#

1
// ❌ 低效：先排序所有数据
2
aggregate([
3
  { $sort: { createdAt: -1 } },
4
  { $match: { status: 'active' } },
5
  { $limit: 10 },
6
])
7

8
// ✅ 高效：先筛选，尽早限制
9
aggregate([
10
  { $match: { status: 'active' } },  // 1. 先筛选（用索引）
11
  { $sort: { createdAt: -1 } },      // 2. 再排序
12
  { $limit: 10 },                    // 3. 尽早限制
13
])

四、生产环境最佳实践#

连接配置#

1
MongooseModule.forRootAsync({
2
  useFactory: () => ({
3
    uri: process.env.MONGODB_URI,
4

5
    // 连接池
6
    maxPoolSize: 10,
7
    minPoolSize: 2,
8

9
    // 超时
10
    serverSelectionTimeoutMS: 5000,
11
    socketTimeoutMS: 45000,
12
    connectTimeoutMS: 10000,
13

14
    // 重试
15
    retryWrites: true,
16
    retryReads: true,
17

18
    // 生产环境关闭自动创建
19
    autoIndex: false,
20
    autoCreate: false,
21
  }),
22
}),

错误处理#

1
@Catch(MongoError)
2
export class MongoExceptionFilter implements ExceptionFilter {
3
  catch(exception: MongoError, host: ArgumentsHost) {
4
    const response = host.switchToHttp().getResponse();
5

6
    let status = 500;
7
    let message = '数据库错误';
8

9
    switch (exception.code) {
10
      case 11000:  // 唯一索引冲突
11
        status = 409;
12
        message = '数据已存在';
13
        break;
14
      case 121:    // 文档验证失败
15
        status = 400;
16
        message = '数据验证失败';
17
        break;
18
      default:
19
        console.error('MongoDB Error:', exception);
20
    }
21

22
    response.status(status).json({
23
      statusCode: status,
24
      message,
25
      timestamp: new Date().toISOString(),
26
    });
27
  }
28
}
29

30
// main.ts
31
app.useGlobalFilters(new MongoExceptionFilter());

数据验证#

1
// 多层验证
2
// 1. DTO 层
3
export class CreateUserDto {
4
  @IsString()
5
  @MinLength(3)
6
  @MaxLength(20)
7
  username: string;
8
}
9

10
// 2. Schema 层
11
@Prop({ required: true, minlength: 3, maxlength: 20 })
12
username: string;
13

14
// 3. Service 层
15
async create(dto: CreateUserDto) {
16
  const existing = await this.userModel.findOne({
17
    username: dto.username
18
  });
19
  if (existing) {
20
    throw new ConflictException('用户名已存在');
21
  }
22
  return this.userModel.create(dto);
23
}

环境配置#

1
MONGODB_URI=mongodb://localhost:27017/dev
2
MONGODB_AUTO_INDEX=true
3

4
# .env.production
5
MONGODB_URI=mongodb://user:pass@prod:27017/prod?replicaSet=rs0
6
MONGODB_AUTO_INDEX=false

数据备份#

1
# 备份
2
mongodump --uri="mongodb://localhost:27017/mydb" --out=/backup/$(date +%Y%m%d)
3

4
# 恢复
5
mongorestore --uri="mongodb://localhost:27017/mydb" /backup/20240115
6

7
# 自动化脚本
8
#!/bin/bash
9
BACKUP_DIR="/backup/mongodb"
10
DATE=$(date +%Y%m%d)
11
mongodump --uri="$MONGODB_URI" --out="$BACKUP_DIR/$DATE"
12

13
# 删除 7 天前的备份
14
find $BACKUP_DIR -type d -mtime +7 -exec rm -rf {} \;

五、完整数据流程#

用户注册流程#

1
1. 前端请求
2
   POST /api/users/register
3
   { username: 'alice', password: 'password123' }
4
   ↓
5
2. DTO 验证（ValidationPipe）
6
   ✅ username 长度 3-20
7
   ✅ password 长度 >= 6
8
   ↓
9
3. Controller 接收
10
   @Post('register')
11
   register(@Body() dto: CreateUserDto)
12
   ↓
13
4. Service 业务逻辑
14
   检查用户是否已存在（使用索引）
15
   ↓
16
5. Pre Save 钩子
17
   检测 password 被修改
18
   加密：'password123' → '$2a$10$...'
19
   ↓
20
6. Schema 验证
21
   ✅ required、unique、minlength
22
   ↓
23
7. 保存到数据库
24
   { username: 'alice', password: '$2a$10$...' }
25
   ↓
26
8. Post Save 钩子
27
   打印日志：✅ 用户 alice 已保存
28
   ↓
29
9. toJSON 转换
30
   删除 password 字段
31
   ↓
32
10. 返回响应
33
    { username: 'alice', email: '...', status: 'active' }

涉及的知识点：

✅ DTO 验证
✅ 索引查询
✅ Pre/Post 钩子
✅ Schema 验证
✅ 默认值
✅ 时间戳
✅ toJSON 转换

六、性能优化检查清单#

部署前检查#

索引：

常查询字段有索引
复合索引顺序正确（ESR）
无多余索引
唯一索引已设置

查询：

Schema：

数据关联设计合理
字段验证完整
无过度正规化/反正规化

安全：

密码已加密
敏感字段不返回
输入验证完整

监控：

慢查询日志
索引使用统计
连接池监控
错误日志

配置：

连接池大小合理
超时配置正确
生产环境关闭 autoIndex
备份策略已设置

七、常见问题 FAQ#

Q1: 什么时候用引用，什么时候用嵌入？

引用：数据常更新、一对多、数据大
嵌入：数据小且不常变化、总是一起查询

Q2: 索引越多越好吗？

❌ 不是！占内存、拖慢写入
只为常用查询建索引

Q3: 如何处理大数据量查询？

分页、流处理、批处理、缓存

Q4: 钩子会影响性能吗？

会的！避免在钩子中执行耗时操作

Q5: 如何调试慢查询？

使用 explain('executionStats')
检查是否用了索引（IXSCAN vs COLLSCAN）
检查 totalDocsExamined 是否过大
优化索引或查询条件

八、总结#

核心知识点#

中间件与钩子：

✅ Pre/Post 钩子自动化处理
✅ 密码加密实战
✅ 数据验证和日志

索引设计：

✅ 索引类型（单字段、复合、唯一、稀疏、文本、TTL）
✅ ESR 规则和选择性原则
✅ explain() 性能分析

性能优化：

✅ 避免 N+1 查询
✅ 字段选择和分页
✅ 并行查询
✅ 聚合优化

生产实践：

✅ 连接池配置
✅ 错误处理
✅ 多层验证
✅ 数据备份

学习路径#

1
MongoDB 基础（上篇）
2
├─ NoSQL 概念
3
├─ Mongoose ODM
4
├─ Schema 设计
5
├─ 查询与聚合
6
└─ 数据关联
7

8
MongoDB 进阶（下篇）
9
├─ 中间件与钩子
10
├─ 索引设计
11
├─ 性能优化
12
└─ 生产实践
13

14
实战应用
15
├─ 用户认证系统
16
├─ 权限管理
17
└─ 完整项目架构

核心原则#

💡 先理解，再优化：不要过早优化
📊 用数据说话：用 explain() 分析
🎯 按需索引：不是越多越好
🔒 安全第一：永远不存明文密码
📝 记录日志：方便问题排查

参考资源：

音乐

音乐