Android中如何在RecyclerView展示带子集合的Firestore文档？

你的核心问题在于Firestore的异步查询特性和你当前同步等待的逻辑冲突——你用while(post.isStillLoading())的方式试图阻塞线程等待子集合加载，但Firestore的回调是在独立线程执行的，这种循环不仅会卡住后台线程，而且因为异步回调的执行时机不确定，最终postList返回时，大部分Post对象的点赞和评论数据还没加载完成。

下面给你几个可行的解决方案，按推荐程度排序：

方案1：反范式化数据结构（推荐） #

Firestore是文档型数据库，反范式化是优化列表加载的常用手段——把帖子展示需要的高频数据（比如点赞数、最新2条评论）直接存在Post文档中，子集合只存储完整的点赞/评论明细。这样获取帖子列表时不需要查询子集合，既提升加载速度，又避免嵌套异步的麻烦。

具体实现： #

1. 修改Post类，添加高频展示字段：

public class Post {
    private String postId;
    private String content;
    private String author;
    private int likeCount; // 点赞总数
    private List<Comment> latestComments; // 最新几条评论（比如前3条）
    // 其他原有字段...

    // getter和setter
}

2. 在添加点赞/评论时，同步更新Post文档的对应字段：

// 示例：添加点赞时更新点赞数
db.collection("FeedsCollection")
  .document(documentID)
  .collection("Posts")
  .document(postId)
  .collection("Likes")
  .document(userId)
  .set(new Like(userId))
  .addOnSuccessListener(v -> {
      // 原子递增点赞数
      db.collection("FeedsCollection")
        .document(documentID)
        .collection("Posts")
        .document(postId)
        .update("likeCount", FieldValue.increment(1));
  });

3. 获取帖子列表时，直接读取Post文档即可，不需要查询子集合：

@Override
protected List<Post> doInBackground(Void... voids) {
    List<Post> postList = new ArrayList<>();
    try {
        QuerySnapshot snapshot = feedsCollection.document(documentID)
                .collection("Posts")
                .get()
                .get(); // 后台线程用同步调用，不阻塞UI
        
        for (DocumentSnapshot doc : snapshot) {
            Post post = doc.toObject(Post.class);
            post.setPostId(doc.getId());
            postList.add(post);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return postList;
}

当用户点击帖子进入详情页时，再单独查询该帖子的Likes和Comments子集合，加载完整数据即可。

方案2：用CountDownLatch同步子集合查询（适合必须加载完整数据的场景） #

如果你的需求必须在列表加载时就获取所有点赞和评论，可以用CountDownLatch在后台线程等待所有子查询完成，再将Post对象加入列表。

修正后的代码： #

@Override
protected List<Post> doInBackground(Void... voids) {
    final List<Post> postList = new ArrayList<>();
    try {
        // 同步获取所有帖子（后台线程中使用get()阻塞等待结果）
        QuerySnapshot postsSnapshot = feedsCollection.document(documentID)
                .collection("Posts")
                .get()
                .get();

        for (DocumentSnapshot postDoc : postsSnapshot) {
            Post post = postDoc.toObject(Post.class);
            String postId = postDoc.getId();
            
            // 用CountDownLatch等待点赞和评论两个查询完成
            CountDownLatch latch = new CountDownLatch(2);

            // 查询点赞子集合
            db.collection("FeedsCollection").document(documentID)
                    .collection("Posts").document(postId)
                    .collection("Likes")
                    .get()
                    .addOnSuccessListener(likesSnapshot -> {
                        List<Like> likeList = likesSnapshot.toObjects(Like.class);
                        post.setLikes(likeList);
                        latch.countDown(); // 点赞查询完成，计数减1
                    })
                    .addOnFailureListener(e -> {
                        // 处理查询失败，也要countDown避免无限等待
                        latch.countDown();
                    });

            // 查询评论子集合
            db.collection("FeedsCollection").document(documentID)
                    .collection("Posts").document(postId)
                    .collection("Comments")
                    .get()
                    .addOnSuccessListener(commentsSnapshot -> {
                        List<Comment> commentList = commentsSnapshot.toObjects(Comment.class);
                        post.setComments(commentList);
                        latch.countDown(); // 评论查询完成，计数减1
                    })
                    .addOnFailureListener(e -> {
                        latch.countDown();
                    });

            // 等待两个子查询都完成
            latch.await();
            postList.add(post);
        }
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
    return postList;
}

注意事项： #

• 必须在后台线程执行latch.await()，否则会阻塞UI线程；
• 要处理查询失败的情况，避免latch永远无法归零导致线程卡死。

方案3：用CompletableFuture简化异步逻辑（Java 8+） #

如果你的项目支持Java 8，可以用CompletableFuture把Firestore的异步回调转换成Future，代码更简洁易读：

@Override
protected List<Post> doInBackground(Void... voids) {
    final List<Post> postList = new ArrayList<>();
    try {
        QuerySnapshot postsSnapshot = feedsCollection.document(documentID)
                .collection("Posts")
                .get()
                .get();

        for (DocumentSnapshot postDoc : postsSnapshot) {
            Post post = postDoc.toObject(Post.class);
            String postId = postDoc.getId();

            // 封装点赞查询为CompletableFuture
            CompletableFuture<List<Like>> likesFuture = new CompletableFuture<>();
            db.collection("FeedsCollection").document(documentID)
                    .collection("Posts").document(postId)
                    .collection("Likes")
                    .get()
                    .addOnSuccessListener(snap -> likesFuture.complete(snap.toObjects(Like.class)))
                    .addOnFailureListener(likesFuture::completeExceptionally);

            // 封装评论查询为CompletableFuture
            CompletableFuture<List<Comment>> commentsFuture = new CompletableFuture<>();
            db.collection("FeedsCollection").document(documentID)
                    .collection("Posts").document(postId)
                    .collection("Comments")
                    .get()
                    .addOnSuccessListener(snap -> commentsFuture.complete(snap.toObjects(Comment.class)))
                    .addOnFailureListener(commentsFuture::completeExceptionally);

            // 等待两个查询完成，获取结果
            List<Like> likes = likesFuture.get();
            List<Comment> comments = commentsFuture.get();

            post.setLikes(likes);
            post.setComments(comments);
            postList.add(post);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return postList;
}

额外建议：替换AsyncTask为现代异步方式 #

AsyncTask已在Android 11中被废弃，推荐用以下方式替代：

• Kotlin项目：用Coroutines + ViewModel + LiveData
• Java项目：用ExecutorService配合Handler，或者ViewModel+LiveData管理数据生命周期，避免内存泄漏。

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