Daten mit Firebase Realtime Database für C++ speichern

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Jetzt starten

Lesen Sie zuerst den Leitfaden Get Started, wenn Sie Ihre App und den Zugriff auf die Datenbank noch nicht eingerichtet haben.

DatabaseReference abrufen

Zum Schreiben von Daten in die Datenbank 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, Daten in die Firebase Realtime Database zu schreiben:

Daten an einer Referenz schreiben, aktualisieren oder löschen

Grundlegende Schreibvorgänge

Bei einfachen Schreibvorgängen können Sie mit SetValue() Daten unter einer bestimmten Referenz speichern und alle vorhandenen Daten an diesem Pfad ersetzen. Mit dieser Methode können Sie von JSON akzeptierte Typen über einen Variantentyp übergeben, der Folgendes unterstützt:

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

Wenn Sie SetValue() auf diese Weise verwenden, werden die Daten an diesem Speicherort überschrieben, einschließlich aller untergeordneten Knoten. Sie können ein untergeordnetes Objekt jedoch aktualisieren, ohne das gesamte Objekt neu zu schreiben. Wenn Sie Nutzern erlauben möchten, ihre Profile zu aktualisieren, können Sie den Nutzernamen so aktualisieren:

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

Daten an eine Datenliste anhängen

Verwenden Sie die Methode PushChild(), um einer Liste in Anwendungen für mehrere Nutzer Daten anzuhängen. Die Methode PushChild() 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 demselben Speicherort gleichzeitig untergeordnete Elemente hinzufügen, ohne dass es zu Schreibkonflikten kommt. Der von PushChild() generierte eindeutige Schlüssel basiert auf einem Zeitstempel. Daher werden Listenelemente automatisch chronologisch sortiert.

Mit der Referenz auf die neuen Daten, die von der Methode PushChild() zurückgegeben werden, können Sie den Wert des automatisch generierten Schlüssels des untergeordneten Elements abrufen oder Daten für das untergeordnete Element festlegen. Wenn Sie GetKey() für einen PushChild()-Bezug aufrufen, wird der Wert des automatisch generierten Schlüssels zurückgegeben.

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 UpdateChildren().

Wenn Sie UpdateChildren() 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. 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&ltstd::string, Object&gt ToMap() {
    std::map&ltstring, Variant&gt result = new std::map&ltstring, Variant&gt();
    result["uid"] = Variant(uid);
    result["score"] = Variant(score);

    return result;
  }
}

Um eine LeaderboardEntry zu erstellen und gleichzeitig im Feed der letzten Ergebnisse und in der Bestenliste des Nutzers zu aktualisieren, wird im Spiel der folgende Code verwendet:

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&ltstd::string, Variant&gt entryValues = entry.ToMap();

  std::map&ltstring, Variant&gt childUpdates = new std::map&ltstring, Variant&gt();
  childUpdates["/scores/" + key] = entryValues;
  childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

  dbref.UpdateChildren(childUpdates);
}

In diesem Beispiel wird mit PushChild() ein Eintrag im Knoten erstellt, der Einträge für alle Nutzer unter /scores/$key enthält, und gleichzeitig wird der Schlüssel mit key() abgerufen. Mit dem Schlüssel kann dann ein zweiter Eintrag in den Punktzahlen des Nutzers unter /user-scores/$userid/$key erstellt werden.

Mit diesen Pfaden können Sie mit einem einzigen Aufruf von UpdateChildren() gleichzeitig mehrere Stellen im JSON-Baum aktualisieren. In diesem Beispiel wird beispielsweise der neue Eintrag an beiden Stellen erstellt. Simultane Aktualisierungen auf diese Weise sind atomar: Entweder sind alle Aktualisierungen erfolgreich oder alle schlagen fehl.

Daten löschen

Am einfachsten löschen Sie Daten, indem Sie RemoveValue() auf eine Referenz zum Speicherort dieser Daten anwenden.

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

Sie wissen, wann Ihre Daten verbindlich sind.

Wenn Sie wissen möchten, wann Ihre Daten auf dem Firebase Realtime Database-Server verbindlich festgelegt werden, prüfen Sie das Ergebnis Future.

Daten als Transaktionen speichern

Wenn Sie mit Daten arbeiten, die durch gleichzeitige Änderungen beschädigt werden können, z. B. mit inkrementellen Zählern, können Sie einen Transaktionsvorgang verwenden. Sie geben diesem Vorgang eine DoTransaction-Funktion. Diese Updatefunktion 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 Ihr neuer Wert erfolgreich geschrieben wurde, wird Ihre Aktualisierungsfunktion noch einmal mit dem neuen aktuellen Wert aufgerufen und der Schreibvorgang wird wiederholt.

In einem Spiel können Sie Nutzern beispielsweise 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() &gt= MaxScores) {
      long minScore = LONG_MAX;
      MutableData *minVal = null;
      std::vector&ltMutableData&gt children = mutableData.children();
      std::vector&ltMutableData&gt::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 &lt minScore) {
          minScore = childScore;
          minVal = &amp*it;
        }
      }
      if (minScore &gt 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&ltstd::string, Variant&gt newScoreMap =
      new std::map&ltstd::string, Variant&gt();
    newScoreMap["score"] = score;
    newScoreMap["email"] = email;
    children.Add(newScoreMap);
    mutableData->set_value(children);
    return kTransactionResultSuccess;
  });
}

Durch die Verwendung einer Transaktion wird verhindert, dass die Bestenliste falsch ist, wenn mehrere Nutzer gleichzeitig Punkte erzielen 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. Dieser Vorgang wird wiederholt, bis die Transaktion akzeptiert wird oder zu viele Versuche unternommen wurden.

Daten offline schreiben

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.

Nächste Schritte

• Daten abrufen