Hoe zou je een database maken voor een mobiele app…

Om een lokale database op Android te maken, zou ik de Room Persistence Library gebruiken.

Het is een abstractie boven SQLite die het werken met databases vereenvoudigt door een geannoteerde API te bieden voor het maken van schema's, queries en migraties.

Belangrijkste stappen:

Voeg afhankelijkheden toe:

// In build.gradle (app-niveau)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Voor Java
    kapt("androidx.room:room-compiler:2.6.1") // Voor Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Voor coroutines
}

Maak entiteiten (Entities): POJO (Plain Old Java Object) of dataklassen die tabellen in de database voorstellen. De annotaties @Entity, @PrimaryKey, @ColumnInfo worden gebruikt om de structuur te definiëren.

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    @ColumnInfo(name = "first_name") val firstName: String?,
    @ColumnInfo(name = "last_name") val lastName: String?
)

Maak DAO (Data Access Object): Interfaces die methoden voor gegevensaccess definiëren (invoegen, verwijderen, bijwerken, queries). De annotaties @Dao, @Insert, @Delete, @Update, @Query worden gebruikt.

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): List<User>

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Maak de databaseklasse: Abstracte klasse die erft van RoomDatabase, die toegang tot DAO biedt en het schema van de database definieert. De annotatie @Database geeft entiteiten en versie aan.

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

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

        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

Werk met de database: Verkrijg de instantie en voer operaties uit via de DAO.

val db = AppDatabase.getDatabase(applicationContext)
val userDao = db.userDao()

// Gegevens invoegen (meestal in een achtergrondthread)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Gegevens ophalen
GlobalScope.launch {
    val users = userDao.getAll()
}

Voordelen van Room:

Query-validatie tijdens compilatie: SQL-query's worden tijdens compilatie gecontroleerd, wat runtime-fouten vermindert.
Eenvoudig werken met threads: Integratie met coroutines of LiveData vereenvoudigt werken met gegevens op de achtergrond.
Eenvoudigere migratie: Biedt tools voor het beheren van schemawijzigingen.
Minder boilerplate-code vergeleken met native SQLite.

Als de vereisten zeer specifiek of klein zijn, kan het gebruik van Shared Preferences voor eenvoudige key-value paren overwogen worden, maar voor gestructureerde gegevens en queries is Room de voorkeur. Voor complexere scenario's met synchronisatie of toegang vanuit verschillende bronnen (bijvoorbeeld web) kan gebruik gemaakt worden van cloud-databases zoals Firebase Realtime Database of Firestore, maar voor lokale opslag is Room de standaard en aanbevolen oplossing.

Hoe zou je een database maken voor een mobiele app?