Mongoose之查询篇：深度解析与实战指南

在Node.js生态中，Mongoose作为MongoDB的官方ODM（对象文档映射）库，为开发者提供了类型安全的数据库操作方式。其中，查询功能是Mongoose的核心能力之一，直接决定了数据检索的效率与准确性。本文将从基础查询语法、条件运算符、链式调用、聚合管道到性能优化，系统梳理Mongoose查询的完整知识体系，并结合实际场景提供可落地的解决方案。

一、基础查询方法：从find()到findOne()

1.1 find()方法详解

find()是Mongoose中最常用的查询方法，用于检索匹配条件的所有文档。其基本语法为：

const results = await Model.find(conditions, projection, options);

• conditions：查询条件对象，如{ age: { $gt: 18 } }表示查询年龄大于18的文档。
• projection：字段筛选，如{ name: 1, _id: 0 }表示仅返回name字段。
• options：配置项，如{ lean: true }可将返回结果转为普通对象（非Mongoose文档）。

实战示例：查询所有年龄大于25且状态为”active”的用户：

const activeUsers = await User.find({
  age: { $gt: 25 },
  status: "active"
}, "name email -_id"); // 仅返回name和email字段

1.2 findOne()与findById()

• findOne()：返回匹配条件的第一个文档，若无匹配则返回null。

  const user = await User.findOne({ email: "test@example.com" });

• findById()：通过_id快速查询单个文档，是findOne({ _id: id })的语法糖。

  const user = await User.findById("507f1f77bcf86cd799439011");

二、条件查询运算符：精准控制查询逻辑

Mongoose支持MongoDB的所有查询运算符，分为比较、逻辑、元素、数组等类别。

2.1 比较运算符

• $eq：等于（默认行为，可省略）
• $ne：不等于
• $gt/$gte：大于/大于等于
• $lt/$lte：小于/小于等于
• $in/$nin：在/不在数组中

示例：查询价格在100到500之间的商品：

const products = await Product.find({
  price: { $gte: 100, $lte: 500 }
});

2.2 逻辑运算符

• $and：与逻辑（多个条件需同时满足）
• $or：或逻辑
• $not：非逻辑

示例：查询状态为”pending”或”processing”且创建时间早于2023年的订单：

const orders = await Order.find({
  $and: [
    { $or: [{ status: "pending" }, { status: "processing" }] },
    { createdAt: { $lt: new Date("2023-01-01") } }
  ]
});

2.3 元素运算符

• $exists：字段是否存在
• $type：字段类型

示例：查询包含phone字段且类型为字符串的用户：

const users = await User.find({
  phone: { $exists: true, $type: "string" }
});

三、链式查询：select()、sort()与limit()

Mongoose支持通过链式调用进一步处理查询结果，提升代码可读性。

3.1 字段筛选：select()

const users = await User.find()
  .select("name age -_id") // 包含name和age，排除_id
  .exec(); // 显式执行查询

3.2 排序与分页

• sort()：按字段升序（1）或降序（-1）排序。
• skip()：跳过指定数量的文档（用于分页）。
• limit()：限制返回的文档数量。

示例：分页查询第二页的用户（每页10条），按年龄降序：

const page = 2;
const users = await User.find()
  .sort({ age: -1 })
  .skip((page - 1) * 10)
  .limit(10);

四、聚合管道：复杂查询的利器

Mongoose的聚合管道（Aggregation Pipeline）允许对数据进行多阶段处理，适用于统计、分组等复杂场景。

4.1 基础聚合示例

需求：统计每个类别的商品平均价格。

const result = await Product.aggregate([
  { $group: {
    _id: "$category",
    avgPrice: { $avg: "$price" },
    count: { $sum: 1 }
  }},
  { $sort: { avgPrice: -1 } }
]);

• $group：按category字段分组，计算平均价格和数量。
• $sort：按平均价格降序排列。

4.2 常用聚合阶段

• $match：过滤文档（类似find()）。
• $project：重塑文档结构。
• $lookup：关联其他集合（类似SQL的JOIN）。
• $unwind：展开数组字段。

示例：关联查询用户及其订单总数：

const result = await User.aggregate([
  { $lookup: {
    from: "orders",
    localField: "_id",
    foreignField: "userId",
    as: "orders"
  }},
  { $project: {
    name: 1,
    orderCount: { $size: "$orders" }
  }}
]);

五、性能优化：从索引到查询缓存

5.1 索引优化

• 创建索引：对高频查询字段建立索引。

  // 在Schema中定义索引
  const userSchema = new Schema({
    email: { type: String, index: true }, // 单字段索引
    name: { type: String },
    age: Number
  });
  // 复合索引
  userSchema.index({ age: 1, status: -1 });

• 索引类型：
  • 单字段索引：{ field: 1 }
  • 复合索引：{ field1: 1, field2: -1 }
  • 文本索引：{ $text: "$description" }（用于全文搜索）

5.2 查询缓存策略

• 应用层缓存：使用Redis缓存频繁查询的结果。

  const cacheKey = `users${Date.now()}`;
  const cachedUsers = await redis.get(cacheKey);
  if (!cachedUsers) {
    const users = await User.find({ status: "active" });
    await redis.setex(cacheKey, 3600, JSON.stringify(users)); // 缓存1小时
  }

• Mongoose中间件：通过pre('find')钩子自动缓存。

5.3 避免N+1查询问题

使用populate()关联查询时，可能引发N+1问题（主查询1次，关联查询N次）。解决方案：

• 批量查询：先查询关联ID，再批量获取。
• $lookup聚合：在聚合管道中一次性关联。

示例：优化用户-订单关联查询：

// 错误方式：N+1问题
const users = await User.find().populate("orders");
// 正确方式：使用聚合
const result = await User.aggregate([
  { $lookup: {
    from: "orders",
    localField: "_id",
    foreignField: "userId",
    as: "orders"
  }}
]);

六、高级技巧：事务与批量操作

6.1 事务支持

Mongoose 5.x+支持MongoDB 4.0+的事务：

const session = await mongoose.startSession();
session.startTransaction();
try {
  const user = await User.create([{ name: "Alice" }], { session });
  const order = await Order.create([{ userId: user[0]._id }], { session });
  await session.commitTransaction();
} catch (err) {
  await session.abortTransaction();
  throw err;
} finally {
  session.endSession();
}

6.2 批量操作

• insertMany()：批量插入文档。

  await User.insertMany([
    { name: "Bob", age: 30 },
    { name: "Charlie", age: 25 }
  ]);

• bulkWrite()：混合操作（插入、更新、删除）。

  await User.bulkWrite([
    { updateOne: { filter: { name: "Bob" }, update: { $set: { age: 31 } } } },
    { deleteOne: { filter: { name: "Charlie" } } }
  ]);

七、总结与最佳实践

1. 索引优先：高频查询字段必须建立索引。
2. 链式调用：优先使用select()、sort()等链式方法，而非后续处理。
3. 聚合替代循环：复杂统计使用聚合管道，避免在Node.js层循环处理。
4. 事务控制：关键操作使用事务保证数据一致性。
5. 缓存策略：对读多写少的场景实施缓存。

通过掌握上述查询技巧，开发者可以高效利用Mongoose操作MongoDB，构建出性能优异、代码简洁的后端服务。