在快照中查询快照？

Question

每当有人回复用户评论过的帖子时，我都会尝试收听任何通知。下面是我的数据库结构。

• Posts：(集合)
  • 帖子1：(文档)
    • 答复: user2，user3
      • 回复：(集合)
        • 答复1：(文件)
        • ownerId: user2

            - Reply 2: (Document) 
            - ownerId: [user3]

目前，我的代码有两个快照监听器。第一个是侦听Posts集合，其中用户位于“答复”数组中。然后，第二个侦听答复集合，其中它返回添加到!=当前用户的所有文档。当检测到新的回复时，它将设置Tab Bar项的徽章。

目前，这是可行的，但我很好奇是否有更好的方法这样做。

func getNotifications() {
        database.collection("Posts")
            .whereField("replies", arrayContains: userData["userId"]!)
            .order(by: "timestamp", descending: true)
            .limit(to: 70)
            .addSnapshotListener() { (querySnapshot, err) in
                if let err = err {
                    print("Error getting documents: \(err)")
                }
                else {
                    guard let snapshot = querySnapshot else {
                        print("Error fetching snapshots: \(err!)")
                        return
                    }
                    snapshot.documentChanges.forEach { documentd in
                        if (documentd.type == .added) {
                            let dataTemp = documentd.document.data()
                            let ifUser = dataTemp["ownerId"] as! String

                            if(ifUser == self.userData["userId"]!) {
                                database.collection("Posts")
                                    .document(documentd.document.documentID)
                                    .collection("Replies")
                                    .whereField("timestamp", isGreaterThan: dataTemp["timestamp"] as! Int)
                                    .addSnapshotListener() { (querySnapshot3, err) in
                                        if let err = err {
                                            print("Error getting documents: \(err)")
                                        }
                                        else {
                                            guard let snapshot = querySnapshot3 else {
                                                print("Error fetching snapshots: \(err!)")
                                                return
                                            }
                                            snapshot.documentChanges.forEach { diff in
                                                if (diff.type == .added) {
                                                    let temp = diff.document.data()
                                                    if((temp["ownerId"] as! String) != self.userData["userId"]!) {
                                                        print("new reply")
                                                        newArr.append(diff.document.data())
                                                        let data = diff.document.data()
                                                        let firebaseTime = data["timestamp"] as! Int
                                                        let date = lround(Date().timeIntervalSince1970)
                                                        if(firebaseTime+10 > date) {
                                                            self.tabBar.items![2].badgeValue = "●"
                                                            self.tabBar.items![2].badgeColor = .clear
                                                            self.tabBar.items![2].setBadgeTextAttributes([NSAttributedString.Key.foregroundColor: UIColor.red], for:.normal)
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                            }
                            else {
                                database.collection("Posts")
                                    .document(documentd.document.documentID)
                                    .collection("Replies")
                                    .whereField("ownerId", isEqualTo: self.userData["userId"]!)
                                    .order(by: "timestamp", descending: false)
                                    .limit(to: 1)
                                    .getDocuments() { (querySnapshot2, err) in
                                        if let err = err {
                                            print("Error getting documents: \(err)")
                                        }
                                        else {
                                        var timestamp = Int()
                                        for documentde in querySnapshot2!.documents {
                                                 
                                            let temp = documentde.data()
                                            timestamp = temp["timestamp"] as! Int
                                        
                                            
                                            database.collection("Posts")
                                                .document(documentd.document.documentID)
                                                .collection("Replies")
                                                .whereField("timestamp", isGreaterThan: timestamp)
                                                .addSnapshotListener() { (querySnapshot3, err) in
                                                    if let err = err {
                                                        print("Error getting documents: \(err)")
                                                    }
                                                    else {
                                                        guard let snapshot = querySnapshot3 else {
                                                            print("Error fetching snapshots: \(err!)")
                                                            return
                                                        }
                                                        snapshot.documentChanges.forEach { diff in
                                                            if (diff.type == .added) {
                                                                let temp = diff.document.data()
                                                                if((temp["ownerId"] as! String) != self.userData["userId"]!) {
                                                                    print("new reply")
                                                                    newArr.append(diff.document.data())
                                                                    let data = diff.document.data()
                                                                    let firebaseTime = data["timestamp"] as! Int
                                                                    let date = lround(Date().timeIntervalSince1970)
                                                                    if(firebaseTime+10 > date) {
                                                                        self.tabBar.items![2].badgeValue = "●"
                                                                        self.tabBar.items![2].badgeColor = .clear
                                                                        self.tabBar.items![2].setBadgeTextAttributes([NSAttributedString.Key.foregroundColor: UIColor.red], for:.normal)
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

    }

Answer 1

您的代码不只是两个侦听器，而是您感兴趣的用户曾经为其回复过的每个帖子中的一个侦听器。这将导致糟糕的表现很快，并有可能使您的应用程序崩溃，因为Firestore有一个限制的每个客户端100个侦听器。

我建议重新设计您的数据模型：

1. 用户曾经回复过的帖子中只有一个侦听器(您的第一个侦听器)
2. 在每个回复增量，一个回复计数器在post中，这将触发上面的快照。
3. 优化1:在一个帖子上的每一个动作上，你可以设置一个字段lastactiontype，这个字段只对回复有一个特定的值reply。这样，只有在回复时才触发快照。
4. 优化2:将每个动作的字段timestamp设置为当前时间，并且只提取快照中的最后n条(例如10条)，这将限制加载时的读取次数。当应用程序离线和恢复联机时，当快照的n个帖子都发生了变化时，您必须实现一些特殊的逻辑来处理这种情况。如果你的应用程序是要缩放的，这是必须的(你不想要一个没有限制的快照，一个拥有100 k文档的集合.)

示例：

firestore.collection("Posts")
.where( "lastaction", "==" , "reply")
.where( "replies", "array-contains", uid)
.orderBy("timestamp", "desc").limit(10)