Realm a mobilalkalmazásokban: mi ez és hogyan működik

Mi az a Realm?

Realm egy objektum-orientált adatbázis, amelyet kifejezetten mobilalkalmazásokhoz hoztak létre. Az SQLite-tól eltérően a Realm nem használ SQL-t és relációs modellt — az adatok élő objektumokként (Live Objects) tárolódnak, amelyek közvetlenül, köztes ORM réteg nélkül érhetők el. A fejlesztő a nyelv szokásos objektumaival (Swift, Kotlin, Dart) dolgozik, amelyek automatikusan elmentődnek az adatbázisba.

A Realm 2014-ben jelent meg Realm Inc. startupként, és 2019-ben felvásárolta a MongoDB Inc. Azóta a Realm MongoDB Realmként fejlődik — az egységes Atlas Device Sync platform részeként a mobilos adatszinkronizációhoz. A helyi Realm adatbázis továbbra is ingyenes és nyílt forráskódú (Apache 2.0 licenc), míg a Realm Sync (felhőalapú szinkronizáció) előfizetéses alapon érhető el.

A MongoDB Developer Report (2025) szerint a Realm-et a mobilalkalmazások 15%-a használja elsődleges helyi tárolóként. A fő forgatókönyvek közé tartoznak az offline módot igénylő alkalmazások, összetett objektummodellek és eszközök közötti szinkronizációs igények, ahol a Realm felülmúlja az SQLite-ot a fejlesztési sebességben és az objektumokkal való munkavégzés kényelmében.

A Realm alapelvei

Live Objects minden Realm objektum memórialeképezett fájlon (memory-mapped file) keresztül kapcsolódik a lemezhez. Egy objektum bármely szálban történő módosítása azonnal megjelenik az összes többi szálban, kézi értesítés nélkül. A felhasználói felület automatikusan újrarajzolódik az adatok változásakor a Realm értesítéseken keresztül. Zero-copy a Realm nem másol adatokat az adatbázisból az objektumokba, az objektumok maguk a memóriában lévő adatok.

Hogyan épül fel a Realm: architektúra és tárolás

A Realm magja C++-ban íródott, és B+ Tree-t használ az adatok indexeléséhez. Az SQLite-tól eltérően, ahol minden sor egy rekord egy relációs táblában, a Realm az objektumokat csomópontokként tárolja egy gráfszerkezetben, közvetlen hivatkozásokkal közöttük (forward pointers). Az objektumok közötti kapcsolatok nem foreign key-ek, hanem közvetlen mutatók, ami kiküszöböli a JOIN műveletek szükségességét.

A Realm fájlok (.realm kiterjesztés) memory-mapped jellegűek — az operációs rendszer maga kezeli a fájloldalak memóriába töltését a hozzáférés során. Ez lehetővé teszi a Realm számára, hogy a rendelkezésre álló RAM-nál nagyobb adatbázisokkal dolgozzon, és a RAM-ba elférő adatok esetében a nyelv natív adatszerkezeteinek (Swift Array vagy Kotlin List) szintjén biztosít olvasási késleltetést.

Zero-copy és Live Objects

Memory-mapped fájlok a Realm kulcsfontosságú technológiája. Ahelyett, hogy az adatbázisfájlból a nyelvi objektumokba másolná az adatokat (ahogy az SQLite teszi az sqlite3_step + sqlite3_column_* segítségével), a Realm az adatbázisfájlt közvetlenül a folyamat címtartományába képezi le. A nyelvi objektumok csupán mutatók a leképezett memóriában lévő adatokra. Egy objektum módosítása külön save hívás nélkül megváltoztatja az adatbázist a lemezen.

A memória fogyasztása a Realm esetében aktív olvasáskor magasabb (a teljes fájl vagy nagy része a memóriába van képezve), de írási műveleteknél alacsonyabb, mivel nincs szükség memória allokálásra objektummásolatok számára. Legfeljebb 1 GB méretű adatbázisok esetén mobileszközökön a memory-mapped megközelítés jobb általános teljesítményt nyújt, mint az SQLite a köztes másolással.

Realm vs SQLite vs Core Data: összehasonlítás

SQLite egy relációs adatbázis-kezelő rendszer SQL-lel és ACID tranzakciókkal. A Realm egy objektum-orientált NoSQL adatbázis memory-mapped hozzáféréssel. A Core Data egy Apple ORM réteg az SQLite tetején. Mindhárom megközelítésnek megvan a maga alkalmazási területe és erőssége. A Realm a közvetlen objektumhozzáférés sebességében és reaktivitásában nyer, az SQLite az univerzalitásban és érettségben, a Core Data az Apple ökoszisztémával való integrációban.

A Realm teljesítménye olvasási műveleteknél 10-50%-kal magasabb, mint az SQLite-é a zero-copy hozzáférésnek köszönhetően. Írási műveleteknél a Realm szintén gyorsabb az SQL szintaktikai elemzés hiánya és a memory-mapped oldalak közvetlen módosítása miatt. Azonban a Realm több operatív memóriát fogyaszthat nagy adatbázisok (>500 MB) esetén, mivel a fájl teljes egészében a címtartományba van képezve.

A Realm és SQLite közötti választás gyakran a prioritásokon múlik: fejlesztési sebesség és reaktivitás (Realm) szemben a kontrollal és univerzalitással (SQLite). A Realm különösen jó MVP-khez és prototípusokhoz, ahol az adatmodell gyakran változik, és fontos az élő UI frissítések gyors elérése. Az SQLite/Room az érett termékek számára előnyösebb nagy adatmennyiségekkel és összetett analitikai lekérdezésekkel.

Realm Androidon: Kotlin SDK

Realm Kotlin SDK a hivatalos könyvtár Androidhoz, Kotlinban írva (nem wrapper a Java SDK felett). Az adatmodell a RealmObject-ból származó osztályokon keresztül kerül meghatározásra, @PrimaryKey annotációval az egyedi azonosítóhoz. A Realm Kotlin támogatja a Kotlin Coroutines-t, Flow-t és KSP-t (Kotlin Symbol Processing) a fordítási idejű kódgeneráláshoz.

RealmQuery type-safe API-t biztosít a szűréshez SQL nélkül. A lekérdezések metódusláncolattal épülnek fel: query → filter → sort → find. Az eredmény visszaadható listaként (memóriába töltéssel) vagy Flow-ként (reaktív adatfolyam, amely az adatok változásakor frissül). A Realm Kotlin támogatja a beágyazott objektumokat és listákat (RealmList) is.

Példa Realm Kotlin SDK

Az adatmodell Realm adat osztályként (data class) kerül meghatározásra, amely implementálja a RealmObject interfészt. A _id mező @PrimaryKey-vel van jelölve az egyedi azonosításhoz. Az „egy-többhöz“ kapcsolat RealmList-en keresztül valósul meg — más RealmObject-ok listáján. Minden írási művelet (create, update, delete) a write tranzakciós blokkon belül történik.

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

Egy Flow-t visszaadó lekérdezés automatikusan új eredményeket bocsát ki a Realm-ben történő bármilyen adatváltozáskor: Project vagy Task hozzáadásakor, frissítésekor vagy törlésekor. A Flow megközelítés ideálisan kombinálható a Compose-szal: a ViewModel-ben lévő collectAsState() automatikusan újrakomponálja a UI-t az adatok változásakor, a lista adapterek kézi frissítése vagy a LiveData használata nélkül.

Realm iOS-en: Swift SDK

Realm Swift SDK natív Swift API-t biztosít async/await, Combine Publishers és Swift Concurrency támogatással. Az adatmodellek a Object-ból származó osztályokként kerülnek meghatározásra, @Persisted használatával a tulajdonságokhoz. A Realm Swift automatikusan frissíti az objektumokat a változásokkor, és az értesítések (NotificationToken) lehetővé teszik az egyes objektumok vagy gyűjtemények változásaira való feliratkozást.

@ObservedRealmObject és @ObservedResults Property Wrapperek SwiftUI-hoz, amelyek automatikusan újrarajzolják a View-t a Realm adatok változásakor. Az @ObservedResults lekérdezési eredményekkel dolgozik, az @ObservedRealmObject egy adott objektummal. Mindkét tulajdonság lemondja a feliratkozást a View deinicializálásakor.

Példa Realm Swift SDK

A SwiftUI integráció a Realm egyik erőssége. Az @ObservedResults Property Wrapper összekapcsolja a Realm lekérdezést a SwiftUI-ban történő megjelenítéssel. Bármely feladat változásakor a SwiftUI automatikusan újrakomponálja a listát. A realm.writeAsync a tranzakciókat háttérszálon hajtja végre a UI blokkolása nélkül.

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

@ObservedResults automatikusan kezeli a Realm lekérdezés életciklusát: a View létrehozásakor feliratkozás jön létre a változásokra, megsemmisítéskor pedig lemondásra kerül. A Property Wrapper opcionális predikátumot (NSPredicate) és rendezést fogad el. Ez kiküszöböli a fetch lekérdezések kézi írásának, a ViewModel létrehozásának és a Realm értesítésekre való feliratkozásnak a szükségességét.

A Realm használati forgatókönyvei

Offline alkalmazások A Realm ideális olyan forgatókönyvekhez, ahol az adatoknak internet nélkül is elérhetőnek kell lenniük. A beépített szinkronizáció (Realm Sync a MongoDB Atlas-szal) automatikusan feloldja az ütközéseket a hálózathoz való csatlakozáskor. Az alkalmazás tovább dolgozik a helyi adatokkal, és a háttér-szinkronizáció frissíti azokat, amikor a kapcsolat elérhetővé válik.

Reaktív felületek A Live Objects és a Flow/Combine értesítések a Realm-et kényelmes választássá teszik a gyakran változó adatokkal rendelkező alkalmazásokhoz: csevegések, feladatfolyamok, közös dokumentumok. A UI automatikusan frissül az adatok hozzáadásakor, módosításakor vagy törlésekor, kézi reloadData vagy invalidate hívás nélkül.

Cross-platform projektek A Realm támogatja a Kotlin Multiplatform (KMP), Flutter, React Native és Xamarin rendszereket. Az adatmodell egyszer kerül meghatározásra és minden platformon használatos. Ez csökkenti a kód duplikációját és garantálja az adatséma konzisztenciáját a közös üzleti logikával rendelkező iOS és Android alkalmazások között.

Realm Sync: szinkronizáció a MongoDB Atlas segítségével

Realm Sync egy felhőalapú szolgáltatás, amely a MongoDB Atlas-ba van beépítve. Az alkalmazás automatikusan szinkronizálja az adatokat a felhasználó eszközei és a szerver között. Az ütközések a „last write wins” stratégia szerint vagy egyedi Conflict Resolution Functions segítségével oldódnak fel a szerveren. A Realm Sync támogatja a részleges szinkronizációt (adatrészhalmaz) a forgalom csökkentése érdekében.

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)
        // Automatikus szinkronizáció aktív
    }
}

SyncConfiguration konfigurálja a MongoDB Atlas kapcsolatot és meghatározza a szinkronizálandó modellek halmazát. A felhasználó hitelesítése után a Realm automatikusan betölti az adatokat a felhőből, és egyesíti azokat a helyi változtatásokkal. A szinkronizáció háttérszálon működik, és nem igényel kézi hívást — elegendő egy Realm példány létrehozása SyncConfiguration segítségével.