Cum ai crea o bază de date pentru o aplicație mobilă…

Pentru crearea unei baze de date locale pe Android, aș folosi Room Persistence Library.

Aceasta este o abstracție peste SQLite, care simplifică lucrul cu baza de date, oferind un API adnotat pentru crearea schemelor, interogărilor și gestionarea migrărilor.

Pașii principali:

Adăugarea dependențelor:

// În build.gradle (nivelul aplicației)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Pentru Java
    kapt("androidx.room:room-compiler:2.6.1") // Pentru Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Pentru corutine
}

Crearea entităților (Entities): POJO (Plain Old Java Object) sau clase de date, reprezentând tabelele din bază. Anotările @Entity, @PrimaryKey, @ColumnInfo sunt folosite pentru definirea structurii.

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

Crearea DAO (Data Access Objects): Interfețe care definesc metodele de acces la date (inserare, ștergere, actualizare, interogări). Anotările @Dao, @Insert, @Delete, @Update, @Query sunt folosite pentru operații.

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

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Crearea clasei Database: Clasă abstractă, care extinde RoomDatabase, oferă acces la DAO și definește schema bazei de date. Anotările @Database indică entitățile și versiunea bazei.

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

Lucrul cu baza de date: Obținerea instanței bazei de date și efectuarea operațiilor prin DAO.

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

// Inserare date (de obicei în thread de fundal)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Obținere date
GlobalScope.launch {
    val users = userDao.getAll()
}

Avantajele Room:

Verificare la compilare a interogărilor: Interogările SQL sunt verificate în timpul compilării, reducând erorile de execuție.
Lucru facil cu firele de execuție: Integrarea cu corutine sau LiveData simplifică manipularea datelor în thread-uri de fundal.
Migrare mai simplă: Oferă instrumente pentru gestionarea modificărilor schemei bazei de date.
Mai puțin cod boilerplate comparativ cu SQLite nativ.

Dacă cerințele ar fi foarte specifice sau foarte mici, s-ar putea lua în considerare utilizarea Shared Preferences pentru perechi simple key-value, dar pentru date structurate și interogări, Room este opțiunea preferată. Pentru scenarii mai complexe, cu nevoie de sincronizare sau acces din mai multe surse (de exemplu, web), se poate lua în considerare utilizarea bazelor de date cloud, precum Firebase Realtime Database sau Firestore, dar pentru stocarea locală, Room este soluția standard și recomandată.

Cum ai crea o bază de date pentru o aplicație mobilă?