Wie würdest du eine Datenbank für eine mobile…

Um eine lokale Datenbank auf Android zu erstellen, würde ich die Room Persistence Library verwenden.

Sie ist eine Abstraktion über SQLite, die die Arbeit mit Datenbanken vereinfacht, indem sie eine annotierte API zum Erstellen von Schemata, Abfragen und Migrationen bereitstellt.

Hauptschritte:

Abhängigkeiten hinzufügen:

// In build.gradle (auf App-Ebene)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Für Java
    kapt("androidx.room:room-compiler:2.6.1") // Für Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Für Coroutines
}

Entitäten erstellen: POJO (Plain Old Java Object) oder Datenklassen, die Tabellen in der Datenbank repräsentieren. Die Annotations @Entity, @PrimaryKey, @ColumnInfo werden verwendet, um die Struktur zu definieren.

@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?
)

DAO erstellen: Schnittstellen, die Methoden für den Datenzugriff definieren (Einfügen, Löschen, Aktualisieren, Abfragen). Die Annotations @Dao, @Insert, @Delete, @Update, @Query werden verwendet.

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

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Datenbankklasse erstellen: Abstrakte Klasse, die von RoomDatabase erbt und Zugriff auf DAO sowie das Schema der Datenbank bereitstellt. Die Annotation @Database gibt die Entitäten und die Version an.

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

Mit der Datenbank arbeiten: Instanz abrufen und Operationen über den DAO ausführen.

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

// Daten einfügen (normalerweise in einem Hintergrund-Thread)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Daten abrufen
GlobalScope.launch {
    val users = userDao.getAll()
}

Vorteile von Room:

Kompilierungszeit-Überprüfung der Abfragen: SQL-Abfragen werden während der Kompilierung überprüft, was Laufzeitfehler reduziert.
Einfache Arbeit mit Threads: Die Integration mit Coroutines oder LiveData erleichtert die Arbeit mit Daten im Hintergrund.
Einfachere Migration: Bietet Werkzeuge zur Verwaltung von Schemaänderungen.
Weniger Boilerplate-Code im Vergleich zu nativen SQLite.

Wenn die Anforderungen sehr spezifisch oder klein sind, könnte man die Verwendung von Shared Preferences für einfache Key-Value-Paare in Betracht ziehen, aber für strukturierte Daten und Abfragen ist Room die bevorzugte Wahl. Für komplexere Szenarien mit Synchronisationsbedarf oder Zugriff aus verschiedenen Quellen (z.B. Web) kann die Nutzung von Cloud-Datenbanken wie Firebase Realtime Database oder Firestore erwogen werden, aber für die lokale Speicherung ist Room die Standard- und empfohlene Lösung.

Wie würdest du eine Datenbank für eine mobile Anwendung erstellen?