Realm i mobilappar: vad det är och hur det fungerar

Vad är Realm?

Realm är en objektorienterad databas som skapats specifikt för mobilapplikationer. Till skillnad från SQLite använder Realm inte SQL och relationsmodell — data lagras som levande objekt (Live Objects) som är direkt tillgängliga utan ett mellanliggande ORM-lager. Utvecklaren arbetar med vanliga språkobjekt (Swift, Kotlin, Dart) som automatiskt sparas i databasen.

Realm dök upp 2014 som startupen Realm Inc. och förvärvades 2019 av MongoDB Inc. Sedan dess utvecklas Realm som MongoDB Realm — en del av den enhetliga Atlas Device Sync-plattformen för mobil datasynkronisering. Den lokala Realm-databasen förblir gratis och öppen (Apache 2.0-licens), medan Realm Sync (molnbaserad synkronisering) distribueras via prenumeration.

Enligt MongoDB Developer Report (2025) används Realm i 15% av mobilapplikationerna som primär lokal lagring. Huvudscenarierna är applikationer med offlineläge, komplexa objektmodeller och behov av synkronisering mellan enheter, där Realm överträffar SQLite i utvecklingshastighet och användarvänlighet vid arbete med objekt.

Principer för Realm

Live Objects varje Realm-objekt är kopplat till disken via en memory-mapped fil. Ändring av ett objekt i någon tråd reflekteras omedelbart i alla andra trådar utan manuell notifiering. Användargränssnittet ritas automatiskt om när data ändras via Realm-notifieringar. Zero-copy Realm kopierar inte data från databasen till objekt, objekten är själva data i minnet.

Hur Realm är uppbyggt: arkitektur och lagring

Realm-kärnan är skriven i C++ och använder B+ Tree för indexering av data. Till skillnad från SQLite, där varje rad är en post i en relationell tabell, lagrar Realm objekt som noder i en grafstruktur med direktreferenser mellan dem (forward pointers). Relationer mellan objekt är inte foreign keys utan direktpekare, vilket eliminerar behovet av JOIN-operationer.

Realm-filer (.realm-tillägg) är memory-mapped — operativsystemet hanterar själv inladdning av filsidor i minnet vid åtkomst. Detta gör att Realm kan arbeta med databaser som överstiger tillgängligt RAM och säkerställer läsfördröjning på nivån av språkets inbyggda datastrukturer (Swift Array eller Kotlin List) för data som ryms i RAM.

Zero-copy och Live Objects

Memory-mapped filer är nyckeltekniken i Realm. Istället för att kopiera data från databasfilen till språkobjekt (som SQLite gör via sqlite3_step + sqlite3_column_*), mappar Realm databasfilen direkt till processens adressutrymme. Språkobjekt är bara pekare till data i det mappade minnet. Ändring av ett objekt ändrar databasen på disken utan separat save-anrop.

Minnesförbrukningen för Realm är högre vid aktiv läsning (hela filen eller stor del av den är mappad i minnet), men lägre vid skrivoperationer eftersom ingen minnesallokering krävs för objektkopior. För databaser upp till 1 GB på mobila enheter ger memory-mapped-metoden bättre total prestanda än SQLite med dess mellanliggande kopiering.

Realm vs SQLite vs Core Data: jämförelse

SQLite är ett relationsdatabashanteringssystem med SQL och ACID-transaktioner. Realm är en objektorienterad NoSQL-databas med memory-mapped åtkomst. Core Data är ett Apple ORM-lager ovanpå SQLite. Var och en av de tre metoderna har sitt tillämpningsområde och styrkor. Realm vinner i hastighet för direkt objektåtkomst och reaktivitet, SQLite i universalitet och mognad, Core Data i integration med Apple-ekosystemet.

Realms prestanda vid läsoperationer är 10-50% högre än SQLite tack vare zero-copy-åtkomst. Vid skrivoperationer är Realm också snabbare på grund av avsaknad av SQL-syntaxanalys och direkt ändring av memory-mapped-sidor. Dock kan Realm förbruka mer RAM vid arbete med stora databaser (>500 MB), eftersom filen mappas helt till adressutrymmet.

Valet mellan Realm och SQLite handlar ofta om prioriteringar: utvecklingshastighet och reaktivitet (Realm) kontroll och universalitet (SQLite). Realm är särskilt bra för MVP och prototyper, där datamodellen ändras ofta och det är viktigt att snabbt få levande UI-uppdateringar. SQLite/Room föredras för mogna produkter med stora datavolymer och komplexa analytiska frågor.

Realm på Android: Kotlin SDK

Realm Kotlin SDK är det officiella biblioteket för Android, skrivet i Kotlin (inte ett wrapper över Java SDK). Datamodellen definieras via klasser som ärver från RealmObject, med annoteringen @PrimaryKey för unik identifiering. Realm Kotlin stöder Kotlin Coroutines, Flow och KSP (Kotlin Symbol Processing) för kompileringstidsgenerering av kod.

RealmQuery tillhandahåller ett type-safe API för filtrering utan SQL. Frågor byggs med metodkedja: query → filter → sort → find. Resultatet kan returneras som lista (med inladdning i minnet) eller som Flow (reaktiv ström som uppdateras vid dataändringar). Realm Kotlin stöder också nästlade objekt och listor (RealmList).

Exempel Realm Kotlin SDK

Datamodellen för Realm definieras som en data-klass som implementerar RealmObject-gränssnittet. Fältet _id är markerat med @PrimaryKey för unik identifiering. Relationen ”en-till-många” implementeras via RealmList — en lista av andra RealmObject. Alla skrivoperationer (create, update, delete) utförs inom ett write-transaktionsblock.

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

En Flow-returnerande fråga emitterar automatiskt nya resultat vid varje dataändring i Realm: tillägg, uppdatering eller borttagning av Project eller Task. Flow-metoden kombineras idealiskt med Compose: collectAsState() i ViewModel återsammanställer automatiskt UI vid dataändringar utan manuell uppdatering av listadaptrar eller användning av LiveData.

Realm på iOS: Swift SDK

Realm Swift SDK tillhandahåller ett native Swift API med stöd för async/await, Combine Publishers och Swift Concurrency. Datamodeller definieras som klasser som ärver från Object, med @Persisted för egenskaper. Realm Swift uppdaterar automatiskt objekt vid ändringar, och notifieringar (NotificationToken) möjliggör prenumeration på ändringar av enskilda objekt eller samlingar.

@ObservedRealmObject och @ObservedResults är Property Wrappers för SwiftUI som automatiskt ritar om View när Realm-data ändras. @ObservedResults arbetar med frågeresultat, @ObservedRealmObject med ett specifikt objekt. Båda egenskaperna avslutar prenumerationen vid deinitiering av View.

Exempel Realm Swift SDK

SwiftUI-integration för Realm är en av SDK:s styrkor. Property Wrapper @ObservedResults kopplar en Realm-fråga till visningen i SwiftUI. Vid ändring av en uppgift återsammanställer SwiftUI automatiskt listan. realm.writeAsync utför transaktioner på bakgrundstråden utan att blockera UI.

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

@ObservedResults hanterar automatiskt livscykeln för en Realm-fråga: när View skapas skapas en prenumeration på ändringar, vid förstörelse avslutas den. Property Wrapper accepterar ett valfritt predikat (NSPredicate) och sortering. Detta eliminerar behovet av att manuellt skriva fetch-frågor, skapa ViewModel och prenumerera på Realm-notifieringar.

Användningsscenarier för Realm

Offline-applikationer Realm är idealiskt för scenarier där data måste vara tillgänglig utan internet. Inbyggd synkronisering (Realm Sync med MongoDB Atlas) löser automatiskt konflikter vid anslutning till nätverket. Applikationen fortsätter att arbeta med lokal data och bakgrundssynkronisering uppdaterar den när anslutning finns.

Reaktiva gränssnitt Live Objects och Flow/Combine-notifieringar gör Realm till ett bekvämt val för applikationer med ofta föränderlig data: chattar, uppgiftsflöden, delade dokument. UI uppdateras automatiskt vid tillägg, ändring eller borttagning av data utan manuella anrop till reloadData eller invalidate.

Cross-plattformsprojekt Realm stöder Kotlin Multiplatform (KMP), Flutter, React Native och Xamarin. Datamodellen definieras en gång och används på alla plattformar. Detta minskar kodduplicering och garanterar konsistens i dataschemat mellan iOS- och Android-applikationer med gemensam affärslogik.

Realm Sync: synkronisering via MongoDB Atlas

Realm Sync är en molntjänst inbyggd i MongoDB Atlas. Applikationen synkroniserar automatiskt data mellan användarens enheter och servern. Konflikter löses enligt strategin „last write wins” eller via anpassade Conflict Resolution Functions på servern. Realm Sync stöder partiell synkronisering (delmängd av data) för att minska trafik.

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)
        // Automatisk synkronisering är aktiv
    }
}

SyncConfiguration konfigurerar anslutningen till MongoDB Atlas och bestämmer vilka modeller som ska synkroniseras. Efter användarautentisering laddar Realm automatiskt data från molnet och slår samman dem med lokala ändringar. Synkronisering fungerar på bakgrundstråden och kräver inget manuellt anrop — det räcker att skapa en Realm-instans med SyncConfiguration.