Firebase Firestore: mi ez, NoSQL és hogyan működik

Mi az a Firebase Firestore?

Firebase Firestore egy rugalmas, skálázható NoSQL adatbázis, amelyet a Google 2019-ben indított el a Firebase Realtime Database evolúciójaként. Az adatokat dokumentumgyűjtemények formájában tárolja, ahol minden dokumentum kulcs-érték párok halmazát tartalmazza. A hagyományos relációs adatbázisokkal ellentétben a Firestore nem igényel előre meghatározott sémát — az adatstruktúra dinamikusan, az írt dokumentumok alapján alakul ki.

A Firestore kulcsfontosságú különbsége a klasszikus felhőalapú adatbázisokhoz képest a beépített valós idejű szinkronizálás. Amikor az adatok módosulnak a szerveren, az összes csatlakoztatott kliens frissítéseket kap egy állandó WebSocket-kapcsolaton keresztül. Ez kiküszöböli a szerver kézi lekérdezésének szükségességét, és lehetővé teszi élő frissítésekkel rendelkező alkalmazások építését: csevegések, tevékenységfolyamok, együttműködő szerkesztők és monitorozó rendszerek.

Az adatbázis minden fő platformon elérhető: Android, iOS, Web (JavaScript) és szerveroldali nyelveken az Admin SDK-n keresztül. A Firestore SDK-t biztosít Swift, Kotlin, JavaScript, Python, Go, Java és Node.js számára. A Google adatai szerint a Firestore naponta több mint 100 milliárd lekérdezést dolgoz fel a teljes Firebase ökoszisztémában, ami megerősíti megbízhatóságát a production alkalmazások alapjaként.

Alapfogalmak: gyűjtemények és dokumentumok

A Firestore-ban az adatok hierarchikus struktúrába vannak szervezve. A gyűjtemény dokumentumok konténere, hasonlóan az SQL táblájához, de rögzített séma nélkül. A dokumentum egy rekord, amely különböző típusú mezőket tartalmaz: karakterláncok, számok, logikai értékek, tömbök, beágyazott objektumok és geopontok. A dokumentumok alkolleket tartalmazhatnak, ami lehetővé teszi bármilyen mélységű beágyazott adatstruktúrák építését.

val db = FirebaseFirestore.getInstance()

val user = hashMapOf(
    "name" to "Anna Petrova",
    "email" to "anna@example.com",
    "age" to 28,
    "isActive" to true
)

db.collection("users")
    .add(user)
    .addOnSuccessListener { docRef ->
        Log.d("TAG", "Dokumentum hozzáadva ID-val: ${docRef.id}")
    }

Minden dokumentum a gyűjteményben egyedi azonosítóval rendelkezik, amely automatikusan generálható vagy kézzel beállítható. A Firestore automatikusan indexeli a dokumentum összes mezőjét, lehetővé téve összetett lekérdezések végrehajtását szűréssel, rendezéssel és az eredmények számának korlátozásával az indexek előzetes konfigurálása nélkül.

Firebase Firestore vs Realtime Database: összehasonlítás

Firestore és a Firebase Realtime Database két felhőalapú valós idejű adatbázis a Google-tól. Bár mindkettő valós idejű szinkronizálást biztosít, alapvető különbségek vannak az adatmodellben, a skálázásban és az árazásban. E különbségek megértése kritikus fontosságú a megfelelő adatbázis kiválasztásakor egy adott projekthez.

A fő architekturális különbség az adatmodell. A Realtime Database mindent egyetlen nagy JSON-fában tárol, ami megnehezíti a mélyen beágyazott lekérdezéseket. Firestore gyűjteményeket és dokumentumokat használ, ami lehetővé teszi összetett lekérdezések végrehajtását több feltétellel. Ezenkívül a Firestore erős adatkonzisztenciát biztosít: sikeres írás után az összes későbbi olvasás garantáltan aktuális adatokat ad vissza.

Skálázhatóság és adatstruktúra

Firestore automatikusan skálázódik akár több millió egyidejű kapcsolatig a több régiós architektúrának köszönhetően. A Realtime Database egy régióra és maximum 200 000 egyidejű kapcsolatra korlátozódik. A globális közönséget tervező projektek számára a Firestore az előnyösebb, mivel az adatok automatikusan replikálódnak több Google-adatközpont között.

Az adatstruktúra a Firestore-ban lehetővé teszi összetett hierarchikus modellek építését alkollekciókkal. Például egy felhasználónak lehet egy „rendelések" alkollekciója, és minden rendelésnek egy „termékek" alkollekciója. A Realtime Database-ben az ilyen mély beágyazás teljesítményproblémákhoz vezet a lekérdezésekben, mivel a gyökértől a kívánt csomópontig tartó teljes útvonal betöltődik.

Hogyan működik az adatszinkronizálás a Firestore-ban

Firestore állandó WebSocket-kapcsolatot használ a kliens és a szerver között a valós idejű adatszinkronizáláshoz. Amikor egy alkalmazás feliratkozik egy dokumentum vagy gyűjtemény változásaira snapshot listener segítségével, az SDK létrehoz egy kommunikációs csatornát, amelyen keresztül a szerver minden adatváltozáskor frissítéseket küld. A kliens csak a módosult dokumentumokat kapja meg, nem a teljes gyűjteményt minden alkalommal.

A szinkronizálási mechanizmus eseményfolyamon alapul: added (dokumentum megjelent), modified (dokumentum módosult) és removed (dokumentum törlődött). A fejlesztő minden eseményt külön feldolgozhat, csak a megfelelő UI-elemeket frissítve. Ez magas teljesítményt biztosít még több ezer dokumentum esetén is, mivel csak a megváltozott komponensek rajzolódnak újra.

Offline hozzáférés és gyorsítótárazás

A Firestore egyik legfontosabb előnye a beépített offline mód támogatása. Az SDK automatikusan gyorsítótárazza az összes beolvasott adatot az eszközön, és hálózat hiányában is tovább működik. Amikor az alkalmazás offline módban ír adatokat, azok egy helyi sorba kerülnek, és a kapcsolat helyreállításakor elküldődnek a szerverre. Az ütközések feloldásához a last-write-wins stratégia használatos.

val docRef = db.collection("cities").document("SF")

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "Figyelési hiba", error)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Aktuális adatok: ${snapshot.data}")
    }
}

A gyorsítótár mérete a FirestoreSettings segítségével konfigurálható. Alapértelmezés szerint 100 MB, de intenzív adatolvasású alkalmazások esetén növelhető. Elérhető továbbá a persistent disk cache mód, amely túléli az alkalmazás újraindítását. Az offline mód elérhetőségének kezeléséhez a enableNetwork és disableNetwork metódusok használatosak, amelyek lehetővé teszik a hálózati kommunikáció ideiglenes kikapcsolását.

Firestore biztonság és hozzáférési szabályok

Firestore Security Rules egy deklaratív jelölőnyelv az adathozzáférés vezérlésére szerver szinten. A szabályok meghatározzák, hogy ki és milyen feltételek mellett olvashat és írhat dokumentumokat. A lekérdezés végrehajtása előtt működnek, és nem igényelnek külön szerverlogikát az engedélyezéshez. A szabályok a Firebase oldalon ellenőrződnek minden adatolvasás vagy -írás előtt.

A hozzáférési szabályok az engedélyezett hozzáférés (allow) elvén épülnek fel. Alapértelmezés szerint minden hozzáférés tiltott. A fejlesztő fokozatosan nyitja meg a hozzáférést konkrét műveletekhez (read, write, create, update, delete) meghatározott feltételek mellett. A feltételek ellenőrizhetik a felhasználó hitelesítését a request.auth, a lekérdezés adatait a request.resource és a meglévő adatokat a resource segítségével.

// Firestore hozzáférési szabályok
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // A felhasználó csak saját adatait olvassa és írja
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Bármely hitelesített felhasználó olvashatja a bejegyzéseket
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Adatérvényesítés szabályokkal

A hozzáférés vezérlésén kívül a Security Rules lehetővé teszi az írt adatok szerkezetének és típusainak érvényesítését. Például ellenőrizhető, hogy az e-mail mező megfelel-e egy reguláris kifejezésnek, vagy hogy az életkor nem haladja-e meg a 120 évet. Az érvényesítés az írás előtt történik, megakadályozva a hibás adatok szerveren való tárolását. A mezők ellenőrzéséhez a request.resource.data objektum használatos, amely a teljes írandó dokumentumot tartalmazza.

A Firestore támogatja azokat a gyűjteményeket is, amelyek csak szerveroldali írásra érhetők el az Admin SDK-n keresztül, kliens hozzáférés nélkül. Ez kényelmes szolgáltatási információk, API-kulcsok és konfigurációk tárolására, amelyek nem lehetnek láthatók a felhasználók számára. Ehhez a szabályokban elegendő letiltani az összes kliensműveletet az érintett gyűjteményeken, csak az Admin SDK-n keresztüli hozzáférést engedélyezve a szerver oldalon.

Firebase Firestore használati példa Androidon

Nézzünk egy példát a Firestore integrálására egy Android-alkalmazásba feladatlista (todo) készítéséhez. Az alkalmazás valós időben olvassa a feladatokat, újakat ad hozzá, és megjelöli a készre. Az aszinkron munkához Firebase callback interfészek és Kotlin korutinok használatosak.

Firebase beállítása és függőségek hozzáadása

A munka megkezdése előtt csatlakoztatni kell a projektet a Firebase-hez a Firebase Console-on keresztül, és hozzá kell adni a google-services.json fájlt az alkalmazás moduljához. Ezután a build.gradle fájlhoz hozzáadódik a firebase-firestore-ktx függőség és a google-services plugin. A könyvtár verziójának meg kell egyeznie az aktuális Firebase BoM verzióval az összes Firebase-komponens kompatibilitásához.

dependencies {
    // Firebase BoM — verziókezelés
    implementation platform("com.google.firebase:firebase-bom:33.0.0")
    implementation "com.google.firebase:firebase-firestore-ktx"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0"
}

Beállítás után létrejön a Task adatmodell és a repository a Firestore-ral való munkához. A modell id, title, isCompleted és timestamp mezőket tartalmaz. A Firestore automatikusan szerializálja a data class-t dokumentummá, a mezőneveket kulcsként használva. Az adatok olvasásához snapshot listener használatos, amely a snapshotFlow kiterjesztésen keresztül Flow-t ad vissza.

data class Task(
    val id: String = "",
    val title: String = "",
    val isCompleted: Boolean = false,
    val createdAt: Timestamp? = null
)

class TaskRepository {
    private val tasksRef = FirebaseFirestore
        .getInstance()
        .collection("tasks")

    fun getTasks(): Flow<List<Task>> = tasksRef
        .orderBy("createdAt", Query.Direction.DESCENDING)
        .snapshotFlow()
        .map { snapshot ->
            snapshot?.toObjects(Task::class.java) ?: emptyList()
        }

    suspend fun addTask(title: String) {
        tasksRef.add(Task(title = title))
    }
}

A view-model feliratkozik a repository Flow-jára, és átadja a feladatlistát a UI rétegnek. Új feladat hozzáadásakor a repository suspend-függvénye hívódik meg a korutin scope-on keresztül. A Firestore automatikusan szinkronizálja a változásokat az összes kliens között: ha egy felhasználó hozzáad egy feladatot, a többiek valós időben látják anélkül, hogy újratöltenék a képernyőt.