Android Academy · Leçon

Base de données Room

Conservez localement des données structurées avec Room. Définissez les Entités, les DAO et la classe Database. Interrogez la base avec SQL et observez les résultats avec LiveData ou Flow.

Base de données Room est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que Room ?

Room est la bibliothèque de persistance recommandée par Google pour Android. Il s'agit d'une couche au-dessus de SQLite qui vous offre :

Des requêtes SQL dont le type est vérifié lors de la compilation
La prise en charge des coroutines Kotlin
L'intégration de LiveData et des flux
La prise en charge des migrations lors des changements de schéma

Les trois composants de Room

Room repose sur trois annotations :

@Entity — une classe de données qui correspond à une table de base de données
@Dao (objet d'accès aux données) — une interface contenant des requêtes SQL
@Database — la classe principale de la base de données qui relie tous les éléments

Ajout des dépendances Room

Ajoutez Room à 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
}

Définition d'une entité

Annotez une classe de données avec @Entity pour créer une table de base de données :

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

Création du DAO

Définissez les requêtes dans une interface DAO. Room génère l'implémentation à votre place :

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)
}

Création de la base de données

La classe @Database est le point d'entrée de Room. Construisez-la une seule fois et conservez-la comme 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 }
            }
        }
    }
}

Utilisation de Room dans un ViewModel

Connectez le DAO à un ViewModel à l'aide de coroutines :

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)
        }
    }
}

Observation des données Room dans l'interface

Collectez le flux provenant de Room dans votre Activity ou votre 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
            }
        }
    }
}

Migrations de base de données

Lorsque vous modifiez votre Entity (ajout d'une colonne, renommage d'une table), vous devez fournir une migration afin de ne pas perdre les données existantes de l'utilisateur.

Incrémentez le numéro de version dans @Database(version = 2) et définissez un objet Migration contenant le code SQL qui transforme l'ancien schéma en nouveau.

Vérification rapide

Quelle annotation Room indique qu'une méthode d'interface est une requête SQL SELECT ?

Récapitulatif : base de données Room

Vous pouvez maintenant créer des applications qui conservent les données localement :

@Entity — classe de données → table de base de données
@Dao — interface avec @Query, @Insert, @Delete
@Database — point d'entrée singleton
Retournez Flow<List> depuis le DAO pour obtenir des mises à jour en temps réel
Appelez le DAO depuis le ViewModel avec viewModelScope.launch

Ensuite : écrivez du code asynchrone sans rappels à l'aide des coroutines.

Questions Fréquemment Posées

La leçon « Base de données Room » est-elle gratuite ?

Oui — le texte complet de « Base de données Room » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « Base de données Room » ?

Conservez localement des données structurées avec Room. Définissez les Entités, les DAO et la classe Database. Interrogez la base avec SQL et observez les résultats avec LiveData ou Flow. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 6.

Combien de temps prend la leçon « Base de données Room » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy