Firebase Firestore: какво е, NoSQL и как работи

Какво е Firebase Firestore?

Firebase Firestore е гъвкава, мащабируема NoSQL база данни, стартирана от Google през 2019 г. като еволюция на Firebase Realtime Database. Тя съхранява данни под формата на колекции от документи, като всеки документ съдържа набор от ключ-стойност двойки. За разлика от традиционните релационни бази данни, Firestore не изисква предварително дефинирана схема — структурата на данните се формира динамично въз основа на записваните документи.

Ключовата разлика на Firestore от класическите облачни бази данни е вградената синхронизация в реално време. Когато данните се променят на сървъра, всички свързани клиенти получават актуализации чрез постоянна WebSocket връзка. Това елиминира необходимостта от ръчно запитване на сървъра и позволява изграждане на приложения с живи актуализации: чатове, емисии за активност, съвместни редактори и системи за наблюдение.

Базата данни е достъпна на всички основни платформи: Android, iOS, Web (JavaScript) и сървърни езици чрез Admin SDK. Firestore предоставя SDK за Swift, Kotlin, JavaScript, Python, Go, Java и Node.js. Според данни на Google, Firestore обработва над 100 милиарда заявки на ден в цялата екосистема на Firebase, което потвърждава неговата надеждност като основа за производствени приложения.

Основни понятия: колекции и документи

В Firestore данните са организирани в йерархична структура. Колекцията е контейнер за документи, подобен на таблица в SQL, но без фиксирана схема. Документът е запис, който съдържа полета от различни типове: низове, числа, булеви стойности, масиви, вложени обекти и геоточки. Документите могат да съдържат подколекции, което позволява изграждане на вложени структури от данни с произволна дълбочина.

val db = FirebaseFirestore.getInstance()

val user = hashMapOf(
    "name" to "Анна Петрова",
    "email" to "anna@example.com",
    "age" to 28,
    "isActive" to true
)

db.collection("users")
    .add(user)
    .addOnSuccessListener { docRef ->
        Log.d("TAG", "Документът е добавен с ID: ${docRef.id}")
    }

Всеки документ в колекция има уникален идентификатор, който може да бъде генериран автоматично или зададен ръчно. Firestore автоматично индексира всички полета на документа, което позволява изпълнение на сложни заявки с филтриране, сортиране и ограничаване на броя резултати без предварителна конфигурация на индекси.

Firebase Firestore срещу Realtime Database: сравнение

Firestore и Firebase Realtime Database са две облачни бази данни в реално време от Google. Въпреки че и двете предоставят синхронизация в реално време, те имат основни разлики в модела на данни, мащабирането и ценообразуването. Разбирането на тези разлики е от решаващо значение при избора на подходяща база данни за конкретен проект.

Основната архитектурна разлика е моделът на данни. Realtime Database съхранява всичко в едно голямо JSON дърво, което усложнява заявки с дълбоко влагане. Firestore използва колекции и документи, което позволява изпълнение на сложни заявки с множество условия. Освен това Firestore осигурява силна консистентност на данните: след успешен запис всички последващи четения гарантирано връщат актуални данни.

Мащабируемост и структура на данните

Firestore се мащабира автоматично до милиони едновременни връзки благодарение на мултирегионалната архитектура. Realtime Database е ограничена до един регион и максимум 200 000 едновременни връзки. За проекти, планиращи глобална аудитория, Firestore е за предпочитане, тъй като данните автоматично се репликират между множество центрове за данни на Google.

Структурата на данните в Firestore позволява изграждане на сложни йерархични модели с подколекции. Например, потребител може да има подколекция „поръчки", а всяка поръчка — подколекция „продукти". В Realtime Database такова дълбоко влагане води до проблеми с производителността при заявки, тъй като се зарежда целият път от корена до желания възел.

Как работи синхронизацията на данни в Firestore

Firestore използва постоянна WebSocket връзка между клиент и сървър за синхронизация на данни в реално време. Когато приложението се абонира за промени на документ или колекция чрез snapshot listener, SDK установява комуникационен канал, по който сървърът изпраща актуализации при всяка промяна на данни. Клиентът получава само променените документи, а не цялата колекция всеки път.

Механизмът за синхронизация се основава на поток от събития: added (документът се появи), modified (документът се промени) и removed (документът беше изтрит). Разработчикът може да обработва всяко събитие поотделно, актуализирайки само съответните UI елементи. Това осигурява висока производителност дори при хиляди документи, тъй като само променените компоненти се прерисуват.

Офлайн достъп и кеширане

Едно от ключовите предимства на Firestore е вградената поддръжка за офлайн режим. SDK автоматично кешира всички прочетени данни на устройството и продължава да работи при липса на мрежа. Когато приложението записва данни в офлайн режим, те се поставят в локална опашка и се изпращат на сървъра при възстановяване на връзката. За разрешаване на конфликти се използва стратегията last-write-wins.

val docRef = db.collection("cities").document("SF")

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "Грешка при слушане", error)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Текущи данни: ${snapshot.data}")
    }
}

Размерът на кеша може да се конфигурира чрез FirestoreSettings. По подразбиране се използва 100 MB, но за приложения с интензивно четене на данни може да бъде увеличен. Също така е наличен режим persistent disk cache, който оцелява при рестартиране на приложението. За управление на достъпността на офлайн режима се използват методите enableNetwork и disableNetwork, позволяващи временно изключване на мрежовата комуникация.

Сигурност и правила за достъп до Firestore

Firestore Security Rules е декларативен език за маркиране за контрол на достъпа до данни на сървърно ниво. Правилата определят кой и при какви условия може да чете и записва документи. Те работят преди изпълнение на заявката и не изискват отделна сървърна логика за оторизация. Правилата се проверяват от страна на Firebase преди всяко четене или запис на данни.

Правилата за достъп се изграждат на принципа на разрешен достъп (allow). По подразбиране целият достъп е забранен. Разработчикът последователно отваря достъп за конкретни операции (read, write, create, update, delete) при определени условия. Условията могат да проверяват удостоверяване на потребителя чрез request.auth, данни на заявката чрез request.resource и съществуващи данни чрез resource.

// Правила за достъп до Firestore
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Потребителят чете и пише само своите данни
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Всеки удостоверен потребител може да чете публикации
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Валидация на данни чрез правила

Освен контрол на достъпа, Security Rules позволяват валидиране на структурата и типовете на записваните данни. Например, може да се провери дали полето за имейл съответства на регулярен израз или дали възрастта не надвишава 120 години. Валидацията се извършва преди запис, което предотвратява съхраняването на некоректни данни на сървъра. За проверка на полета се използва обектът request.resource.data, който съдържа целия записван документ.

Firestore също поддържа колекции, достъпни само за сървърен запис чрез Admin SDK, без достъп от страна на клиентите. Това е удобно за съхраняване на служебна информация, API ключове и конфигурации, които не трябва да бъдат видими за потребителите. За целта в правилата е достатъчно да се забранят всички клиентски операции на съответните колекции, разрешавайки достъп само чрез Admin SDK от сървърна страна.

Пример за използване на Firebase Firestore в Android

Нека разгледаме пример за интегриране на Firestore в Android приложение за създаване на списък със задачи (todo). Приложението ще чете задачи в реално време, ще добавя нови и ще отбелязва завършени. За асинхронна работа се използват callback интерфейси на Firebase и Kotlin корутини.

Настройка на Firebase и добавяне на зависимости

Преди започване на работа е необходимо да свържете проекта с Firebase чрез Firebase Console и да добавите файла google-services.json към модула на приложението. След това в build.gradle се добавя зависимостта firebase-firestore-ktx и плъгинът google-services. Версията на библиотеката трябва да съответства на текущата версия на Firebase BoM за съвместимост на всички Firebase компоненти помежду им.

dependencies {
    // Firebase BoM — управление на версиите
    implementation platform("com.google.firebase:firebase-bom:33.0.0")
    implementation "com.google.firebase:firebase-firestore-ktx"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0"
}

След настройка се създава модел на данни Task и хранилище за работа с Firestore. Моделът съдържа полета id, title, isCompleted и timestamp. Firestore автоматично сериализира data class в документ, използвайки имената на полета като ключове. За четене на данни се използва snapshot listener, който връща Flow чрез разширението snapshotFlow.

data class Task(
    val id: String = "",
    val title: String = "",
    val isCompleted: Boolean = false,
    val createdAt: Timestamp? = null
)

class TaskRepository {
    private val tasksRef = FirebaseFirestore
        .getInstance()
        .collection("tasks")

    fun getTasks(): Flow<List<Task>> = tasksRef
        .orderBy("createdAt", Query.Direction.DESCENDING)
        .snapshotFlow()
        .map { snapshot ->
            snapshot?.toObjects(Task::class.java) ?: emptyList()
        }

    suspend fun addTask(title: String) {
        tasksRef.add(Task(title = title))
    }
}

View-model се абонира за Flow от хранилището и предава списъка със задачи на UI нивото. При добавяне на нова задача се извиква suspend функцията на хранилището чрез корутин scope. Firestore автоматично синхронизира промените между всички клиенти: ако един потребител добави задача, останалите я виждат в реално време без презареждане на екрана.