Android Firestore如何获取并合并多个位置的两个集合数据？

嘿，我懂你现在要搞定的是Firestore里跨集合关联Products和Users数据的事儿——这种需求在NoSQL数据库里太常见了，毕竟Firestore不像SQL那样有原生JOIN，得咱们手动处理关联。我结合你给出的数据库结构和代码片段，给你捋捋两种靠谱的实现方式～

先明确需求&结构 #

你的数据库结构是：

• Products集合：每个文档存productname、price、userid（关联Users集合的文档ID）
• Users集合：每个文档存name、image、mail

目标是把每个Product对应的User数据合并到一起，返回包含完整信息的产品列表。

方式一：N+1查询（适合少量产品场景） #

如果你的产品数量不多，可以先查所有产品，再逐个根据userid查对应的用户数据，最后合并。这里要注意异步操作的顺序，得等所有用户查询都完成后再返回结果，不然会出现数据不全的情况。

假设你的ProductModel已经包含用户相关字段（或者嵌套一个UserModel），比如：

public class ProductModel {
    private String productId;
    private String productname;
    private String price;
    private String userid;
    // 新增用户关联字段
    private String userName;
    private String userImage;
    private String userMail;

    // 构造函数、getter、setter 自行补充
}

补全你的getProductData方法：

public void getProductData(final FireCallback.Product fireCallback) {
    final List<ProductModel> productModelList = new ArrayList<>();
    FirebaseFirestore firestore = FirebaseFirestore.getInstance();

    firestore.collection("products").get()
            .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                @Override
                public void onComplete(@NonNull Task<QuerySnapshot> productTask) {
                    if (productTask.isSuccessful()) {
                        QuerySnapshot productSnapshot = productTask.getResult();
                        if (productSnapshot == null || productSnapshot.isEmpty()) {
                            fireCallback.onCallback(productModelList);
                            return;
                        }

                        // 用原子计数器跟踪异步任务完成情况（线程安全）
                        final int totalProducts = productSnapshot.size();
                        final AtomicInteger completedQueries = new AtomicInteger(0);

                        for (QueryDocumentSnapshot productDoc : productSnapshot) {
                            ProductModel product = productDoc.toObject(ProductModel.class);
                            product.setProductId(productDoc.getId());
                            productModelList.add(product);

                            String userId = product.getUserid();
                            if (userId == null || userId.isEmpty()) {
                                // 无关联用户，直接计数+1
                                completedQueries.incrementAndGet();
                                checkAndReturnResult(completedQueries, totalProducts, productModelList, fireCallback);
                                continue;
                            }

                            // 查询对应用户数据
                            firestore.collection("users").document(userId).get()
                                    .addOnCompleteListener(new OnCompleteListener<DocumentSnapshot>() {
                                        @Override
                                        public void onComplete(@NonNull Task<DocumentSnapshot> userTask) {
                                            if (userTask.isSuccessful() && userTask.getResult().exists()) {
                                                DocumentSnapshot userDoc = userTask.getResult();
                                                // 合并用户数据到产品模型
                                                product.setUserName(userDoc.getString("name"));
                                                product.setUserImage(userDoc.getString("image"));
                                                product.setUserMail(userDoc.getString("mail"));
                                            } else {
                                                Log.e("Firestore", "获取用户数据失败", userTask.getException());
                                            }

                                            completedQueries.incrementAndGet();
                                            checkAndReturnResult(completedQueries, totalProducts, productModelList, fireCallback);
                                        }
                                    });
                        }
                    } else {
                        Log.e("Firestore", "获取产品数据失败", productTask.getException());
                        fireCallback.onCallback(productModelList);
                    }
                }
            });
}

// 封装判断所有任务是否完成的逻辑
private void checkAndReturnResult(AtomicInteger completed, int total, List<ProductModel> list, FireCallback.Product callback) {
    if (completed.get() == total) {
        callback.onCallback(list);
    }
}

方式二：批量查询（推荐，性能更优） #

如果产品数量较多，N+1查询会产生大量请求，这时候可以先收集所有userid，再用whereIn批量查询用户，最后把用户数据映射到产品上——只需要2次请求，效率高很多。

修改后的核心代码：

public void getProductData(final FireCallback.Product fireCallback) {
    final List<ProductModel> productModelList = new ArrayList<>();
    FirebaseFirestore firestore = FirebaseFirestore.getInstance();

    firestore.collection("products").get()
            .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                @Override
                public void onComplete(@NonNull Task<QuerySnapshot> productTask) {
                    if (!productTask.isSuccessful()) {
                        Log.e("Firestore", "获取产品数据失败", productTask.getException());
                        fireCallback.onCallback(productModelList);
                        return;
                    }

                    QuerySnapshot productSnapshot = productTask.getResult();
                    if (productSnapshot == null || productSnapshot.isEmpty()) {
                        fireCallback.onCallback(productModelList);
                        return;
                    }

                    // 1. 收集所有需要查询的userid
                    List<String> userIds = new ArrayList<>();
                    for (QueryDocumentSnapshot productDoc : productSnapshot) {
                        ProductModel product = productDoc.toObject(ProductModel.class);
                        product.setProductId(productDoc.getId());
                        productModelList.add(product);

                        String userId = product.getUserid();
                        if (userId != null && !userId.isEmpty() && !userIds.contains(userId)) {
                            userIds.add(userId);
                        }
                    }

                    if (userIds.isEmpty()) {
                        // 没有需要关联的用户，直接返回
                        fireCallback.onCallback(productModelList);
                        return;
                    }

                    // 2. 批量查询所有用户数据
                    firestore.collection("users")
                            .whereIn(FieldPath.documentId(), userIds)
                            .get()
                            .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                                @Override
                                public void onComplete(@NonNull Task<QuerySnapshot> userTask) {
                                    if (userTask.isSuccessful()) {
                                        // 把用户数据存入Map，方便快速查找
                                        Map<String, DocumentSnapshot> userMap = new HashMap<>();
                                        for (QueryDocumentSnapshot userDoc : userTask.getResult()) {
                                            userMap.put(userDoc.getId(), userDoc);
                                        }

                                        // 3. 遍历产品，合并对应的用户数据
                                        for (ProductModel product : productModelList) {
                                            String userId = product.getUserid();
                                            if (userMap.containsKey(userId)) {
                                                DocumentSnapshot userDoc = userMap.get(userId);
                                                product.setUserName(userDoc.getString("name"));
                                                product.setUserImage(userDoc.getString("image"));
                                                product.setUserMail(userDoc.getString("mail"));
                                            }
                                        }
                                    } else {
                                        Log.e("Firestore", "批量获取用户数据失败", userTask.getException());
                                    }

                                    // 4. 返回最终合并后的列表
                                    fireCallback.onCallback(productModelList);
                                }
                            });
                }
            });
}

额外提示 #

1. 安全规则：确保你的Firestore安全规则允许读取products和users集合，不然会出现权限错误。
2. 数据冗余优化：如果用户信息不经常变动，可以考虑在Products文档里冗余存储常用的用户字段（比如userName、userImage），这样就不用每次都关联查询用户集合——但要注意用户信息更新时，需要同步更新所有关联的Products文档（可以用Cloud Functions实现自动同步）。

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