ObjectBox : qu'est-ce que c'est, BD NoSQL et travail avec les données

Qu'est-ce qu'ObjectBox ?

ObjectBox est une base de données NoSQL en mémoire développée par la société allemande ObjectBox.io. Contrairement aux bases de données relationnelles traditionnelles, ObjectBox stocke les objets directement dans des fichiers plats en utilisant son propre format SLOT (Super Lightweight Object Tree). Cela élimine la surcharge de l'ORM et de l'analyse SQL. Le format SLOT est optimisé pour les appareils à mémoire limitée : les données sont défragmentées automatiquement et la taille de la BD est en moyenne 4 à 6 fois inférieure à celle d'une base de données SQLite équivalente avec le même nombre d'enregistrements.

ObjectBox prend en charge toutes les principales plates-formes mobiles : Android, iOS et Flutter. Pour Android, la génération de code est disponible via le ObjectBox Gradle Plugin, qui traite les entités annotées et crée des classes Box pour travailler avec les données. Pour Flutter, un plugin natif avec une enveloppe Dart est utilisé. Outre les plates-formes mobiles, ObjectBox fonctionne sur Linux, macOS, Windows et WebAssembly, ce qui permet de réutiliser le modèle de données entre l'application mobile et la synchronisation serveur.

Selon une étude d'ObjectBox (2023), la base de données est utilisée dans plus de 5 000 applications sur Google Play, y compris des applications de plus de 10 millions d'utilisateurs. Principaux cas d'utilisation : mise en cache des données, fonctionnement hors ligne et stockage de séries temporelles (IoT). ObjectBox est particulièrement populaire dans les applications de suivi de santé et de fitness qui nécessitent un enregistrement rapide des lectures de capteurs sur l'appareil sans connexion Internet constante et pour collecter des analyses à partir de plusieurs appareils.

Historique et positionnement

ObjectBox est apparu comme une alternative à Realm et SQLite pour la plateforme Android. La première version stable est sortie en 2018. La principale différence avec Realm est qu'ObjectBox n'a pas de restrictions GPL (utilise Apache 2.0) et prend en charge davantage de plates-formes : des appareils mobiles aux serveurs Linux.

Fonctionnalités principales

ObjectBox fournit : la génération automatique de classes Box, des index intégrés pour une recherche rapide, des transactions avec prise en charge de l'annulation, des requêtes réactives via RxJava et Kotlin Flow, et une synchronisation entre appareils via ObjectBox Sync (protocole propriétaire). Contrairement à Firebase Realtime Database, ObjectBox Sync fonctionne selon un modèle peer-to-peer sans serveur central, ce qui réduit la latence et les coûts d'infrastructure.

Comment fonctionne ObjectBox ?

ObjectBox stocke les données dans son propre format binaire .mdb (ObjectBox Data File). Chaque entité est mappée sur un fichier, où les enregistrements sont stockés séquentiellement avec un décalage fixe. Cela permet de lire et d'écrire des objets individuels sans analyser complètement le fichier.

Travailler avec ObjectBox ne nécessite pas de SQL : les requêtes sont construites via une API fluide dans le code. Le compilateur génère des classes d'assistance MyObjectBox et des Boxes qui encapsulent toutes les opérations CRUD. Le modèle de données est décrit à l'aide d'annotations @Entity, @Id, @Index et @Relation.

// Connecting ObjectBox in Android
class App: Application() {
    lateinit var boxStore: BoxStore

    override fun onCreate() {
        super.onCreate()
        boxStore = MyObjectBox.builder()
            .androidContext(this)
            .build()
    }
}

ObjectBox vs SQLite : comparaison des performances

Selon les benchmarks officiels, ObjectBox surpasse nettement SQLite en vitesse, en particulier pour les insertions par lots et les lectures massives. Cependant, SQLite reste le standard de facto pour les applications mobiles en raison de sa prévalence et de sa prise en charge SQL intégrée.

Quand ObjectBox n'est pas optimal

ObjectBox est inférieur à SQLite dans les scénarios nécessitant des requêtes JOIN complexes, des fonctions d'agrégation (SUM, COUNT avec regroupement) ou une intégration avec un schéma SQL existant. Si le projet utilise déjà SQLite avec Room ORM, la migration vers ObjectBox nécessitera de réécrire toute la logique d'accès aux données. ObjectBox ne prend pas non plus en charge les requêtes SQL personnalisées — seulement l'API fluide. Cependant, pour les opérations CRUD typiques et la mise en cache, ObjectBox offre une amélioration des performances allant jusqu'à 100 fois, comme le confirment les benchmarks officiels sur les appareils Android avec différentes versions du système d'exploitation.

Exemples de code avec ObjectBox

ObjectBox utilise des annotations pour définir les entités. Après la compilation, des classes Box sont créées avec les méthodes put, get, remove et query. Voici des opérations typiques pour un modèle Task dans une application de liste de tâches.

Définition d'une entité

Chaque entité est annotée avec @Entity. Un champ avec @Id devient la clé primaire, et @Index accélère les recherches sur ce champ. ObjectBox prend en charge la génération automatique d'ID lorsque la valeur est 0.

@Entity
data class Task(
    @Id var id: Long = 0,
    @Index var title: String = "",
    var isCompleted: Boolean = false,
    var priority: Int = 0
)

Opérations CRUD

Box est la classe principale pour travailler avec les entités. La méthode put() sauvegarde ou met à jour un objet, get() lit par ID et remove() supprime. Toutes les opérations de base sont synchrones et s'exécutent sur le thread appelant.

val taskBox: Box<Task> = boxStore.boxFor(Task::class.java)

// Create
val task = Task(title = "Buy products", priority = 3)
val newId = taskBox.put(task)

// Read
val savedTask = taskBox.get(newId)

// Update
savedTask.isCompleted = true
taskBox.put(savedTask)

// Delete
taskBox.remove(newId)

Requêtes réactives

ObjectBox prend en charge les requêtes réactives via .subscribe(). L'abonné reçoit des notifications lorsque les données correspondant à la condition de la requête changent. C'est pratique pour l'interface utilisateur qui met automatiquement à jour la liste lors de l'ajout ou de la suppression d'éléments.

val query = taskBox.query()
    .equal(Task_.isCompleted, false)
    .orderDesc(Task_.priority)
    .build()

query.subscribe { tasks ->
    // tasks — List, mis à jour automatiquement
    updateUi(tasks)
}

Relations et requêtes dans ObjectBox

ObjectBox prend en charge les relations entre entités — Un-à-Un, Un-à-Plusieurs et Plusieurs-à-Plusieurs. Les relations sont définies via l'annotation @Relation. Contrairement à SQLite, ObjectBox n'utilise pas de clés étrangères : les relations sont implémentées via des listes d'ID dans des fichiers plats, ce qui accélère la navigation dans le graphe d'objets.

Un-à-Plusieurs via @Backlink

La relation @Backlink permet de naviguer d'une entité enfant vers son parent sans champ de référence séparé. ObjectBox maintient automatiquement le backlink, éliminant la duplication de données et la synchronisation entre deux tables.

Requêtes fluides

ObjectBox Query Builder permet de construire des chaînes de conditions : equal, notEqual, greater, less, in, contains, startsWith. Toutes les conditions peuvent être combinées via and/or. Le résultat peut être trié, limité et récupéré sous forme de List ou LazyList (pour les grands ensembles de données).

Configuration des index pour une recherche plus rapide

ObjectBox indexe automatiquement le champ @Id. Pour les index personnalisés, utilisez l'annotation @Index sur les champs fréquemment interrogés. Les index accélèrent les requêtes equal et in mais ralentissent les insertions — n'indexez pas les champs qui ne sont pas recherchés. ObjectBox prend en charge les index composites pour filtrer par plusieurs champs simultanément. Les index composites sont particulièrement utiles pour les filtres de liste : par exemple, la recherche de tâches incomplètes avec une priorité élevée est des dizaines de fois plus rapide avec un index composite sur les champs isCompleted et priority.

ObjectBox Sync — synchronisation entre appareils

ObjectBox Sync est une technologie propriétaire de synchronisation de données en temps réel entre appareils. Elle utilise un protocole basé sur WebSocket avec résolution de conflits par dernier écrit. Sync convient aux applications nécessitant une synchronisation hors ligne : notes, listes de tâches, données IoT de plusieurs capteurs. Cependant, l'achat d'une licence est nécessaire pour la production.

// Query with multiple conditions
val highPriorityIncomplete = taskBox.query()
    .greater(Task_.priority, 5)
    .equal(Task_.isCompleted, false)
    .build()
    .find()

// Substring search
val searchResults = taskBox.query()
    .contains(Task_.title, "product", StringOrder.CASE_INSENSITIVE)
    .build()
    .find()