Menyimpan data di dalam database lokal menggunakan Room

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:

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

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 memanggil Room.databaseBuilder() atau Room.inMemoryDatabaseBuilder().

• 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

    @Entity
    data class User(
        @PrimaryKey val uid: Int,
        @ColumnInfo(name = "first_name") val firstName: String?,
        @ColumnInfo(name = "last_name") val lastName: String?
    )
    

    @Entity
    public class User {
        @PrimaryKey
        public int uid;

        @ColumnInfo(name = "first_name")
        public String firstName;

        @ColumnInfo(name = "last_name")
        public String lastName;
    }
    

UserDao

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

    @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

    @Database(entities = arrayOf(User::class), version = 1)
    abstract class AppDatabase : RoomDatabase() {
        abstract fun userDao(): UserDao
    }
    

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

    val db = Room.databaseBuilder(
                applicationContext,
                AppDatabase::class.java, "database-name"
            ).build()
    

    AppDatabase db = Room.databaseBuilder(getApplicationContext(),
            AppDatabase.class, "database-name").build();
    

Untuk pengalaman langsung dengan Room, coba codelab Android Room dengan View dan Persistensi Android. Untuk mempelajari contoh kode Room, lihat contoh Komponen Arsitektur Android.