Mongoose 如何处理文档关联和 Populate 功能？

Mongoose 提供了多种方式来处理文档之间的关联关系，包括引用（Reference）、嵌入（Embedding）和 Populate 功能。

关联类型

1. 嵌入式关联（Embedding）

将相关数据直接嵌入到父文档中，适合一对一或一对多关系，且子文档较小的情况。

javascript
const addressSchema = new Schema({
  street: String,
  city: String,
  country: String
});

const userSchema = new Schema({
  name: String,
  address: addressSchema  // 嵌入式关联
});

const User = mongoose.model('User', userSchema);

2. 引用式关联（Reference）

通过 ObjectId 引用其他文档，适合一对多或多对多关系。

javascript
const authorSchema = new Schema({
  name: String,
  email: String
});

const bookSchema = new Schema({
  title: String,
  author: {
    type: Schema.Types.ObjectId,
    ref: 'Author'  // 引用式关联
  }
});

const Author = mongoose.model('Author', authorSchema);
const Book = mongoose.model('Book', bookSchema);

Populate 功能

Populate 是 Mongoose 提供的强大功能，可以自动替换引用的 ObjectId 为完整的文档。

基本 Populate

javascript
// 创建作者和书籍
const author = await Author.create({ name: 'John Doe', email: 'john@example.com' });
const book = await Book.create({ title: 'My Book', author: author._id });

// 使用 populate 获取完整作者信息
const populatedBook = await Book.findById(book._id).populate('author');
console.log(populatedBook.author.name);  // "John Doe"

多字段 Populate

javascript
const bookSchema = new Schema({
  title: String,
  author: { type: Schema.Types.ObjectId, ref: 'Author' },
  publisher: { type: Schema.Types.ObjectId, ref: 'Publisher' }
});

const book = await Book.findById(id)
  .populate('author')
  .populate('publisher');

嵌套 Populate

javascript
const commentSchema = new Schema({
  text: String,
  user: { type: Schema.Types.ObjectId, ref: 'User' }
});

const postSchema = new Schema({
  title: String,
  comments: [{ type: Schema.Types.ObjectId, ref: 'Comment' }]
});

const post = await Post.findById(id)
  .populate({
    path: 'comments',
    populate: { path: 'user' }
  });

选择字段

javascript
const book = await Book.findById(id)
  .populate({
    path: 'author',
    select: 'name email'  // 只选择特定字段
  });

条件 Populate

javascript
const books = await Book.find()
  .populate({
    path: 'author',
    match: { status: 'active' }  // 只填充符合条件的作者
  });

多对多关系

使用数组引用

javascript
const studentSchema = new Schema({
  name: String,
  courses: [{ type: Schema.Types.ObjectId, ref: 'Course' }]
});

const courseSchema = new Schema({
  title: String,
  students: [{ type: Schema.Types.ObjectId, ref: 'Student' }]
});

const Student = mongoose.model('Student', studentSchema);
const Course = mongoose.model('Course', courseSchema);

// 添加课程到学生
const student = await Student.findById(studentId);
student.courses.push(courseId);
await student.save();

// 查询学生的所有课程
const studentWithCourses = await Student.findById(studentId).populate('courses');

使用中间集合

javascript
const enrollmentSchema = new Schema({
  student: { type: Schema.Types.ObjectId, ref: 'Student' },
  course: { type: Schema.Types.ObjectId, ref: 'Course' },
  enrolledAt: { type: Date, default: Date.now }
});

const Enrollment = mongoose.model('Enrollment', enrollmentSchema);

// 查询学生的所有课程
const enrollments = await Enrollment.find({ student: studentId })
  .populate('course');

虚拟字段 Populate

使用虚拟字段创建动态关联：

javascript
const authorSchema = new Schema({
  name: String,
  books: [{ type: Schema.Types.ObjectId, ref: 'Book' }]
});

const bookSchema = new Schema({
  title: String,
  author: { type: Schema.Types.ObjectId, ref: 'Author' }
});

// 在 Book Schema 上添加虚拟字段
bookSchema.virtual('authorBooks', {
  ref: 'Book',
  localField: 'author',
  foreignField: 'author'
});

const Book = mongoose.model('Book', bookSchema);

// 启用虚拟字段
const book = await Book.findById(id).populate('authorBooks');

性能优化

1. 选择性 Populate：只填充需要的字段
2. 限制数量：使用 limit 限制填充的文档数量
3. 分页：使用 skip 和 limit 实现分页
4. 避免 N+1 查询：合理设计数据结构
5. 使用索引：为引用字段创建索引

javascript
const books = await Book.find()
  .populate({
    path: 'author',
    select: 'name',
    options: { limit: 10 }
  });

最佳实践

1. 根据数据访问模式选择嵌入或引用
2. 避免过度嵌套和过深的 populate
3. 考虑使用虚拟字段处理复杂关联
4. 为引用字段创建索引以提高查询性能
5. 在多对多关系中考虑使用中间集合
6. 注意 populate 可能导致的性能问题