Utilizza gli elenchi di dati su Android

Questo documento spiega come lavorare con gli elenchi di dati in Firebase. Per conoscere le Nozioni di base sulla lettura e sulla scrittura dei dati Firebase Lettura e scrittura di dati su Android.

Ottieni un riferimento Database

Per leggere e scrivere dati dal database, è necessaria un'istanza di DatabaseReference:

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

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

Lettura e scrittura di elenchi

Aggiunta a un elenco di dati

Utilizza il metodo push() per aggiungere dati a un elenco nelle applicazioni multiutente. Il metodo push() genera una chiave univoca ogni volta che viene al riferimento Firebase specificato. Utilizzando questi chiavi generate automaticamente per ogni nuovo elemento nell'elenco, diversi client possono aggiungi elementi secondari alla stessa località contemporaneamente senza conflitti di scrittura. La chiave univoca generata da push() si basa su un timestamp, quindi le voci dell'elenco sono in ordine cronologico.

Puoi utilizzare il riferimento ai nuovi dati restituiti dal metodo push() per ottenere il valore della chiave generata automaticamente del publisher secondario o i relativi dati. Chiamata in corso getKey() su un riferimento push() restituisce il valore del parametro generata automaticamente.

Puoi utilizzare queste chiavi generate automaticamente per semplificare la suddivisione dei dati alla struttura del centro di costo. Per ulteriori informazioni, consulta il fan-out dei dati esempio.

Ascolta gli eventi bambino

Quando utilizzi gli elenchi, l'applicazione deve rilevare gli eventi figlio piuttosto che gli eventi valore utilizzati per i singoli oggetti.

Gli eventi secondari vengono attivati in risposta a operazioni specifiche che si verificano nei figli di un nodo da un'operazione, ad esempio un nuovo figlio aggiunto tramite il metodo push() o un figlio aggiornato tramite il metodo updateChildren(). Ciascuno di questi elementi insieme può essere utile per ascoltare le modifiche a un nodo specifico in un database.

Per ascoltare gli eventi secondari su DatabaseReference, allega un ChildEventListener:

Ad esempio, un'app di social blogging potrebbe utilizzare questi metodi per monitorare l'attività nei commenti di un post, come illustrato di seguito:

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

Ascolta gli eventi di valore

Mentre l'utilizzo di un ChildEventListener è il metodo consigliato per leggere gli elenchi di dati, esistono delle situazioni in cui l'aggiunta di ValueEventListener a un elenco riferimento è utile.

Se colleghi un ValueEventListener a un elenco di dati, verrà restituito l'intero elenco di dati come singolo DataSnapshot, che puoi poi ripetere in loop per accedere ai singoli bambini.

Anche quando esiste una sola corrispondenza per la query, lo snapshot è comunque una elenco; contiene un solo elemento. Per accedere all'elemento, devi eseguire un loop sul risultato:

// 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

Questo pattern può essere utile quando vuoi recuperare tutti gli elementi secondari di un elenco in una singola operazione, invece di ascoltare onChildAdded aggiuntivi eventi.

Scollega listener

I callback vengono rimossi chiamando il metodo removeEventListener() sul tuo Riferimento database Firebase.

Se un listener è stato aggiunto più volte a una posizione di dati, viene richiamate più volte per ogni evento, ma dovete scollegarlo volte per rimuoverlo completamente.

La chiamata a removeEventListener() per un listener padre non rimuove automaticamente i listener registrati sui relativi nodi figlio; removeEventListener() deve essere chiamato anche per tutti gli ascoltatori secondari per rimuovere il callback.

Ordinare e filtrare i dati

Puoi utilizzare la classe Query Realtime Database per recuperare i dati ordinati per chiave, per valore o per valore di un elemento figlio. Puoi anche filtrare il risultato ordinato in base a un numero specifico di risultati o a un intervallo di chiavi e i relativi valori.

Ordinare i dati

Per recuperare i dati ordinati, inizia specificando uno dei metodi di ordinamento per determinare l'ordinamento dei risultati:

Puoi utilizzare un solo metodo di ordine alla volta. La chiamata di un metodo di ordinamento più volte nella stessa query genera un errore.

L'esempio seguente mostra come recuperare un elenco dei post principali ordinati in base al numero di stelle:

// 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

Definisce una query che, se combinata con un listener secondario, sincronizza il client con i post dell'utente provenienti dal percorso nel database in base al loro ID utente, ordinati in base al numero di stelle ricevute da ciascun post. Questa tecnica di utilizzo degli ID come chiavi di indice è chiamata fan out dei dati. Puoi scoprire di più in Strutturare il database.

La chiamata al metodo orderByChild() specifica la chiave figlio per ordinare risultati. In questo caso, i post vengono ordinati in base al valore del rispettivo "starCount" figlio. Le query possono essere ordinate anche per secondari, nel caso in cui si disponessero di dati simili ai seguenti:

"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" : 950000,
      "likes" : 117000,
      "shares": 144,
    },
    "title" : "Using Android Architecture Components with Firebase Realtime Database (Part 3)",
    "author": "Doug",
  }
},

In questo esempio, possiamo ordinare gli elementi dell'elenco in base ai valori nidificati sotto la chiave metrics specificando il percorso relativo all'elemento secondario nidificato nella chiamata orderByChild().

// 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

Per ulteriori informazioni su come vengono ordinati gli altri tipi di dati, consulta: Come vengono ordinati i dati delle query.

Filtrare i dati

Per filtrare i dati, puoi combinare uno qualsiasi dei metodi per limiti o intervalli con un al momento di creare una query.

A differenza dei metodi di ordinamento, puoi combinare più funzioni di limite o intervallo. Ad esempio, puoi combinare i metodi startAt() e endAt() per limitare i risultati a un intervallo specificato di valori.

Anche quando esiste una sola corrispondenza per la query, lo snapshot viene comunque un elenco; contiene un solo elemento. Per accedere all'elemento, devi avere per scorrere il risultato:

// 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

Limita il numero di risultati

Puoi utilizzare i metodi limitToFirst() e limitToLast() per impostare un numero massimo di elementi secondari da sincronizzare per un determinato callback. Ad esempio, se utilizzi limitToFirst() per impostare il limite di 100, inizialmente ricevi a 100 onChildAdded() callback. Se hai meno di 100 elementi archiviati nel database Firebase, viene attivato un callback onChildAdded() per ogni elemento.

Man mano che gli elementi cambiano, ricevi onChildAdded() callback per gli elementi che entrano nel la query e onChildRemoved() callback per gli elementi che non lo sono, in modo che il numero totale rimane 100.

L'esempio seguente mostra come un'app di blogging di esempio definisce una query per recupera un elenco dei 100 post più recenti di tutti gli utenti:

// 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

Questo esempio definisce solo una query, per sincronizzare effettivamente i dati di cui ha bisogno hai un listener allegato.

Filtra per chiave o valore

Puoi utilizzare startAt(), startAfter(), endAt(), endBefore() e equalTo() per scegliere punti di inizio, fine ed equivalenza arbitrari per query. Può essere utile per impaginare i dati o per trovare elementi con bambini che hanno un valore specifico.

Come vengono ordinati i dati delle query

Questa sezione spiega come i dati vengono ordinati in base a ciascun metodo in ordine di ordinamento in Query corso.

orderByChild

Quando utilizzi orderByChild(), i dati contenenti la chiave secondaria specificata vengono ordinate come segue:

1. Gli elementi secondari con un valore null per la chiave figlio specificata per prima cosa.
2. Elementi secondari con un valore false per la chiave figlio specificata viene dopo. Se più elementi secondari hanno un valore false, vengono ordinate lessicograficamente per chiave.
3. Elementi secondari con un valore true per la chiave figlio specificata viene dopo. Se più elementi secondari hanno un valore true, vengono alfabetizzati in base alla chiave.
4. Gli elementi secondari con un valore numerico vengono visualizzati dopo, in ordine crescente. Se più elementi secondari hanno lo stesso valore numerico per il valore secondario specificato nodo, vengono ordinati per chiave.
5. Le stringhe vengono dopo i numeri e sono ordinate lessicograficamente in ordine crescente ordine. Se più elementi secondari hanno lo stesso valore per l'elemento secondario specificato nodo, sono ordinate lessicograficamente per chiave.
6. Gli oggetti sono gli ultimi e vengono ordinati in ordine lessicografico per chiave in ordine crescente.

orderByKey

Quando utilizzi orderByKey() per ordinare i dati, questi vengono restituiti in ordine crescente per chiave.

1. Gli elementi secondari con una chiave analizzabile come numero intero a 32 bit vengono visualizzati per primi e ordinati in ordine crescente.
2. Figli con un valore stringa come chiave successivo, ordinati lessicograficamente in ordine crescente.

orderByValue

Quando utilizzi orderByValue(), gli elementi secondari vengono ordinati in base al valore. I criteri di ordinamento sono gli stessi di orderByChild(), tranne per il fatto che viene utilizzato il valore del nodo anziché il valore di una chiave secondaria specificata.

Passaggi successivi

• Scopri come strutturare i dati
• Memorizzare i dati offline