Firebase Realtime DB — co to je, architektura a práce s JSON

Co je Firebase Realtime Database?

Firebase Realtime Database je cloudová NoSQL databáze, která ukládá a synchronizuje data v reálném čase mezi všemi připojenými klienty. Spuštěna v roce 2012 jako Firebase (před akvizicí společností Google), stala se první cloudovou databází reálného času pro mobilní vývojáře. Data jsou prezentována ve formátu JSON a organizována v hierarchickém stromu, kde každý uzel má jedinečnou cestu.

Hlavní hodnotou Realtime Database je vestavěná synchronizace. Když aplikace změní data na jakémkoli zařízení, všichni ostatní připojení klienti okamžitě obdrží aktualizaci prostřednictvím trvalého připojení. To zbavuje vývojáře nutnosti implementovat vlastní synchronizační mechanismus, WebSocket server nebo REST API pro přenos dat mezi klienty.

Databáze poskytuje SDK pro všechny hlavní platformy: Android (Java, Kotlin), iOS (Swift, Objective-C), Web (JavaScript) a serverová prostředí prostřednictvím Admin SDK. Podle údajů Google je Realtime Database používána ve více než 1,5 milionu aktivních Firebase projektů po celém světě. Navzdory příchodu modernějšího Firestore zůstává Realtime Database oblíbenou volbou pro projekty s jednoduchou strukturou dat.

Struktura dat: JSON strom

Na rozdíl od relačních databází, Realtime Database nepoužívá tabulky a řádky. Všechna data tvoří jeden JSON strom, který vypadá jako vnořené objekty JavaScript. Například pro ukládání uživatelů a jejich zpráv se vytváří hierarchie: users/userId/name a messages/messageId/text. Každá cesta ve stromu je řetězec a data lze číst přímo této cestě.

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

Důležitou vlastností je, že hluboké vnoření ovlivňuje výkon. Když aplikace čte data na určité cestě, načítá všechny podřízené uzly této cesty. Proto se doporučuje navrhovat strukturu dat co nejplošší, vyhýbat se vnoření hlubšímu než 3—účtovně. K vyřešení tohoto problému se používá denormalizace dat — duplikování informací v různých uzlech stromu.

Realtime Database vs Firestore: kdy vybrat

Realtime Database a Firestore jsou často srovnávány jako dvě cloudové databáze reálného času od Google. Výběr mezi nimi závisí na konkrétních požadavcích projektu: složitosti dotazů, požadované konzistenci a plánované zátěži. Pochopení silných stránek každé databáze pomáhá při správném architektonickém rozhodnutí.

Hlavní výhodou Realtime Database je nízká latence synchronizace. Protože všechna data jsou uložena v jednom JSON stromu bez dalších vrstev abstrakce, synchronizace je rychlejší než ve Firestore. Pro aplikace, kde je rychlost dodávky aktualizací kritická (chaty, online hry, systémy pro společné editování), může být Realtime Database vhodnější volbou.

Kdy použít Realtime Database

Realtime Database je vhodnější pro scénáře s jednoduchou strukturou dat a vysokou frekvencí aktualizací. Typické příklady: chaty, lajky v reálném čase, indikátory psaní, stavy přítomnosti uživatelů. Je to také dobrá volba pro prototypy a projekty s omezeným rozpočtem, protože ceny jsou založeny na objemu dat, nikoli na počtu operací.

Na druhé straně, pro aplikace se složitými dotazy (filtrování podle více polí, řazení, agregace) nabízí Firestore mnohem výkonnější možnosti. Realtime Database podporuje pouze filtrování podle jednoho parametru a nemůže řadit výsledky podle více polí současně. Pokud projekt plánuje složitou analýzu dat na straně klienta, Firestore bude praktičtější volbou.

Jak funguje synchronizace v Realtime Database

Realtime Database používá trvalé WebSocket připojení pro obousměrnou synchronizaci dat. Když klient zavolá setValue nebo updateChildren na určité cestě, data jsou odeslána na Firebase server prostřednictvím otevřeného kanálu. Server aplikuje změny a rozesílá aktualizace všem přihlášeným klientům během milisekund. Každé připojení je identifikováno jedinečným klíčem relace.

Mechanismus přihlášení funguje prostřednictvím listenerů. Vývojář se může přihlásit ke změně konkrétního uzlu (addListenerForSingleValueEvent) nebo dostávat trvalé aktualizace (addValueEventListener). Při každé změně dat je voláno callback onDataChange s úplným snímkem dat na zadané cestě. To se liší od Firestore, kde přicházejí pouze změněné dokumenty — v Realtime Database se vždy načítají všechna data uzlu.

Offline režim a řízení konfliktů

Realtime Database podporuje offline režim na Android a iOS prostřednictvím cache na disku. SDK uchovává lokální kopii dat a pokračuje ve zpracování zápisových operací při absenci sítě. Když je připojení obnoveno, všechny nahromaděné změny jsou odeslány na server. K řešení konfliktů se používá strategie last-write-wins, ale vývojář může implementovat vlastní logiku prostřednictvím ServerValue.TIMESTAMP pro řešení kolizí.

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

// Zápis dat
myRef.push().setValue(
    hashMapOf(
        "text" to "Nová zpráva",
        "timestamp" to ServerValue.TIMESTAMP
    )
)

// Čtení s neustálou aktualizací
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", "Chyba: ${error.message}")
    }
})

Pro optimalizaci provozu a výkonu se doporučuje používat child listeners místo value listeners, když je třeba sledovat změny konkrétních podřízených uzlů. ChildEventListener poskytuje samostatné callbacky pro přidávání, změnu, odstranění a přesun podřízených prvků, což umožňuje přesnější kontrolu aktualizací UI a zabraňuje překreslování všech prvků seznamu při každé změně dat.

Bezpečnostní pravidla a validace dat

Realtime Database používá deklarativní jazyk pravidel pro řízení přístupu k datům. Pravidla popisují, kdo může číst a zapisovat data na každé cestě JSON stromu. Jsou kontrolována na serveru Firebase před každým požadavkem a nevyžadují serverovou logiku pro autorizaci. Pravidla podporují proměnné, vestavěné objekty a funkce pro flexibilní konfiguraci přístupu.

Ve výchozím nastavení je přístup k databázi zakázán pro všechny uživatele. Vývojář postupně otevírá přístup pomocí pravidla ".read" a ".write" na různých úrovních stromu. Podmínky mohou kontrolovat autentizaci prostřednictvím proměnné auth, typ požadavku (read/write) a existující data prostřednictvím objektu data. Kromě toho pravidla podporují validaci zapisovaných dat prostřednictvím objektu newData.

{
  "rules": {
    "users": {
      "$uid": {
        // Pouze vlastník může číst svá data
        ".read": "$uid === auth.uid",
        // Pouze vlastník může psát
        ".write": "$uid === auth.uid",
        // Validace polí při zápisu
        ".validate": "newData.hasChildren(['name', 'email'])"
      }
    },
    "messages": {
      // Každý autentizovaný může číst
      ".read": "auth !== null",
      // Pouze autentizovaný může psát
      ".write": "auth !== null",
      ".indexOn": ["timestamp"]
    }
  }
}

Pravidla také podporují indexování dat prostřednictvím direktivy ".indexOn". Bez ní budou dotazy s řazením (orderByChild) odmítnuty nebo provedeny neefektivně. Indexy jsou specifikovány pro každou cestu, kde se provádí řazení podle určitého pole. Pravidla jsou kaskádová: hlubší pravidla přepisují rodičovská, a pokud na nějaké úrovni přístup neexistuje, je považován za povolený nebo zakázaný v závislosti na rodičovském pravidle.

Typy dat a omezení

Realtime Database podporuje pět typů dat: String, Number, Boolean, Map (objekt) a List (pole). Hloubka vnoření je omezena na 32 úrovní a maximální velikost jednoho uzlu nesmí přesáhnout 256 MB. Pro efektivní práci s databází se doporučuje navrhovat plochou strukturu dat a používat denormalizaci k zamezení hlubokých dotazů, které načítají velké objemy dat.

Příklad použití Realtime Database v Android

Podívejme se na praktický příklad integrace Realtime Database do Android aplikace pro stavy uživatelů (online/offline). Aplikace bude zobrazovat seznam uživatelů s jejich aktuálním stavem, aktualizovaným v reálném čase. Pro demonstraci se používá Firebase Authentication pro identifikaci uživatelů a korutiny pro asynchronní operace.

Nastavení závislostí a inicializace

Pro začátek přidejte závislost firebase-database-ktx do souboru build.gradle modulu aplikace. Verze knihovny je spravována prostřednictvím Firebase BoM pro zajištění kompatibility všech komponent. Po přidání závislosti je třeba inicializovat Firebase ve třídě Application nebo pomocí lenivé inicializace ve 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"
}

Po konfiguraci je vytvořeno repository pro práci s uživateli. Každý uživatel je reprezentován uzlem ve stromu /users/{uid} s poli name, email a status. Pro sledování stavu se používá onDisconnect — speciální mechanismus Firebase, který automaticky provádí zápisovou operaci při přerušení spojení klienta. To zaručuje, že se stav uživatele změní na "offline" při zavření aplikace nebo ztrátě sítě bez dalšího kódu na straně klienta.

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

Klíčovým prvkem příkladu je onDisconnect. Tento mechanismus umožňuje nastavit zápisovou operaci, která bude provedena na serveru při přerušení spojení klienta. V tomto případě je při odpojení uživatele jeho stav automaticky nastaven na "offline" bez nutnosti zpracovávání události zavření aplikace. Pokud aplikace neočekávaně skončí, Firebase sám provede operaci onDisconnect a ostatní uživatelé uvidí správný stav.