Mit Datenlisten auf Android-Geräten arbeiten

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

In diesem Dokument erfahren Sie, wie Sie in Firebase mit Datenlisten arbeiten. Informationen zu den Grundlagen des Lesens und Schreibens von Firebase-Daten finden Sie unter Daten auf Android-Geräten lesen und schreiben.

DatabaseReference abrufen

Zum Lesen und Schreiben von Daten aus der Datenbank benötigen Sie eine Instanz von DatabaseReference:

private lateinit var database: DatabaseReference
// ...
database = Firebase.database.reference
ReadAndWriteSnippets.kt

private DatabaseReference mDatabase;
// ...
mDatabase = FirebaseDatabase.getInstance().getReference();
ReadAndWriteSnippets.java

Listen lesen und schreiben

Daten an eine Datenliste anhängen

Verwenden Sie die Methode push(), um einer Liste in Anwendungen für mehrere Nutzer Daten anzuhängen. Die Methode push() 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 push() generierte eindeutige Schlüssel basiert auf einem Zeitstempel. Daher werden Listenelemente automatisch chronologisch sortiert.

Sie können die Referenz auf die neuen Daten verwenden, die von der Methode push() zurückgegeben werden, um den Wert des automatisch generierten Schlüssels des untergeordneten Elements abzurufen oder Daten für das untergeordnete Element festzulegen. Wenn Sie getKey() für eine push()-Referenz aufrufen, wird der Wert des automatisch generierten Schlüssels zurückgegeben.

Mit diesen automatisch generierten Schlüsseln können Sie die Flattening-Datenstruktur vereinfachen. Weitere Informationen finden Sie im Beispiel für die Datenfan-out-Funktion.

Auf untergeordnete Ereignisse warten

Wenn Sie mit Listen arbeiten, sollte Ihre Anwendung auf untergeordnete Ereignisse achten und nicht auf die Wert-Ereignisse, die für einzelne Objekte verwendet werden.

Untergeordnete Ereignisse werden als Reaktion auf bestimmte Vorgänge ausgelöst, die mit den untergeordneten Elementen eines Knotens durch einen Vorgang stattfinden, z. B. wenn ein neues untergeordnetes Element über die Methode push() hinzugefügt oder ein untergeordnetes Element über die Methode updateChildren() aktualisiert wird. Zusammen können sie nützlich sein, um Änderungen an einem bestimmten Knoten in einer Datenbank zu überwachen.

Wenn Sie untergeordnete Ereignisse für DatabaseReference überwachen möchten, fügen Sie einen ChildEventListener hinzu:

Eine Social-Blogging-App könnte diese Methoden beispielsweise kombinieren, um Aktivitäten in den Kommentaren eines Beitrags zu überwachen, wie unten dargestellt:

val childEventListener = object : ChildEventListener {
    override fun onChildAdded(dataSnapshot: DataSnapshot, previousChildName: String?) {
        Log.d(TAG, "onChildAdded:" + dataSnapshot.key!!)

        // A new comment has been added, add it to the displayed list
        val comment = dataSnapshot.getValue<Comment>()

        // ...
    }

    override fun onChildChanged(dataSnapshot: DataSnapshot, previousChildName: String?) {
        Log.d(TAG, "onChildChanged: ${dataSnapshot.key}")

        // A comment has changed, use the key to determine if we are displaying this
        // comment and if so displayed the changed comment.
        val newComment = dataSnapshot.getValue<Comment>()
        val commentKey = dataSnapshot.key

        // ...
    }

    override fun onChildRemoved(dataSnapshot: DataSnapshot) {
        Log.d(TAG, "onChildRemoved:" + dataSnapshot.key!!)

        // A comment has changed, use the key to determine if we are displaying this
        // comment and if so remove it.
        val commentKey = dataSnapshot.key

        // ...
    }

    override fun onChildMoved(dataSnapshot: DataSnapshot, previousChildName: String?) {
        Log.d(TAG, "onChildMoved:" + dataSnapshot.key!!)

        // A comment has changed position, use the key to determine if we are
        // displaying this comment and if so move it.
        val movedComment = dataSnapshot.getValue<Comment>()
        val commentKey = dataSnapshot.key

        // ...
    }

    override fun onCancelled(databaseError: DatabaseError) {
        Log.w(TAG, "postComments:onCancelled", databaseError.toException())
        Toast.makeText(
            context,
            "Failed to load comments.",
            Toast.LENGTH_SHORT,
        ).show()
    }
}
databaseReference.addChildEventListener(childEventListener)
QueryActivity.kt

ChildEventListener childEventListener = new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String previousChildName) {
        Log.d(TAG, "onChildAdded:" + dataSnapshot.getKey());

        // A new comment has been added, add it to the displayed list
        Comment comment = dataSnapshot.getValue(Comment.class);

        // ...
    }

    @Override
    public void onChildChanged(DataSnapshot dataSnapshot, String previousChildName) {
        Log.d(TAG, "onChildChanged:" + dataSnapshot.getKey());

        // A comment has changed, use the key to determine if we are displaying this
        // comment and if so displayed the changed comment.
        Comment newComment = dataSnapshot.getValue(Comment.class);
        String commentKey = dataSnapshot.getKey();

        // ...
    }

    @Override
    public void onChildRemoved(DataSnapshot dataSnapshot) {
        Log.d(TAG, "onChildRemoved:" + dataSnapshot.getKey());

        // A comment has changed, use the key to determine if we are displaying this
        // comment and if so remove it.
        String commentKey = dataSnapshot.getKey();

        // ...
    }

    @Override
    public void onChildMoved(DataSnapshot dataSnapshot, String previousChildName) {
        Log.d(TAG, "onChildMoved:" + dataSnapshot.getKey());

        // A comment has changed position, use the key to determine if we are
        // displaying this comment and if so move it.
        Comment movedComment = dataSnapshot.getValue(Comment.class);
        String commentKey = dataSnapshot.getKey();

        // ...
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        Log.w(TAG, "postComments:onCancelled", databaseError.toException());
        Toast.makeText(mContext, "Failed to load comments.",
                Toast.LENGTH_SHORT).show();
    }
};
databaseReference.addChildEventListener(childEventListener);
QueryActivity.java

Auf Wertänderungen warten

Die Verwendung eines ChildEventListener wird zwar empfohlen, um Listen mit Daten zu lesen, es gibt aber Situationen, in denen es sinnvoll ist, einer Listenreferenz ein ValueEventListener hinzuzufügen.

Wenn Sie einer Datenliste ein ValueEventListener anhängen, wird die gesamte Datenliste als einzelnes DataSnapshot zurückgegeben. Sie können dann eine Schleife über die Liste ausführen, um auf einzelne untergeordnete Elemente zuzugreifen.

Auch wenn es nur eine Übereinstimmung für die Suchanfrage gibt, ist der Snapshot immer eine Liste, die nur ein Element enthält. Um auf den Artikel zuzugreifen, musst du das Ergebnis durchgehen:

// My top posts by number of stars
myTopPostsQuery.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(dataSnapshot: DataSnapshot) {
        for (postSnapshot in dataSnapshot.children) {
            // TODO: handle the post
        }
    }

    override fun onCancelled(databaseError: DatabaseError) {
        // Getting Post failed, log a message
        Log.w(TAG, "loadPost:onCancelled", databaseError.toException())
        // ...
    }
})
QueryActivity.kt

// My top posts by number of stars
myTopPostsQuery.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
        for (DataSnapshot postSnapshot: dataSnapshot.getChildren()) {
            // TODO: handle the post
        }
    }

    @Override
    public void onCancelled(@NonNull DatabaseError databaseError) {
        // Getting Post failed, log a message
        Log.w(TAG, "loadPost:onCancelled", databaseError.toException());
        // ...
    }
});
QueryActivity.java

Dieses Muster kann nützlich sein, wenn du alle untergeordneten Elemente einer Liste in einem einzigen Vorgang abrufen möchtest, anstatt auf zusätzliche onChildAdded-Ereignisse zu warten.

Listener trennen

Callbacks werden entfernt, indem Sie die removeEventListener()-Methode der Firebase-Datenbankreferenz aufrufen.

Wenn ein Listener einem Datenspeicherort mehrmals hinzugefügt wurde, wird er für jedes Ereignis mehrmals aufgerufen. Sie müssen ihn also genauso oft trennen, um ihn vollständig zu entfernen.

Wenn removeEventListener() auf einem übergeordneten Listener aufgerufen wird, werden die bei den untergeordneten Knoten registrierten Listener nicht automatisch entfernt. removeEventListener() muss auch auf allen untergeordneten Listenern aufgerufen werden, um den Rückruf zu entfernen.

Daten sortieren und filtern

Mit der Klasse Realtime Database Query können Sie Daten nach Schlüssel, Wert oder Wert eines untergeordneten Elements abrufen. Sie können die sortierten Ergebnisse auch auf eine bestimmte Anzahl von Ergebnissen oder einen Bereich von Schlüsseln oder Werten begrenzen.

Daten sortieren

Wenn Sie sortierte Daten abrufen möchten, müssen Sie zuerst eine der Sortierungsmethoden angeben, um zu bestimmen, wie die Ergebnisse sortiert werden:

Sie können jeweils nur eine Sortiermethode verwenden. Wenn Sie eine Methode zum Sortieren mehrmals in derselben Abfrage aufrufen, wird ein Fehler ausgegeben.

Im folgenden Beispiel wird gezeigt, wie du eine Liste der Top-Beiträge eines Nutzers abrufen kannst, sortiert nach der Anzahl der Sterne:

// My top posts by number of stars
val myUserId = uid
val myTopPostsQuery = databaseReference.child("user-posts").child(myUserId)
    .orderByChild("starCount")

myTopPostsQuery.addChildEventListener(object : ChildEventListener {
    // TODO: implement the ChildEventListener methods as documented above
    // ...
})
QueryActivity.kt

// My top posts by number of stars
String myUserId = getUid();
Query myTopPostsQuery = databaseReference.child("user-posts").child(myUserId)
        .orderByChild("starCount");
myTopPostsQuery.addChildEventListener(new ChildEventListener() {
    // TODO: implement the ChildEventListener methods as documented above
    // ...
});
QueryActivity.java

Dadurch wird eine Abfrage definiert, die in Kombination mit einem untergeordneten Listener den Client mit den Beiträgen des Nutzers aus dem Pfad in der Datenbank basierend auf seiner Nutzer-ID synchronisiert, sortiert nach der Anzahl der Sterne, die die einzelnen Beiträge erhalten haben. Diese Methode, IDs als Indexschlüssel zu verwenden, wird als Datenfan-out bezeichnet. Weitere Informationen finden Sie unter Datenbank strukturieren.

Der Aufruf der Methode orderByChild() gibt den untergeordneten Schlüssel an, nach dem die Ergebnisse sortiert werden sollen. In diesem Fall werden Beiträge nach dem Wert des jeweiligen untergeordneten "starCount"-Elements sortiert. Abfragen können auch nach verschachtelten untergeordneten Elementen sortiert werden, wenn Sie Daten wie diese haben:

"posts": {
  "ts-functions": {
    "metrics": {
      "views" : 1200000,
      "likes" : 251000,
      "shares": 1200,
    },
    "title" : "Why you should use TypeScript for writing Cloud Functions",
    "author": "Doug",
  },
  "android-arch-3": {
    "metrics": {
      "views" : 900000,
      "likes" : 117000,
      "shares": 144,
    },
    "title" : "Using Android Architecture Components with Firebase Realtime Database (Part 3)",
    "author": "Doug",
  }
},

In diesem Beispiel können wir unsere Listenelemente nach Werten sortieren, die unter dem Schlüssel metrics verschachtelt sind, indem wir den relativen Pfad zum verschachtelten untergeordneten Element in unserem orderByChild()-Aufruf angeben.

// Most viewed posts
val myMostViewedPostsQuery = databaseReference.child("posts")
    .orderByChild("metrics/views")
myMostViewedPostsQuery.addChildEventListener(object : ChildEventListener {
    // TODO: implement the ChildEventListener methods as documented above
    // ...
})
QueryActivity.kt

// Most viewed posts
Query myMostViewedPostsQuery = databaseReference.child("posts")
        .orderByChild("metrics/views");
myMostViewedPostsQuery.addChildEventListener(new ChildEventListener() {
    // TODO: implement the ChildEventListener methods as documented above
    // ...
});
QueryActivity.java

Weitere Informationen zur Sortierung anderer Datentypen finden Sie unter Sortierung von Abfragedaten.

Daten filtern

Wenn Sie Daten filtern möchten, können Sie beim Erstellen einer Abfrage eine beliebige der Methoden zum Begrenzen oder Bestimmen des Bereichs mit einer Sortiermethode kombinieren.

Im Gegensatz zu den Sortiermethoden können Sie mehrere Limit- oder Bereichsfunktionen kombinieren. Sie können beispielsweise die Methoden startAt() und endAt() kombinieren, um die Ergebnisse auf einen bestimmten Wertebereich zu beschränken.

Auch wenn es nur eine Übereinstimmung für die Abfrage gibt, ist der Snapshot immer eine Liste, die nur ein Element enthält. Um auf das Element zuzugreifen, musst du das Ergebnis durchlaufen:

// My top posts by number of stars
myTopPostsQuery.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(dataSnapshot: DataSnapshot) {
        for (postSnapshot in dataSnapshot.children) {
            // TODO: handle the post
        }
    }

    override fun onCancelled(databaseError: DatabaseError) {
        // Getting Post failed, log a message
        Log.w(TAG, "loadPost:onCancelled", databaseError.toException())
        // ...
    }
})
QueryActivity.kt

// My top posts by number of stars
myTopPostsQuery.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
        for (DataSnapshot postSnapshot: dataSnapshot.getChildren()) {
            // TODO: handle the post
        }
    }

    @Override
    public void onCancelled(@NonNull DatabaseError databaseError) {
        // Getting Post failed, log a message
        Log.w(TAG, "loadPost:onCancelled", databaseError.toException());
        // ...
    }
});
QueryActivity.java

Anzahl der Ergebnisse begrenzen

Mit den Methoden limitToFirst() und limitToLast() können Sie eine maximale Anzahl von untergeordneten Elementen festlegen, die für einen bestimmten Rückruf synchronisiert werden sollen. Wenn Sie beispielsweise mit limitToFirst() ein Limit von 100 festlegen, erhalten Sie anfangs nur bis zu 100 onChildAdded()-Callbacks. Wenn in deiner Firebase-Datenbank weniger als 100 Elemente gespeichert sind, wird für jedes Element ein onChildAdded()-Callback ausgelöst.

Wenn sich Artikel ändern, erhalten Sie onChildAdded() Callbacks für Artikel, die in die Abfrage aufgenommen werden, und onChildRemoved() Callbacks für Artikel, die daraus entfernt werden, sodass die Gesamtzahl bei 100 bleibt.

Im folgenden Beispiel wird gezeigt, wie in einer Beispiel-Blogging-App eine Abfrage definiert wird, um eine Liste der 100 aktuellsten Beiträge aller Nutzer abzurufen:

// Last 100 posts, these are automatically the 100 most recent
// due to sorting by push() keys.
databaseReference.child("posts").limitToFirst(100)
QueryActivity.kt

// Last 100 posts, these are automatically the 100 most recent
// due to sorting by push() keys
Query recentPostsQuery = databaseReference.child("posts")
        .limitToFirst(100);
QueryActivity.java

In diesem Beispiel wird nur eine Abfrage definiert. Für die tatsächliche Synchronisierung von Daten muss ein Listener angehängt sein.

Nach Schlüssel oder Wert filtern

Mit startAt(), startAfter(), endAt(), endBefore() und equalTo() können Sie beliebige Start-, End- und Äquivalenzpunkte für Abfragen auswählen. Das kann nützlich sein, um Daten zu paginarisieren oder Elemente mit untergeordneten Elementen zu finden, die einen bestimmten Wert haben.

Sortierung von Abfragedaten

In diesem Abschnitt wird erläutert, wie Daten nach den einzelnen Sortierungsmethoden in der Query-Klasse sortiert werden.

orderByChild

Bei Verwendung von orderByChild() werden Daten, die den angegebenen untergeordneten Schlüssel enthalten, so sortiert:

1. Untergeordnete Elemente mit einem null-Wert für den angegebenen untergeordneten Schlüssel werden zuerst angezeigt.
2. Als Nächstes folgen untergeordnete Elemente mit dem Wert false für den angegebenen untergeordneten Schlüssel. Wenn mehrere untergeordnete Elemente den Wert false haben, werden sie lexikografisch nach Schlüssel sortiert.
3. Als Nächstes folgen untergeordnete Elemente mit dem Wert true für den angegebenen untergeordneten Schlüssel. Wenn mehrere untergeordnete Elemente den Wert true haben, werden sie nach Schlüssel sortiert.
4. Als Nächstes folgen untergeordnete Elemente mit einem numerischen Wert, sortiert in aufsteigender Reihenfolge. Wenn mehrere untergeordnete Elemente denselben numerischen Wert für den angegebenen untergeordneten Knoten haben, werden sie nach Schlüssel sortiert.
5. Strings folgen den Zahlen und werden lexikografisch in aufsteigender Reihenfolge sortiert. Wenn mehrere untergeordnete Elemente denselben Wert für den angegebenen untergeordneten Knoten haben, werden sie nach Schlüssel sortiert.
6. Objekte kommen zuletzt und werden in aufsteigender Reihenfolge nach Schlüssel sortiert.

orderByKey

Wenn Sie Ihre Daten mit orderByKey() sortieren, werden sie in aufsteigender Reihenfolge nach Schlüssel zurückgegeben.

1. Untergeordnete Elemente mit einem Schlüssel, der als 32‑Bit-Ganzzahl geparst werden kann, werden zuerst in aufsteigender Reihenfolge sortiert.
2. Als Nächstes folgen untergeordnete Elemente mit einem Stringwert als Schlüssel, sortiert in aufsteigender lexikografischer Reihenfolge.

orderByValue

Bei Verwendung von orderByValue() werden untergeordnete Elemente nach ihrem Wert sortiert. Die Sortierkriterien sind dieselben wie bei orderByChild(), mit der Ausnahme, dass der Wert des Knotens anstelle des Werts eines angegebenen untergeordneten Schlüssels verwendet wird.

Nächste Schritte

• Weitere Informationen zum Strukturieren von Daten
• Daten offline speichern