Android Academy · Lección

Base de datos Room

Conserve datos estructurados localmente con Room. Defina Entities, DAOs y la clase Database. Consulte con SQL y observe los resultados con LiveData o Flow.

Base de datos Room es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 2 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 6 lecciones en total.

¿Qué es Room?

Room es la biblioteca de persistencia recomendada por Google para Android. Es una capa envolvente sobre SQLite que ofrece:

Consultas SQL con seguridad de tipos, verificadas en tiempo de compilación
Compatibilidad con corrutinas de Kotlin
Integración con LiveData / Flow
Compatibilidad con migraciones para cambios de esquema

Los tres componentes de Room

Room se construye a partir de tres anotaciones:

@Entity — una clase de datos que se asigna a una tabla de la base de datos
@Dao (Data Access Object) — una interfaz con consultas SQL
@Database — la clase principal de la base de datos que lo conecta todo

Añadir las dependencias de Room

Añada Room a app/build.gradle:

// app/build.gradle
plugins {
    id 'kotlin-kapt'  // needed for Room annotation processor
}

dependencies {
    val roomVersion = "2.6.1"
    implementation "androidx.room:room-runtime:$roomVersion"
    kapt "androidx.room:room-compiler:$roomVersion"
    implementation "androidx.room:room-ktx:$roomVersion" // coroutine support
}

Definir una entidad

Anote una clase de datos con @Entity para crear una tabla de base de datos:

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "notes")
data class Note(
    @PrimaryKey(autoGenerate = true)
    val id: Int = 0,
    val title: String,
    val body: String,
    val createdAt: Long = System.currentTimeMillis()
)

// Each field = one column in the database table
// @PrimaryKey autoGenerate = Room assigns the id automatically

Crear el DAO

Defina las consultas en una interfaz DAO. Room genera la implementación automáticamente:

import androidx.room.*
import kotlinx.coroutines.flow.Flow

@Dao
interface NoteDao {

    @Query("SELECT * FROM notes ORDER BY createdAt DESC")
    fun getAllNotes(): Flow<List<Note>>  // emits new list whenever data changes

    @Query("SELECT * FROM notes WHERE id = :noteId")
    suspend fun getNoteById(noteId: Int): Note?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(note: Note)

    @Update
    suspend fun update(note: Note)

    @Delete
    suspend fun delete(note: Note)
}

Crear la base de datos

La clase @Database es el punto de entrada a Room. Créela una vez y consérvela como singleton:

import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import android.content.Context

@Database(entities = [Note::class], version = 1, exportSchema = false)
abstract class NoteDatabase : RoomDatabase() {

    abstract fun noteDao(): NoteDao

    companion object {
        @Volatile private var INSTANCE: NoteDatabase? = null

        fun getInstance(context: Context): NoteDatabase {
            return INSTANCE ?: synchronized(this) {
                Room.databaseBuilder(
                    context.applicationContext,
                    NoteDatabase::class.java,
                    "note_database"
                ).build().also { INSTANCE = it }
            }
        }
    }
}

Usar Room en ViewModel

Conecte el DAO en un ViewModel mediante corrutinas:

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class NoteViewModel(private val dao: NoteDao) : ViewModel() {

    val notes = dao.getAllNotes()  // Flow — auto-updates when DB changes

    fun addNote(title: String, body: String) {
        viewModelScope.launch {
            dao.insert(Note(title = title, body = body))
        }
    }

    fun deleteNote(note: Note) {
        viewModelScope.launch {
            dao.delete(note)
        }
    }
}

Observar datos de Room en la interfaz

Recopile el Flow de Room en su Activity o Fragment:

import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class NoteActivity : AppCompatActivity() {
    private val viewModel: NoteViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...

        lifecycleScope.launch {
            viewModel.notes.collect { notes ->
                adapter.submitList(notes)  // update RecyclerView
            }
        }
    }
}

Migraciones de bases de datos

Cuando cambie su Entity (añada una columna o cambie el nombre de una tabla), debe proporcionar una migración para no perder los datos existentes de los usuarios.

Incremente el número de versión en @Database(version = 2) y defina un objeto Migration con el código SQL para transformar el esquema antiguo en el nuevo.

Comprobación rápida

¿Qué anotación de Room marca un método de interfaz como una consulta SQL SELECT?

Repaso: base de datos Room

Ahora puede crear aplicaciones con persistencia de datos local:

@Entity — clase de datos → tabla de base de datos
@Dao — interfaz con @Query, @Insert, @Delete
@Database — punto de entrada singleton
Devuelva Flow<List> desde el DAO para obtener actualizaciones en tiempo real
Llame al DAO desde ViewModel mediante viewModelScope.launch

A continuación: escriba código asíncrono sin callbacks mediante corrutinas.

Preguntas frecuentes

¿La lección «Base de datos Room» es gratis?

Sí — el texto completo de «Base de datos Room» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 6 lecciones en total.

¿Qué aprenderé en «Base de datos Room»?

Conserve datos estructurados localmente con Room. Defina Entities, DAOs y la clase Database. Consulte con SQL y observe los resultados con LiveData o Flow. Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 6.

¿Cuánto tiempo toma la lección «Base de datos Room»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy