如何借助Mongoose与Socket.io实现话题实时在线用户数更新？

Hey there! Let's tackle this performance issue head-on—your current approach of iterating through 100+ topics every time a room document changes is definitely going to cause unnecessary database load and slowdowns. Here's how to optimize this real-time user count feature for your Express/Socket.io/Mongoose stack:

Core Problems with Your Current Implementation #

• N+1 Database Queries: Every room change triggers 100+ separate count queries (one per topic) which is extremely inefficient.
• Unnecessary Data Processing: You're updating counts for all topics even when only one topic's user count has changed.

Optimized Solutions #

1. Track Counts In-Memory (Primary Recommendation)

Maintain a in-memory map to store current user counts per topic. This avoids repeated database queries and lets you push only the changed count to clients.

// Initialize a map to track counts (load initial state on server start)
const topicUserCounts = new Map();

// Load initial counts from DB when the server starts
async function loadInitialTopicCounts() {
  // Get all topic slugs first
  const topics = await topicModel.find().select('slug');
  
  // Use a single aggregation to get counts for all topics in one query
  const countResults = await roomModel.aggregate([
    { $match: { isSearching: true } },
    { $group: { _id: '$preferredTopic', count: { $sum: 1 } } }
  ]);
  
  // Populate the map
  topics.forEach(topic => {
    const result = countResults.find(r => r._id === topic.slug);
    topicUserCounts.set(topic.slug, result?.count || 0);
  });
}
loadInitialTopicCounts();

// Handle Socket.io client events (adjust based on your join/leave logic)
io.on('connection', (socket) => {
  // Example: When a user joins a topic
  socket.on('join-topic', async (topicSlug) => {
    // Update DB (mark user as searching in their room document)
    // ... your existing DB update logic here ...
    
    // Update in-memory count
    const currentCount = topicUserCounts.get(topicSlug) || 0;
    const newCount = currentCount + 1;
    topicUserCounts.set(topicSlug, newCount);
    
    // Push only the updated count to all clients
    io.emit('topic-count-updated', { slug: topicSlug, count: newCount });
  });

  // Example: When a user leaves a topic
  socket.on('leave-topic', async (topicSlug) => {
    // Update DB (mark user as not searching)
    // ... your existing DB update logic here ...
    
    const currentCount = topicUserCounts.get(topicSlug) || 0;
    const newCount = Math.max(0, currentCount - 1);
    topicUserCounts.set(topicSlug, newCount);
    
    io.emit('topic-count-updated', { slug: topicSlug, count: newCount });
  });
});

// Sync in-memory counts with DB changes (for edge cases like external DB updates)
const roomChangeStream = roomModel.watch(
  [{ $match: { operationType: { $in: ['update', 'insert', 'delete'] } } }],
  { fullDocument: 'updateLookup' } // Required to get pre-change document data
);

roomChangeStream.on('change', async (change) => {
  let affectedTopic;
  let countDelta = 0;

  switch (change.operationType) {
    case 'insert':
      // New room document: if user is searching, increment the topic count
      if (change.fullDocument.isSearching) {
        affectedTopic = change.fullDocument.preferredTopic;
        countDelta = 1;
      }
      break;
    case 'update':
      // Check if isSearching or preferredTopic changed
      const oldRoom = change.fullDocumentBeforeChange;
      const newRoom = change.fullDocument;

      // If user switched topics, adjust counts for both old and new topics
      if (oldRoom.preferredTopic !== newRoom.preferredTopic) {
        if (oldRoom.isSearching) {
          const oldCount = topicUserCounts.get(oldRoom.preferredTopic) || 0;
          topicUserCounts.set(oldRoom.preferredTopic, Math.max(0, oldCount - 1));
          io.emit('topic-count-updated', { slug: oldRoom.preferredTopic, count: oldCount - 1 });
        }
        if (newRoom.isSearching) {
          const newCount = topicUserCounts.get(newRoom.preferredTopic) || 0;
          topicUserCounts.set(newRoom.preferredTopic, newCount + 1);
          io.emit('topic-count-updated', { slug: newRoom.preferredTopic, count: newCount + 1 });
        }
        return;
      }

      // If only isSearching status changed
      if (oldRoom.isSearching !== newRoom.isSearching) {
        affectedTopic = newRoom.preferredTopic;
        countDelta = newRoom.isSearching ? 1 : -1;
      }
      break;
    case 'delete':
      // Deleted room: if user was searching, decrement the topic count
      if (change.fullDocumentBeforeChange.isSearching) {
        affectedTopic = change.fullDocumentBeforeChange.preferredTopic;
        countDelta = -1;
      }
      break;
  }

  // Update and broadcast if needed
  if (affectedTopic && countDelta !== 0) {
    const currentCount = topicUserCounts.get(affectedTopic) || 0;
    const newCount = Math.max(0, currentCount + countDelta);
    topicUserCounts.set(affectedTopic, newCount);
    io.emit('topic-count-updated', { slug: affectedTopic, count: newCount });
  }
});

2. Frontend Optimization (Flutter)

Instead of reloading the entire list every time, update only the specific topic's count when you receive the topic-count-updated event:

• Maintain a Map<String, int> in your Flutter state to track counts per topic slug.
• When the event arrives, update the map entry and trigger a partial rebuild of the list item (not the entire list).

Key Improvements #

• Reduced DB Load: No more 100+ queries per room change—only a single aggregation on server start, and targeted updates when needed.
• Efficient Real-Time Updates: Clients only receive the count for the topic that changed, minimizing data transfer.
• Consistency: The change stream ensures your in-memory counts stay in sync with the database, even if updates happen outside Socket.io.

内容的提问来源于stack exchange，提问作者Vineet Mehra