如何监听Firestore集合的count()变化？有无更优雅实现方式？

首先明确：Firestore的count()聚合查询不支持直接实时监听，这类聚合查询是一次性计算结果，没有内置的实时更新机制。不过我们可以通过以下几种更高效的方式实现类似需求：

方式一：维护独立的计数文档（推荐） #

核心思路是单独存储未读消息的计数，每次符合条件的消息状态变更时（比如新增未读消息、标记已读），同步更新这个计数文档。之后只需监听这个计数文档的变化即可，避免了每次拉取整个集合的开销。

客户端更新计数示例（Dart） #

假设我们创建一个unread_message_counts集合，每个用户对应一个以selfUid为ID的文档，存储count字段：

// 新增未读消息时，增加计数
Future<void> incrementUnreadCount(String selfUid) async {
  final countDoc = FirebaseFirestore.instance
      .collection('unread_message_counts')
      .doc(selfUid);
  
  await countDoc.set({
    'count': FieldValue.increment(1),
  }, SetOptions(merge: true));
}

// 标记消息已读时，减少计数
Future<void> decrementUnreadCount(String selfUid) async {
  final countDoc = FirebaseFirestore.instance
      .collection('unread_message_counts')
      .doc(selfUid);
  
  await countDoc.update({
    'count': FieldValue.increment(-1),
  });
}

// 监听计数变化
Stream<int> listenUnreadCount(String selfUid) {
  return FirebaseFirestore.instance
      .collection('unread_message_counts')
      .doc(selfUid)
      .snapshots()
      .map((snapshot) => snapshot.data()?['count'] ?? 0);
}

云函数自动维护计数（保证一致性） #

如果担心客户端更新计数时出现遗漏（比如客户端离线），可以用Firebase云函数监听messages集合的变更，自动更新计数：

const functions = require("firebase-functions");
const admin = require("firebase-admin");
admin.initializeApp();

exports.updateUnreadCount = functions.firestore
  .document('messages/{messageId}')
  .onWrite(async (change, context) => {
    const before = change.before.data();
    const after = change.after.data();
    const selfUid = after?.selfUid;
    const partnerUid = after?.partnerUid;

    // 处理新增未读消息
    if (!before && after && after.dateRead === null) {
      await updateCount(selfUid, 1);
      await updateCount(partnerUid, 1);
    }

    // 处理消息从未读变已读
    if (before && after && before.dateRead === null && after.dateRead !== null) {
      await updateCount(selfUid, -1);
      await updateCount(partnerUid, -1);
    }

    // 处理未读消息被删除
    if (!after && before && before.dateRead === null) {
      await updateCount(selfUid, -1);
      await updateCount(partnerUid, -1);
    }
  });

async function updateCount(userId, delta) {
  if (!userId) return;
  const countDoc = admin.firestore().collection('unread_message_counts').doc(userId);
  await countDoc.set({
    count: admin.firestore.FieldValue.increment(delta),
  }, { merge: true });
}

方式二：监听查询快照并在客户端计数 #

如果未读消息数量不多，这种方式最简单直接——直接监听符合条件的查询快照，每次更新时取文档长度作为计数：

Stream<int> listenUnreadCount(String selfUid) {
  return FirebaseFirestore.instance
      .collection('messages')
      .where('dateRead', isEqualTo: null)
      .where(Filter.or(
        Filter("selfUid", isEqualTo: selfUid),
        Filter("partnerUid", isEqualTo: selfUid),
      ))
      .snapshots()
      .map((snapshot) => snapshot.docs.length);
}

注意：如果未读消息数量很大，这种方式会消耗较多带宽和Firestore读取配额，因为每次更新都会传输所有匹配文档的内容，而不仅仅是计数。

方式三：分布式计数器（高并发场景） #

如果你的应用有大量并发更新计数的场景（比如很多用户同时发送消息），可以用Firestore的分布式计数器方案。将计数拆分为多个分片文档，每个分片存储部分数值，更新时随机选择一个分片递增，读取时求和所有分片的数值。这种方式可以避免单个文档的并发更新限制（Firestore单文档每秒最多支持1次写入）。

简单示例（Dart） #

// 初始化10个分片
Future<void> initializeCounter(String selfUid) async {
  final batch = FirebaseFirestore.instance.batch();
  for (int i = 0; i < 10; i++) {
    final shardDoc = FirebaseFirestore.instance
        .collection('unread_message_counters')
        .doc('$selfUid-shard-$i');
    batch.set(shardDoc, {'count': 0});
  }
  await batch.commit();
}

// 递增计数
Future<void> incrementCounter(String selfUid) async {
  final shardId = Random().nextInt(10);
  final shardDoc = FirebaseFirestore.instance
      .collection('unread_message_counters')
      .doc('$selfUid-shard-$shardId');
  await shardDoc.update({'count': FieldValue.increment(1)});
}

// 监听并计算总计数
Stream<int> listenCounter(String selfUid) {
  return FirebaseFirestore.instance
      .collection('unread_message_counters')
      .where(FieldPath.documentId, isGreaterThanOrEqualTo: '$selfUid-shard-')
      .where(FieldPath.documentId, isLessThan: '$selfUid-shard-99')
      .snapshots()
      .map((snapshot) {
        return snapshot.docs.fold(0, (sum, doc) => sum + (doc.data()['count'] ?? 0));
      });
}

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