(Optional) Prototypen erstellen und mit der Firebase Emulator Suite testen
Bevor wir darüber sprechen, wie Ihre App aus der Echtzeitdatenbank liest und in sie schreibt, stellen wir eine Reihe von Tools vor, mit denen Sie Prototypen erstellen und die Funktionalität der Echtzeitdatenbank testen können: Firebase Emulator Suite. Wenn Sie verschiedene Datenmodelle ausprobieren, Ihre Sicherheitsregeln optimieren oder daran arbeiten, die kostengünstigste Möglichkeit für die Interaktion mit dem Back-End zu finden, kann die Möglichkeit, lokal zu arbeiten, ohne Live-Dienste bereitzustellen, eine gute Idee sein.
Ein Echtzeitdatenbank-Emulator ist Teil der Emulator Suite, der es Ihrer App ermöglicht, mit Ihrem emulierten Datenbankinhalt und Ihrer emulierten Datenbankkonfiguration sowie optional Ihren emulierten Projektressourcen (Funktionen, andere Datenbanken und Sicherheitsregeln) zu interagieren.emulator_suite_short
Die Verwendung des Echtzeitdatenbank-Emulators erfordert nur wenige Schritte:
- Fügen Sie der Testkonfiguration Ihrer App eine Codezeile hinzu, um eine Verbindung zum Emulator herzustellen.
- Führen Sie im Stammverzeichnis Ihres lokalen Projektverzeichnisses
firebase emulators:start. - Aufrufe aus dem Prototypcode Ihrer App wie gewohnt mit einem Realtime Database-Plattform-SDK oder mit der Realtime Database REST API durchführen.
Eine detaillierte Anleitung zu Echtzeitdatenbank- und Cloud-Funktionen ist verfügbar. Sie sollten sich auch die Einführung zur Emulator Suite ansehen.
Holen Sie sich eine Datenbankreferenz
Um Daten aus der Datenbank zu lesen oder zu schreiben, benötigen Sie eine Instanz von DatabaseReference :
DatabaseReference ref = FirebaseDatabase.instance.ref();
Daten schreiben
Dieses Dokument behandelt die Grundlagen des Lesens und Schreibens von Firebase-Daten.
Firebase-Daten werden in eine DatabaseReference geschrieben und abgerufen, indem auf von der Referenz ausgegebene Ereignisse gewartet oder darauf gehorcht wird. Ereignisse werden einmal für den Anfangszustand der Daten und jedes Mal, wenn sich die Daten ändern, ausgegeben.
Grundlegende Schreiboperationen
Für grundlegende Schreibvorgänge können Sie set() verwenden, um Daten in einer angegebenen Referenz zu speichern und alle vorhandenen Daten in diesem Pfad zu ersetzen. Sie können einen Verweis auf die folgenden Typen festlegen: String , boolean , int , double , Map , List .
Sie können beispielsweise einen Benutzer mit set() wie folgt hinzufügen:
DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");
await ref.set({
"name": "John",
"age": 18,
"address": {
"line1": "100 Mountain View"
}
});
Wenn Sie set() auf diese Weise verwenden, werden Daten am angegebenen Speicherort überschrieben, einschließlich aller untergeordneten Knoten. Sie können jedoch weiterhin ein untergeordnetes Objekt aktualisieren, ohne das gesamte Objekt neu zu schreiben. Wenn Sie Benutzern erlauben möchten, ihre Profile zu aktualisieren, können Sie den Benutzernamen wie folgt aktualisieren:
DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");
// Only update the name, leave the age and address!
await ref.update({
"age": 19,
});
Die update() Methode akzeptiert einen Unterpfad zu Knoten, sodass Sie mehrere Knoten in der Datenbank gleichzeitig aktualisieren können:
DatabaseReference ref = FirebaseDatabase.instance.ref("users");
await ref.update({
"123/age": 19,
"123/address/line1": "1 Mountain View",
});
Daten lesen
Lesen Sie Daten, indem Sie auf Wertereignisse warten
Um Daten an einem Pfad zu lesen und auf Änderungen zu warten, verwenden Sie die onValue Eigenschaft von DatabaseReference , um auf DatabaseEvent s zu warten.
Mit DatabaseEvent können Sie die Daten in einem bestimmten Pfad lesen, so wie sie zum Zeitpunkt des Ereignisses vorhanden sind. Dieses Ereignis wird einmal ausgelöst, wenn der Listener angehängt wird, und jedes Mal erneut, wenn sich die Daten, einschließlich aller untergeordneten Elemente, ändern. Das Ereignis verfügt über eine snapshot Eigenschaft, die alle Daten an diesem Ort enthält, einschließlich untergeordneter Daten. Wenn keine Daten vorhanden sind, ist die Eigenschaft „ exists “ des Snapshots „ false “ und die Eigenschaft „ value “ ist null.
Das folgende Beispiel zeigt eine Social-Blogging-Anwendung, die die Details eines Beitrags aus der Datenbank abruft:
DatabaseReference starCountRef =
FirebaseDatabase.instance.ref('posts/$postId/starCount');
starCountRef.onValue.listen((DatabaseEvent event) {
final data = event.snapshot.value;
updateStarCount(data);
});
Der Listener empfängt einen DataSnapshot , der die Daten an der angegebenen Position in der Datenbank zum Zeitpunkt des Ereignisses in seiner value enthält.
Daten einmal lesen
Einmal lesen mit get()
Das SDK ist für die Verwaltung von Interaktionen mit Datenbankservern konzipiert, unabhängig davon, ob Ihre App online oder offline ist.
Im Allgemeinen sollten Sie die oben beschriebenen Wertereignistechniken verwenden, um Daten zu lesen und über Aktualisierungen der Daten vom Backend benachrichtigt zu werden. Diese Techniken reduzieren Ihren Verbrauch und Ihre Kosten und sind darauf optimiert, Ihren Benutzern das beste Erlebnis zu bieten, wenn sie online und offline gehen.
Wenn Sie die Daten nur einmal benötigen, können Sie get() einen Snapshot der Daten aus der Datenbank abrufen. Wenn get() aus irgendeinem Grund den Serverwert nicht zurückgeben kann, prüft der Client den lokalen Speichercache und gibt eine Fehlermeldung zurück, wenn der Wert immer noch nicht gefunden wird.
Das folgende Beispiel zeigt das einmalige Abrufen des öffentlich zugänglichen Benutzernamens eines Benutzers aus der Datenbank:
final ref = FirebaseDatabase.instance.ref();
final snapshot = await ref.child('users/$userId').get();
if (snapshot.exists) {
print(snapshot.value);
} else {
print('No data available.');
}
Die unnötige Verwendung von get() kann die Nutzung der Bandbreite erhöhen und zu Leistungseinbußen führen, was durch die Verwendung eines Echtzeit-Listeners wie oben gezeigt verhindert werden kann.
Daten einmal mit Once() lesen
In einigen Fällen möchten Sie möglicherweise, dass der Wert aus dem lokalen Cache sofort zurückgegeben wird, anstatt auf dem Server nach einem aktualisierten Wert zu suchen. In diesen Fällen können Sie once() verwenden, um die Daten sofort aus dem lokalen Festplatten-Cache abzurufen.
Dies ist nützlich für Daten, die nur einmal geladen werden müssen und sich voraussichtlich nicht häufig ändern oder eine aktive Überwachung erfordern. Beispielsweise verwendet die Blogging-App in den vorherigen Beispielen diese Methode, um das Profil eines Benutzers zu laden, wenn dieser mit dem Verfassen eines neuen Beitrags beginnt:
final event = await ref.once(DatabaseEventType.value);
final username = event.snapshot.value?.username ?? 'Anonymous';
Daten aktualisieren oder löschen
Aktualisieren Sie bestimmte Felder
Um gleichzeitig auf bestimmte untergeordnete Knoten eines Knotens zu schreiben, ohne andere untergeordnete Knoten zu überschreiben, verwenden Sie die Methode update() .
Wenn Sie update() aufrufen, können Sie untergeordnete Werte auf niedrigerer Ebene aktualisieren, indem Sie einen Pfad für den Schlüssel angeben. Wenn Daten zur besseren Skalierung an mehreren Standorten gespeichert werden, können Sie alle Instanzen dieser Daten mithilfe von Daten-Fanout aktualisieren. Beispielsweise möchte eine Social-Blogging-App möglicherweise einen Beitrag erstellen und ihn gleichzeitig auf den Feed der letzten Aktivitäten und den Aktivitäts-Feed des postenden Benutzers aktualisieren. Zu diesem Zweck verwendet die Blogging-Anwendung Code wie diesen:
void writeNewPost(String uid, String username, String picture, String title,
String body) async {
// A post entry.
final postData = {
'author': username,
'uid': uid,
'body': body,
'title': title,
'starCount': 0,
'authorPic': picture,
};
// Get a key for a new Post.
final newPostKey =
FirebaseDatabase.instance.ref().child('posts').push().key;
// Write the new post's data simultaneously in the posts list and the
// user's post list.
final Map<String, Map> updates = {};
updates['/posts/$newPostKey'] = postData;
updates['/user-posts/$uid/$newPostKey'] = postData;
return FirebaseDatabase.instance.ref().update(updates);
}
In diesem Beispiel wird push() verwendet, um einen Beitrag im Knoten zu erstellen, der Beiträge für alle Benutzer unter /posts/$postid enthält, und gleichzeitig den Schlüssel mit key abzurufen. Der Schlüssel kann dann verwendet werden, um einen zweiten Eintrag in den Beiträgen des Benutzers unter /user-posts/$userid/$postid zu erstellen.
Mit diesen Pfaden können Sie mit einem einzigen Aufruf von update() gleichzeitige Aktualisierungen an mehreren Stellen im JSON-Baum durchführen, so wie in diesem Beispiel der neue Beitrag an beiden Stellen erstellt wird. Auf diese Weise durchgeführte gleichzeitige Aktualisierungen sind atomar: Entweder sind alle Aktualisierungen erfolgreich oder alle Aktualisierungen schlagen fehl.
Fügen Sie einen Abschlussrückruf hinzu
Wenn Sie wissen möchten, wann Ihre Daten festgeschrieben wurden, können Sie Abschlussrückrufe registrieren. Sowohl set() als auch update() geben Future s zurück, an die Sie Erfolgs- und Fehlerrückrufe anhängen können, die aufgerufen werden, wenn der Schreibvorgang in die Datenbank übernommen wurde und der Aufruf nicht erfolgreich war.
FirebaseDatabase.instance
.ref('users/$userId/email')
.set(emailAddress)
.then((_) {
// Data saved successfully!
})
.catchError((error) {
// The write failed...
});
Daten löschen
Der einfachste Weg, Daten zu löschen, besteht darin remove() für einen Verweis auf den Speicherort dieser Daten aufzurufen.
Sie können auch löschen, indem Sie null als Wert für einen anderen Schreibvorgang angeben, z. B. set() oder update() . Sie können diese Technik mit update() verwenden, um mehrere untergeordnete Elemente in einem einzigen API-Aufruf zu löschen.
Daten als Transaktionen speichern
Wenn Sie mit Daten arbeiten, die durch gleichzeitige Änderungen beschädigt werden könnten, z. B. inkrementelle Zähler, können Sie eine Transaktion verwenden, indem Sie einen Transaktionshandler an runTransaction() übergeben. Ein Transaktionshandler nimmt den aktuellen Zustand der Daten als Argument und gibt den neuen gewünschten Zustand zurück, den Sie schreiben möchten. Wenn ein anderer Client an den Speicherort schreibt, bevor Ihr neuer Wert erfolgreich geschrieben wurde, wird Ihre Aktualisierungsfunktion erneut mit dem neuen aktuellen Wert aufgerufen und der Schreibvorgang wird wiederholt.
In der Beispiel-Social-Blogging-App könnten Sie Benutzern beispielsweise erlauben, Beiträge zu markieren bzw. die Markierung aufzuheben und zu verfolgen, wie viele Sterne ein Beitrag wie folgt erhalten hat:
void toggleStar(String uid) async {
DatabaseReference postRef =
FirebaseDatabase.instance.ref("posts/foo-bar-123");
TransactionResult result = await postRef.runTransaction((Object? post) {
// Ensure a post at the ref exists.
if (post == null) {
return Transaction.abort();
}
Map<String, dynamic> _post = Map<String, dynamic>.from(post as Map);
if (_post["stars"] is Map && _post["stars"][uid] != null) {
_post["starCount"] = (_post["starCount"] ?? 1) - 1;
_post["stars"][uid] = null;
} else {
_post["starCount"] = (_post["starCount"] ?? 0) + 1;
if (!_post.containsKey("stars")) {
_post["stars"] = {};
}
_post["stars"][uid] = true;
}
// Return the new data.
return Transaction.success(_post);
});
}
Standardmäßig werden bei jeder Ausführung der Transaktionsaktualisierungsfunktion Ereignisse ausgelöst. Wenn Sie die Funktion also mehrmals ausführen, werden möglicherweise Zwischenzustände angezeigt. Sie können applyLocally auf false setzen, um diese Zwischenzustände zu unterdrücken und stattdessen warten, bis die Transaktion abgeschlossen ist, bevor Ereignisse ausgelöst werden:
await ref.runTransaction((Object? post) {
// ...
}, applyLocally: false);
Das Ergebnis einer Transaktion ist ein TransactionResult , das Informationen enthält, z. B. ob die Transaktion festgeschrieben wurde, und den neuen Snapshot:
DatabaseReference ref = FirebaseDatabase.instance.ref("posts/123");
TransactionResult result = await ref.runTransaction((Object? post) {
// ...
});
print('Committed? ${result.committed}'); // true / false
print('Snapshot? ${result.snapshot}'); // DataSnapshot
Eine Transaktion stornieren
Wenn Sie eine Transaktion sicher abbrechen möchten, rufen Sie Transaction.abort() auf, um eine AbortTransactionException auszulösen:
TransactionResult result = await ref.runTransaction((Object? user) {
if (user !== null) {
return Transaction.abort();
}
// ...
});
print(result.committed); // false
Atomare serverseitige Inkremente
Im obigen Anwendungsfall schreiben wir zwei Werte in die Datenbank: die ID des Benutzers, der den Beitrag markiert bzw. die Markierung aufhebt, und die erhöhte Anzahl der Sterne. Wenn wir bereits wissen, dass der Benutzer den Beitrag markiert, können wir anstelle einer Transaktion eine atomare Inkrementierungsoperation verwenden.
void addStar(uid, key) async {
Map<String, Object?> updates = {};
updates["posts/$key/stars/$uid"] = true;
updates["posts/$key/starCount"] = ServerValue.increment(1);
updates["user-posts/$key/stars/$uid"] = true;
updates["user-posts/$key/starCount"] = ServerValue.increment(1);
return FirebaseDatabase.instance.ref().update(updates);
}
Dieser Code verwendet keinen Transaktionsvorgang und wird daher nicht automatisch erneut ausgeführt, wenn es zu einem Konflikt mit der Aktualisierung kommt. Da der Inkrementierungsvorgang jedoch direkt auf dem Datenbankserver erfolgt, besteht keine Möglichkeit eines Konflikts.
Wenn Sie anwendungsspezifische Konflikte erkennen und ablehnen möchten, beispielsweise wenn ein Benutzer einen Beitrag markiert, den er bereits zuvor markiert hat, sollten Sie benutzerdefinierte Sicherheitsregeln für diesen Anwendungsfall schreiben.
Arbeiten Sie offline mit Daten
Wenn ein Client seine Netzwerkverbindung verliert, funktioniert Ihre App weiterhin ordnungsgemäß.
Jeder Client, der mit einer Firebase-Datenbank verbunden ist, verwaltet seine eigene interne Version aller aktiven Daten. Wenn Daten geschrieben werden, werden sie zuerst in diese lokale Version geschrieben. Der Firebase-Client synchronisiert diese Daten dann nach dem „Best-Effort“-Prinzip mit den Remote-Datenbankservern und mit anderen Clients.
Dadurch lösen alle Schreibvorgänge in die Datenbank sofort lokale Ereignisse aus, bevor Daten auf den Server geschrieben werden. Das bedeutet, dass Ihre App unabhängig von Netzwerklatenz oder Konnektivität reaktionsfähig bleibt.
Sobald die Verbindung wiederhergestellt ist, empfängt Ihre App die entsprechenden Ereignisse, sodass der Client mit dem aktuellen Serverstatus synchronisiert wird, ohne dass benutzerdefinierter Code geschrieben werden muss.
Weitere Informationen zum Offline-Verhalten finden Sie unter Weitere Informationen zu Online- und Offline-Funktionen .