Utiliser Hive avec Flutter

Utiliser Hive avec Flutter

1. Objectif

   • Comprendre ce qu’est Hive.
   • Savoir pourquoi l’utiliser dans une application Flutter.
   • Apprendre à installer et configurer Hive.
   • Maîtriser les opérations CRUD (Create, Read, Update, Delete).
   • Utiliser Hive avec des objets personnalisés grâce aux adapters.
   • Découvrir les bonnes pratiques et comparer Hive avec d’autres solutions de persistance.

2. ? Qu’est-ce que Hive ?

   • Hive est une base de données NoSQL écrite en pur Dart.
   • Elle est rapide, légère et offline-first (fonctionne sans internet).
   • Hive stocke les données sous forme de paires clé-valeur et est optimisée pour des opérations de lecture-écriture rapides.
   • Elle permet de stocker des données localement, sur l'appareil, ainsi que dans le cloud.
   • Idéale pour :
     • Stocker des paramètres (ex : thème sombre/clair).
     • Sauvegarder des favoris.
     • Créer un cache local pour éviter les appels API répétés.
     • Stocker des objets simples (utilisateurs, produits, etc.).

3. ? Installation et configuration

   1. Ajouter les dépendances dans pubspec.yaml:

      • Avant de pouvoir utiliser Hive dans notre application Flutter, nous devons ajouter les dépendances nécessaires à notre fichier pubspec.yaml.
      • Ouvrez votre fichier pubspec.yaml et ajoutez les dépendances suivantes :

      dependencies:
        hive: ^2.2.3
        hive_flutter: ^1.1.0
        path_provider: ^2.1.1
      

   2. Une fois ces dépendances ajoutées, exécutez Flutter Pub Get pour les télécharger et les installer.

   3. Importer et initialiser Hive dans main.dart:

      • Maintenant que nous avons configuré les dépendances, nous pouvons commencer à utiliser Hive dans notre application Flutter.
      • La première étape consiste à initialiser Hive en appelant Hive.initFlutter() dans notre fonction main(). Nous devons également enregistrer les adaptateurs personnalisés que nous souhaitons utiliser avec Hive.

      import 'package:flutter/material.dart';
      import 'package:hive_flutter/hive_flutter.dart';
      
      void main() async {
        WidgetsFlutterBinding.ensureInitialized();
        await Hive.initFlutter(); // Initialisation Hive
        await Hive.openBox('settings'); // Ouvrir un "box"
        runApp(MyApp());
      }
      

4. ? Concepts de base dans Hive

   • Box : équivalent d’une table ou d’un dictionnaire clé-valeur.
   • Clé : Identifiant unique qui peut être de différents types :
     • String (chaîne de caractères)
     • int (nombre entier)
     • double (nombre décimal)
     • bool (booléen)
     • List (liste)
     • Map (map)
   • Valeur : Donnée stockée qui peut être :
     • Types primitifs: String, int, double, bool
     • Collections: List, Map
     • Objets personnalisés (avec un adapter)
   ? Exemple simple :

   // Ouvrir ou créer une boîte
   var box = await Hive.openBox('settings');
   
   // ?️ ÉCRITURE - Stocker des données
   box.put('theme', 'dark');           // Clé: 'theme', Valeur: 'dark'
   box.put('notifications', true);     // Clé: 'notifications', Valeur: true
   box.put('user_id', 12345);          // Clé: 'user_id', Valeur: 12345
   
   // ? LECTURE - Récupérer des données
   print(box.get('theme'));            // Affiche: dark
   print(box.get('notifications'));    // Affiche: true
   print(box.get('user_id'));          // Affiche: 12345
   
   // ?️ SUPPRESSION - Supprimer des données
   box.delete('theme');                // Supprime la clé 'theme'
   box.delete('notifications');        // Supprime la clé 'notifications'
   
   // ? VÉRIFICATION - Vérifier l'existence d'une clé
   bool hasTheme = box.containsKey('theme'); // false
   
   // ? COMPTAGE - Nombre d'éléments dans la boîte
   int itemCount = box.length;               // Nombre de paires clé-valeur
   
   // ? NETTOYAGE - Supprimer toutes les données
   box.clear();                         // Vide toute la boîte
   

   ? Exemple avec des collections :

   var box = await Hive.openBox('user_data');
   
   // Stocker une liste
   box.put('favorites', ['apple', 'banana', 'orange']);
   
   // Stocker un map
   box.put('user_profile', {
     'name': 'John Doe',
     'age': 30,
     'email': 'john@example.com'
   });
   
   // Récupérer les données
   List favorites = box.get('favorites');
   Map profile = box.get('user_profile');
   
   print(favorites);    // [apple, banana, orange]
   print(profile['name']); // John Doe
   

5. ? Exemple pratique : Gestion des favoris

   • a) Sauvegarder un favori :

   var favoritesBox = Hive.box('favorites');
   favoritesBox.put('song1', 'My Favorite Song');
   

6. b) Lire un favori :

print(favoritesBox.get('song1')); // My Favorite Song

7. c) Supprimer un favori :

favoritesBox.delete('song1');

8. d) Observer les changements en temps réel :

ValueListenableBuilder(
  valueListenable: Hive.box('favorites').listenable(),
  builder: (context, box, widget) {
    return ListView(
      children: box.values.map((fav) => Text(fav)).toList(),
    );
  },
);

9. ? Utiliser Hive avec des objets (Adapters)

   • a) Définir un modèle :

   import 'package:hive/hive.dart';
   
   part 'user_model.g.dart';
   
   @HiveType(typeId: 0)
   class User extends HiveObject {
     @HiveField(0)
     String id;
   
     @HiveField(1)
     String name;
   
     User({required this.id, required this.name});
   }
   

10. b) Générer l’adapter :

flutter packages pub run build_runner build

11. c) Enregistrer l’adapter dans main.dart:

Hive.registerAdapter(UserAdapter());
await Hive.openBox('users');

12. d) Utiliser :

var userBox = Hive.box('users');

// Ajouter un utilisateur
userBox.put('u1', User(id: '1', name: 'Alice'));

// Lire un utilisateur
User? u = userBox.get('u1');
print(u?.name); // Alice

13. ?️ Bonnes pratiques

    • Toujours ouvrir les boxes avant utilisation.
    • Utiliser ValueListenableBuilder pour une UI réactive.
    • Éviter de stocker des objets trop complexes → préférer SQLite/Drift.
    • Bien choisir les typeId uniques pour les adapters.

14. ? Hive vs SQLite vs Drift

Critère	Hive (NoSQL)	SQLite (sqflite)	Drift (ORM)
Performance	? Très rapide	Bonne	Bonne mais typée
Structure	Clé-valeur	Relationnelle	Relationnelle typée
Simplicité	Très simple	Moyenne (SQL à écrire)	Plus complexe (build_runner)
Idéal pour	Cache, favoris, settings	Données structurées	Projets complexes

15. ? Conclusion

    • Utiliser Hive pour une persistance rapide et simple (favoris, cache, settings).
    • Préférer SQLite ou Drift pour des données relationnelles complexes.