Trabajar con listas de datos en Android

Este documento cubre el trabajo con listas de datos en Firebase. Para conocer los conceptos básicos de lectura y escritura de datos de Firebase, consulte Leer y escribir datos en Android .

Obtener una referencia de base de datos

Para leer y escribir datos de la base de datos, necesita una instancia de DatabaseReference :

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

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

Leer y escribir listas

Agregar a una lista de datos

Utilice el método push() para agregar datos a una lista en aplicaciones multiusuario. El método push() genera una clave única cada vez que se agrega un nuevo elemento secundario a la referencia de Firebase especificada. Al utilizar estas claves generadas automáticamente para cada elemento nuevo de la lista, varios clientes pueden agregar elementos secundarios a la misma ubicación al mismo tiempo sin conflictos de escritura. La clave única generada por push() se basa en una marca de tiempo, por lo que los elementos de la lista se ordenan automáticamente cronológicamente.

Puede utilizar la referencia a los nuevos datos devueltos por el método push() para obtener el valor de la clave generada automáticamente por el niño o establecer datos para el niño. Llamar getKey() en una referencia push() devuelve el valor de la clave generada automáticamente.

Puede utilizar estas claves generadas automáticamente para simplificar el aplanamiento de su estructura de datos. Para obtener más información, consulte el ejemplo de distribución de datos.

Escuche eventos infantiles

Cuando trabaje con listas, su aplicación debe escuchar los eventos secundarios en lugar de los eventos de valor utilizados para objetos individuales.

Los eventos secundarios se activan en respuesta a operaciones específicas que les suceden a los hijos de un nodo a partir de una operación, como un nuevo hijo agregado mediante el método push() o un hijo que se actualiza mediante el método updateChildren() . Cada uno de estos juntos puede ser útil para escuchar cambios en un nodo específico en una base de datos.

Para escuchar eventos secundarios en DatabaseReference , adjunte un ChildEventListener :

Por ejemplo, una aplicación de blogs sociales podría utilizar estos métodos juntos para monitorear la actividad en los comentarios de una publicación, como se muestra a continuación:

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

Escuche eventos de valor

Si bien el uso de ChildEventListener es la forma recomendada de leer listas de datos, hay situaciones en las que es útil adjuntar un ValueEventListener a una referencia de lista.

Adjuntar un ValueEventListener a una lista de datos devolverá la lista completa de datos como un único DataSnapshot , que luego puede recorrer para acceder a niños individuales.

Incluso cuando solo hay una coincidencia para la consulta, la instantánea sigue siendo una lista; solo contiene un solo elemento. Para acceder al elemento, debe recorrer el resultado:

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

Este patrón puede resultar útil cuando desea recuperar todos los elementos secundarios de una lista en una sola operación, en lugar de escuchar eventos onChildAdded adicionales.

Separar oyentes

Las devoluciones de llamada se eliminan llamando al método removeEventListener() en la referencia de tu base de datos de Firebase.

Si un oyente se ha agregado varias veces a una ubicación de datos, se llama varias veces para cada evento y debe separarlo la misma cantidad de veces para eliminarlo por completo.

Llamar removeEventListener() en un oyente principal no elimina automáticamente los oyentes registrados en sus nodos secundarios; También se debe invocar removeEventListener() en cualquier oyente secundario para eliminar la devolución de llamada.

Ordenar y filtrar datos

Puede utilizar la clase Query de base de datos en tiempo real para recuperar datos ordenados por clave, por valor o por valor de un hijo. También puede filtrar el resultado ordenado según un número específico de resultados o un rango de claves o valores.

ordenar datos

Para recuperar datos ordenados, comience especificando uno de los métodos de ordenación para determinar cómo se ordenan los resultados:

Sólo puedes utilizar un método de orden por vez. Llamar a un método de orden por varias veces en la misma consulta genera un error.

El siguiente ejemplo demuestra cómo puedes recuperar una lista de las publicaciones principales de un usuario ordenadas por su número de estrellas:

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

Esto define una consulta que, cuando se combina con un escucha secundario, sincroniza al cliente con las publicaciones del usuario desde la ruta en la base de datos en función de su ID de usuario, ordenadas por la cantidad de estrellas que ha recibido cada publicación. Esta técnica de utilizar ID como claves de índice se denomina distribución en abanico de datos; puede leer más sobre esto en Estructurar su base de datos .

La llamada al método orderByChild() especifica la clave secundaria para ordenar los resultados. En este caso, las publicaciones se ordenan por el valor de su respectivo hijo "starCount" . Las consultas también se pueden ordenar por elementos secundarios anidados, en caso de que tenga datos similares a estos:

"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",
  }
},

En este ejemplo, podemos ordenar los elementos de nuestra lista por valores anidados bajo la clave metrics especificando la ruta relativa al hijo anidado en nuestra llamada 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

Para obtener más información sobre cómo se ordenan otros tipos de datos, consulte Cómo se ordenan los datos de la consulta .

Filtrar datos

Para filtrar datos, puede combinar cualquiera de los métodos de límite o rango con un método de ordenar por al crear una consulta.

A diferencia de los métodos de orden por, puede combinar múltiples funciones de límite o rango. Por ejemplo, puede combinar los métodos startAt() y endAt() para limitar los resultados a un rango específico de valores.

Incluso cuando solo hay una coincidencia para la consulta, la instantánea sigue siendo una lista; solo contiene un solo elemento. Para acceder al elemento, debe recorrer el resultado:

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

Limitar el número de resultados.

Puede utilizar los métodos limitToFirst() y limitToLast() para establecer un número máximo de elementos secundarios que se sincronizarán para una devolución de llamada determinada. Por ejemplo, si usa limitToFirst() para establecer un límite de 100, inicialmente solo recibirá hasta 100 devoluciones de llamada onChildAdded() . Si tiene menos de 100 elementos almacenados en su base de datos de Firebase, se activa una devolución de llamada onChildAdded() para cada elemento.

A medida que los elementos cambian, recibe devoluciones de llamada onChildAdded() para los elementos que ingresan a la consulta y devoluciones de llamada onChildRemoved() para los elementos que salen de ella, de modo que el número total permanezca en 100.

El siguiente ejemplo demuestra cómo una aplicación de blogs de ejemplo define una consulta para recuperar una lista de las 100 publicaciones más recientes de todos los usuarios:

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

Este ejemplo solo define una consulta; para sincronizar realmente los datos, necesita tener un oyente adjunto.

Filtrar por clave o valor

Puede utilizar startAt() , startAfter() , endAt() , endBefore() y equalTo() para elegir puntos de inicio, finalización y equivalencia arbitrarios para las consultas. Esto puede resultar útil para paginar datos o buscar elementos con elementos secundarios que tengan un valor específico.

Cómo se ordenan los datos de la consulta

Esta sección explica cómo se ordenan los datos mediante cada uno de los métodos de ordenación en la clase Query .

orderByChild

Cuando se utiliza orderByChild() , los datos que contienen la clave secundaria especificada se ordenan de la siguiente manera:

1. Los niños con un valor null para la clave secundaria especificada son lo primero.
2. Los niños con un valor false para la clave secundaria especificada son los siguientes. Si varios hijos tienen un valor false , se ordenan lexicográficamente por clave.
3. Los niños con un valor true para la clave secundaria especificada son los siguientes. Si varios hijos tienen un valor true , se ordenan lexicográficamente por clave.
4. Los niños con un valor numérico vienen a continuación, ordenados en orden ascendente. Si varios hijos tienen el mismo valor numérico para el nodo hijo especificado, se ordenan por clave.
5. Las cadenas van después de los números y están ordenadas lexicográficamente en orden ascendente. Si varios hijos tienen el mismo valor para el nodo hijo especificado, se ordenan lexicográficamente por clave.
6. Los objetos van al final y se ordenan lexicográficamente por clave en orden ascendente.

orderByKey

Cuando usas orderByKey() para ordenar tus datos, los datos se devuelven en orden ascendente por clave.

1. Los niños con una clave que se puede analizar como un entero de 32 bits aparecen primero, ordenados en orden ascendente.
2. Los niños con un valor de cadena como clave vienen a continuación, ordenados lexicográficamente en orden ascendente.

orderByValue

Cuando se usa orderByValue() , los niños se ordenan por su valor. Los criterios de orden son los mismos que en orderByChild() , excepto que se usa el valor del nodo en lugar del valor de una clave secundaria especificada.

Próximos pasos

• Aprenda a estructurar datos
• Almacenar datos sin conexión