როგორ შექმნიდით მონაცემთა ბაზას მობილური აპლიკაციისთვის?

Android-ზე ადგილობრივი მონაცემთა ბაზის შექმნისთვის მე ვიყენებდი Room Persistence Library:

ეს SQLite-ის ბაზაზე დაფუძნებული აბსტრაქციაა, რომელიც გამარტივებს ბაზასთან მუშაობას, უზრუნველყოფს ანოტირებული API-ს სქემების, შეკითხვებისა და მიგრაციების შექმნისთვის:

ძირითადი ნაბიჯები:

1. დამოკიდებულებების დამატება:

   // build.gradle (აპლიკაციის დონეზე)
   dependencies {
       implementation("androidx.room:room-runtime:2.6.1")
       annotationProcessor("androidx.room:room-compiler:2.6.1") // Java-სთვის
       kapt("androidx.room:room-compiler:2.6.1") // Kotlin-სთვის
       implementation("androidx.room:room-ktx:2.6.1") // კურუტინებისთვის
   }
   

2. სუბიექტების (Entities) შექმნა: POJO ან data კლასები, რომლებიც წარმოადგენს ბაზის სქემას. @Entity, @PrimaryKey, @ColumnInfo გამოიყენება სტრუქტურის განსაზღვრაში:

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

3. DAO (Data Access Objects) შექმნა: ინტერფეისები, რომლებიც განსაზღვრავენ მონაცემთა წვდომის მეთოდებს (ჩამატება, წაშლა, განახლება, შეკითხვები). @Dao, @Insert, @Delete, @Update, @Query გამოიყენება ოპერაციების განსაზღვრაში:

   @Dao
   interface UserDao {
       @Query("SELECT * FROM users")
       fun getAll(): List<User>
   
       @Insert
       fun insertAll(vararg users: User)
   
       @Delete
       fun delete(user: User)
   }
   

4. მონაცემთა ბაზის კლასი შექმნა: აბსტრაქტული კლასი, რომელიც იშვიათად მემკვიდრეობს RoomDatabase-ს, უზრუნველყოფს DAO-ებს და განსაზღვრავს ბაზის სქემას. @Database გამოიყენება სუბიექტებისა და ვერსიის მითითებისთვის:

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

5. მონაცემებთან მუშაობა: ბაზის მაგალითის მიღება და ოპერაციების განხორციელება DAO-ის საშუალებით:

   val db = AppDatabase.getDatabase(applicationContext)
   val userDao = db.userDao()
   
   // მონაცემების დამატება (საშუალოდ ფონურ ნაკადში)
   GlobalScope.launch {
       userDao.insertAll(User(firstName = "John", lastName = "Doe"))
   }
   
   // მონაცემების მიღება
   GlobalScope.launch {
       val users = userDao.getAll()
   }
   

Room-ის უპირატესობები:

• შეკითხვების კომპილაციის დროს შემოწმება: SQL შეკითხვები შემოწმდება კომპილაციის დროს, რაც ამცირებს შეცდომების რაოდენობას.
• ფონური ნაკადებით მუშაობა მარტივია: კურუტინებისა და LiveData-ს ინტეგრაცია გამარტივებს მონაცემებთან მუშაობას ფონურ რეჟიმში.
• მიგრაცია უფრო მარტივია: უზრუნველყოფს ინსტრუმენტებს სქემის ცვლილებების მართვისთვის.
• პატარა ბლოკიანი კოდი ნატიური SQLite-ის შედარებით:

თუ მოთხოვნები ძალიან სპეციფიკურია ან ძალიან მცირე მოცულობისაა, შეიძლება განიხილოს Shared Preferences მარტივი key-value წყვილებისთვის, მაგრამ სტრუქტურირებული მონაცემებისა და შეკითხვებისთვის Room არის სასურველი არჩევანი. უფრო რთული სცენარებისთვის, სადაც სჭირდება სინქრონიზაცია ან წვდომა სხვადასხვა წყაროსგან (მაგალითად, ვებ), შეიძლება განიხილოს cloud ბაზები, როგორიცაა Firebase Realtime Database ან Firestore, მაგრამ ადგილობრივი შენახვისთვის Room არის სტანდარტული და რეკომენდებული გადაწყვეტილება.