Realm dalam aplikasi seluler: apa itu dan bagaimana cara kerjanya

Apa itu Realm?

Realm adalah database berorientasi objek yang dibuat khusus untuk aplikasi seluler. Berbeda dengan SQLite, Realm tidak menggunakan SQL dan model relasional — data disimpan sebagai objek langsung (Live Objects) yang dapat diakses secara langsung tanpa lapisan ORM perantara. Pengembang bekerja dengan objek bahasa biasa (Swift, Kotlin, Dart) yang secara otomatis disimpan di database.

Realm muncul pada tahun 2014 sebagai startup Realm Inc., dan pada tahun 2019 diakuisisi oleh MongoDB Inc. Sejak itu, Realm dikembangkan sebagai MongoDB Realm — bagian dari platform terpadu Atlas Device Sync untuk sinkronisasi data seluler. Database lokal Realm tetap gratis dan terbuka (lisensi Apache 2.0), sedangkan Realm Sync (sinkronisasi cloud) didistribusikan melalui langganan.

Menurut MongoDB Developer Report (2025), Realm digunakan di 15% aplikasi seluler sebagai penyimpanan lokal utama. Skenario utama adalah aplikasi dengan mode offline, model objek kompleks, dan kebutuhan sinkronisasi antar perangkat, di mana Realm melampaui SQLite dalam kecepatan pengembangan dan kemudahan bekerja dengan objek.

Prinsip Realm

Live Objects setiap objek Realm terhubung ke disk melalui pemetaan memori (memory-mapped file). Perubahan objek di thread mana pun segera tercermin di semua thread lain tanpa pemberitahuan manual. Antarmuka UI secara otomatis digambar ulang saat data berubah melalui notifikasi Realm. Zero-copy Realm tidak menyalin data dari database ke objek, objek itu sendiri adalah data di memori.

Bagaimana Realm dibangun: arsitektur dan penyimpanan

Inti Realm ditulis dalam C++ dan menggunakan B+ Tree untuk mengindeks data. Berbeda dengan SQLite, di mana setiap baris adalah catatan dalam tabel relasional, Realm menyimpan objek sebagai simpul dalam struktur grafik dengan referensi langsung di antara mereka (forward pointers). Hubungan antar objek bukan foreign key, melainkan penunjuk langsung, yang menghilangkan kebutuhan akan operasi JOIN.

File Realm (ekstensi .realm) bersifat memory-mapped — OS sendiri mengelola pemuatan halaman file ke memori saat diakses. Hal ini memungkinkan Realm bekerja dengan database yang melebihi memori operasional yang tersedia dan memastikan latensi baca pada tingkat struktur data asli bahasa (Swift Array atau Kotlin List) untuk data yang muat di RAM.

Zero-copy dan Live Objects

File Memory-mapped adalah teknologi kunci Realm. Alih-alih menyalin data dari file database ke objek bahasa (seperti yang dilakukan SQLite melalui sqlite3_step + sqlite3_column_*), Realm memetakan file database langsung ke ruang alamat proses. Objek bahasa hanyalah penunjuk ke data di memori yang dipetakan. Mengubah objek mengubah database di disk tanpa panggilan save terpisah.

Konsumsi memori Realm lebih tinggi saat pembacaan aktif (seluruh file atau sebagian besarnya dipetakan ke memori), tetapi lebih rendah saat operasi tulis, karena tidak diperlukan alokasi memori untuk salinan objek. Untuk database hingga 1 GB di perangkat seluler, pendekatan memory-mapped memberikan kinerja keseluruhan yang lebih baik daripada SQLite dengan penyalinan perantaranya.

Realm vs SQLite vs Core Data: perbandingan

SQLite adalah sistem manajemen database relasional dengan SQL dan transaksi ACID. Realm adalah database NoSQL berorientasi objek dengan akses memory-mapped. Core Data adalah lapisan ORM Apple di atas SQLite. Masing-masing dari tiga pendekatan memiliki area aplikasi dan kekuatannya sendiri. Realm unggul dalam kecepatan akses langsung ke objek dan reaktivitas, SQLite dalam universalitas dan kedewasaan, Core Data dalam integrasi dengan ekosistem Apple.

Kinerja Realm pada operasi baca 10-50% lebih tinggi dari SQLite berkat akses zero-copy. Pada operasi tulis, Realm juga lebih cepat karena tidak adanya analisis sintaks SQL dan perubahan langsung pada halaman memory-mapped. Namun, Realm dapat mengonsumsi lebih banyak memori operasional saat bekerja dengan database besar (>500 MB), karena file dipetakan sepenuhnya ke ruang alamat.

Pilihan antara Realm dan SQLite sering kali tergantung pada prioritas: kecepatan pengembangan dan reaktivitas (Realm) versus kontrol dan universalitas (SQLite). Realm sangat baik untuk MVP dan prototipe, di mana model data sering berubah dan penting untuk mendapatkan pembaruan UI langsung dengan cepat. SQLite/Room lebih disukai untuk produk matang dengan volume data besar dan kueri analitis yang kompleks.

Realm di Android: Kotlin SDK

Realm Kotlin SDK adalah pustaka resmi untuk Android, ditulis dalam Kotlin (bukan pembungkus di atas Java SDK). Model data ditentukan melalui kelas yang mewarisi dari RealmObject, dengan anotasi @PrimaryKey untuk pengidentifikasi unik. Realm Kotlin mendukung Kotlin Coroutines, Flow, dan KSP (Kotlin Symbol Processing) untuk pembuatan kode waktu kompilasi.

RealmQuery menyediakan API type-safe untuk pemfilteran tanpa SQL. Kueri dibangun dengan rantai metode: query → filter → sort → find. Hasil dapat dikembalikan sebagai daftar (dengan pemuatan ke memori) atau sebagai Flow (stream reaktif yang diperbarui saat data berubah). Realm Kotlin juga mendukung objek bersarang dan daftar (RealmList).

Contoh Realm Kotlin SDK

Model data Realm didefinisikan sebagai data class yang mengimplementasikan antarmuka RealmObject. Bidang _id ditandai dengan @PrimaryKey untuk identifikasi unik. Relasi “satu-ke-banyak” diimplementasikan melalui RealmList — daftar RealmObject lainnya. Semua operasi tulis (create, update, delete) dilakukan di dalam blok transaksi write.

class Project : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId().generate()
    var name: String = ""
    var tasks: RealmList<Task> = realmListOf()
}

class Task : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId().generate()
    var title: String = ""
    var isComplete: Boolean = false
}

val config = Realm.Configuration.Builder(
    schema = setOf(Project::class, Task::class)
).build()

val realm = Realm.open(config)
realm.write { transactionRealm ->
    val project = copyToRealm(Project().apply {
        name = "Mobile App"
    })
    project.tasks.add(copyToRealm(Task().apply {
        title = "Design UI"
    }))
}

val projects: Flow<RealmResults<Project>> =
    realm.query<Project>()
        .sort(Project::name, Sort.ASCENDING)
        .asFlow()

Kueri yang mengembalikan Flow secara otomatis mengeluarkan hasil baru saat ada perubahan data di Realm: penambahan, pembaruan, atau penghapusan Project atau Task. Pendekatan Flow sangat cocok dengan Compose: collectAsState() di ViewModel secara otomatis mengomposisi ulang UI saat data berubah tanpa pembaruan manual adapter daftar atau penggunaan LiveData.

Realm di iOS: Swift SDK

Realm Swift SDK menyediakan API Swift asli dengan dukungan async/await, Combine Publishers, dan Swift Concurrency. Model data ditentukan sebagai kelas yang mewarisi dari Object, menggunakan @Persisted untuk properti. Realm Swift secara otomatis memperbarui objek saat perubahan, dan notifikasi (NotificationToken) memungkinkan berlangganan perubahan pada objek atau koleksi individual.

@ObservedRealmObject dan @ObservedResults adalah Property Wrapper untuk SwiftUI yang secara otomatis menggambar ulang View saat data Realm berubah. @ObservedResults bekerja dengan hasil kueri, @ObservedRealmObject dengan objek tertentu. Kedua properti membatalkan langganan saat View dideinisialisasi.

Contoh Realm Swift SDK

Integrasi SwiftUI Realm adalah salah satu kekuatan SDK. Property Wrapper @ObservedResults menghubungkan kueri Realm dengan tampilan di SwiftUI. Saat tugas berubah, SwiftUI secara otomatis mengomposisi ulang daftar. realm.writeAsync menjalankan transaksi di thread latar belakang tanpa memblokir UI.

import RealmSwift

class TaskItem: Object, Identifiable {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var title: String = ""
    @Persisted var isDone: Bool = false
    @Persisted var priority: Int = 0
}

struct TaskListView: View {
    @ObservedResults(TaskItem.self,
        sortDescriptor: SortDescriptor(["priority"]))
    var tasks

    var body: some View {
        List {
            ForEach(tasks) { task in
                TaskRow(task: task)
            }
        }
        Button("Tambah Tugas") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults secara otomatis mengelola siklus hidup kueri Realm: saat View dibuat, langganan perubahan dibuat, saat dihancurkan, langganan dibatalkan. Property Wrapper menerima predikat opsional (NSPredicate) dan pengurutan. Ini menghilangkan kebutuhan untuk menulis kueri fetch secara manual, membuat ViewModel, dan berlangganan notifikasi Realm.

Skenario penggunaan Realm

Aplikasi offline Realm sangat ideal untuk skenario di mana data harus tersedia tanpa internet. Sinkronisasi bawaan (Realm Sync dengan MongoDB Atlas) secara otomatis menyelesaikan konflik saat terhubung ke jaringan. Aplikasi terus bekerja dengan data lokal, dan sinkronisasi latar belakang memperbaruinya saat koneksi tersedia.

Antarmuka reaktif Live Objects dan notifikasi Flow/Combine membuat Realm menjadi pilihan yang nyaman untuk aplikasi dengan data yang sering berubah: obrolan, umpan tugas, dokumen bersama. UI diperbarui secara otomatis saat data ditambahkan, diubah, atau dihapus tanpa panggilan manual reloadData atau invalidate.

Proyek lintas platform Realm mendukung Kotlin Multiplatform (KMP), Flutter, React Native, dan Xamarin. Model data ditentukan sekali dan digunakan di semua platform. Ini mengurangi duplikasi kode dan menjamin konsistensi skema data antara aplikasi iOS dan Android dengan logika bisnis bersama.

Realm Sync: sinkronisasi melalui MongoDB Atlas

Realm Sync adalah layanan cloud yang terintegrasi dalam MongoDB Atlas. Aplikasi secara otomatis menyinkronkan data antara perangkat pengguna dan server. Konflik diselesaikan dengan strategi “last write wins” atau melalui fungsi Conflict Resolution kustom di server. Realm Sync mendukung sinkronisasi parsial (subset data) untuk mengurangi lalu lintas.

class SyncRepository {
    private val app = App(
        AppConfiguration(
            appId = "my-realm-app-id"
        )
    )

    suspend fun syncData() {
        val user = app.login(Credentials.anonymous())
        val config = SyncConfiguration.Builder(
            user, setOf(Project::class)
        ).build()

        val syncedRealm = Realm.open(config)
        // Sinkronisasi otomatis aktif
    }
}

SyncConfiguration mengonfigurasi koneksi ke MongoDB Atlas dan menentukan set model yang akan disinkronkan. Setelah autentikasi pengguna, Realm secara otomatis memuat data dari cloud dan menggabungkannya dengan perubahan lokal. Sinkronisasi bekerja di thread latar belakang dan tidak memerlukan panggilan manual — cukup buat instance Realm dengan SyncConfiguration.