Android Academy · Lezione

Database Room

Renda persistenti localmente i dati strutturati con Room. Definisca Entities, DAO e la classe Database. Esegua query SQL e osservi i risultati con LiveData o Flow.

Database Room è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 2 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 6 lezioni in totale.

Che cos'è Room?

Room è la libreria di persistenza consigliata da Google per Android. È un wrapper attorno a SQLite che offre:

Query SQL type-safe verificate in fase di compilazione
Supporto alle coroutine Kotlin
Integrazione con LiveData / Flow
Supporto alle migrazioni per le modifiche allo schema

I tre componenti di Room

Room è costituito da tre annotazioni:

@Entity — una data class che corrisponde a una tabella del database
@Dao (Data Access Object) — un'interfaccia con query SQL
@Database — la classe principale del database che collega tutto

Aggiunta delle dipendenze di Room

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

Definizione di un'Entity

Annoti una data class con @Entity per creare una tabella del database:

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

Creazione del DAO

Definisca le query in un'interfaccia DAO. Room ne genera automaticamente l'implementazione:

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

Creazione del database

La classe @Database è il punto di ingresso a Room. La costruisca una sola volta e la mantenga come 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 }
            }
        }
    }
}

Utilizzo di Room nel ViewModel

Colleghi il DAO a un ViewModel usando le coroutine:

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

Osservazione dei dati di Room nell'interfaccia utente

Raccolga il Flow da Room nella propria Activity o nel proprio 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
            }
        }
    }
}

Migrazioni del database

Quando modifica la propria Entity (aggiunge una colonna o rinomina una tabella), deve fornire una migrazione per evitare di perdere i dati degli utenti esistenti.

Incrementi il numero di versione in @Database(version = 2) e definisca un oggetto Migration con il codice SQL necessario a trasformare lo schema precedente in quello nuovo.

Verifica rapida

Quale annotazione di Room contrassegna un metodo dell'interfaccia come query SQL SELECT?

Riepilogo: database Room

Ora può creare app con la persistenza locale dei dati:

@Entity — data class → tabella del database
@Dao — interfaccia con @Query, @Insert, @Delete
@Database — punto di ingresso singleton
Restituisca Flow<List> dal DAO per aggiornamenti in tempo reale
Chiami il DAO dal ViewModel usando viewModelScope.launch

Prossimo argomento: scrivere codice asincrono senza callback usando le coroutine.

Domande Frequenti

La lezione «Database Room» è gratuita?

Sì — il testo completo di «Database Room» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 6 lezioni in totale.

Cosa imparerò in «Database Room»?

Renda persistenti localmente i dati strutturati con Room. Definisca Entities, DAO e la classe Database. Esegua query SQL e osservi i risultati con LiveData o Flow. Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 6.

Quanto tempo richiede la lezione «Database Room»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Android Academy