Jak byste vytvořili databázi pro mobilní aplikaci…

Pro vytvoření místní databáze na Androidu bych použil Room Persistence Library.

Toto je abstrakce nad SQLite, která zjednodušuje práci s databází, poskytuje anotované API pro tvorbu schémat, dotazy a správu migrací.

Hlavní kroky:

Přidání závislostí:

// V build.gradle (úrovni aplikace)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Pro Java
    kapt("androidx.room:room-compiler:2.6.1") // Pro Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Pro coroutine
}

Vytvoření entit (Entities): POJO nebo datové třídy reprezentující tabulky v databázi. Anotace @Entity, @PrimaryKey, @ColumnInfo se používají k definici struktury.

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

Vytvoření DAO (Data Access Objects): Rozhraní definující metody přístupu k datům (vkládání, mazání, aktualizace, dotazy). Anotace @Dao, @Insert, @Delete, @Update, @Query se používají k definici operací.

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

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Vytvoření třídy databáze: Abstraktní třída, která dědí z RoomDatabase, poskytuje přístup k DAO a definuje schéma databáze. Anotace @Database se používá k určení entit a verze databáze.

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

Práce s databází: Získání instance databáze a provádění operací přes DAO.

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

// Vkládání dat (obvykle ve vlákně na pozadí)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Získání dat
GlobalScope.launch {
    val users = userDao.getAll()
}

Výhody Room:

Kontrola dotazů při kompilaci: SQL dotazy jsou kontrolovány při kompilaci, což snižuje počet chyb za běhu.
Snadná práce s vlákny: Integrace s korutinami nebo LiveData usnadňuje práci s daty na pozadí.
Jednodušší migrace: Nabízí nástroje pro správu změn schématu databáze.
Méně šablonového kódu ve srovnání s nativním SQLite.

Pokud by požadavky byly velmi specifické nebo velmi malé, mohl by být zvážen použití Shared Preferences pro jednoduché key-value páry, ale pro strukturovaná data a dotazy je preferovanou volbou Room. Pro složitější scénáře s potřebou synchronizace nebo přístupu z různých zdrojů (například webu) lze zvážit použití cloudových databází, jako je Firebase Realtime Database nebo Firestore, ale pro lokální ukládání je Room standardním a doporučeným řešením.

Jak byste vytvořili databázi pro mobilní aplikaci?