Firebase Realtime DB — apa itu, arsitektur dan bekerja dengan JSON

Apa itu Firebase Realtime Database?

Firebase Realtime Database adalah basis data cloud NoSQL yang menyimpan dan menyinkronkan data secara waktu nyata di antara semua klien yang terhubung. Diluncurkan pada tahun 2012 sebagai Firebase (sebelum diakuisisi oleh Google), ia menjadi basis data cloud waktu nyata pertama untuk pengembang seluler. Data disajikan dalam format JSON dan diatur dalam pohon hierarkis, di mana setiap node memiliki jalur unik.

Nilai utama Realtime Database adalah sinkronisasi bawaan. Ketika aplikasi mengubah data di perangkat mana pun, semua klien terhubung lainnya segera menerima pembaruan melalui koneksi permanen. Ini membebaskan pengembang dari implementasi mekanisme sinkronisasi sendiri, server WebSocket, atau REST API untuk transfer data antar klien.

Basis data menyediakan SDK untuk semua platform utama: Android (Java, Kotlin), iOS (Swift, Objective-C), Web (JavaScript), dan lingkungan server melalui Admin SDK. Menurut data Google, Realtime Database digunakan di lebih dari 1,5 juta proyek Firebase aktif di seluruh dunia. Meskipun hadirnya Firestore yang lebih modern, Realtime Database tetap menjadi pilihan populer untuk proyek dengan struktur data sederhana.

Struktur data: pohon JSON

Tidak seperti basis data relasional, Realtime Database tidak menggunakan tabel dan baris. Semua data membentuk satu pohon JSON yang terlihat seperti objek JavaScript bersarang. Misalnya, untuk menyimpan pengguna dan pesan mereka, dibuat hierarki: users/userId/name dan messages/messageId/text. Setiap jalur dalam pohon adalah string, dan data dapat dibaca langsung melalui jalur ini.

{
  "users": {
    "user1": {
      "name": "Ivan Petrov",
      "email": "ivan@example.com"
    },
    "user2": {
      "name": "Maria Sokolova",
      "email": "maria@example.com"
    }
  },
  "messages": {
    "-Nabc123": {
      "text": "Halo!",
      "userId": "user1"
    }
  }
}

Fitur penting adalah bahwa bersarang yang dalam mempengaruhi kinerja. Ketika aplikasi membaca data di jalur tertentu, ia memuat semua node anak dari jalur tersebut. Oleh karena itu, disarankan untuk merancang struktur data sedatar mungkin, menghindari bersarang lebih dalam dari 3–4 level. Untuk mengatasi masalah ini, digunakan denormalisasi data — duplikasi informasi di node yang berbeda dari pohon.

Realtime Database vs Firestore: kapan memilih

Realtime Database dan Firestore sering dibandingkan sebagai dua basis data cloud waktu nyata dari Google. Pilihan di antara mereka tergantung pada kebutuhan spesifik proyek: kompleksitas kueri, konsistensi yang diperlukan, dan beban yang direncanakan. Memahami kekuatan masing-masing basis data membantu dalam mengambil keputusan arsitektur yang tepat.

Keuntungan utama Realtime Database adalah latensi sinkronisasi yang rendah. Karena semua data disimpan dalam satu pohon JSON tanpa lapisan abstraksi tambahan, sinkronisasi lebih cepat daripada Firestore. Untuk aplikasi di mana kecepatan pengiriman pembaruan sangat penting (obrolan, game online, sistem pengeditan bersama), Realtime Database mungkin menjadi pilihan yang lebih tepat.

Kapan menggunakan Realtime Database

Realtime Database lebih cocok untuk skenario dengan struktur data sederhana dan frekuensi pembaruan tinggi. Contoh tipikal: obrolan, suka waktu nyata, indikator mengetik, status kehadiran pengguna. Ini juga merupakan pilihan yang baik untuk prototipe dan proyek dengan anggaran terbatas, karena penetapan harga didasarkan pada volume data, bukan jumlah operasi.

Di sisi lain, untuk aplikasi dengan kueri kompleks (penyaringan berdasarkan beberapa bidang, pengurutan, agregasi) Firestore menawarkan kemampuan yang jauh lebih kuat. Realtime Database hanya mendukung penyaringan berdasarkan satu parameter dan tidak dapat mengurutkan hasil berdasarkan beberapa bidang secara bersamaan. Jika proyek merencanakan analitik data kompleks di sisi klien, Firestore akan menjadi pilihan yang lebih praktis.

Bagaimana sinkronisasi bekerja di Realtime Database

Realtime Database menggunakan koneksi WebSocket permanen untuk sinkronisasi data dua arah. Ketika klien memanggil setValue atau updateChildren pada jalur tertentu, data dikirim ke server Firebase melalui saluran terbuka. Server menerapkan perubahan dan menyebarkan pembaruan ke semua klien yang berlangganan dalam hitungan milidetik. Setiap koneksi diidentifikasi oleh kunci sesi unik.

Mekanisme langganan bekerja melalui listener. Pengembang dapat berlangganan perubahan node tertentu (addListenerForSingleValueEvent) atau menerima pembaruan permanen (addValueEventListener). Pada setiap perubahan data, callback onDataChange dipanggil dengan snapshot data lengkap di jalur yang ditentukan. Ini berbeda dengan Firestore, di mana hanya dokumen yang diubah yang datang — di Realtime Database, semua data node selalu dimuat.

Mode offline dan manajemen konflik

Realtime Database mendukung mode offline di Android dan iOS melalui caching disk. SDK menyimpan salinan lokal data dan terus memproses operasi tulis saat tidak ada jaringan. Ketika koneksi dipulihkan, semua perubahan yang terkumpul dikirim ke server. Untuk menyelesaikan konflik, digunakan strategi last-write-wins, tetapi pengembang dapat menerapkan logika kustom melalui ServerValue.TIMESTAMP untuk menyelesaikan bentrokan.

val database = FirebaseDatabase.getInstance()
val myRef = database.getReference("messages")

// Menulis data
myRef.push().setValue(
    hashMapOf(
        "text" to "Pesan baru",
        "timestamp" to ServerValue.TIMESTAMP
    )
)

// Membaca dengan pembaruan konstan
myRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val data = snapshot.getValue()
        Log.d("TAG", "Data: $data")
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w("TAG", "Kesalahan: ${error.message}")
    }
})

Untuk optimalisasi lalu lintas dan kinerja, disarankan menggunakan child listeners daripada value listeners ketika perlu melacak perubahan node anak tertentu. ChildEventListener menyediakan callback terpisah untuk penambahan, perubahan, penghapusan, dan pemindahan elemen anak, yang memungkinkan kontrol pembaruan UI yang lebih presisi dan menghindari penggambaran ulang semua elemen daftar pada setiap perubahan data.

Aturan keamanan dan validasi data

Realtime Database menggunakan bahasa aturan deklaratif untuk kontrol akses data. Aturan menjelaskan siapa yang dapat membaca dan menulis data di setiap jalur pohon JSON. Aturan diperiksa di server Firebase sebelum setiap permintaan dan tidak memerlukan logika server untuk otorisasi. Aturan mendukung variabel, objek bawaan, dan fungsi untuk konfigurasi akses yang fleksibel.

Secara default, akses ke basis data dilarang untuk semua pengguna. Pengembang secara bertahap membuka akses menggunakan aturan ".read" dan ".write" di berbagai tingkat pohon. Kondisi dapat memeriksa otentikasi melalui variabel auth, jenis permintaan (read/write), dan data yang ada melalui objek data. Selain itu, aturan mendukung validasi data yang ditulis melalui objek newData.

{
  "rules": {
    "users": {
      "$uid": {
        // Hanya pemilik yang dapat membaca data sendiri
        ".read": "$uid === auth.uid",
        // Hanya pemilik yang dapat menulis
        ".write": "$uid === auth.uid",
        // Validasi bidang saat menulis
        ".validate": "newData.hasChildren(['name', 'email'])"
      }
    },
    "messages": {
      // Setiap pengguna terautentikasi dapat membaca
      ".read": "auth !== null",
      // Hanya terautentikasi dapat menulis
      ".write": "auth !== null",
      ".indexOn": ["timestamp"]
    }
  }
}

Aturan juga mendukung pengindeksan data melalui direktif ".indexOn". Tanpanya, kueri dengan pengurutan (orderByChild) akan ditolak atau dijalankan secara tidak efisien. Indeks ditentukan untuk setiap jalur di mana pengurutan berdasarkan bidang tertentu dilakukan. Aturan bersifat kaskade: aturan yang lebih dalam menimpa aturan induk, dan jika pada suatu tingkat tidak ada akses, itu dianggap diizinkan atau dilarang tergantung pada aturan induk.

Tipe data dan batasan

Realtime Database mendukung lima tipe data: String, Number, Boolean, Map (objek), dan List (array). Kedalaman bersarang dibatasi hingga 32 level, dan ukuran maksimum satu node tidak boleh melebihi 256 MB. Untuk bekerja secara efisien dengan basis data, disarankan merancang struktur data datar dan menggunakan denormalisasi untuk menghindari kueri dalam yang memuat volume data besar.

Contoh penggunaan Realtime Database di Android

Mari kita lihat contoh praktis integrasi Realtime Database di aplikasi Android untuk status pengguna (online/offline). Aplikasi akan menampilkan daftar pengguna dengan status mereka saat ini, yang diperbarui secara waktu nyata. Untuk demonstrasi, digunakan Firebase Authentication untuk identifikasi pengguna dan coroutine untuk operasi asinkron.

Pengaturan dependensi dan inisialisasi

Untuk memulai, tambahkan dependensi firebase-database-ktx ke file build.gradle modul aplikasi. Versi pustaka dikelola melalui Firebase BoM untuk memastikan kompatibilitas semua komponen. Setelah menambahkan dependensi, Firebase perlu diinisialisasi di kelas Application atau melalui inisialisasi malas di ViewModel.

dependencies {
    implementation platform("com.google.firebase:firebase-bom:33.0.0")
    implementation "com.google.firebase:firebase-database-ktx"
    implementation "com.google.firebase:firebase-auth-ktx"
}

Setelah konfigurasi, dibuat repositori untuk bekerja dengan pengguna. Setiap pengguna diwakili oleh node di pohon /users/{uid} dengan bidang name, email, dan status. Untuk melacak status, digunakan onDisconnect — mekanisme khusus Firebase yang secara otomatis menjalankan operasi tulis saat koneksi klien terputus. Ini memastikan bahwa status pengguna berubah menjadi "offline" saat aplikasi ditutup atau jaringan hilang tanpa kode tambahan di sisi klien.

class PresenceRepository {
    private val database = FirebaseDatabase.getInstance()
    private val auth = FirebaseAuth.getInstance()
    private val presenceRef = database
        .getReference("presence")

    fun trackPresence() {
        val uid = auth.currentUser?.uid ?: return
        val userRef = presenceRef.child(uid)

        userRef.onDisconnect().setValue("offline")
        userRef.setValue("online")
    }

    fun getPresenceStream(): Flow<Map<String, String>> =
        presenceRef.snapshotFlow()
            .map { snapshot ->
                (snapshot.value as? Map<*, *>)
                    ?.mapKeys { it.key.toString() }
                    ?.mapValues { it.value.toString() }
                    ?: emptyMap()
            }
}

Elemen kunci dari contoh ini adalah onDisconnect. Mekanisme ini memungkinkan pengaturan operasi tulis yang akan dijalankan di server saat koneksi klien terputus. Dalam kasus ini, saat pengguna terputus, statusnya secara otomatis diatur ke "offline" tanpa perlu menangani peristiwa penutupan aplikasi. Jika aplikasi berhenti secara tidak terduga, Firebase sendiri akan menjalankan operasi onDisconnect, dan pengguna lain akan melihat status yang benar.