Firebase 如何组合多个firestore查询

如何组合streambuilder的多个查询我只能访问最后一个查询，如何防止每次返回页面时刷新流

Stream<dynamic> _main;

@override
  void initState() {
    super.initState();
    _m = _firestore
        .collection(..)
        .where(..)
        .where(..)
        .snapshots()
        .listen((QuerySnapshot snapshot) => _onMUpdate(snapshot));
  }

void _onMUpdate(QuerySnapshot snapshot) async {
    snapshot.documents.forEach((doc) {
        Stream<DocumentSnapshot> u = _firestore
            .collection(..)
            .document(doc.data['m'])
            .snapshots();
        Stream<QuerySnapshot> me = _firestore
            .collection(..)
            .document(doc.documentID)
            .collection(..)
            .limit(1)
            .snapshots();
        Stream<QuerySnapshot> n = _firestore
            .collection(..)
            .document(doc.documentID)
            .collection(..)
            .snapshots();
        _main =  StreamZip([u, me, n]).asBroadcastStream();
    });
  }

Stream\u main；
@凌驾
void initState（）{
super.initState（）；
_m=\U火炉店
.收集（……）
.其中（……）
.其中（……）
.快照（）
.listen（（QuerySnapshot快照）=>\u onUpdate（快照））；
}
void\u onUpdate（QuerySnapshot快照）异步{
snapshot.documents.forEach（（doc）{
流u=\u firestore
.收集（……）
.文件（文件数据['m']）
.快照（）；
Stream me=\u firestore
.收集（……）
.document（doc.documentID）
.收集（……）
.限额（1）
.快照（）；
流n=\u firestore
.收集（……）
.document（doc.documentID）
.收集（……）
.快照（）；
_main=StreamZip（[u，me，n]）.asBroadcastStream（）；
});
}

---

我想提前感谢您的帮助

StreamBuilder将根据最后一个快照更新布局，因此，如果您将其合并，则无所谓，只有最后一个将更新您的屏幕

我相信您可以在StreamBuilder上执行以下操作：

// snapshotList will be your AsyncSnapshot. snapshotList.data will be your List<QuerySnapshot>

StreamBuilder<List<QuerySnapshot>>(
    stream: streamList,
    builder: (BuildContext context, AsyncSnapshot<List<QuerySnapshot>> snapshotList) {
        snapshotList.data.forEach((doc) {
            return something
        }
    }
)

//快照列表将是您的快照。snapshotList.data将成为您的列表
StreamBuilder(
流：流列表，
生成器：（BuildContext上下文，异步快照快照列表）{
snapshotList.data.forEach（（文档）{
归还某物
}
}
)

---

让我知道这是否适用于您：）

在您的情况下，我认为使用Observable是最佳选择

您可以创建单独的类集团

把所有的溪流都放在那里

在那里创建getter

Observable get merge=>Observable.zip3(
_流程1，
_第2条，
_第3条，
（一、二、三）=>
（1.toString（）+2.toString（）+3.toString（））；

之后，您可以像这样在Streambuilder中使用此getter

StreamBuilder<String>(
            stream: counterBloc.merge,
            builder: (context, snapshot) {
              return Text(
                'Flutter Observable - ${snapshot.data.toString()}',
              );
            }),

StreamBuilder(
流：counterBloc.merge，
生成器：（上下文，快照）{
返回文本(
'颤振可观测-${snapshot.data.toString（）}'，
);
}),

我在counter应用程序的基础上创建了一个示例。当按下按钮时，它将数据发送到3个流，然后显示它们

下面是代码示例

它的工作原理如下图所示

在这里阅读更多关于zip3的信息

另外，您可以使用

BehaviorSubject

而不是

Stream

，它将保留流的最后一个值

使用这种方法，你们将把逻辑和UI分开，并且可以在应用程序中的任何地方重用这些流

---

能否添加有关数据库结构的详细信息？不清楚您要做什么，但循环中的这些嵌套查询看起来一点也不好。

StreamBuilder<String>(
            stream: counterBloc.merge,
            builder: (context, snapshot) {
              return Text(
                'Flutter Observable - ${snapshot.data.toString()}',
              );
            }),