Hive : qu'est-ce que c'est, stockage NoSQL et développement sans code natif

Qu'est-ce que Hive ?

Hive est une base de données NoSQL écrite entièrement en Dart qui ne nécessite aucune bibliothèque native. Elle a été créée par Simon Leiter en 2019 comme alternative à SQLite pour les projets Flutter. Hive stocke les données au format binaire .hive optimisé pour une lecture et une écriture rapides sur les appareils mobiles. Le format .hive utilise un schéma de sérialisation personnalisé où chaque type de donnée possède son propre préfixe d'octet, permettant de lire le fichier sans connaissance préalable du schéma — contrairement à Protocol Buffers ou FlatBuffers.

L'idée centrale de Hive est la simplicité maximale. La base de données ne nécessite pas d'initialisation de moteur natif, n'inclut pas d'analyseur SQL et n'utilise pas de réflexion. Toutes les opérations sont des appels directs de fonctions Dart avec sérialisation binaire via WriteBuffer et ReadBuffer.

Selon l'enquête de la Flutter Community (2023), Hive fait partie des 5 packages de stockage de données les plus utilisés dans Flutter, juste derrière shared_preferences en popularité, mais le surpassant en fonctionnalité et en vitesse.

Architecture de Hive

Hive utilise le concept de Box — analogue à une table dans les bases de données relationnelles. Chaque Box est un fichier sur disque contenant un ensemble de paires clé-valeur. La clé peut être int ou String, la valeur peut être n'importe quel type primitif, liste, Map ou un objet personnalisé via TypeAdapter. Les Boxes sont isolés les uns des autres et ouverts indépendamment.

Avantages par rapport aux solutions natives

Hive ne nécessite pas de canaux de plateforme. Cela signifie qu'il fonctionne de la même manière sur Android, iOS, Web, macOS, Windows et Linux sans configuration supplémentaire. Pour les projets ciblant la compilation web, Hive reste la seule solution NoSQL légère — SQLite ne fonctionne pas dans les navigateurs. Hive utilise IndexedDB comme backend pour le web, garantissant la persistance des données même dans un environnement de navigateur.

Comment fonctionne Hive ?

Hive sérialise les données au format binaire lors de l'écriture et les désérialise lors de la lecture. Le mécanisme interne est basé sur BinaryWriter et BinaryReader, qui conditionnent les données en tableaux d'octets compacts. La taille de stockage sur disque est en moyenne 2 à 3 fois inférieure à la représentation JSON des mêmes données.

Lors de l'ouverture d'un Box, Hive charge tout le fichier en RAM. Cela offre une vitesse de lecture élevée (microsecondes) mais impose une limite de taille : il est recommandé de ne pas stocker plus de 50 à 100 Mo par Box. Pour des volumes plus importants, utilisez LazyBox — chargement paresseux des enregistrements depuis le disque.

Transactions et concurrence

Hive fonctionne en monothread au sein d'un isolat Dart. Les opérations d'écriture sont effectuées de manière synchrone avec verrouillage de fichier. Pour un accès asynchrone, utilisez Hive.openBox() avec await. L'accès concurrent depuis plusieurs isolats n'est pas pris en charge directement — un mécanisme de synchronisation séparé est nécessaire.

Hive vs SharedPreferences vs SQLite

Hive occupe un créneau entre SharedPreferences et SQLite. Il est plus complexe que SharedPreferences (prend en charge les objets personnalisés) mais plus simple que SQLite (pas de requêtes SQL nécessaires). Comparons les principales caractéristiques.

Quand choisir Hive

Hive est optimal pour les petits volumes de données : paramètres d'application, cache de réponses API, file d'attente de synchronisation locale, favoris et historique de navigation. Si les données ne dépassent pas 50 Mo et ne nécessitent pas de requêtes relationnelles — Hive est plus rapide et plus simple que SQLite.

Quand Hive n'est pas adapté

Hive ne prend pas en charge les requêtes avec filtrage par plusieurs champs, JOIN ou fonctions d'agrégation. Si vous avez besoin de requêtes complexes comme « sélectionner toutes les tâches d'aujourd'hui avec une priorité supérieure à 3 » — utilisez SQLite avec drift ou floor. Hive n'est pas non plus adapté au stockage de plus de 100 Mo de données en raison du chargement en mémoire.

Exemples de code avec Hive

Hive commence par l'initialisation et l'ouverture d'un Box. Voici les opérations de base pour un scénario typique — stocker une liste de tâches dans une application Flutter. Tous les exemples fonctionnent sans appels de plateforme natifs.

Initialisation et ouverture d'un Box

Avant d'utiliser Hive, vous devez appeler Hive.initFlutter() dans la fonction main. Ensuite, ouvrez un Box via Hive.openBox() — le résultat sera une instance de Box prête pour la lecture et l'écriture.

import 'package:hive/hive.dart';
import 'package:hive_flutter/hive_flutter.dart';

void async main() {
    await Hive.initFlutter();
    final settingsBox = await Hive.openBox('settings');
    runApp(MyApp());
}

Opérations CRUD

Box fournit les méthodes put, get, delete et un itérateur pour parcourir toutes les entrées. Les clés et les valeurs sont typées via des génériques — par défaut Box<dynamic> accepte tout type, mais il est recommandé de spécifier un type concret.

// Écrire des données
final box = await Hive.openBox<String>('tasks');
await box.put('task_1', 'Acheter des courses');

// Lecture
final task = box.get('task_1');

// Toutes les clés
final allTasks = box.values.toList();

// Supprimer
await box.delete('task_1');

// Vider le Box
await box.clear();

Observation réactive via WatchBox

WatchBox est une extension de Box qui notifie les abonnés des changements. Dans Flutter, cela s'intègre avec ValueListenableBuilder : lorsque n'importe quelle valeur dans le Box change, le widget est reconstruit automatiquement sans appeler setState.

final watchBox = await Hive.openBox('settings');

// Dans le widget
ValueListenableBuilder(
    valueListenable: watchBox.listenable(),
    builder: (context, box, _) {
        final counter = box.get('counter') ?? 0;
        return Text('Compteur : $counter');
    },
)

TypeAdapter et objets personnalisés

TypeAdapter est le mécanisme de Hive pour sérialiser les objets Dart personnalisés. L'adaptateur décrit comment convertir un objet au format binaire (write) et inversement (read). Contrairement à json_serializable, TypeAdapter ne nécessite pas de réflexion et est plus rapide.

Création d'un TypeAdapter

L'adaptateur implémente l'interface TypeAdapter avec deux méthodes : read et write. La classe est enregistrée via Hive.registerAdapter() avant d'ouvrir le Box. Chaque adaptateur reçoit un ID numérique — il est sauvegardé dans le fichier pour l'identification du type.

// Modèle de données
class Task {
    final String title;
    final bool isCompleted;
    Task({required this.title, this.isCompleted = false});
}

// TypeAdapter
class TaskAdapter extends TypeAdapter<Task> {
    @override
    final int typeId = 0;

    @override
    Task read(BinaryReader reader) {
        return Task(
            title: reader.readString(),
            isCompleted: reader.readBool(),
        );
    }

    @override
    void write(BinaryWriter writer, Task obj) {
        writer.writeString(obj.title);
        writer.writeBool(obj.isCompleted);
    }
}

Génération d'adaptateurs via génération de code

Pour les projets avec un grand nombre de modèles, Hive fournit hive_generator et build_runner. L'annotation @HiveType sur la classe et @HiveField sur les champs génèrent l'adaptateur automatiquement. C'est pratique lorsque le modèle comporte 10+ champs — l'écriture manuelle de read/write devient fastidieuse.

Optimisation des performances de Hive

Hive lit depuis la mémoire plutôt que depuis le disque, offrant des vitesses allant jusqu'à 30 000 opérations par seconde. Pour optimiser : ouvrez un Box une fois et réutilisez-le dans toute l'application, n'appelez pas openBox de manière répétée. Utilisez Hive.box() (getter synchrone) après l'initialisation — il retourne un Box déjà ouvert sans créer une nouvelle instance.

Hive avec Provider et Riverpod

Hive s'intègre facilement avec les gestionnaires d'état populaires de Flutter. Pour Provider, utilisez ChangeNotifierProvider qui lit les données du Box à l'initialisation et se met à jour via listenable. Pour Riverpod, un StreamProvider abonné à WatchBox fonctionne bien. Cette combinaison fournit des mises à jour réactives de l'UI à chaque changement de données dans Hive sans appels manuels de setState. Dans un projet Flutter typique, cette architecture permet de synchroniser l'état entre les écrans sans singleton global.