Realm in mobiele apps: wat is het en hoe werkt het

Wat is Realm?

Realm is een objectgeoriënteerde database, speciaal gemaakt voor mobiele applicaties. In tegenstelling tot SQLite gebruikt Realm geen SQL en een relationeel model — gegevens worden opgeslagen als levende objecten (Live Objects), die direct toegankelijk zijn zonder een tussenliggende ORM-laag. De ontwikkelaar werkt met gewone taalobjecten (Swift, Kotlin, Dart), die automatisch in de database worden opgeslagen.

Realm verscheen in 2014 als startup Realm Inc. en werd in 2019 overgenomen door MongoDB Inc. Sindsdien wordt Realm ontwikkeld als MongoDB Realm — onderdeel van het uniforme Atlas Device Sync-platform voor mobiele gegevenssynchronisatie. De lokale Realm-database blijft gratis en open source (Apache 2.0-licentie), terwijl Realm Sync (cloudsynchronisatie) op abonnementsbasis wordt aangeboden.

Volgens het MongoDB Developer Report (2025) wordt Realm in 15% van de mobiele applicaties gebruikt als primaire lokale opslag. Belangrijkste scenario's zijn applicaties met een offlinemodus, complexe objectmodellen en behoefte aan synchronisatie tussen apparaten, waar Realm SQLite overtreft in ontwikkelsnelheid en gebruiksgemak van objecten.

Principes van Realm

Live Objects elk Realm-object is via een memory-mapped bestand aan de schijf gekoppeld. Een wijziging van een object in een thread wordt onmiddellijk weerspiegeld in alle andere threads zonder handmatige melding. De UI wordt automatisch opnieuw getekend bij gegevenswijzigingen via Realm-meldingen. Zero-copy Realm kopieert geen gegevens van de database naar objecten, objecten zijn de gegevens in het geheugen.

Hoe is Realm opgebouwd: architectuur en opslag

De kern van Realm is geschreven in C++ en gebruikt B+ Tree voor het indexeren van gegevens. In tegenstelling tot SQLite, waar elke rij een record in een relationele tabel is, slaat Realm objecten op als knooppunten in een grafstructuur met directe verwijzingen ertussen (forward pointers). Relaties tussen objecten zijn geen foreign keys, maar directe aanwijzers, wat de noodzaak voor JOIN-operaties elimineert.

Realm-bestanden (.realm-extensie) zijn memory-mapped het besturingssysteem beheert zelf het laden van bestandspagina's in het geheugen bij toegang. Hierdoor kan Realm werken met databases die groter zijn dan het beschikbare werkgeheugen en zorgt het voor leeslatentie op het niveau van native datastructuren van de taal (Swift Array of Kotlin List) voor gegevens die in RAM passen.

Zero-copy en Live Objects

Memory-mapped bestanden zijn de sleuteltechnologie van Realm. In plaats van gegevens uit het databasebestand naar taalobjecten te kopiëren (zoals SQLite doet via sqlite3_step + sqlite3_column_*), wijst Realm het databasebestand direct toe aan de adresruimte van het proces. Taalobjecten zijn slechts aanwijzers naar gegevens in het toegewezen geheugen. Het wijzigen van een object verandert de database op schijf zonder afzonderlijke save-aanroep.

Het geheugengebruik van Realm is hoger bij actief lezen (het hele bestand of een groot deel ervan is toegewezen in het geheugen), maar lager bij schrijfbewerkingen, omdat er geen geheugen hoeft te worden toegewezen voor kopieën van objecten. Voor databases tot 1 GB op mobiele apparaten biedt de memory-mapped aanpak betere algemene prestaties dan SQLite met zijn tussentijdse kopiëren.

Realm vs SQLite vs Core Data: vergelijking

SQLite is een relationeel databasebeheersysteem met SQL en ACID-transacties. Realm is een objectgeoriënteerde NoSQL-database met memory-mapped toegang. Core Data is een Apple ORM-laag bovenop SQLite. Elk van de drie benaderingen heeft zijn eigen toepassingsgebied en sterke punten. Realm wint in snelheid van directe objecttoegang en reactiviteit, SQLite in universaliteit en volwassenheid, Core Data in integratie met het Apple-ecosysteem.

De prestaties van Realm bij leesbewerkingen zijn 10-50% hoger dan SQLite dankzij zero-copy toegang. Bij schrijfbewerkingen is Realm ook sneller door het ontbreken van SQL-syntaxisanalyse en directe wijziging van memory-mapped pagina's. Realm kan echter meer werkgeheugen verbruiken bij het werken met grote databases (>500 MB), omdat het bestand volledig in de adresruimte wordt toegewezen.

De keuze tussen Realm en SQLite hangt vaak af van prioriteiten: ontwikkelingssnelheid en reactiviteit (Realm) versus controle en universaliteit (SQLite). Realm is vooral goed voor MVP's en prototypes, waar het gegevensmodel vaak verandert en het belangrijk is om snel live UI-updates te krijgen. SQLite/Room heeft de voorkeur voor volwassen producten met grote hoeveelheden gegevens en complexe analytische queries.

Realm op Android: Kotlin SDK

Realm Kotlin SDK is de officiële bibliotheek voor Android, geschreven in Kotlin (geen wrapper rond Java SDK). Het gegevensmodel wordt gedefinieerd via klassen die overerven van RealmObject, met de annotatie @PrimaryKey voor een unieke identificatie. Realm Kotlin ondersteunt Kotlin Coroutines, Flow en KSP (Kotlin Symbol Processing) voor compile-time codegeneratie.

RealmQuery biedt een type-safe API voor filteren zonder SQL. Query's worden opgebouwd via een methodenketen: query → filter → sort → find. Het resultaat kan worden geretourneerd als lijst (met laden in het geheugen) of als Flow (reactieve stream die wordt bijgewerkt bij gegevenswijzigingen). Realm Kotlin ondersteunt ook geneste objecten en lijsten (RealmList).

Voorbeeld Realm Kotlin SDK

Het gegevensmodel van Realm wordt gedefinieerd als een data class die de RealmObject-interface implementeert. Het veld _id is gemarkeerd met @PrimaryKey voor unieke identificatie. De relatie „��n-op-veel“ wordt geïmplementeerd via RealmList — een lijst van andere RealmObjecten. Alle schrijfbewerkingen (create, update, delete) worden uitgevoerd binnen een write-transactieblok.

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

Een Flow-retournerende query emitteert automatisch nieuwe resultaten bij elke gegevenswijziging in Realm: toevoegen, bijwerken of verwijderen van Project of Task. De Flow-benadering combineert ideaal met Compose: collectAsState() in ViewModel herstelt de UI automatisch bij gegevenswijzigingen zonder handmatige update van lijstadapter of gebruik van LiveData.

Realm op iOS: Swift SDK

Realm Swift SDK biedt een native Swift API met ondersteuning voor async/await, Combine Publishers en Swift Concurrency. Gegevensmodellen worden gedefinieerd als klassen die overerven van Object, met @Persisted voor eigenschappen. Realm Swift werkt objecten automatisch bij bij wijzigingen, en meldingen (NotificationToken) maken het mogelijk om te abonneren op wijzigingen van afzonderlijke objecten of collecties.

@ObservedRealmObject en @ObservedResults zijn Property Wrappers voor SwiftUI die de View automatisch opnieuw tekenen bij wijziging van Realm-gegevens. @ObservedResults werkt met queryresultaten, @ObservedRealmObject met een specifiek object. Beide eigenschappen annuleren het abonnement bij deinitialisatie van de View.

Voorbeeld Realm Swift SDK

SwiftUI-integratie van Realm is een van de sterke punten van de SDK. De Property Wrapper @ObservedResults koppelt een Realm-query aan de weergave in SwiftUI. Bij wijziging van een taak herstelt SwiftUI de lijst automatisch. realm.writeAsync voert transacties uit op de achtergrondthread zonder de UI te blokkeren.

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("Taak toevoegen") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults beheert automatisch de levenscyclus van een Realm-query: bij het maken van een View wordt een abonnement op wijzigingen aangemaakt, bij vernietiging wordt het geannuleerd. De Property Wrapper accepteert een optioneel predicaat (NSPredicate) en sortering. Dit elimineert de noodzaak om handmatig fetch-query's te schrijven, een ViewModel te maken en te abonneren op Realm-meldingen.

Gebruiksscenario's voor Realm

Offline applicaties Realm is ideaal voor scenario's waar gegevens beschikbaar moeten zijn zonder internet. Ingebouwde synchronisatie (Realm Sync met MongoDB Atlas) lost automatisch conflicten op bij verbinding met het netwerk. De applicatie blijft werken met lokale gegevens en achtergrondsynchronisatie werkt deze bij wanneer er een verbinding is.

Reactieve interfaces Live Objects en Flow/Combine-meldingen maken Realm een handige keuze voor applicaties met vaak veranderende gegevens: chatberichten, takenfeeds, gedeelde documenten. De UI wordt automatisch bijgewerkt bij toevoegen, wijzigen of verwijderen van gegevens zonder handmatige aanroep van reloadData of invalidate.

Cross-platform projecten Realm ondersteunt Kotlin Multiplatform (KMP), Flutter, React Native en Xamarin. Het gegevensmodel wordt eenmalig gedefinieerd en op alle platformen gebruikt. Dit vermindert code-duplicatie en garandeert consistentie van het gegevensschema tussen iOS- en Android-applicaties met gemeenschappelijke bedrijfslogica.

Realm Sync: synchronisatie via MongoDB Atlas

Realm Sync is een cloudservice ingebouwd in MongoDB Atlas. De applicatie synchroniseert automatisch gegevens tussen de apparaten van de gebruiker en de server. Conflicten worden opgelost volgens de „last write wins“-strategie of via aangepaste Conflict Resolution Functions op de server. Realm Sync ondersteunt gedeeltelijke synchronisatie (subset of data) om het datagebruik te verminderen.

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)
        // Automatische synchronisatie is actief
    }
}

SyncConfiguration configureert de verbinding met MongoDB Atlas en bepaalt de set te synchroniseren modellen. Na authenticatie van de gebruiker laadt Realm automatisch gegevens uit de cloud en voegt deze samen met lokale wijzigingen. Synchronisatie werkt op de achtergrondthread en vereist geen handmatige aanroep — het volstaat om een Realm-instantie met SyncConfiguration te maken.