Realm in mobilen Anwendungen: Was es ist und wie es funktioniert

Was ist Realm?

Realm ist eine objektorientierte Datenbank, die speziell für mobile Anwendungen entwickelt wurde. Im Gegensatz zu SQLite verwendet Realm weder SQL noch ein relationales Modell — Daten werden als Live Objects gespeichert, auf die ohne eine intermediate ORM-Schicht direkt zugegriffen wird. Der Entwickler arbeitet mit normalen Sprachobjekten (Swift, Kotlin, Dart), die automatisch in der Datenbank gespeichert werden.

Realm erschien 2014 als Startup Realm Inc. und wurde 2019 von MongoDB Inc. übernommen. Seitdem wird Realm als MongoDB Realm entwickelt — Teil der einheitlichen Atlas Device Sync-Plattform für mobile Datensynchronisation. Die lokale Basis-Realm-Datenbank bleibt kostenlos und Open Source (Apache 2.0-Lizenz), während Realm Sync (Cloud-Synchronisation) im Abonnement erhältlich ist.

Laut MongoDB Developer Report (2025) wird Realm in 15% der mobilen Anwendungen als primärer lokaler Speicher verwendet. Die Hauptanwendungsfälle sind Anwendungen mit Offline-Modus, komplexen Objektmodellen und der Notwendigkeit der Synchronisierung zwischen Geräten, wo Realm SQLite in der Entwicklungsgeschwindigkeit und Benutzerfreundlichkeit bei der Arbeit mit Objekten übertrifft.

Prinzipien von Realm

Live Objects — jedes Realm-Objekt ist über eine speicherabgebildete Datei (memory-mapped file) mit der Festplatte verbunden. Eine Änderung eines Objekts in einem beliebigen Thread wird sofort in allen anderen Threads ohne manuelle Benachrichtigung widergespiegelt. Die Benutzeroberfläche wird bei Datenänderungen über Realm-Benachrichtigungen automatisch neu gezeichnet. Zero-copy — Realm kopiert keine Daten aus der Datenbank in Objekte; die Objekte sind die Daten im Speicher.

Wie Realm funktioniert: Architektur und Speicherung

Realm-Kern ist in C++ geschrieben und verwendet B+ Tree zur Datenindizierung. Im Gegensatz zu SQLite, wo jede Zeile ein Datensatz in einer relationalen Tabelle ist, speichert Realm Objekte als Knoten in einer Graphstruktur mit direkten Referenzen zwischen ihnen (Forward Pointers). Beziehungen zwischen Objekten sind keine Fremdschlüssel, sondern direkte Zeiger, was die Notwendigkeit von JOIN-Operationen eliminiert.

Realm-Dateien (.realm-Erweiterung) sind speicherabgebildet (memory-mapped) — das Betriebssystem selbst verwaltet das Laden von Dateiseiten in den Speicher beim Zugriff. Dadurch kann Realm mit Datenbanken arbeiten, die größer als der verfügbare RAM sind, und bietet eine Lese-Latenz auf dem Niveau nativer Sprachdatenstrukturen (Swift Array oder Kotlin List) für Daten, die in den RAM passen.

Zero-copy und Live Objects

Speicherabgebildete Dateien — die Schlüsseltechnologie von Realm. Anstatt Daten aus der Datenbankdatei in Sprachobjekte zu kopieren (wie SQLite es über sqlite3_step + sqlite3_column_* tut), bildet Realm die Datenbankdatei direkt in den Adressraum des Prozesses ab. Sprachobjekte sind lediglich Zeiger auf Daten im abgebildeten Speicher. Das Ändern eines Objekts verändert die Datenbank auf der Festplatte ohne einen separaten save-Aufruf.

Der Speicherverbrauch ist bei Realm beim aktiven Lesen höher (die gesamte Datei oder ein großer Teil ist in den Speicher abgebildet), aber bei Schreibvorgängen geringer, da keine Speicherzuweisung für Objektkopien erforderlich ist. Für Datenbanken bis zu 1 GB auf mobilen Geräten bietet der Memory-Mapped-Ansatz eine bessere Gesamtleistung als SQLite mit seiner Zwischenkopie.

Realm vs SQLite vs Core Data: Vergleich

SQLite ist ein relationales DBMS mit SQL und ACID-Transaktionen. Realm ist eine objektorientierte NoSQL-Datenbank mit Memory-Mapped-Zugriff. Core Data ist die ORM-Schicht von Apple über SQLite. Jeder der drei Ansätze hat seinen eigenen Anwendungsbereich und Stärken. Realm punktet bei direkter Objektzugriffsgeschwindigkeit und Reaktivität, SQLite bei Vielseitigkeit und Reife, Core Data bei der Integration in das Apple-Ökosystem.

Die Leseleistung von Realm ist dank Zero-Copy-Zugriff 10-50% höher als bei SQLite. Realm ist auch beim Schreiben schneller, da keine SQL-Analyse erforderlich ist und Memory-Mapped-Seiten direkt geändert werden. Allerdings kann Realm bei der Arbeit mit großen Datenbanken (>500 MB) mehr RAM verbrauchen, da die Datei vollständig in den Adressraum abgebildet wird.

Die Wahl zwischen Realm und SQLite hängt oft von Prioritäten ab: Entwicklungsgeschwindigkeit und Reaktivität (Realm) versus Kontrolle und Vielseitigkeit (SQLite). Realm eignet sich besonders gut für MVPs und Prototypen, bei denen sich das Datenmodell häufig ändert und schnelle Live-UI-Updates wichtig sind. SQLite/Room ist für ausgereifte Produkte mit großen Datenmengen und komplexen analytischen Abfragen zu bevorzugen.

Realm auf Android: Kotlin SDK

Realm Kotlin SDK ist die offizielle Bibliothek für Android, geschrieben in Kotlin (kein Wrapper über Java SDK). Das Datenmodell wird durch Klassen definiert, die von RealmObject erben, mit der @PrimaryKey-Annotation für eine eindeutige Kennung. Realm Kotlin unterstützt Kotlin Coroutines, Flow und KSP (Kotlin Symbol Processing) zur Compile-Zeit-Codegenerierung.

RealmQuery bietet eine typsichere API zur Filterung ohne SQL. Abfragen werden durch eine Methodenkette erstellt: query → filter → sort → find. Das Ergebnis kann als Liste (in den Speicher geladen) oder als Flow (reaktiver Stream, der bei Datenänderungen aktualisiert wird) zurückgegeben werden. Realm Kotlin unterstützt auch verschachtelte Objekte und Listen (RealmList).

Realm Kotlin SDK Beispiel

Datenmodell Realm wird als Datenklasse definiert, die das RealmObject-Interface implementiert. Das Feld _id ist mit @PrimaryKey zur eindeutigen Identifizierung markiert. Die Eins-zu-Viele-Beziehung wird über RealmList implementiert — eine Liste anderer RealmObject-Instanzen. Alle Schreiboperationen (Erstellen, Aktualisieren, Löschen) werden innerhalb eines write-Transaktionsblocks ausgeführt.

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

Eine Flow-zurückgebende Abfrage gibt bei jeder Datenänderung in Realm automatisch neue Ergebnisse aus: Hinzufügen, Aktualisieren oder Löschen eines Project oder Task. Der Flow-Ansatz harmoniert perfekt mit Compose: collectAsState() im ViewModel setzt die UI bei Datenänderungen automatisch neu zusammen, ohne manuelles Aktualisieren von Listenadaptern oder Verwendung von LiveData.

Realm auf iOS: Swift SDK

Realm Swift SDK bietet eine native Swift-API mit Unterstützung für async/await, Combine Publishers und Swift Concurrency. Datenmodelle werden als Klassen definiert, die von Object erben, mit @Persisted für Eigenschaften. Realm Swift aktualisiert Objekte bei Änderungen automatisch, und Benachrichtigungen (NotificationToken) ermöglichen das Abonnieren von Änderungen einzelner Objekte oder Sammlungen.

@ObservedRealmObject und @ObservedResults sind Property Wrapper für SwiftUI, die die Ansicht bei Änderungen von Realm-Daten automatisch neu zeichnen. @ObservedResults arbeitet mit Abfrageergebnissen, @ObservedRealmObject mit einem bestimmten Objekt. Beide Eigenschaften kündigen das Abonnement bei der Deinitialisierung der Ansicht.

Realm Swift SDK Beispiel

SwiftUI-Integration Realm ist eine der Stärken des SDK. Der Property Wrapper @ObservedResults verknüpft eine Realm-Abfrage mit der SwiftUI-Anzeige. Wenn sich eine Aufgabe ändert, setzt SwiftUI die Liste automatisch neu zusammen. realm.writeAsync führt Transaktionen im Hintergrundthread aus, ohne die UI zu blockieren.

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

@ObservedResults verwaltet automatisch den Lebenszyklus der Realm-Abfrage: beim Erstellen der Ansicht wird ein Abonnement für Änderungen erstellt; beim Zerstören wird es gekündigt. Der Property Wrapper akzeptiert ein optionales Prädikat (NSPredicate) und einen Sortierdeskriptor. Dies eliminiert die Notwendigkeit, manuell Fetch-Anfragen zu schreiben, ViewModels zu erstellen und Realm-Benachrichtigungen zu abonnieren.

Realm-Anwendungsfälle

Offline-Anwendungen — Realm ist ideal für Szenarien, in denen Daten ohne Internet verfügbar sein müssen. Die integrierte Synchronisierung (Realm Sync mit MongoDB Atlas) löst Konflikte beim Verbinden mit dem Netzwerk automatisch. Die App arbeitet mit lokalen Daten weiter, und die Hintergrundsynchronisation aktualisiert sie, sobald eine Verbindung verfügbar ist.

Reaktive Oberflächen — Live Objects und Flow/Combine-Benachrichtigungen machen Realm zu einer bequemen Wahl für Anwendungen mit häufig aktualisierten Daten: Chats, Aufgaben-Feeds, gemeinsame Dokumente. Die UI wird bei Hinzufügen, Ändern oder Löschen von Daten automatisch aktualisiert, ohne manuelles Aufrufen von reloadData oder invalidate.

Plattformübergreifende Projekte — Realm unterstützt Kotlin Multiplatform (KMP), Flutter, React Native und Xamarin. Das Datenmodell wird einmal definiert und auf allen Plattformen verwendet. Dies reduziert Code-Duplizierung und gewährleistet Schema-Konsistenz zwischen iOS- und Android-Anwendungen mit gemeinsamer Geschäftslogik.

Realm Sync: Synchronisation über MongoDB Atlas

Realm Sync ist ein Cloud-Dienst, der in MongoDB Atlas integriert ist. Die Anwendung synchronisiert Daten automatisch zwischen den Geräten des Benutzers und dem Server. Konflikte werden durch die Strategie „Last Write Wins“ oder durch benutzerdefinierte Conflict Resolution Functions auf dem Server gelöst. Realm Sync unterstützt partielle Synchronisation (Teilmenge der Daten) zur Reduzierung des Datenverkehrs.

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 Synchronisation ist aktiv
    }
}

SyncConfiguration konfiguriert die Verbindung zu MongoDB Atlas und definiert die Menge der zu synchronisierenden Modelle. Nach der Benutzerauthentifizierung lädt Realm automatisch Daten aus der Cloud und führt sie mit lokalen Änderungen zusammen. Die Synchronisation läuft im Hintergrundthread und erfordert keine manuellen Aufrufe — erstellen Sie einfach eine Realm-Instanz mit SyncConfiguration.