A Beginner's Guide to Using Hive with Models in Flutter

 How to Use Hive for Storing and Retrieving Data in Flutter with Custom Models




Introduction

In mobile app development, especially with Flutter, local storage plays a crucial role in persisting data. One of the most popular solutions for local data storage in Flutter is Hive, a lightweight and fast NoSQL database that provides a simple API for storing and retrieving data.

In this blog, we’ll walk through how to use Hive with custom models in Flutter. We’ll demonstrate how to store and retrieve data of a custom model (User), using Hive's built-in functionality. We will also discuss the importance of null safety when dealing with data retrieval.


Setting Up Hive in Flutter

Before diving into the code, let’s first ensure that Hive is set up in your Flutter project. If you haven’t already, you’ll need to add the Hive package and the Hive Flutter package to your pubspec.yaml:


# versions available, run `flutter pub outdated`.
dependencies:
  flutter:
    sdk: flutter


  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  cupertino_icons: ^1.0.8
  hive: ^2.0.0
  hive_flutter: ^1.1.0

dev_dependencies:
  flutter_test:
    sdk: flutter

  # The "flutter_lints" package below contains a set of recommended lints to
  # encourage good coding practices. The lint set provided by the package is
  # activated in the `analysis_options.yaml` file located at the root of your
  # package. See that file for information about deactivating specific lint
  # rules and activating additional ones.
  flutter_lints: ^4.0.0
  build_runner: ^2.0.0
  hive_generator: ^1.1.0


1. Create Your Custom Model Class (User)

Before storing data in Hive, we need to create a custom data model. In this example, we’re going to use a simple User class with name and age fields.

import 'package:hive/hive.dart';
part 'user.g.dart';
@HiveType(typeId: 0)
class User {
  @HiveField(0)
  final String name;

  @HiveField(1)
  final int age;

  User(this.name, this.age);
}


Here’s what’s happening in the code:

  • @HiveType(typeId: 0): This annotation tells Hive that we are defining a custom type and gives it a unique ID. Each model class needs to have a unique typeId.
  • @HiveField(): Each field in the model is annotated with @HiveField to define its number. These numbers help Hive identify which data is being serialized or deserialized.

2. Generate the Adapter

To let Hive know how to serialize and deserialize the User class, we need to generate a type adapter using the hive_generator package. Run the following command to generate the adapter:



flutter packages pub run build_runner build

This will generate a file called user.g.dart that contains the UserAdapter for the User model. Now Hive can store and retrieve User objects.

3. Initialize Hive in Your Flutter App

Next, we need to initialize Hive in the main function and register the UserAdapter.


import 'package:flutter/material.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'model/user.dart';


void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  // Initialize Hive
  await Hive.initFlutter();
  // Register User Adapter
  Hive.registerAdapter(UserAdapter());

  // Open the box to store User data
  await Hive.openBox<User>('userBox');

  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Hive TypeAdapter Example')),
        body: Center(
          child: ElevatedButton(
            onPressed: () async {
              var userBox = Hive.box<User>('userBox');

              // Create and add User object
              var user = User('John Doe', 30);
              await userBox.add(user);

              // Retrieve User object
              User? retrievedUser = userBox.getAt(0);  // Notice the '?' here
              if (retrievedUser != null) {
                print('User: ${retrievedUser.name}, Age: ${retrievedUser.age}');
              } else {
                print('No user found.');
              }
            },
            child: Text('Save and Retrieve Data'),
          )
          ,
        ),
      ),
    );
  }
}





4. Explanation of the Code

Initializing Hive


await Hive.initFlutter();

This initializes Hive for use with Flutter. You need this setup before you can interact with Hive boxes.

Registering the Adapter

Hive.registerAdapter(UserAdapter());

Here, we’re registering the adapter for the User class, which is generated in the user.g.dart file. This step ensures that Hive knows how to store and retrieve User objects.

Opening a Box

await Hive.openBox<User>('userBox');

This opens a box called 'userBox', which will store all the User objects. If the box doesn’t exist, it will be created.

Saving a User Object


var user = User('John Doe', 30); 
await userBox.add(user);

This code creates a new User object and stores it in the userBox. The add() method stores the object at the next available index.

User? retrievedUser = userBox.getAt(0);


This retrieves the first User object in the box. Notice that we use User? as the type because Hive’s getAt() method can return null if the object at the specified index doesn’t exist.

5. Handling Null Safety

In this code, we used null safety to handle the case where the box might not contain any data. Since getAt(0) returns a nullable User?, we check if the object is null before attempting to access its properties.


// Retrieve User object
User? retrievedUser = userBox.getAt(0);  // Notice the '?' here
if (retrievedUser != null) {
  print('User: ${retrievedUser.name}, Age: ${retrievedUser.age}');
} else {
  print('No user found.');
}

This ensures that our code doesn’t throw an exception when no data is found at the specified index.

6. Running the App

When you run this app, you’ll see a button labeled "Save and Retrieve Data". When pressed, it will:

  1. Save a new User object (John Doe, 30) to the box.
  2. Retrieve the first User object from the box and print the details in the console.

Conclusion

Hive is a powerful, fast, and easy-to-use local storage solution for Flutter apps. In this blog, we learned how to:

  1. Set up Hive in Flutter.
  2. Define a custom data model (User) and register its adapter.
  3. Store and retrieve custom objects in Hive.
  4. Handle nullable values properly using null safety.

This setup is perfect for small to medium-sized apps where you need to store simple data locally. Hive is highly efficient, even with large datasets, making it a great choice for persistent storage in Flutter.

Let us know in the comments if you have any questions or need further assistance!


github.  https://github.com/Sutharpraveen/hive




Comments

Post a Comment

Popular posts from this blog

Unlocking the Power of OOP: A Beginner's Guide to Objects, Encapsulation, Inheritance, Abstraction, and Polymorphism

Image
 OOPs (Object-Oriented Programming System) This article explains the fundamental concepts of OOP and its most significant advantages What is OOPs (Object Oriented Programming System)? Object-oriented programming System (OOPs) is defined as a programming paradigm (and not a specific language) built on the concept of objects, i.e., a set of data contained in fields, and code, indicating procedures – instead of the usual logic-based system. Key Concepts of OOP To understand and use object-oriented programming, it is necessary to know the following key concepts : 1. Class A class is a blueprint or template of an object. It is a user-defined data type. We define variables, constants, member functions, and other functionality inside a class. it binds data and functions together in a single unit. It does not consume memory at run time. Note that classes are not considered as a data structure. It is a logical entity. It is the best example of data binding. Note that a class can exist witho...
Read more

HTTP GET Response in Flutter

Model Class // To parse this JSON data, do // // final welcome = welcomeFromJson(jsonString); import 'dart:convert' ; List<Welcome> welcomeFromJson (String str) => List <Welcome>. from (json.decode(str).map((x) => Welcome . fromJson (x))) ; String welcomeToJson (List<Welcome> data) => json.encode( List < dynamic >. from (data.map((x) => x.toJson()))) ; class Welcome { Welcome({ required this . userId , required this . id , required this . title , }) ; int userId ; int id ; String title ; factory Welcome. fromJson (Map<String , dynamic > json) => Welcome ( userId: json[ "userId" ] , id: json[ "id" ] , title: json[ "title" ] , ) ; Map<String , dynamic > toJson () => { "userId" : userId , "id" : id , "title" : title , } ; } Main Class // Importing important packages require to connect // Flutter and Dart import ...
Read more

Building a Flutter Firebase Firestore CRUD App

    In this tutorial, we will walk you through the process of creating a Flutter application that performs CRUD (Create, Read, Update, Delete) operations on a list of items using Firebase Firestore. Firestore is a cloud-based NoSQL database provided by Firebase, and Flutter is a powerful open-source framework for building cross-platform mobile apps. By combining these technologies, you can create a real-time and cloud-synced list management app.  Prerequisites Before we start, ensure that you have the following prerequisites in place: Adding Dependencies First, we need to add the necessary dependencies to our Flutter project. Open your project's pubspec.yaml file and add the following dependencies: dependencies:   flutter:     sdk: flutter   firebase_core: ^latest_version   cloud_firestore: ^latest_version Replace latest_version with the actual latest versions of the firebase_core and cloud_firestore packages available on the Flutter packages webs...
Read more