Realm в мобильных приложениях: что это такое и как работает

Что такое Realm?

Realm — это объектно-ориентированная база данных, созданная специально для мобильных приложений. В отличие от SQLite, Realm не использует SQL и реляционную модель — данные хранятся как живые объекты (Live Objects), доступ к которым осуществляется напрямую, без промежуточного ORM-слоя. Разработчик работает с обычными объектами языка (Swift, Kotlin, Dart), которые автоматически сохраняются в БД.

Realm появился в 2014 году как стартап Realm Inc., а в 2019 году был приобретён MongoDB Inc. С тех пор Realm развивается как MongoDB Realm — часть единой платформы Atlas Device Sync для мобильной синхронизации данных. Базовая локальная БД Realm остаётся бесплатной и открытой (лицензия Apache 2.0), а Realm Sync (облачная синхронизация) распространяется по подписке.

По данным MongoDB Developer Report (2025), Realm используется в 15% мобильных приложений как основное локальное хранилище. Основные сценарии — приложения с офлайн-режимом, сложными объектными моделями и потребностью в синхронизации между устройствами, где Realm превосходит SQLite по скорости разработки и удобству работы с объектами.

Принципы Realm

Live Objects — каждый объект Realm связан с диском через отображение в память (memory-mapped file). Изменение объекта в любом потоке немедленно отражается во всех других потоках без ручного уведомления. Интерфейс UI автоматически перерисовывается при изменении данных через Realm-уведомления. Zero-copy — Realm не копирует данные из БД в объекты, объекты — это и есть данные в памяти.

Как устроена Realm: архитектура и хранение

Ядро Realm написано на C++ и использует B+ Tree для индексации данных. В отличие от SQLite, где каждая строка — это запись в реляционной таблице, Realm хранит объекты как узлы в графовой структуре с прямыми ссылками между ними (forward pointers). Связи между объектами — это не foreign keys, а прямые указатели, что устраняет необходимость в JOIN-операциях.

Файлы Realm (расширение .realm) являются memory-mapped — ОС сама управляет загрузкой страниц файла в память по мере обращения. Это позволяет Realm работать с базами, превышающими доступную оперативную память, и обеспечивает read latency на уровне нативных структур данных языка (Swift Array или Kotlin List) для данных, умещающихся в RAM.

Zero-copy и Live Objects

Memory-mapped файлы — ключевая технология Realm. Вместо того чтобы копировать данные из файла БД в объекты языка (как делает SQLite через sqlite3_step + sqlite3_column_*), Realm отображает файл базы прямо в адресное пространство процесса. Объекты языка — это просто указатели на данные в отображённой памяти. Изменение объекта меняет базу на диске без отдельного save-вызова.

Потребление памяти Realm выше при активном чтении (весь файл или его большая часть отображена в память), но ниже при операциях записи, так как не требуется выделение памяти под копии объектов. Для баз размером до 1 ГБ на мобильных устройствах memory-mapped подход даёт лучшую общую производительность, чем SQLite с его промежуточным копированием.

Realm vs SQLite vs Core Data: сравнение

SQLite — реляционная СУБД с SQL и ACID-транзакциями. Realm — объектная NoSQL БД с memory-mapped доступом. Core Data — ORM-слой Apple поверх SQLite. Каждый из трёх подходов имеет свою область применения и сильные стороны. Realm выигрывает в скорости прямого доступа к объектам и реактивности, SQLite — в универсальности и зрелости, Core Data — в интеграции с Apple-экосистемой.

Производительность Realm на операциях чтения на 10-50% выше SQLite благодаря zero-copy доступу. На операциях записи Realm также быстрее за счёт отсутствия SQL-синтаксического анализа и прямого изменения memory-mapped страниц. Однако Realm может потреблять больше оперативной памяти при работе с большими базами (>500 МБ), так как файл полностью отображается в адресное пространство.

Выбор между Realm и SQLite часто сводится к приоритетам: скорость разработки и реактивность (Realm) против контроля и универсальности (SQLite). Realm особенно хорош для MVP и прототипов, где модель данных меняется часто и важно быстро получать живые обновления UI. SQLite/Room предпочтительнее для зрелых продуктов с большими объёмами данных и сложными аналитическими запросами.

Realm на Android: Kotlin SDK

Realm Kotlin SDK — официальная библиотека для Android, написанная на Kotlin (не обёртка над Java SDK). Модель данных определяется через классы, наследуемые от RealmObject, с аннотацией @PrimaryKey для уникального идентификатора. Realm Kotlin поддерживает Kotlin Coroutines, Flow и KSP (Kotlin Symbol Processing) для compile-time генерации кода.

RealmQuery предоставляет type-safe API для фильтрации без SQL. Запросы строятся цепочкой методов: query → filter → sort → find. Результат может быть возвращён как список (с загрузкой в память) или как Flow (реактивный стрим, обновляющийся при изменении данных). Realm Kotlin также поддерживает вложенные объекты и списки (RealmList).

Пример Realm Kotlin SDK

Модель данных Realm определяется как data class, реализующий интерфейс RealmObject. Поле _id помечено @PrimaryKey для уникальной идентификации. Связь "один-ко-многим" реализуется через RealmList — список других RealmObject-ов. Все операции записи (create, update, delete) выполняются внутри write-блока транзакции.

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

Flow-возвращаемый запрос автоматически эмитит новые результаты при любом изменении данных в Realm: добавлении, обновлении или удалении Project или Task. Flow-подход идеально сочетается с Compose: collectAsState() в ViewModel автоматически перекомпоновывает UI при изменении данных без ручного обновления адаптеров списков или использования LiveData.

Realm на iOS: Swift SDK

Realm Swift SDK предоставляет нативный Swift API с поддержкой async/await, Combine Publishers и Swift Concurrency. Модели данных определяются как классы, наследуемые от Object, с использованием @Persisted для свойств. Realm Swift автоматически обновляет объекты при изменениях, а уведомления (NotificationToken) позволяют подписываться на изменения отдельных объектов или коллекций.

@ObservedRealmObject и @ObservedResults — Property Wrappers для SwiftUI, которые автоматически перерисовывают View при изменении данных Realm. @ObservedResults работает с результатами запроса, @ObservedRealmObject — с конкретным объектом. Оба свойства отменяют подписку при деинициализации View.

Пример Realm Swift SDK

SwiftUI-интеграция Realm — одна из сильных сторон SDK. Property Wrapper @ObservedResults связывает запрос Realm с отображением в SwiftUI. При изменении любой задачи SwiftUI автоматически перекомпоновывает список. realm.writeAsync выполняет транзакции на фоновом потоке без блокировки 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("Add Task") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults автоматически управляет жизненным циклом запроса Realm: при создании View создаётся подписка на изменения, при уничтожении — отменяется. Property Wrapper принимает необязательный предикат (NSPredicate) и сортировку. Это устраняет необходимость вручную писать fetch-запросы, создавать ViewModel и подписываться на уведомления Realm.

Сценарии использования Realm

Офлайн-приложения — Realm идеально подходит для сценариев, где данные должны быть доступны без интернета. Встроенная синхронизация (Realm Sync с MongoDB Atlas) автоматически разрешает конфликты при подключении к сети. Приложение продолжает работать с локальными данными, а фоновая синхронизация обновляет их при появлении соединения.

Реактивные интерфейсы — Live Objects и Flow/Combine уведомления делают Realm удобным выбором для приложений с часто обновляющимися данными: чаты, ленты задач, совместные документы. UI автоматически обновляется при добавлении, изменении или удалении данных без ручного вызова reloadData или invalidate.

Кросс-платформенные проекты — Realm поддерживает Kotlin Multiplatform (KMP), Flutter, React Native и Xamarin. Модель данных определяется один раз и используется на всех платформах. Это сокращает дублирование кода и гарантирует консистентность схемы данных между iOS и Android приложениями с общей бизнес-логикой.

Realm Sync: синхронизация через MongoDB Atlas

Realm Sync — облачный сервис, встроенный в MongoDB Atlas. Приложение автоматически синхронизирует данные между устройствами пользователя и сервером. Конфликты разрешаются по стратегии "last write wins" или через кастомные Conflict Resolution Functions на сервере. Realm Sync поддерживает частичную синхронизацию (subset of data) для уменьшения трафика.

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)
        // Автоматическая синхронизация активна
    }
}

SyncConfiguration настраивает подключение к MongoDB Atlas и определяет набор синхронизируемых моделей. После аутентификации пользователя Realm автоматически загружает данные из облака и объединяет их с локальными изменениями. Синхронизация работает в фоновом потоке и не требует ручного вызова — достаточно создать экземпляр Realm с SyncConfiguration.