Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Offlinedaten aktivieren

Firestore unterstützt die Offlinedatenpersistenz. Mit diesem Feature wird eine Kopie der Firestore-Daten, die Ihre Anwendung aktiv verwendet, im Cache gespeichert, sodass Ihre Anwendung auf die Daten zugreifen kann, wenn das Gerät offline ist. Sie können die im Cache gespeicherten Daten schreiben, lesen, überwachen und abfragen. Wenn das Gerät wieder online ist, synchronisiert Firestore alle von Ihrer Anwendung vorgenommenen lokalen Änderungen mit dem Firestore-Back-End.

Wenn Sie die Offlinepersistenz verwenden möchten, müssen Sie keine Änderungen am Code vornehmen, mit dem Sie auf Firestore-Daten zugreifen. Sobald die Offlinepersistenz aktiviert ist, verwaltet die Firestore-Clientbibliothek automatisch den Online- und Offlinedatenzugriff und synchronisiert lokale Daten, wenn das Gerät wieder online ist.

Offlinepersistenz konfigurieren

Wenn Sie Firestore initialisieren, können Sie die Offlinepersistenz aktivieren oder deaktivieren:

  • Für Android und iOS ist die Offlinepersistenz standardmäßig aktiviert. Zum Deaktivieren der Persistenz setzen Sie die Option PersistenceEnabled auf false.
  • Im Web ist die Offlinepersistenz standardmäßig deaktiviert. Zum Aktivieren der Persistenz rufen Sie die Methode enablePersistence auf. Der Cache von Firestore wird zwischen den Sitzungen nicht automatisch geleert. Wenn Ihre Web-App vertrauliche Informationen verarbeitet, sollten Sie daher den Nutzer fragen, ob er ein vertrauenswürdiges Gerät verwendet, bevor Sie die Persistenz aktivieren.
Web
firebase.firestore().enablePersistence()
  .catch((err) => {
      if (err.code == 'failed-precondition') {
          // Multiple tabs open, persistence can only be enabled
          // in one tab at a a time.
          // ...
      } else if (err.code == 'unimplemented') {
          // The current browser does not support all of the
          // features required to enable persistence
          // ...
      }
  });
// Subsequent queries will use persistence, if it was enabled successfully
Swift
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
Objective-C
FIRFirestoreSettings *settings = [[FIRFirestoreSettings alloc] init];
settings.persistenceEnabled = YES;

// Any additional options
// ...

// Enable offline data persistence
FIRFirestore *db = [FIRFirestore firestore];
db.settings = settings;
  
Java
Android
FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setPersistenceEnabled(true)
        .build();
db.setFirestoreSettings(settings);
Kotlin+KTX
Android
val settings = firestoreSettings {
    isPersistenceEnabled = true
}
db.firestoreSettings = settings

Cache-Größe konfigurieren

Wenn die Persistenz aktiviert ist, speichert Firestore jedes vom Back-End empfangene Dokument für den Offlinezugriff im Cache. Firestore legt einen Standardgrenzwert für die Cache-Größe fest. Wenn der Standardwert überschritten wurde, versucht Firestore regelmäßig, ältere, nicht verwendete Dokumente zu bereinigen. Sie können einen anderen Schwellenwert für die Cache-Größe konfigurieren oder den Bereinigungsprozess vollständig deaktivieren:

Web
firebase.firestore().enablePersistence()
  .catch((err) => {
      if (err.code == 'failed-precondition') {
          // Multiple tabs open, persistence can only be enabled
          // in one tab at a a time.
          // ...
      } else if (err.code == 'unimplemented') {
          // The current browser does not support all of the
          // features required to enable persistence
          // ...
      }
  });
// Subsequent queries will use persistence, if it was enabled successfully
Web
// The default cache size threshold is 40 MB. Configure "cacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "CACHE_SIZE_UNLIMITED"
// to disable clean-up.
firebase.firestore().settings({
  cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});

firebase.firestore().enablePersistence()
  
Swift
// The default cache size threshold is 100 MB. Configure "cacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "FirestoreCacheSizeUnlimited"
// to disable clean-up.
let settings = Firestore.firestore().settings
settings.cacheSizeBytes = FirestoreCacheSizeUnlimited
Firestore.firestore().settings = settings
Objective-C
// The default cache size threshold is 100 MB. Configure "cacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "kFIRFirestoreCacheSizeUnlimited"
// to disable clean-up.
FIRFirestoreSettings *settings = [FIRFirestore firestore].settings;
settings.cacheSizeBytes = kFIRFirestoreCacheSizeUnlimited;
[FIRFirestore firestore].settings = settings;
  
Java
Android

// The default cache size threshold is 100 MB. Configure "setCacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "CACHE_SIZE_UNLIMITED"
// to disable clean-up.
FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setCacheSizeBytes(FirebaseFirestoreSettings.CACHE_SIZE_UNLIMITED)
        .build();
db.setFirestoreSettings(settings);
Kotlin+KTX
Android

// The default cache size threshold is 100 MB. Configure "setCacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "CACHE_SIZE_UNLIMITED"
// to disable clean-up.
val settings = FirebaseFirestoreSettings.Builder()
        .setCacheSizeBytes(FirebaseFirestoreSettings.CACHE_SIZE_UNLIMITED)
        .build()
db.firestoreSettings = settings

Offlinedaten überwachen

Wenn Sie die Offlinepersistenz aktiviert haben, empfangen Ihre Listener während der Offlinenutzung entsprechende Ereignisse, wenn sich die lokal im Cache gespeicherten Daten ändern. Sie können Dokumente, Sammlungen und Abfragen überwachen.

Verwenden Sie das Attribut fromCache für die SnapshotMetadata in Ihrem Snapshot-Ereignis, um zu prüfen, ob Sie Daten vom Server oder vom Cache empfangen. Wenn fromCache den Wert true hat, kamen die Daten aus dem Cache und sind möglicherweise veraltet oder unvollständig. Wenn fromCache den Wert false hat, sind die Daten vollständig und spiegeln die neuesten Aktualisierungen auf dem Server wider.

Standardmäßig wird kein Ereignis ausgelöst, wenn nur die SnapshotMetadata geändert wurden. Wenn Sie sich auf die fromCache-Werte verlassen, geben Sie beim Anhängen Ihres Überwachungs-Handlers die Überwachungsoption includeMetadataChanges an.

Web
db.collection("cities").where("state", "==", "CA")
  .onSnapshot({ includeMetadataChanges: true }, (snapshot) => {
      snapshot.docChanges().forEach((change) => {
          if (change.type === "added") {
              console.log("New city: ", change.doc.data());
          }

          var source = snapshot.metadata.fromCache ? "local cache" : "server";
          console.log("Data came from " + source);
      });
  });
Swift
// Listen to metadata updates to receive a server snapshot even if
// the data is the same as the cached data.
db.collection("cities").whereField("state", isEqualTo: "CA")
    .addSnapshotListener(includeMetadataChanges: true) { querySnapshot, error in
        guard let snapshot = querySnapshot else {
            print("Error retreiving snapshot: \(error!)")
            return
        }

        for diff in snapshot.documentChanges {
            if diff.type == .added {
                print("New city: \(diff.document.data())")
            }
        }

        let source = snapshot.metadata.isFromCache ? "local cache" : "server"
        print("Metadata: Data fetched from \(source)")
}
Objective-C
// Listen to metadata updates to receive a server snapshot even if
// the data is the same as the cached data.
[[[db collectionWithPath:@"cities"] queryWhereField:@"state" isEqualTo:@"CA"]
    addSnapshotListenerWithIncludeMetadataChanges:YES
    listener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error retreiving snapshot: %@", error);
        return;
      }
      for (FIRDocumentChange *diff in snapshot.documentChanges) {
        if (diff.type == FIRDocumentChangeTypeAdded) {
          NSLog(@"New city: %@", diff.document.data);
        }
      }

      NSString *source = snapshot.metadata.isFromCache ? @"local cache" : @"server";
      NSLog(@"Metadata: Data fetched from %@", source);
    }];
  
Java
Android
db.collection("cities").whereEqualTo("state", "CA")
        .addSnapshotListener(MetadataChanges.INCLUDE, new EventListener<QuerySnapshot>() {
            @Override
            public void onEvent(@Nullable QuerySnapshot querySnapshot,
                                @Nullable FirebaseFirestoreException e) {
                if (e != null) {
                    Log.w(TAG, "Listen error", e);
                    return;
                }

                for (DocumentChange change : querySnapshot.getDocumentChanges()) {
                    if (change.getType() == Type.ADDED) {
                        Log.d(TAG, "New city:" + change.getDocument().getData());
                    }

                    String source = querySnapshot.getMetadata().isFromCache() ?
                            "local cache" : "server";
                    Log.d(TAG, "Data fetched from " + source);
                }

            }
        });
Kotlin+KTX
Android
db.collection("cities").whereEqualTo("state", "CA")
        .addSnapshotListener(MetadataChanges.INCLUDE) { querySnapshot, e ->
            if (e != null) {
                Log.w(TAG, "Listen error", e)
                return@addSnapshotListener
            }

            for (change in querySnapshot!!.documentChanges) {
                if (change.type == DocumentChange.Type.ADDED) {
                    Log.d(TAG, "New city: ${change.document.data}")
                }

                val source = if (querySnapshot.metadata.isFromCache)
                    "local cache"
                else
                    "server"
                Log.d(TAG, "Data fetched from $source")
            }
        }

Offlinedaten abrufen

Wenn Sie ein Dokument erhalten, während das Gerät offline ist, gibt Firestore Daten aus dem Cache zurück.

Beim Abfragen einer Sammlung wird ein leeres Ergebnis zurückgegeben, wenn keine Dokumente im Cache gespeichert sind. Beim Abrufen eines bestimmten Dokuments wird stattdessen ein Fehler zurückgegeben.

Offlinedaten abfragen

Die Abfrage funktioniert mit Offlinepersistenz. Sie können die Ergebnisse von Abfragen entweder mit einem direkten "get"-Aufruf oder durch Überwachung abrufen, wie in den vorherigen Abschnitten beschrieben. Sie können auch neue Abfragen für lokal beibehaltene Daten erstellen, während das Gerät offline ist. Die Abfragen werden jedoch anfangs nur für die im Cache gespeicherten Dokumente ausgeführt.

Netzwerkzugriff deaktivieren und aktivieren

Mit der folgenden Methode können Sie den Netzwerkzugriff für Ihren Firestore-Client deaktivieren. Während der Netzwerkzugriff deaktiviert ist, rufen alle Snapshot-Listener und Dokumentanfragen Ergebnisse aus dem Cache ab. Schreibvorgänge werden so lange in die Warteschlange gestellt, bis der Netzwerkzugriff wieder aktiviert wird.

Web
firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });
Swift
Firestore.firestore().disableNetwork { (error) in
    // Do offline things
    // ...
}
Objective-C
[[FIRFirestore firestore] disableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do offline actions
  // ...
}];
  
Java
Android
db.disableNetwork()
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // Do offline things
                // ...
            }
        });
Kotlin+KTX
Android
db.disableNetwork().addOnCompleteListener {
    // Do offline things
    // ...
}

Verwenden Sie die folgende Methode, um den Netzwerkzugriff wieder zu aktivieren:

Web
firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });
Swift
Firestore.firestore().enableNetwork { (error) in
    // Do online things
    // ...
}
Objective-C
[[FIRFirestore firestore] enableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do online actions
  // ...
}];
  
Java
Android
db.enableNetwork()
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // Do online things
                // ...
            }
        });
Kotlin+KTX
Android
db.enableNetwork().addOnCompleteListener {
    // Do online things
    // ...
}