Room memberikan lapisan abstraksi pada SQLite untuk memungkinkan akses database yang lancar sekaligus memanfaatkan kemampuan SQLite secara optimal.
Aplikasi yang menangani data terstruktur dalam jumlah sangat banyak akan sangat terbantu jika data tersebut disimpan secara lokal. Kasus penggunaan yang paling umum adalah membuat cache dari bagian-bagian data yang relevan. Dengan demikian, ketika perangkat tidak dapat mengakses jaringan, pengguna masih dapat menjelajahi konten ketika offline. Setiap perubahan konten yang diinisiasi oleh pengguna kemudian akan disinkronkan ke server setelah perangkat kembali online.
Karena Room dapat menangani masalah ini, kami sangat merekomendasikan Anda untuk menggunakan Room, bukan SQLite. Namun, jika Anda lebih memilih untuk menggunakan API SQLite secara langsung, baca Menyimpan Data Menggunakan SQLite.
Untuk menggunakan Room di aplikasi Anda, tambahkan dependensi berikut ke file build.gradle
aplikasi Anda:
Kotlin
dependencies { def room_version = "2.2.6" implementation "androidx.room:room-runtime:$room_version" kapt "androidx.room:room-compiler:$room_version" // optional - Kotlin Extensions and Coroutines support for Room implementation "androidx.room:room-ktx:$room_version" // optional - Test helpers testImplementation "androidx.room:room-testing:$room_version" }
Java
dependencies { def room_version = "2.2.6" implementation "androidx.room:room-runtime:$room_version" annotationProcessor "androidx.room:room-compiler:$room_version" // optional - RxJava support for Room implementation "androidx.room:room-rxjava2:$room_version" // optional - Guava support for Room, including Optional and ListenableFuture implementation "androidx.room:room-guava:$room_version" // optional - Test helpers testImplementation "androidx.room:room-testing:$room_version" }
Terdapat 3 komponen utama dalam Room:
Database: Berisi penampung database dan berfungsi sebagai titik akses utama bagi koneksi saat ini ke data relasional aplikasi yang persisten.
Class yang dianotasikan dengan
@Database
harus memenuhi ketentuan berikut:- Berupa class abstrak yang memperluas
RoomDatabase
. - Menyertakan daftar entitas yang terkait dengan database dalam anotasi.
- Berisi metode abstrak yang memiliki 0 argumen dan menampilkan class yang dianotasikan dengan
@Dao
.
Saat waktu proses, Anda dapat memperoleh instance
Database
dengan memanggilRoom.databaseBuilder()
atauRoom.inMemoryDatabaseBuilder()
.- Berupa class abstrak yang memperluas
Entitas: Merepresentasikan tabel dalam database
DAO: Berisi metode yang digunakan untuk mengakses database.
Aplikasi menggunakan database Room untuk mendapatkan objek akses data, atau DAO, yang terkait dengan database tersebut. Kemudian, aplikasi akan menggunakan setiap DAO untuk mendapatkan entitas dari database dan menyimpan kembali perubahan yang dibuat pada entitas tersebut ke database. Terakhir, aplikasi akan menggunakan entitas untuk mendapatkan dan menetapkan nilai yang terkait dengan kolom tabel dalam database.
Lihat hubungan antara berbagai komponen yang ada dalam Room pada Gambar 1:

Cuplikan kode berikut berisi contoh konfigurasi database dengan satu entitas dan satu DAO:
User
Kotlin
@Entity data class User( @PrimaryKey val uid: Int, @ColumnInfo(name = "first_name") val firstName: String?, @ColumnInfo(name = "last_name") val lastName: String? )
Java
@Entity public class User { @PrimaryKey public int uid; @ColumnInfo(name = "first_name") public String firstName; @ColumnInfo(name = "last_name") public String lastName; }
UserDao
Kotlin
@Dao interface UserDao { @Query("SELECT * FROM user") fun getAll(): List<User> @Query("SELECT * FROM user WHERE uid IN (:userIds)") fun loadAllByIds(userIds: IntArray): List<User> @Query("SELECT * FROM user WHERE first_name LIKE :first AND " + "last_name LIKE :last LIMIT 1") fun findByName(first: String, last: String): User @Insert fun insertAll(vararg users: User) @Delete fun delete(user: User) }
Java
@Dao public interface UserDao { @Query("SELECT * FROM user") List<User> getAll(); @Query("SELECT * FROM user WHERE uid IN (:userIds)") List<User> loadAllByIds(int[] userIds); @Query("SELECT * FROM user WHERE first_name LIKE :first AND " + "last_name LIKE :last LIMIT 1") User findByName(String first, String last); @Insert void insertAll(User... users); @Delete void delete(User user); }
AppDatabase
Kotlin
@Database(entities = arrayOf(User::class), version = 1) abstract class AppDatabase : RoomDatabase() { abstract fun userDao(): UserDao }
Java
@Database(entities = {User.class}, version = 1) public abstract class AppDatabase extends RoomDatabase { public abstract UserDao userDao(); }
Setelah membuat file di atas, Anda akan mendapatkan instance dari database yang dibuat menggunakan kode berikut:
Kotlin
val db = Room.databaseBuilder( applicationContext, AppDatabase::class.java, "database-name" ).build()
Java
AppDatabase db = Room.databaseBuilder(getApplicationContext(), AppDatabase.class, "database-name").build();
Catatan: Jika aplikasi Anda berjalan dalam satu proses, ikuti pola desain singleton saat membuat instance objek AppDatabase
. Setiap instance RoomDatabase
cukup mahal, dan Anda tidak selalu memerlukan akses ke beberapa instance dalam satu proses.
Jika aplikasi berjalan dalam beberapa proses, sertakan enableMultiInstanceInvalidation()
pada pemanggilan builder database Anda. Dengan demikian, jika instance AppDatabase
disertakan dalam setiap proses, Anda dapat membatalkan file database bersama dalam satu proses dan pembatalan ini akan otomatis disebarkan ke instance AppDatabase
dalam proses lainnya.
Untuk pengalaman langsung dengan Room, coba codelab Android Room dengan View dan Persistensi Android. Untuk mempelajari contoh kode Room, lihat contoh Komponen Arsitektur Android.