Optional: Prototyp erstellen und mit Firebase Local Emulator Suite testen
Bevor wir uns damit befassen, wie Ihre App Daten aus Realtime Database liest und in Realtime Database schreibt, stellen wir Ihnen einige Tools vor, mit denen Sie Prototypen erstellen und die Realtime Database-Funktionen testen können: Firebase Local Emulator Suite. Wenn Sie verschiedene Datenmodelle ausprobieren, Ihre Sicherheitsregeln optimieren oder die kostengünstigste Möglichkeit zur Interaktion mit dem Back-End finden möchten, kann es sehr hilfreich sein, lokal arbeiten zu können, ohne Live-Dienste bereitzustellen.
Ein Realtime Database-Emulator ist Teil des Local Emulator Suite. Er ermöglicht es Ihrer App, mit den emulierten Datenbankinhalten und der emulierten Konfiguration sowie optional mit den emulierten Projektressourcen (Funktionen, anderen Datenbanken und Sicherheitsregeln) zu interagieren.
Die Verwendung des Realtime Database-Emulators ist ganz einfach:
- 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:startaus. - Sie können wie gewohnt über ein Realtime Database-Plattform-SDK oder die Realtime Database REST API Aufrufe aus dem Prototypcode Ihrer App starten.
Eine detaillierte Anleitung für Realtime Database und Cloud Functions ist verfügbar. Sehen Sie sich auch die Local Emulator SuiteEinführung an.
Datenbankreferenz abrufen
Wenn Sie Daten aus der Datenbank lesen oder schreiben möchten, benötigen Sie eine Instanz von firebase.database.Reference:
Web
import { getDatabase } from "firebase/database";
const database = getDatabase();
Web
var database = firebase.database();
Daten schreiben
In diesem Dokument werden die Grundlagen des Abrufens von Daten und die Sortierung und Filterung von Firebase-Daten erläutert.
Firebase-Daten werden abgerufen, indem Sie einen asynchronen Listener zu firebase.database.Reference anfügen. Der Listener wird einmal für den anfänglichen Status der Daten und dann bei jeder Änderung der Daten ausgelöst.
Grundlegende Schreibvorgänge
Bei einfachen Schreibvorgängen können Sie mit set() Daten in einer bestimmten Referenz speichern und alle vorhandenen Daten an diesem Pfad ersetzen. Eine Social-Blogging-Anwendung könnte beispielsweise einen Nutzer mit set() so hinzufügen:
Web
import { getDatabase, ref, set } from "firebase/database";
function writeUserData(userId, name, email, imageUrl) {
const db = getDatabase();
set(ref(db, 'users/' + userId), {
username: name,
email: email,
profile_picture : imageUrl
});
}
Web
function writeUserData(userId, name, email, imageUrl) {
firebase.database().ref('users/' + userId).set({
username: name,
email: email,
profile_picture : imageUrl
});
}
Wenn Sie set() verwenden, werden die Daten an dem angegebenen Speicherort überschrieben, einschließlich aller untergeordneten Knoten.
Daten lesen
Auf Wertänderungen warten
Wenn Sie Daten an einem Pfad lesen und auf Änderungen warten möchten, verwenden Sie onValue(), um Ereignisse zu beobachten. Mit diesem Ereignis können Sie statische Snapshots der Inhalte an einem bestimmten Pfad lesen, wie sie zum Zeitpunkt des Ereignisses vorhanden waren. Diese Methode wird einmal ausgelöst, wenn der Listener angehängt wird, und dann jedes Mal, wenn sich die Daten, einschließlich der untergeordneten Elemente, ändern. Dem Ereignis-Callback wird ein Snapshot übergeben, der alle Daten an diesem Speicherort enthält, einschließlich untergeordneter Daten. Wenn keine Daten vorhanden sind, gibt der Snapshot false zurück, wenn exists() aufgerufen wird, und null, wenn val() aufgerufen wird.
Im folgenden Beispiel wird eine Social-Blogging-Anwendung veranschaulicht, die die Anzahl der Sterne eines Beitrags aus der Datenbank abruft:
Web
import { getDatabase, ref, onValue } from "firebase/database";
const db = getDatabase();
const starCountRef = ref(db, 'posts/' + postId + '/starCount');
onValue(starCountRef, (snapshot) => {
const data = snapshot.val();
updateStarCount(postElement, data);
});
Web
var starCountRef = firebase.database().ref('posts/' + postId + '/starCount');
starCountRef.on('value', (snapshot) => {
const data = snapshot.val();
updateStarCount(postElement, data);
});
Der Listener empfängt ein snapshot, das die Daten am angegebenen Speicherort in der Datenbank zum Zeitpunkt des Ereignisses enthält. Sie können die Daten in der snapshot mit der Methode val() abrufen.
Daten einmal lesen
Daten einmal mit get() lesen
Das SDK wurde entwickelt, um Interaktionen mit Datenbankservern zu verwalten, unabhängig davon, ob Ihre App online oder offline ist.
Im Allgemeinen sollten Sie die oben beschriebenen Methoden für Wert-Ereignisse verwenden, um Daten zu lesen und über Aktualisierungen der Daten aus dem Backend benachrichtigt zu werden. Die Abrufmethoden reduzieren die Nutzung und Abrechnung und sind so optimiert, dass Nutzer beim Wechsel zwischen Online- und Offlinemodus die bestmögliche Leistung erhalten.
Wenn Sie die Daten nur einmal benötigen, können Sie mit get() einen Snapshot der Daten aus der Datenbank abrufen. Wenn get() den Serverwert aus irgendeinem Grund nicht zurückgeben kann, sucht der Client im Cache des lokalen Speichers und gibt einen Fehler zurück, wenn der Wert immer noch nicht gefunden wird.
Die unnötige Verwendung von get() kann die Bandbreitennutzung erhöhen und zu Leistungseinbußen führen. Dies kann durch die Verwendung eines Echtzeit-Listeners wie oben gezeigt verhindert werden.
Web
import { getDatabase, ref, child, get } from "firebase/database";
const dbRef = ref(getDatabase());
get(child(dbRef, `users/${userId}`)).then((snapshot) => {
if (snapshot.exists()) {
console.log(snapshot.val());
} else {
console.log("No data available");
}
}).catch((error) => {
console.error(error);
});
Web
const dbRef = firebase.database().ref();
dbRef.child("users").child(userId).get().then((snapshot) => {
if (snapshot.exists()) {
console.log(snapshot.val());
} else {
console.log("No data available");
}
}).catch((error) => {
console.error(error);
});
Daten einmal mit einem Beobachter lesen
In einigen Fällen möchten Sie möglicherweise, dass der Wert aus dem lokalen Cache sofort zurückgegeben wird, anstatt nach einem aktualisierten Wert auf dem Server zu suchen. In diesen Fällen können Sie once() verwenden, um die Daten sofort aus dem lokalen Laufwerkcache abzurufen.
Das ist nützlich für Daten, die nur einmal geladen werden müssen und sich voraussichtlich nicht häufig ändern oder für die aktives Zuhören erforderlich ist. In der Blogging-App aus den vorherigen Beispielen wird diese Methode beispielsweise verwendet, um das Profil eines Nutzers zu laden, wenn er mit dem Verfassen eines neuen Beitrags beginnt:
Web
import { getDatabase, ref, onValue } from "firebase/database";
import { getAuth } from "firebase/auth";
const db = getDatabase();
const auth = getAuth();
const userId = auth.currentUser.uid;
return onValue(ref(db, '/users/' + userId), (snapshot) => {
const username = (snapshot.val() && snapshot.val().username) || 'Anonymous';
// ...
}, {
onlyOnce: true
});
Web
var userId = firebase.auth().currentUser.uid;
return firebase.database().ref('/users/' + userId).once('value').then((snapshot) => {
var username = (snapshot.val() && snapshot.val().username) || 'Anonymous';
// ...
});
Daten aktualisieren oder löschen
Bestimmte Felder aktualisieren
Wenn Sie gleichzeitig in bestimmte untergeordnete Elemente eines Knotens schreiben möchten, ohne andere untergeordnete Knoten zu überschreiben, verwenden Sie die Methode update().
Wenn Sie update() aufrufen, können Sie untergeordnete Werte der unteren Ebene aktualisieren, indem Sie einen Pfad für den Schlüssel angeben. Wenn Daten zur besseren Skalierung an mehreren Orten gespeichert werden, können Sie alle Instanzen dieser Daten mithilfe der Datenfan-out-Funktion aktualisieren.
In einer App für soziales Bloggen kann beispielsweise ein Beitrag erstellt und gleichzeitig im Feed der letzten Aktivitäten und im Feed der Aktivitäten des Nutzers, der den Beitrag gepostet hat, aktualisiert werden. Dazu wird Code wie dieser verwendet:
Web
import { getDatabase, ref, child, push, update } from "firebase/database";
function writeNewPost(uid, username, picture, title, body) {
const db = getDatabase();
// A post entry.
const postData = {
author: username,
uid: uid,
body: body,
title: title,
starCount: 0,
authorPic: picture
};
// Get a key for a new Post.
const newPostKey = push(child(ref(db), 'posts')).key;
// Write the new post's data simultaneously in the posts list and the user's post list.
const updates = {};
updates['/posts/' + newPostKey] = postData;
updates['/user-posts/' + uid + '/' + newPostKey] = postData;
return update(ref(db), updates);
}
Web
function writeNewPost(uid, username, picture, title, body) {
// A post entry.
var postData = {
author: username,
uid: uid,
body: body,
title: title,
starCount: 0,
authorPic: picture
};
// Get a key for a new Post.
var newPostKey = firebase.database().ref().child('posts').push().key;
// Write the new post's data simultaneously in the posts list and the user's post list.
var updates = {};
updates['/posts/' + newPostKey] = postData;
updates['/user-posts/' + uid + '/' + newPostKey] = postData;
return firebase.database().ref().update(updates);
}
In diesem Beispiel wird push() verwendet, um einen Beitrag im Knoten zu erstellen, der Beiträge für alle Nutzer unter /posts/$postid enthält, und gleichzeitig den Schlüssel abzurufen. Mit dem Schlüssel kann dann ein zweiter Eintrag in den Beiträgen des Nutzers unter /user-posts/$userid/$postid erstellt werden.
Mit diesen Pfaden kannst du mit einem einzigen Aufruf von update() gleichzeitig mehrere Stellen im JSON-Baum aktualisieren. In diesem Beispiel wird beispielsweise der neue Beitrag an beiden Stellen erstellt. Simultane Aktualisierungen auf diese Weise sind atomar: Entweder sind alle Aktualisierungen erfolgreich oder alle schlagen fehl.
Abschluss-Callback hinzufügen
Wenn Sie wissen möchten, wann Ihre Daten verbindlich gespeichert wurden, können Sie einen Abschluss-Callback hinzufügen. Sowohl set() als auch update() akzeptieren einen optionalen Abschluss-Callback, der aufgerufen wird, wenn die Daten in der Datenbank verbindlich festgelegt wurden. Wenn der Aufruf fehlgeschlagen ist, wird dem Callback ein Fehlerobjekt übergeben, das angibt, warum der Fehler aufgetreten ist.
Web
import { getDatabase, ref, set } from "firebase/database";
const db = getDatabase();
set(ref(db, 'users/' + userId), {
username: name,
email: email,
profile_picture : imageUrl
})
.then(() => {
// Data saved successfully!
})
.catch((error) => {
// The write failed...
});
Web
firebase.database().ref('users/' + userId).set({
username: name,
email: email,
profile_picture : imageUrl
}, (error) => {
if (error) {
// The write failed...
} else {
// Data saved successfully!
}
});
Daten löschen
Am einfachsten lassen sich Daten löschen, indem Sie remove() auf eine Referenz zum Speicherort dieser Daten anwenden.
Sie können auch löschen, indem Sie null als Wert für einen anderen Schreibvorgang wie set() oder update() angeben. Mit dieser Methode und update() können Sie mehrere untergeordnete Elemente in einem einzigen API-Aufruf löschen.
Promise erhalten
Wenn Sie wissen möchten, wann Ihre Daten auf dem Firebase Realtime Database-Server verbindlich gespeichert werden, können Sie einen Promise verwenden.
Sowohl set() als auch update() können eine Promise zurückgeben, anhand derer Sie erkennen können, wann die Schreibvorgänge in der Datenbank verbindlich werden.
Listener trennen
Callbacks werden entfernt, indem Sie die off()-Methode der Firebase-Datenbankreferenz aufrufen.
Sie können einen einzelnen Listener entfernen, indem Sie ihn als Parameter an off() übergeben.
Wenn Sie off() für den Standort ohne Argumente aufrufen, werden alle Listener an diesem Standort entfernt.
Wenn off() auf einen übergeordneten Listener angewendet wird, werden die bei den untergeordneten Knoten registrierten Listener nicht automatisch entfernt. off() muss auch auf alle untergeordneten Listener angewendet werden, um den Rückruf zu entfernen.
Daten als Transaktionen speichern
Wenn Sie mit Daten arbeiten, die durch gleichzeitige Änderungen beschädigt werden könnten, z. B. mit inkrementellen Zählern, können Sie einen Transaktionsvorgang verwenden. Sie können diesem Vorgang eine Aktualisierungsfunktion und einen optionalen Rückruf bei Abschluss zuweisen. Die Update-Funktion nimmt den aktuellen Status der Daten als Argument und gibt den neuen gewünschten Status zurück, den Sie schreiben möchten. Wenn ein anderer Client an den Speicherort schreibt, bevor der neue Wert erfolgreich geschrieben wurde, wird die Aktualisierungsfunktion noch einmal mit dem neuen aktuellen Wert aufgerufen und der Schreibvorgang wird noch einmal versucht.
In der Beispiel-App für soziales Bloggen könnten Sie Nutzern beispielsweise erlauben, Beiträge zu bewerten und die Anzahl der Sterne zu verfolgen, die ein Beitrag erhalten hat. Dazu gehen Sie so vor:
Web
import { getDatabase, ref, runTransaction } from "firebase/database";
function toggleStar(uid) {
const db = getDatabase();
const postRef = ref(db, '/posts/foo-bar-123');
runTransaction(postRef, (post) => {
if (post) {
if (post.stars && post.stars[uid]) {
post.starCount--;
post.stars[uid] = null;
} else {
post.starCount++;
if (!post.stars) {
post.stars = {};
}
post.stars[uid] = true;
}
}
return post;
});
}
Web
function toggleStar(postRef, uid) {
postRef.transaction((post) => {
if (post) {
if (post.stars && post.stars[uid]) {
post.starCount--;
post.stars[uid] = null;
} else {
post.starCount++;
if (!post.stars) {
post.stars = {};
}
post.stars[uid] = true;
}
}
return post;
});
}
Durch die Verwendung einer Transaktion wird verhindert, dass die Anzahl der Sterne falsch ist, wenn mehrere Nutzer gleichzeitig denselben Beitrag mit einem Stern markieren oder der Client veraltete Daten hat. Wenn die Transaktion abgelehnt wird, gibt der Server den aktuellen Wert an den Client zurück, der die Transaktion dann noch einmal mit dem aktualisierten Wert ausführt. Dies wird wiederholt, bis die Transaktion akzeptiert wird oder Sie sie abbrechen.
Atomare serverseitige Increments
Im obigen Anwendungsfall schreiben wir zwei Werte in die Datenbank: die ID des Nutzers, der dem Beitrag ein bzw. kein Sternchen gibt, und die inkrementierte Anzahl der Sterne. Wenn wir bereits wissen, dass der Nutzer den Beitrag mit einem Stern markiert, können wir anstelle einer Transaktion einen atomaren Inkrementierungsvorgang verwenden.
Web
function addStar(uid, key) {
import { getDatabase, increment, ref, update } from "firebase/database";
const dbRef = ref(getDatabase());
const updates = {};
updates[`posts/${key}/stars/${uid}`] = true;
updates[`posts/${key}/starCount`] = increment(1);
updates[`user-posts/${key}/stars/${uid}`] = true;
updates[`user-posts/${key}/starCount`] = increment(1);
update(dbRef, updates);
}
Web
function addStar(uid, key) {
const updates = {};
updates[`posts/${key}/stars/${uid}`] = true;
updates[`posts/${key}/starCount`] = firebase.database.ServerValue.increment(1);
updates[`user-posts/${key}/stars/${uid}`] = true;
updates[`user-posts/${key}/starCount`] = firebase.database.ServerValue.increment(1);
firebase.database().ref().update(updates);
}
Da in diesem Code kein Transaktionsvorgang verwendet wird, wird er nicht automatisch neu ausgeführt, wenn es ein in Konflikt stehendes Update gibt. Da der Inkrementenvorgang jedoch direkt auf dem Datenbankserver ausgeführt wird, besteht keine Gefahr eines Konflikts.
Wenn Sie anwendungsspezifische Konflikte erkennen und ablehnen möchten, z. B. wenn ein Nutzer einem Beitrag ein Sternchen hinzufügt, das er ihm bereits zuvor gegeben hat, sollten Sie benutzerdefinierte Sicherheitsregeln für diesen Anwendungsfall schreiben.
Offline mit Daten arbeiten
Wenn ein Client die Netzwerkverbindung verliert, funktioniert Ihre App weiterhin ordnungsgemäß.
Jeder Client, der mit einer Firebase-Datenbank verbunden ist, verwaltet seine eigenen internen Versionen aller aktiven Daten. Beim Schreiben von Daten werden sie zuerst in diese lokale Version geschrieben. Der Firebase-Client synchronisiert diese Daten dann auf Best-Effort-Basis mit den Remote-Datenbankservern und anderen Clients.
Daher werden alle Schreibvorgänge in der Datenbank sofort als lokale Ereignisse ausgelöst, bevor Daten auf den Server geschrieben werden. So bleibt Ihre App unabhängig von der Netzwerklatenz oder der Verbindung reaktionsschnell.
Sobald die Verbindung wiederhergestellt ist, erhält Ihre App die entsprechenden Ereignisse, damit der Client mit dem aktuellen Serverstatus synchronisiert wird, ohne dass benutzerdefinierter Code geschrieben werden muss.
Weitere Informationen zum Offlineverhalten finden Sie unter Weitere Informationen zu Online- und Offlinefunktionen.