The Android Developer Challenge is back! Submit your idea before December 2.

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.

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 syarat berikut:

    • Berupa class abstrak yang memperluas RoomDatabase.
    • Menyertakan daftar entitas yang terkait dengan database dalam anotasi.
    • Berisi metode abstrak yang memiliki 0 argumen dan menghasilkan class yang dianotasikan dengan @Dao.

    Pada waktu proses, Anda dapat memperoleh instance dari 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:

Gambar 1. Diagram arsitektur Room

Cuplikan kode berikut menyertakan 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 umumnya Anda tidak selalu memerlukan akses ke beberapa instance dalam satu proses.

Jika aplikasi berjalan dalam beberapa proses, sertakan enableMultiInstanceInvalidation() pada pemanggilan pembuat database. Dengan demikian, apabila instance AppDatabase disertakan dalam setiap proses, Anda dapat membatalkan validasi file database bersama dalam sebuah proses dan pembatalan ini akan otomatis disebarkan ke instance AppDatabase dalam proses lainnya.

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