Speichern von Daten mit Firebase Realtime Database für C++

Loslegen

Sehen Sie sich zunächst die Anleitung Get Started an, wenn Sie Ihre App und den Zugriff auf die Datenbank noch nicht eingerichtet haben.

Holen Sie sich eine Datenbankreferenz

Um Daten in die Datenbank zu schreiben, benötigen Sie eine Instanz von DatabaseReference :

    // Get the root reference location of the database.
    firebase::database::DatabaseReference dbref = database->GetReference();

Daten speichern

Es gibt vier Methoden zum Schreiben von Daten in die Firebase-Echtzeitdatenbank:

Methode Häufige Verwendungen
SetValue() Schreiben oder ersetzen Sie Daten in einen definierten Pfad, z. B. users/<user-id>/<username> .
PushChild() Zu einer Datenliste hinzufügen. Jedes Mal, wenn Sie Push() aufrufen, generiert Firebase einen eindeutigen Schlüssel, der auch als eindeutige Kennung verwendet werden kann, z. B. user-scores/<user-id>/<unique-score-id> .
UpdateChildren() Aktualisieren Sie einige Schlüssel für einen definierten Pfad, ohne alle Daten zu ersetzen.
RunTransaction() Aktualisieren Sie komplexe Daten, die durch gleichzeitige Aktualisierungen beschädigt werden könnten.

Daten an einer Referenz schreiben, aktualisieren oder löschen

Grundlegende Schreiboperationen

Für grundlegende Schreibvorgänge können Sie SetValue() verwenden, um Daten in einer angegebenen Referenz zu speichern und alle vorhandenen Daten in diesem Pfad zu ersetzen. Mit dieser Methode können Sie von JSON akzeptierte Typen über einen Variant-Typ übergeben, der Folgendes unterstützt:

  • Null (dadurch werden die Daten gelöscht)
  • Ganzzahlen (64-Bit)
  • Gleitkommazahlen mit doppelter Genauigkeit
  • Boolesche Werte
  • Saiten
  • Vektoren von Varianten
  • Zuordnungen von Strings zu Varianten

Wenn Sie SetValue() 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:

dbref.Child("users").Child(userId).Child("username").SetValue(name);

An eine Datenliste anhängen

Verwenden Sie die PushChild() Methode, um in Mehrbenutzeranwendungen Daten an eine Liste anzuhängen. Die PushChild() Methode generiert jedes Mal einen eindeutigen Schlüssel, wenn der angegebenen Firebase-Referenz ein neues untergeordnetes Element hinzugefügt wird. Durch die Verwendung dieser automatisch generierten Schlüssel für jedes neue Element in der Liste können mehrere Clients gleichzeitig Kinder an derselben Position hinzufügen, ohne dass es zu Schreibkonflikten kommt. Der von PushChild() generierte eindeutige Schlüssel basiert auf einem Zeitstempel, sodass Listenelemente automatisch chronologisch sortiert werden.

Sie können den Verweis auf die neuen Daten, die von der PushChild() Methode zurückgegeben werden, verwenden, um den Wert des automatisch generierten Schlüssels des untergeordneten Elements abzurufen oder Daten für das untergeordnete Element festzulegen. Der Aufruf GetKey() für eine PushChild() Referenz gibt den Wert des automatisch generierten Schlüssels zurück.

Aktualisieren Sie bestimmte Felder

Um gleichzeitig auf bestimmte untergeordnete Knoten eines Knotens zu schreiben, ohne andere untergeordnete Knoten zu überschreiben, verwenden Sie die Methode UpdateChildren() .

Wenn Sie UpdateChildren() 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. Ein Spiel könnte beispielsweise eine LeaderboardEntry Klasse wie diese haben:

class LeaderboardEntry {
  std::string uid;
  int score = 0;

 public:
  LeaderboardEntry() {
  }

  LeaderboardEntry(std::string uid, int score) {
    this->uid = uid;
    this->score = score;
  }

  std::map<std::string, Object> ToMap() {
    std::map<string, Variant> result = new std::map<string, Variant>();
    result["uid"] = Variant(uid);
    result["score"] = Variant(score);

    return result;
  }
}

Um einen LeaderboardEntry zu erstellen und ihn gleichzeitig mit dem aktuellen Punkte-Feed und der eigenen Punkteliste des Benutzers zu aktualisieren, verwendet das Spiel den folgenden Code:

void WriteNewScore(std::string userId, int score) {
  // Create new entry at /user-scores/$userid/$scoreid and at
  // /leaderboard/$scoreid simultaneously
  std::string key = dbref.Child("scores").PushChild().GetKey();
  LeaderBoardEntry entry = new LeaderBoardEntry(userId, score);
  std::map<std::string, Variant> entryValues = entry.ToMap();

  std::map<string, Variant> childUpdates = new std::map<string, Variant>();
  childUpdates["/scores/" + key] = entryValues;
  childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

  dbref.UpdateChildren(childUpdates);
}

In diesem Beispiel wird PushChild() verwendet, um einen Eintrag im Knoten zu erstellen, der Einträge für alle Benutzer unter /scores/$key enthält, und gleichzeitig den Schlüssel mit key() abzurufen. Der Schlüssel kann dann verwendet werden, um einen zweiten Eintrag in den Punktzahlen des Benutzers unter /user-scores/$userid/$key zu erstellen.

Mit diesen Pfaden können Sie mit einem einzigen Aufruf von UpdateChildren() gleichzeitige Aktualisierungen an mehreren Stellen im JSON-Baum durchführen, so wie in diesem Beispiel der neue Eintrag an beiden Stellen erstellt wird. Auf diese Weise durchgeführte gleichzeitige Aktualisierungen sind atomar: Entweder sind alle Aktualisierungen erfolgreich oder alle Aktualisierungen schlagen fehl.

Daten löschen

Der einfachste Weg, Daten zu löschen, besteht darin RemoveValue() für einen Verweis auf den Speicherort dieser Daten aufzurufen.

Sie können auch löschen, indem Sie einen null Variant als Wert für einen anderen Schreibvorgang angeben, z. B. SetValue() oder UpdateChildren() . Sie können diese Technik mit UpdateChildren() verwenden, um mehrere untergeordnete Elemente in einem einzigen API-Aufruf zu löschen.

Erfahren Sie, wann Ihre Daten festgeschrieben werden.

Um zu erfahren, wann Ihre Daten an den Firebase-Echtzeitdatenbankserver übertragen werden, überprüfen Sie das zukünftige Ergebnis auf Erfolg.

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 Transaktionsoperation verwenden. Sie geben dieser Operation eine DoTransaction Funktion. Diese Aktualisierungsfunktion 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 einem Spiel könnten Sie beispielsweise Benutzern erlauben, eine Bestenliste mit den fünf höchsten Punktzahlen zu aktualisieren:

void AddScoreToLeaders(std::string email,
                       long score,
                       DatabaseReference leaderBoardRef) {
  leaderBoardRef.RunTransaction([](firebase::database::MutableData* mutableData) {
    if (mutableData.children_count() >= MaxScores) {
      long minScore = LONG_MAX;
      MutableData *minVal = null;
      std::vector<MutableData> children = mutableData.children();
      std::vector<MutableData>::iterator it;
      for (it = children.begin(); it != children.end(); ++it) {
        if (!it->value().is_map())
          continue;
        long childScore = (long)it->Child("score").value().int64_value();
        if (childScore < minScore) {
          minScore = childScore;
          minVal = &*it;
        }
      }
      if (minScore > score) {
        // The new score is lower than the existing 5 scores, abort.
        return kTransactionResultAbort;
      }

      // Remove the lowest score.
      children.Remove(minVal);
    }

    // Add the new high score.
    std::map<std::string, Variant> newScoreMap =
      new std::map<std::string, Variant>();
    newScoreMap["score"] = score;
    newScoreMap["email"] = email;
    children.Add(newScoreMap);
    mutableData->set_value(children);
    return kTransactionResultSuccess;
  });
}

Mithilfe einer Transaktion wird verhindert, dass die Bestenliste falsch ist, wenn mehrere Benutzer gleichzeitig Punktestände erfassen oder der Client über veraltete Daten verfügt. Wenn die Transaktion abgelehnt wird, gibt der Server den aktuellen Wert an den Client zurück, der die Transaktion erneut mit dem aktualisierten Wert ausführt. Dies wiederholt sich, bis die Transaktion akzeptiert wird oder zu viele Versuche unternommen wurden.

Daten offline schreiben

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.

Nächste Schritte