Utilizza gli elenchi di dati su Android

Questo documento illustra come utilizzare gli elenchi di dati in Firebase. Per apprendere le nozioni di base sulla lettura e sulla scrittura di dati Firebase, consulta Lettura e scrittura di dati su Android.

Nota: per impostazione predefinita, l'accesso in lettura e scrittura al database è limitato, pertanto solo gli utenti autenticati possono leggere o scrivere dati. Per iniziare senza configurare Authentication, puoi configurare le regole per l'accesso pubblico. In questo modo, il tuo database sarà aperto a chiunque, anche a chi non utilizza la tua app, quindi assicurati di limitare di nuovo il database quando configuri l'autenticazione.

Ottieni un riferimento Database

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

Kotlin+KTX

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

Java

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

Lettura e scrittura di elenchi

Aggiungere elementi 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 aggiunto un nuovo asset secondario al riferimento Firebase specificato. Utilizzando queste chiavi generate automaticamente per ogni nuovo elemento dell'elenco, diversi client possono aggiungere contemporaneamente elementi figlio alla stessa località senza conflitti di scrittura. La chiave unica generata da push() si basa su un timestamp, pertanto gli elementi dell'elenco vengono ordinati automaticamente in ordine cronologico.

Puoi utilizzare il riferimento ai nuovi dati restituiti dal metodo push() per ottenere il valore della chiave generata automaticamente dell'elemento secondario o impostare i dati per l'elemento secondario. La chiamata a getKey() su un riferimento push() restituisce il valore della chiave generata automaticamente.

Puoi utilizzare queste chiavi generate automaticamente per semplificare l'appiattimento della struttura dei dati. Per ulteriori informazioni, consulta l'esempio di fan-out dei dati.

Ascolta gli eventi secondari

Quando lavori con gli elenchi, l'applicazione deve ascoltare gli eventi secondari anziché gli eventi di 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(). Insieme, questi elementi possono essere utili per ascoltare le modifiche apportate a un nodo specifico in un database.

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

modulo	Callback evento	Utilizzo tipico
ChildEventListener	onChildAdded()	Recupera elenchi di articoli o ascolta le aggiunte a un elenco di articoli. Questo callback viene attivato una volta per ogni elemento figlio esistente e poi di nuovo ogni volta che viene aggiunto un nuovo asset secondario al percorso specificato. Il valore DataSnapshot passato all'ascoltatore contiene i dati del nuovo bambino.
	onChildChanged()	Rileva le modifiche agli elementi di un elenco. Questo evento viene attivato ogni volta che un nodo figlio viene modificato, comprese eventuali modifiche ai discendenti del nodo figlio. L'oggetto DataSnapshot passato all'ascoltatore di eventi contiene i dati aggiornati per l'elemento secondario.
	onChildRemoved()	Ascolta gli elementi che vengono rimossi da un elenco. Il valore DataSnapshot passato al callback dell'evento contiene i dati dell'elemento secondario rimosso.
	onChildMoved()	Rileva le modifiche all'ordine degli elementi in un elenco ordinato. Questo evento viene attivato ogni volta che il callback onChildChanged() viene attivato da un aggiornamento che causa il riordinamento dell'elemento secondario. Viene utilizzato con i dati ordinati con orderByChild o orderByValue.

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

Kotlin+KTX

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

Java

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 relativi ai valori

Sebbene l'utilizzo di un ChildEventListener sia il modo consigliato per leggere gli elenchi di dati, in alcune situazioni è utile associare un ValueEventListener a un riferimento all'elenco.

Se colleghi un ValueEventListener a un elenco di dati, viene restituito l'intero elenco di dati come un singolo ValueEventListener, che puoi poi eseguire in loop per accedere ai singoli elementi secondari.DataSnapshot

Anche se esiste una sola corrispondenza per la query, lo snapshot è comunque un elenco, ma contiene un solo elemento. Per accedere all'elemento, devi scorrere sul risultato:

Kotlin+KTX

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

Java

// 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 un'unica operazione, anziché ascoltare altri eventi onChildAdded.

Scollegare gli ascoltatori

I callback vengono rimossi chiamando il metodo removeEventListener() sul riferimento al database Firebase.

Se un ascoltatore è stato aggiunto più volte a una posizione dei dati, viene chiamato più volte per ogni evento e devi scollegarlo lo stesso numero di volte per rimuoverlo completamente.

La chiamata di removeEventListener() su un listener padre non comporta la rimozione automatica dei listener registrati sui nodi figlio; removeEventListener() deve essere chiamato anche su tutti i listener figlio per rimuovere il callback.

Ordinamento e filtri dei dati

Puoi utilizzare la classe Query Realtime Database per recuperare i dati ordinati per chiave, valore o 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 o valori.

Nota: l'applicazione di filtri e l'ordinamento possono essere costosi, soprattutto se eseguiti sul client. Se la tua app utilizza query, definisci la regola .indexOn per indicizzare queste chiavi sul server e migliorare le prestazioni delle query come descritto in Indicizzazione dei dati.

Ordinare i dati

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

Metodo	Utilizzo
orderByChild()	Ordina i risultati in base al valore di una chiave secondaria o di un percorso secondario nidificato specificato.
orderByKey()	Ordina i risultati per chiavi secondarie.
orderByValue()	Ordina i risultati in base ai valori secondari.

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

L'esempio seguente mostra come recuperare un elenco dei post più popolari di un utente, ordinati in base al numero di stelle:

Kotlin+KTX

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

Java

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

Questa definisce una query che, se combinata con un listener secondario, consente di sincronizzare il client con i post dell'utente dal percorso nel database in base al relativo ID utente, ordinati in base al numero di stelle ricevute da ogni 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 secondaria in base alla quale ordinare i risultati. In questo caso, i post vengono ordinati in base al valore del rispettivo elemento figlio "starCount". Le query possono essere ordinate anche per elementi figli nidificati, nel caso in cui tu abbia dati come:

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

Kotlin+KTX

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

Java

// 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 sull'ordinamento di altri tipi di dati, consulta Come vengono ordinati i dati delle query.

Filtrare i dati

Per filtrare i dati, puoi combinare uno dei metodi di limite o intervallo con un metodo di ordinamento durante la creazione di una query.

Metodo	Utilizzo
limitToFirst()	Imposta il numero massimo di elementi da restituire dall'inizio dell'elenco ordinato dei risultati.
limitToLast()	Imposta il numero massimo di elementi da restituire dalla fine dell'elenco ordinato dei risultati.
startAt()	Restituisce gli elementi maggiori o uguali alla chiave o al valore specificato a seconda del metodo di ordinamento scelto.
startAfter()	Restituisce gli elementi maggiori della chiave o del valore specificato a seconda del metodo di ordinamento scelto.
endAt()	Restituisce gli elementi minori o uguali alla chiave o al valore specificato a seconda del metodo di ordinamento scelto.
endBefore()	Restituisce gli elementi inferiori alla chiave o al valore specificato a seconda del metodo di ordinamento scelto.
equalTo()	Restituisce gli elementi uguali alla chiave o al valore specificato a seconda del metodo di ordinamento scelto.

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 di valori specificato.

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

Kotlin+KTX

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

Java

// 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 un limite di 100, inizialmente riceverai fino a 100 callback limitToFirst().onChildAdded() Se hai meno di 100 elementi archiviati nel database Firebase, viene attivato un callback onChildAdded() per ogni elemento.

Quando gli elementi cambiano, ricevi onChildAdded() callback per gli elementi che entrano nella query e onChildRemoved() callback per gli elementi che ne escono, in modo che il numero totale rimanga 100.

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

Kotlin+KTX

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

Java

// 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 è necessario avere un listener collegato.

Filtra per chiave o valore

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

Come vengono ordinati i dati delle query

Questa sezione spiega come vengono ordinati i dati in base a ciascuno dei metodi di ordinamento nella classe Query.

orderByChild

Quando utilizzi orderByChild(), i dati che contengono la chiave secondaria specificata sono ordinati come segue:

1. Gli elementi secondari con un valore null per la chiave secondaria specificata vengono per primi.
2. Gli elementi secondari con un valore false per la chiave secondaria specificata vengono visualizzati successivamente. Se più elementi secondari hanno un valore false, vengono ordinati in ordine alfabetico in base alla chiave.
3. Gli elementi secondari con un valore true per la chiave secondaria specificata vengono visualizzati successivamente. Se più elementi secondari hanno un valore true, vengono ordinati lessicograficamente per chiave.
4. Seguono gli elementi secondari con un valore numerico, ordinati in ordine crescente. Se più elementi secondari hanno lo stesso valore numerico per il nodo secondario specificato, vengono ordinati in base alla chiave.
5. Le stringhe vengono visualizzate dopo i numeri e sono ordinate in ordine crescente in base alla loro sequenza lessicografica. Se più elementi figlio hanno lo stesso valore per il nodo figlio specificato, vengono ordinati in ordine alfabetico 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 loro valore. I criteri di ordinamento sono gli stessi di orderByChild(), ad eccezione del fatto che viene utilizzato il valore del nodo al posto del valore di una chiave figlio specificata.

Passaggi successivi

• Scopri come strutturare i dati
• Memorizzare i dati offline