如何在streambuilder中查询firestore文档并更新listview

我试图从名为“posts”的Firestore集合中检索帖子，该集合包含帖子创建者的用户ID和帖子描述，这可以通过使用StreamBuilder和FutureBuilder实现（不可取，因为它只获取一次快照，并且不会在字段更改时更新）

但是，我想查询另一个名为“users”的集合，并使用post creator的userID检索与该userID匹配的文档

这是我的第一个方法：

StreamBuilder<QuerySnapshot>(
  stream:Firestore.instance.collection("posts").snapshots(),
  builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
    if (!snapshot.hasData) {
      return Center(
        child: _showProgressBar,
      );
    }

   List<DocumentSnapshot> reversedDocuments = snapshot.data.documents.reversed.toList();
    return ListView.builder(
      itemCount: reversedDocuments.length,
      itemBuilder: (BuildContext context, int index){

        String postAuthorID = reversedDocuments[index].data["postAuthorID"].toString();
        String postAuthorName = '';
        Firestore.instance.collection("users")
        .where("userID", isEqualTo: postAuthorID).snapshots().listen((dataSnapshot) {
            print(postAuthorName = dataSnapshot.documents[0].data["username"]);
          setState(() {
            postAuthorName = dataSnapshot.documents[0].data["username"];                  
          });
        });

        String desc = reversedDocuments[index].data["post_desc"].toString();

        return new ListTile(
          title: Container(
            child: Row(
              children: <Widget>[
                Expanded(
                  child: Card(
                    child: new Column(
                      children: <Widget>[
                        ListTile(
                          title: Text(postAuthorName, //Here, the value is not changed, it holds empty space.
                            style: TextStyle(
                              fontSize: 20.0,
                            ),
                          ),
                          subtitle: Text(desc),
                        ),
                       )

StreamBuilder(
流：Firestore.instance.collection（“posts”）.snapshots（），
生成器：（BuildContext上下文，异步快照）{
如果（！snapshot.hasData）{
返回中心(
孩子：_showProgressBar，
);
}
List reversedDocuments=snapshot.data.documents.reversed.toList（）；
返回ListView.builder(
itemCount:reversedDocuments.length，
itemBuilder:（构建上下文，int索引）{
字符串postAuthorID=reversedDocuments[index]。数据[“postAuthorID”]。toString（）；
字符串postAuthorName=''；
Firestore.instance.collection（“用户”）
.where（“userID”，isEqualTo:postAuthorID）.snapshots（）.listen（（dataSnapshot）{
打印（postAuthorName=dataSnapshot.documents[0]。数据[“用户名]）；
设置状态（）{
postAuthorName=dataSnapshot.documents[0]。数据[“用户名”]；
});
});
String desc=reversedDocuments[index]。数据[“post_desc”]。toString（）；
返回新的ListTile(
标题：集装箱(
孩子：排(
儿童：[
扩大(
孩子：卡片(
子：新列(
儿童：[
列表砖(
title:Text（postAuthorName，//此处，值未更改，它保留空白。
样式：TextStyle(
字体大小：20.0，
),
),
字幕：文本（描述），
),
)

了解ListView.builder（）只能基于DocumentSnapshot列表呈现项，并且不能处理生成器内部的查询

经过多次研究： 我尝试了许多替代方法，例如，尝试在initState（）中构建列表，尝试使用嵌套流生成器：

return StreamBuilder<QuerySnapshot>(
  stream: Firestore.instance.collection('posts').snapshots(),
  builder: (context, snapshot1){
    return StreamBuilder<QuerySnapshot>(
      stream: Firestore.instance.collection("users").snapshots(),
      builder: (context, snapshot2){
        return ListView.builder(
          itemCount: snapshot1.data.documents.length,
          itemBuilder: (context, index){
            String desc = snapshot1.data.documents[index].data['post_description'].toString();
            String taskAuthorID = snapshot1.data.documents[index].data['post_authorID'].toString();
            var usersMap = snapshot2.data.documents.asMap();
            String authorName;
            username.forEach((len, snap){
              print("Position: $len, Data: ${snap.data["username"]}");
              if(snap.documentID == post_AuthorID){
                authorName = snap.data["username"].toString();
              }
            });
            return ListTile(
              title: Text(desc),
              subtitle: Text(authorName), //Crashes here...
            );
          },
        );
      }
    );
  }
);

返回StreamBuilder(
流：Firestore.instance.collection（'posts'）.snapshots（），
生成器：（上下文，快照1）{
返回流生成器(
流：Firestore.instance.collection（“用户”）.snapshots（），
生成器：（上下文，快照2）{
返回ListView.builder(
itemCount:snapshot1.data.documents.length，
itemBuilder：（上下文，索引）{
String desc=snapshot1.data.documents[index].data['post_description'].toString（）；
字符串taskAuthorID=snapshot1.data.documents[index].data['post_authorID'].toString（）；
var usersMap=snapshot2.data.documents.asMap（）；
字符串authorName；
username.forEach（（len，snap）{
打印（“位置：$len，数据：${snap.Data[“username”]}”）；
if（snap.documentID==后期创作）{
authorName=snap.data[“username”].toString（）；
}
});
返回列表块(
标题：文本（描述），
字幕：Text（authorName），//此处崩溃。。。
);
},
);
}
);
}
);

尝试使用Stream Group，但找不到完成此操作的方法，因为它只合并了两个流，但我希望第二个流由第一个流的值获取

这是我的Firebase系列屏幕截图：

Firestore“帖子”收藏：

Firestore“用户”集合：

---

我知道这是一件非常简单的事情，但仍然找不到任何教程或文章来实现这一点。

我发布了一个类似的问题，后来找到了一个解决方案：使itemBuilder返回的小部件有状态，并在其中使用FutureBuilder

这是我的代码。在您的情况下，您可能希望使用新的有状态小部件而不是ListTile，这样您就可以添加FutureBuilder来调用异步函数

StreamBuilder(
                  stream: Firestore.instance
                      .collection("messages").snapshots(),
                  builder: (context, snapshot) {
                    switch (snapshot.connectionState) {
                      case ConnectionState.none:
                      case ConnectionState.waiting:
                        return Center(
                          child: PlatformProgressIndicator(),
                        );
                      default:
                        return ListView.builder(
                          reverse: true,
                          itemCount: snapshot.data.documents.length,
                          itemBuilder: (context, index) {
                            List rev = snapshot.data.documents.reversed.toList();
                            ChatMessageModel message = ChatMessageModel.fromSnapshot(rev[index]);
                            return ChatMessage(message);
                          },
                        );
                    }
                  },
                )


class ChatMessage extends StatefulWidget {
  final ChatMessageModel _message;
  ChatMessage(this._message);
  @override
  _ChatMessageState createState() => _ChatMessageState(_message);
}

class _ChatMessageState extends State<ChatMessage> {
  final ChatMessageModel _message;

  _ChatMessageState(this._message);

  Future<ChatMessageModel> _load() async {
    await _message.loadUser();
    return _message;
  }

  @override
  Widget build(BuildContext context) {

    return Container(
      margin: const EdgeInsets.symmetric(horizontal: 10.0, vertical: 10.0),
      child: FutureBuilder(
        future: _load(),
        builder: (context, AsyncSnapshot<ChatMessageModel>message) {
          if (!message.hasData)
            return Container();
          return Row(
            children: <Widget>[
              Container(
                margin: const EdgeInsets.only(right: 16.0),
                child: GestureDetector(
                  child: CircleAvatar(
                    backgroundImage: NetworkImage(message.data.user.pictureUrl),
                  ),
                  onTap: () {
                    Navigator.of(context)
                        .push(MaterialPageRoute(builder: (context) => 
                        ProfileScreen(message.data.user)));
                  },
                ),
              ),
              Expanded(
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: <Widget>[
                    Text(
                      message.data.user.name,
                      style: Theme.of(context).textTheme.subhead,
                    ),
                    Container(
                        margin: const EdgeInsets.only(top: 5.0),
                        child: _message.mediaUrl != null
                            ? Image.network(_message.mediaUrl, width: 250.0)
                            : Text(_message.text))
                  ],
                ),
              )
            ],
          );
        },
      ),
    );
  }
}
class ChatMessageModel {
  String id;
  String userId;
  String text;
  String mediaUrl;
  int createdAt;
  String replyId;
  UserModel user;

  ChatMessageModel({String text, String mediaUrl, String userId}) {
    this.text = text;
    this.mediaUrl = mediaUrl;
    this.userId = userId;
  }

  ChatMessageModel.fromSnapshot(DocumentSnapshot snapshot) {
    this.id = snapshot.documentID;
    this.text = snapshot.data["text"];
    this.mediaUrl = snapshot.data["mediaUrl"];
    this.createdAt = snapshot.data["createdAt"];
    this.replyId = snapshot.data["replyId"];
    this.userId = snapshot.data["userId"];
  }

  Map toMap() {
    Map<String, dynamic> map = {
      "text": this.text,
      "mediaUrl": this.mediaUrl,
      "userId": this.userId,
      "createdAt": this.createdAt
    };
    return map;

  }

  Future<void> loadUser() async {
    DocumentSnapshot ds = await Firestore.instance
        .collection("users").document(this.userId).get();
    if (ds != null)
      this.user = UserModel.fromSnapshot(ds);
  }

}

StreamBuilder(
流：Firestore.instance
.collection（“messages”）.snapshots（），
生成器：（上下文，快照）{
交换机（快照.连接状态）{
案例连接状态。无：
案例连接状态。正在等待：
返回中心(
子项：PlatformProgressIndicator（），
);
违约：
返回ListView.builder(
相反：是的，
itemCount:snapshot.data.documents.length，
itemBuilder：（上下文，索引）{
List rev=snapshot.data.documents.reversed.toList（）；
ChatMessageModel message=ChatMessageModel.fromSnapshot（修订版[索引]）；
返回聊天室消息（message）；
},
);
}
},
)
类ChatMessage扩展StatefulWidget{
最终ChatMessageModel\u消息；
ChatMessage（此.\u消息）；
@凌驾
_ChatMessageState createState（）=>\u ChatMessageState（\u message）；
}
类ChatMessageState扩展了状态{
最终ChatMessageModel\u消息；
_ChatMessageState（此.\u消息）；
Future\u load（）异步{
wait_message.loadUser（）；
返回消息；
}
@凌驾
小部件构建（构建上下文）{
返回容器(
边距：常量边集。对称（水平：10.0，垂直：10.0），
[
  Group_A header card,
  Group_A's User_1 card,
  Group_A's User_2 card,
  Group_B header card,
  Group_B's User_1 card,
  Group_B's User_2 card,
]

class GroupWithUsers {
  final Group group;
  final List<User> users;

  GroupWithUsers(this.group, this.users);
}

    Stream<List<GroupWithUsers>> stream = Firestore.instance
        .collection(GROUP_COLLECTION_NAME)
        .orderBy('createdAt', descending: true)
        .snapshots()
        .asyncMap((QuerySnapshot groupSnap) => groupsToPairs(groupSnap));

    return StreamBuilder(
        stream: stream,
        builder: (BuildContext c, AsyncSnapshot<List<GroupWithUsers>> snapshot) {
            // build whatever
    });

  Future<List<GroupWithUsers>> groupsToPairs(QuerySnapshot groupSnap) {
    return Future.wait(groupSnap.documents.map((DocumentSnapshot groupDoc) async {
      return await groupToPair(groupDoc);
    }).toList());
  }

Future<GroupWithUsers> groupToPair(DocumentSnapshot groupDoc) {
    return Firestore.instance
        .collection(USER_COLLECTION_NAME)
        .where('groupId', isEqualTo: groupDoc.documentID)
        .orderBy('createdAt', descending: false)
        .getDocuments()
        .then((usersSnap) {
      List<User> users = [];
      for (var doc in usersSnap.documents) {
        users.add(User.from(doc));
      }

      return GroupWithUser(Group.from(groupDoc), users);
    });
  }