Firebase Firestore: wat is het, NoSQL en hoe werkt het

Wat is Firebase Firestore?

Firebase Firestore is een flexibele, schaalbare NoSQL-database die in 2019 door Google is gelanceerd als evolutie van Firebase Realtime Database. Het slaat gegevens op in de vorm van documentcollecties, waarbij elk document een set sleutel-waardeparen bevat. In tegenstelling tot traditionele relationele databases vereist Firestore geen vooraf gedefinieerd schema — de gegevensstructuur wordt dynamisch gevormd op basis van de geschreven documenten.

Het belangrijkste verschil van Firestore met klassieke clouddatabases is de ingebouwde realtime synchronisatie. Wanneer gegevens op de server veranderen, ontvangen alle verbonden clients updates via een permanente WebSocket-verbinding. Dit elimineert de noodzaak voor handmatige serverpolling en maakt het mogelijk applicaties met live-updates te bouwen: chats, activiteitenfeeds, gezamenlijke editors en monitorsystemen.

De database is beschikbaar op alle belangrijke platforms: Android, iOS, Web (JavaScript) en servertalen via Admin SDK. Firestore biedt SDK voor Swift, Kotlin, JavaScript, Python, Go, Java en Node.js. Volgens Google verwerkt Firestore meer dan 100 miljard query's per dag in het hele Firebase-ecosysteem, wat de betrouwbaarheid als basis voor productieapplicaties bevestigt.

Basisconcepten: collecties en documenten

In Firestore zijn gegevens georganiseerd in een hiërarchische structuur. Een collectie is een container van documenten, vergelijkbaar met een tabel in SQL, maar zonder vast schema. Een document is een record dat velden van verschillende typen bevat: strings, getallen, booleaanse waarden, arrays, geneste objecten en geopunten. Documenten kunnen subcollecties bevatten, wat het mogelijk maakt geneste gegevensstructuren van elke diepte te bouwen.

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", "Document toegevoegd met ID: ${docRef.id}")
    }

Elk document in een collectie heeft een unieke identificatie die automatisch kan worden gegenereerd of handmatig kan worden ingesteld. Firestore indexeert automatisch alle velden van een document, waardoor complexe query's met filtering, sortering en beperking van het aantal resultaten mogelijk zijn zonder voorafgaande indexconfiguratie.

Firebase Firestore vs Realtime Database: vergelijking

Firestore en Firebase Realtime Database zijn twee cloud-realtime databases van Google. Hoewel beide realtime synchronisatie bieden, hebben ze fundamentele verschillen in gegevensmodel, schaalbaarheid en prijsstelling. Inzicht in deze verschillen is cruciaal bij het kiezen van de juiste database voor een specifiek project.

Het belangrijkste architectuurverschil is het gegevensmodel. Realtime Database slaat alles op in één grote JSON-boom, wat query's met diepe nesting bemoeilijkt. Firestore gebruikt collecties en documenten, wat het mogelijk maakt complexe query's met meerdere voorwaarden uit te voeren. Bovendien biedt Firestore sterke gegevensconsistentie: na een succesvolle schrijven retourneren alle volgende lezingen gegarandeerd actuele gegevens.

Schaalbaarheid en gegevensstructuur

Firestore schaalt automatisch naar miljoenen gelijktijdige verbindingen dankzij de multi-regionale architectuur. Realtime Database is beperkt tot één regio en maximaal 200.000 gelijktijdige verbindingen. Voor projecten die een wereldwijd publiek plannen, heeft Firestore de voorkeur omdat gegevens automatisch worden gerepliceerd tussen meerdere Google-datacenters.

De gegevensstructuur in Firestore maakt het mogelijk complexe hiërarchische modellen met subcollecties te bouwen. Een gebruiker kan bijvoorbeeld een subcollectie „bestellingen" hebben en elke bestelling een subcollectie „producten". In Realtime Database leidt dergelijke diepe nesting tot prestatieproblemen bij query's, omdat het hele pad van de root naar het gewenste knooppunt wordt geladen.

Hoe gegevenssynchronisatie in Firestore werkt

Firestore gebruikt een permanente WebSocket-verbinding tussen client en server voor realtime gegevenssynchronisatie. Wanneer een app zich abonneert op wijzigingen van een document of collectie via een snapshot listener, vestigt de SDK een communicatiekanaal waarlangs de server updates stuurt bij elke gegevenswijziging. De client ontvangt alleen de gewijzigde documenten, niet de volledige collectie elke keer.

Het synchronisatiemechanisme is gebaseerd op een gebeurtenisstroom: added (document verschenen), modified (document gewijzigd) en removed (document verwijderd). De ontwikkelaar kan elke gebeurtenis afzonderlijk verwerken en alleen de bijbehorende UI-elementen bijwerken. Dit zorgt voor hoge prestaties, zelfs met duizenden documenten, omdat alleen gewijzigde componenten opnieuw worden getekend.

Offline toegang en caching

Een van de belangrijkste voordelen van Firestore is de ingebouwde ondersteuning voor offline modus. De SDK cached automatisch alle gelezen gegevens op het apparaat en blijft werken zonder netwerk. Wanneer de app gegevens in offline modus schrijft, worden ze in een lokale wachtrij geplaatst en naar de server gestuurd wanneer de verbinding wordt hersteld. Voor het oplossen van conflicten wordt de last-write-wins-strategie gebruikt.

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

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

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Huidige gegevens: ${snapshot.data}")
    }
}

De cachegrootte kan worden geconfigureerd via FirestoreSettings. Standaard wordt 100 MB gebruikt, maar voor apps met intensief gegevens lezen kan dit worden verhoogd. Er is ook een persistent disk cache-modus beschikbaar die het herstarten van de app overleeft. Voor het beheren van de offline modus worden de methoden enableNetwork en disableNetwork gebruikt, waarmee de netwerkcommunicatie tijdelijk kan worden uitgeschakeld.

Firestore-beveiliging en toegangsregels

Firestore Security Rules is een declaratieve markup-taal voor het beheren van gegevenstoegang op serverniveau. De regels bepalen wie en onder welke voorwaarden documenten kan lezen en schrijven. Ze werken voordat de query wordt uitgevoerd en vereisen geen aparte serverlogica voor autorisatie. De regels worden aan de Firebase-kant gecontroleerd voor elke lees- of schrijfactie.

Toegangsregels zijn gebouwd op het principe van toegestane toegang (allow). Standaard is alle toegang verboden. De ontwikkelaar opent achtereenvolgens toegang voor specifieke bewerkingen (read, write, create, update, delete) onder bepaalde voorwaarden. Voorwaarden kunnen gebruikersauthenticatie controleren via request.auth, querygegevens via request.resource en bestaande gegevens via resource.

// Firestore-toegangsregels
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Gebruiker leest en schrijft alleen eigen gegevens
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Elke geverifieerde gebruiker kan berichten lezen
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Gegevensvalidatie via regels

Naast toegangscontrole maakt Security Rules het mogelijk de structuur en typen van geschreven gegevens te valideren. Zo kan worden gecontroleerd of het e-mailveld overeenkomt met een reguliere expressie of dat de leeftijd niet boven de 120 jaar is. Validatie wordt uitgevoerd vóór het schrijven, wat voorkomt dat onjuiste gegevens op de server worden opgeslagen. Voor het controleren van velden wordt het object request.resource.data gebruikt, dat het volledige te schrijven document bevat.

Firestore ondersteunt ook collecties die alleen toegankelijk zijn voor serverschrijven via Admin SDK, zonder toegang van clients. Dit is handig voor het opslaan van service-informatie, API-sleutels en configuraties die niet zichtbaar moeten zijn voor gebruikers. Hiervoor volstaat het in de regels om alle clientbewerkingen op de betreffende collecties te verbieden, met alleen toegang via Admin SDK aan de serverzijde.

Voorbeeld van Firebase Firestore in Android

Laten we een voorbeeld bekijken van de integratie van Firestore in een Android-app voor het maken van een takenlijst (todo). De app zal taken in realtime lezen, nieuwe toevoegen en voltooide markeren. Voor asynchroon werk worden Firebase callback-interfaces en Kotlin-coroutines gebruikt.

Firebase configureren en afhankelijkheden toevoegen

Voordat u begint, moet u het project verbinden met Firebase via Firebase Console en het bestand google-services.json toevoegen aan de app-module. Vervolgens wordt in build.gradle de afhankelijkheid firebase-firestore-ktx en de google-services-plugin toegevoegd. De bibliotheekversie moet overeenkomen met de huidige BoM-versie van Firebase voor compatibiliteit van alle Firebase-componenten.

dependencies {
    // Firebase BoM — versiebeheer
    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"
}

Na configuratie worden het gegevensmodel Task en de repository voor het werken met Firestore gemaakt. Het model bevat de velden id, title, isCompleted en timestamp. Firestore serialiseert automatisch de data class naar een document, met veldnamen als sleutels. Voor het lezen van gegevens wordt een snapshot listener gebruikt die een Flow retourneert via de extensie snapshotFlow.

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

Het view-model abonneert zich op de Flow van de repository en geeft de takenlijst door aan de UI-laag. Bij het toevoegen van een nieuwe taak wordt de suspend-functie van de repository aangeroepen via de coroutine-scope. Firestore synchroniseert automatisch wijzigingen tussen alle clients: als een gebruiker een taak toevoegt, zien anderen deze in realtime zonder het scherm te verversen.