ROOM secara detail

Room adalah perpustakaan yang kuat untuk bekerja dengan data pada aplikasi Android. Ini memungkinkan pengembang untuk dengan mudah membuat dan mengelola basis data SQL mereka. Room menyediakan lapisan abstraksi di atas SQLite, mesin database yang paling umum untuk aplikasi Android. Bacaan ini akan membahas dasar-dasar Room dan cara menggunakannya dengan Jetpack Compose.

Apa itu Room?

Room adalah library yang kuat untuk mengelola data di Android. Ini menyediakan lapisan abstraksi di atas SQLite, yang dimasukkan ke dalam sistem operasi Android. Room menyederhanakan pembuatan dan pengelolaan database, sehingga pengembang dapat fokus pada logika aplikasi alih-alih berurusan dengan kerumitan SQL. Room juga menyediakan beberapa fitur bermanfaat seperti migrasi data otomatis dan debugging yang lebih mudah.

Cara menggunakan Room dengan Jetpack Compose

Menggunakan Room dengan Jetpack Compose sangatlah mudah. Pertama, buatlah sebuah kelas yang memperpanjang RoomDatabase dan beri keterangan dengan @Database. Ini akan menentukan nama database, versi, dan entitas yang merupakan bagian dari database. Kemudian, buatlah antarmuka Data Access Object, atau DAO, yang berisi metode untuk berinteraksi dengan database. Terakhir, buatlah kelas yang memperluas Room dan mengimplementasikan antarmuka DAO. Kelas ini akan berisi kueri SQL yang sebenarnya untuk database.

Memulai dengan Room

Untuk memulai, pengembang perlu menambahkan Room ke file build.gradle aplikasi mereka. Hal ini memungkinkan Room untuk digunakan dalam aplikasi mereka.

dependencies {
   def room_version = "2.4.3"
   implementation "androidx.room:room-runtime:$room_version"
   annotationProcessor "androidx.room:room-compiler:$room_version"
   // optional - Kotlin Extensions and Coroutines support for Room
   implementation "androidx.room:room-ktx:$room_version"
   // To support LiveData in Compose
   implementation 'androidx.compose.runtime:runtime-livedata:1.3.2'
}

Setelah Room ditambahkan ke aplikasi, pengembang dapat membuat kelas RoomDatabase di dalam aplikasi. Kelas ini akan berfungsi sebagai titik masuk ke perpustakaan Room. Kelas RoomDatabase akan mendefinisikan struktur basis data, serta menyediakan metode untuk mengakses dan memodifikasi data.

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

   companion object {
      @Volatile        
      private var INSTANCE: AppDatabase? = null  
       
      fun getDatabase(context: Context): AppDatabase {            
         val tempInstance = INSTANCE            
         if (tempInstance != null) {                
            return tempInstance            
         }             
         synchronized(this) {                
            val instance = Room.databaseBuilder(                    
               context.applicationContext,                    
               AppDatabase::class.java,                    
               "app_database"                
            ).build()                
            INSTANCE = instance                
            return instance            
         }        
      }    
   }
}

nomor versi memungkinkan pengembang untuk mengubah skema database (struktur tabel) di masa depan. Ketika memperbarui skema database, pengembang harus menambah nomor versi dan menerapkan strategi migrasi. Untuk sebagian besar kasus, migrasi otomatis yang disediakan oleh Room sudah cukup, dan dapat digunakan sebagai berikut:

@Database(   
version = 2,
   entities = [User::class],
   autoMigrations = [     
      AutoMigration (from = 1, to = 2)   
   ]
)

Daftar entitas yang disediakan pada anotasi @Database mendefinisikan tabel-tabel SQLite dalam database dan akan dibahas selanjutnya. Pengembang perlu membuat kelas Entity untuk setiap tabel dalam database. Ini mendefinisikan struktur data yang akan disimpan dalam database. Dalam hal ini, kita akan membuat entitas User.

@Entity(tableName = "user_table")  
data class User (      
   @PrimaryKey(autoGenerate = true)      
   var id: Int,      
   var name: String  
)  

Nilai tableName bersifat opsional dan dapat digunakan untuk memberikan nama yang berbeda untuk tabel daripada nama entitas.

Kunciutama diperlukan untuk semua entitas. Ini adalah nilai unik untuk setiap entitas yang mengidentifikasinya. Jika diatur ke tipe integer, mengaktifkan auto-generate (seperti pada contoh di atas) akan membuat SQLite secara otomatis menambah nilai untuk pengembang ketika entitas baru dimasukkan.

Terakhir, pengembang perlu membuat Data Access Object, atau DAO. Ini adalah kelas yang akan menyediakan metode untuk mengakses dan memodifikasi data dalam database.

@Dao  
interface UserDao {      
   @Insert      
   fun insert(user: User)        
   @Query("SELECT * FROM user_table")      
   fun getAll(): LiveData<List<User>>  
}  

Room menawarkan anotasi untuk semua operasi dasar, termasuk @Insert, @Update dan @Delete. Room juga menawarkan @Query, yang memungkinkan pengembang untuk mengimplementasikan kueri SQL apa pun.

Ketika menggunakan @Query, , pengembang juga dapat menggunakan variabel. Sebagai contoh:

@Query("SELECT * FROM user_table WHERE name = :name") 
fun getAllUsersWithName(name: String): Array<User> 

Nilai yang disediakan untuk "nama" akan menggantikan placeholder “:name” pada kueri di atas.

Setelah semua kelas yang diperlukan telah dibuat, pengembang dapat mulai menggunakan Room ketika bekerja dengan data di Jetpack Compose. Untuk melakukan ini, pengembang dapat menggunakan kelas RoomDatabase untuk mendapatkan instance dari database, kemudian menggunakan metode DAO untuk meminta dan memodifikasi data.

// Get the database instance  
val database = AppDatabase.getDatabase(context)

// Get a list of users from the database as Compose state  
val users by database.userDao().getAll().observeAsState()  

// Add a new user to the database  
database.userDao().insert(User(name = "John Doe"))  

Kesimpulan

Kesimpulannya, Room adalah pustaka yang kuat untuk mengelola data di Android. Ini menyederhanakan pembuatan dan pengelolaan database. Menggunakan Room dengan Jetpack Compose sangat mudah dan membuatnya lebih mudah untuk membuat aplikasi yang menyimpan dan mengambil data. Dengan Room, pengembang dapat fokus pada logika aplikasi dan membiarkan Room menangani manajemen database.