如何使用Loopback从MongoDB中获取多个随机对象

Hey there! I’ve helped a few folks build similar recommendation modules, so let’s walk through the best ways to fetch 4-5 random books from MongoDB using LoopBack. Here are the most practical approaches tailored to your needs:

1. 最优方案：MongoDB原生$sample聚合（强烈推荐） #

MongoDB has a built-in aggregation stage $sample that’s specifically designed to return random documents efficiently. This is hands down the best option because it’s optimized at the database level—no need to pull all documents into your app and shuffle them (which is a huge performance hit for large collections).

To implement this in LoopBack, add a custom method to your BookRepository:

// src/repositories/book.repository.ts
import { DefaultCrudRepository, juggler } from '@loopback/repository';
import { Book } from '../models';
import { inject } from '@loopback/core';

export class BookRepository extends DefaultCrudRepository<
  Book,
  typeof Book.prototype.id
> {
  constructor(@inject('datasources.mongodb') dataSource: juggler.DataSource) {
    super(Book, dataSource);
  }

  // Fetch 4-5 random books (default to 4 if no count is provided)
  async getRandomBooks(count: number = 4): Promise<Book[]> {
    // Use MongoDB's $sample aggregation stage
    return this.aggregate([{ $sample: { size: count } }]).exec();
  }
}

优点： #

• Performance: $sample uses efficient random sampling under the hood, even for large collections.
• Simplicity: No extra logic needed—let MongoDB handle the randomization.
• Scalability: Works well as your book collection grows.

2. 带条件的随机推荐（同分类/标签） #

If you want to narrow down recommendations to books in the same category or with matching tags (e.g., "show books related to the one the user is reading"), combine $match with $sample:

async getRelatedRandomBooks(currentBookCategory: string, currentBookId: string, count: number = 4): Promise<Book[]> {
  return this.aggregate([
    // First filter books by the same category and exclude the current book
    { $match: { 
      category: currentBookCategory,
      _id: { $ne: currentBookId }
    } },
    // Then sample random books from the filtered set
    { $sample: { size: count } }
  ]).exec();
}

This ensures your recommendations are relevant and random at the same time.

3. 备选方案：随机Skip（仅适合小集合） #

If you’re working with an older MongoDB version that doesn’t support $sample (pre-3.2, which is rare now), you can use a random skip approach. Note that this is not ideal for large collections because skip() forces MongoDB to scan all documents up to the skip point, which gets slow as your data grows.

Here’s how to implement it:

async getRandomBooksLegacy(count: number = 4): Promise<Book[]> {
  // Get total number of books
  const totalBooks = await this.count();
  // Calculate a random skip value (make sure we don't go out of bounds)
  const randomSkip = Math.floor(Math.random() * (totalBooks - count));
  // Fetch the random subset
  return this.find({ skip: randomSkip, limit: count });
}

缺点： #

• Poor performance for large collections (O(n) time complexity vs O(k) for $sample).
• Risk of duplicate recommendations if the user refreshes often (you’d need extra logic to track previously shown books).

额外优化建议 #

• Exclude already viewed books: If you want to avoid showing the same book twice to a user, store their viewed book IDs in a session or database, then add a $match condition to exclude those IDs.
• Handle small subsets: If your filtered category has fewer than 4 books, adjust the size parameter to match the available count (e.g., use Math.min(count, filteredTotal) in the $sample stage).
• Cache recommendations: For high-traffic apps, cache the random results for a short period (5-10 minutes) to reduce database load.

内容的提问来源于stack exchange，提问作者Niels Kristiansen