¿Por qué usar Room para manejar datos locales en tus apps?

Si tu aplicación trabaja con grandes cantidades de datos estructurados, una excelente práctica es conservar esos datos localmente. ¿Por qué? Porque el caso de uso más común consiste en almacenar en caché información relevante para que el usuario pueda acceder a ella incluso cuando no tiene conexión a Internet. De esta manera, la experiencia no se interrumpe y el contenido sigue disponible. Para lograrlo, Room es tu mejor aliado. Esta biblioteca de persistencia ofrece una capa de abstracción sobre SQLite, lo que te permite interactuar con la base de datos de forma sencilla y segura, sin perder las ventajas que ofrece SQLite.

Beneficios clave de Room:

• Verificación en tiempo de compilación para tus consultas SQL.

• Anotaciones prácticas que reducen el código repetitivo y propenso a errores.

• Migraciones optimizadas para mantener la integridad de tu base de datos.

Gracias a estas ventajas, te recomendamos usar Room en lugar de trabajar directamente con las APIs de SQLite. Así podrás escribir código más limpio, seguro y fácil de mantener.

Como es costumbre, agregar las siguientes dependencias a build.gradle del modulo app: 

dependencies {
    val room_version = "2.8.4"
    implementation("androidx.room:room-runtime:$room_version")
    // If this project uses any Kotlin source, use Kotlin Symbol Processing (KSP)
    // See Add the KSP plugin to your project
    ksp("androidx.room:room-compiler:$room_version")
    // If this project only uses Java source, use the Java annotationProcessor
    // No additional plugins are necessary
    annotationProcessor("androidx.room:room-compiler:$room_version")
    // optional - Kotlin Extensions and Coroutines support for Room
    implementation("androidx.room:room-ktx:$room_version")
    // optional - RxJava2 support for Room
    implementation("androidx.room:room-rxjava2:$room_version")
    // optional - RxJava3 support for Room
    implementation("androidx.room:room-rxjava3:$room_version")
    // optional - Guava support for Room, including Optional and ListenableFuture
    implementation("androidx.room:room-guava:$room_version")
    // optional - Test helpers
    testImplementation("androidx.room:room-testing:$room_version")
    // optional - Paging 3 Integration
    implementation("androidx.room:room-paging:$room_version")
}

Room se basa en tres componentes principales que trabajan juntos para gestionar la persistencia de datos en una aplicación Android. El primero es la clase de base de datos, que actúa como el punto de acceso principal y contiene la conexión subyacente a los datos persistentes. Esta clase es responsable de proporcionar instancias de los DAOs asociados, lo que permite que la aplicación interactúe con la base de datos de manera estructurada.

El segundo componente son las entidades de datos, que representan las tablas dentro de la base de datos. Cada entidad define la estructura de los datos que se almacenan, incluyendo los campos y sus tipos, y se asocia directamente con las filas de las tablas. Gracias a estas entidades, la aplicación puede recuperar información en forma de objetos y también actualizar o insertar nuevos registros de manera sencilla.

El tercer componente son los DAOs, u objetos de acceso a datos. Estos proporcionan los métodos necesarios para realizar operaciones sobre la base de datos, como consultas, inserciones, actualizaciones y eliminaciones. Los DAOs permiten que la lógica de acceso a datos esté claramente separada del resto de la aplicación, lo que mejora la organización y el mantenimiento del código.

En conjunto, la clase de base de datos, las entidades y los DAOs forman la arquitectura de Room. Esta estructura facilita que la aplicación obtenga datos como objetos, los manipule y los persista sin necesidad de escribir código SQL complejo. Además, asegura una integración fluida con el ciclo de vida de la aplicación y promueve buenas prácticas en el manejo de datos.

Ejemplo de implementación

En esta sección veremos cómo implementar una base de datos en Room con una sola entidad y un único DAO. Este ejemplo es ideal para comprender la estructura básica antes de trabajar con proyectos más complejos.

Entidad de datos

La entidad define la estructura de la tabla en la base de datos. Cada instancia de la clase representa una fila en la tabla. En este caso, creamos una entidad llamada User:

@Entity
data class User(
	@PrimaryKey val uid: Int,
	@ColumnInfo(name = "first_name") val firstName: String?,
	@ColumnInfo(name = "last_name") val lastName: String?
)

sta clase incluye un identificador único y dos columnas opcionales para el nombre y apellido. Las anotaciones @Entity, @PrimaryKey y @ColumnInfo son esenciales para que Room entienda cómo mapear los datos.

Objeto de acceso a datos (DAO)

El DAO define los métodos que permiten interactuar con la base de datos. Aquí creamos UserDao, que incluye operaciones básicas como consultar, insertar y eliminar:

@Dao
interface UserDao {
	@Query("SELECT * FROM user")
	fun getAll(): List
	@Query("SELECT * FROM user WHERE uid IN (:userIds)")
	fun loadAllByIds(userIds: IntArray): List
	@Query("SELECT * FROM user WHERE first_name LIKE :first AND last_name LIKE :last LIMIT 1")
   ByName(first: String, last: String): User
	@Insert
	fun insertAll(vararg users: User)
	@Delete
	fun delete(user: User)
}

Este DAO permite obtener todos los usuarios, buscar por identificadores, filtrar por nombre y apellido, insertar múltiples registros y eliminar un usuario específico.

Clase de base de datos

La clase que contiene la base de datos debe ser abstracta y extender RoomDatabase. Además, se anota con @Database para indicar las entidades y la versión:

@ = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
	abstract fun userDao(): UserDao
}

importante seguir el patrón Singleton al crear la instancia de esta clase, ya que cada objeto RoomDatabase es costoso y normalmente solo se necesita una instancia por proceso.

Uso en la aplicación

Una vez definidas la entidad, el DAO y la clase de base de datos, podemos crear la instancia de la base de datos y acceder a los métodos del DAO:

val db = Room.databaseBuilder(
	applicationContext,
	AppDatabase::class.java, "database-name"
).build()
val userDao = db.userDao()
val users: List = userDao.getAll()

Con este código, la aplicación obtiene una referencia al DAO y puede realizar operaciones sobre la base de datos de manera sencilla y segura.