firebase - 如何减少 Firebase Cloud Firestore 上的读取操作？

Question

作为一名热情的高中教师，我正在为我的只读应用程序使用 Firebase Cloud Firestore 和 Flutter。我的数据是大约 2000 个 image.png 文件，其中包含一些标签作为类别和子类别。类别、子类别和图像之间有一个顺序。我使用 Cloud Firestore 的原因是，我可以随时更改(= 添加、删除、更新)我的类别子类别和图像，我的用户将能够更新我的最新内容。

到目前为止一切正常，我的应用程序离线功能齐全，我可以与我的内容同步，但如果设备在线，即使数据库没有变化，Firestore 中的所有文档每次都会被读取。这让我觉得我犯了一个巨大的错误。

这是打开应用程序时发生的代码:

return FutureBuilder<QuerySnapshot>(
      future: _getCategories(),
      builder: (context, catSnapshot) {

            if((!catSnapshot.hasData) && !catSnapshot.hasError) return customProgressIndicator("Categories Synchronizing");

        if(_categories.isNotEmpty) _categories.clear();
        _categories = catSnapshot.data.documents.map<Category>((document) => Category.fromJson(document.data)).toList();

        return FutureBuilder(
          future: _getSubCategories(),
          builder: (context, subSnapshot) {
            if(!subSnapshot.hasData && !subSnapshot.hasError) return customProgressIndicator("Subcategories Synchronizing");

            if(_subcategories.isNotEmpty) _subcategories.clear();
            for(int i=0; i<_categories.length; i++) {
              String catName = _categories[i].name;
              List<Subcategory> subcategoriesI = subSnapshot.data.documents.where((document) => document.data["catName"]==catName).map<Subcategory>((document) => Subcategory.fromJson(document.data)).toList();
              _subcategories[catName] = subcategoriesI;
            }

            return RefreshIndicator(
              onRefresh: _onRefresh,
              child: _categories.length==0 ? whenNoData() : ListView.builder(
                itemBuilder: (context, i) => _createCategoryItem(i),
                itemCount: _categories.length,
                padding: EdgeInsets.all(8.0),
              ),         );       },      );    },   )

这是我的主页:

class _CategoryListPageState  extends State<CategoryListPage> {
  List<Category> _categories = [];
  Map<String, List<Subcategory>> _subcategories = {};

 Future<QuerySnapshot> _getCategories() async{

    var conn=await UserHasConnection();
    print("connection: " + conn.toString());
    Future<QuerySnapshot> snapshots;

      if (widget.isUserPro) {
        snapshots = Firestore.instance.collection("categories").where("isPro", isEqualTo: true).orderBy("showOrder").getDocuments();
        snapshots.timeout(Duration(seconds: globalTimeOut), onTimeout: () {print("Timeout Category");});
        return snapshots;
      }   else {
        snapshots = Firestore.instance.collection("categories").orderBy("showOrder").getDocuments();
        snapshots.timeout(Duration(seconds: globalTimeOut), onTimeout: () {print("Timeout Category");});
        return snapshots;
      }
  }

  _getSubCategories() async{
    Future<QuerySnapshot> snapshots;
      if(widget.isUserPro){
    snapshots=Firestore.instance.collection("subcategories").where("isPro", isEqualTo: true).orderBy("showOrder").getDocuments();
        snapshots.timeout(Duration(seconds: globalTimeOut), onTimeout: () {
          print("Timeout Subcategory");
        });
        return snapshots;
      }  else  {  snapshots=Firestore.instance.collection("subcategories").orderBy("showOrder").getDocuments();
        snapshots.timeout(Duration(seconds: globalTimeOut), onTimeout: () {
          print("Timeout Subcategory");
        });
        return snapshots;
      }
  }

这些是我的 Firestore 文档集:

categories
  isPro: boolean (there aid free and paid-proUser's)
  name: string, name of the category
  scCount: int, number of subcategories it has
  showOrder: its order among other categories

subcategories
  catName: name of the category it belongs to
  fcCount: number of image.png it has
  imageBytes: subcategories have an image
  isPro: boolean, subcategories can also be free or paid
  name: subcategories have a name
  showOrder: each subcategory has an order among other subcategories in that category
  title: title of the subcat, similar to name

flashcards
  backBytes: back image base64encoded
  backStamp
  catName: category of this image belongs to
  frontBytes: front image base64encoded
  frontStamp
  isPro: cards are also free or paid (for search function below)
  name
  showOrder: order of this card in the subcategory
  subName: name of the subcategory that this card belongs to

*** 我有针对不同设备屏幕尺寸的单独的 flascards、flashcards2x、flashcards3x 集合

还有一个搜索功能，它是从 flashcardContents 集合的 frontContent 属性完成的:

flashcardContents
  frontContent
  globalOrder
  isPro
  name
  showOrder
  updateTime
  updateType: (1-adden, 2-updated, 3-deleted)

最后，我的 FirebaseService 函数:

class FlashcardFirebaseService extends IServiceBase {
  Future<List<Flashcard>> QueryRatedFlashCards(List<Flashcard> _flashcards,
      List<String> flashcardNames, String ratioPostfix, bool isUserPro) async {
    var snapshot;
    flashcardNames.forEach((flashcardName) {
      print("flashcardName: " + flashcardName);

      if (isUserPro) {
        //For pro user
        snapshot = Firestore.instance
            .collection("flashcards${ratioPostfix}")
            .where("name", isEqualTo: flashcardName)
            .snapshots();
      } else {
        snapshot = Firestore.instance
            .collection("flashcards${ratioPostfix}")
            .where("name", isEqualTo: flashcardName)
            .where("isPro", isEqualTo: false)
            .snapshots();
      }

      snapshot.listen((onData) {
        _flashcards.addAll(onData.documents
            .map<Flashcard>((document) => Flashcard.fromJson(document.data))
            .toList());
      });
    });
    return _flashcards;
  }

  static Future<List<Category>> SyncCategories(bool isPro, double lastStamp){
    Firestore.instance
        .collection("categories")
        .getDocuments().then((data){
          return data;
    });
  }

  static Future<List<Category>> SyncSubcategories(bool isPro){
    Firestore.instance
        .collection("subcategories")
        .getDocuments().then((data){
      return data;
    });      }  }


class FlashcardSearchService extends IServiceBase {
  static Future SyncLocalSearchDb() async {
    Query baseQuery;
    AppConfig appConfig;
    appConfig = await AppConfigService.GetAppConfiguration().then((appConfig){
      if (appConfig != null) {
        var lastSyncDate;
        try {
          lastSyncDate = appConfig.fcLastSync;
        } catch (ex) {}

        print("lastSyncDate ---------------------------:"+ (lastSyncDate/1000).toString());

        baseQuery = Firestore.instance
            .collection("flashcardContents")
            .where("updateTime", isGreaterThan: lastSyncDate/1000);
      } else {
        appConfig = null;

        print("appConfig null");

        //Create all card contents
        baseQuery = Firestore.instance.collection("flashcardContents");
        appConfig = new AppConfig();
      }

      baseQuery.getDocuments().then((query) {
        query.documents.forEach((doc) => _syncFlashcardContent(doc));
        if(query.documents.length>0)
          {
            appConfig.fcLastSync = new DateTime.now().millisecondsSinceEpoch.toDouble();
            print("new lastSyncDate ---------------------------:"+ (appConfig.fcLastSync /1000).toString());
            print("SYNC!!! " + appConfig.fcLastSync.toString());
         AppConfigService.UpdateApplicationConfigurationSyncTime(appConfig);

          } else {
              print("CANT SYNC!!! " + appConfig.fcLastSync.toString());
            }
        return appConfig;
      }).timeout(Duration(seconds: globalTimeOut),onTimeout: (){
        print("TimeOutSync");
        return appConfig;
      });
    });

总而言之，我有一个抽认卡 image.png 集合供我的学生用于学习。我的内容每周都会有一定程度的变化，我希望我的用户能跟上我的步伐。问题是，如果设备在线，我的代码会不断读取所有文档，即使没有更改，即使我在几秒钟后关闭应用程序，我也会打开它。这对我来说变得负担不起了。

抱歉发了这么长的帖子，我希望至少你喜欢代码，任何想法都是有值(value)的，值得赞赏。

我发现我的应用有那么多阅读次数的主要原因是:“如果监听器断开连接超过 30 分钟(例如，如果用户离线)，您将按阅读次数付费，就好像您发出了一个全新的请求。”所以新的问题是:是否有可能改变这个听众的行为？或者有没有办法绕过它？我觉得我的应用不太适合 Firestore，但到目前为止这似乎是唯一的问题!

总结一下:我需要一个可以工作的监听器，例如，一天一次，因为我的收藏可能一天更改一次。或者我需要一种方法来绕过这个。例如，当我的应用程序离线时，监听器不起作用。在不禁用 Firestore 离线持久性的情况下禁用我的应用程序网络连接的任何选项？谢谢

Answer 1

我们在 Stack Overflow 上真的不可能诊断出您数据库上所有读取的来源，因为我们不了解您应用程序的全部操作(我们没有您的所有源代码，我们也没有了解用户的行为)。然而，一个非常常见的意外读取来源来自 Firebase 控制台本身。当您使用控制台浏览数据库时，您将花费读取次数来填充控制台。如果您在正在积极更改的集合上让控制台窗口保持打开状态，那么在控制台打开时，随着时间的推移会进一步累积读取数。