Hive #

Saat aplikasi kita mulai tumbuh dan mengelola data yang lebih kompleks daripada sekadar preferensi pengguna, kita membutuhkan solusi penyimpanan yang lebih bertenaga daripada SharedPreferences. Di sisi lain, menggunakan database relasional penuh seperti SQLite terkadang terasa berlebihan (overkill) untuk proyek yang hanya memerlukan penyimpanan lokal yang cepat, fleksibel, dan tanpa konfigurasi tabel yang rumit. Di sinilah basis data NoSQL (Not Only SQL) lokal menjadi sangat relevan. Di ekosistem Flutter, Hive adalah salah satu basis data NoSQL berbasis kunci-nilai (key-value) yang paling populer, ditulis murni menggunakan bahasa pemrograman Dart, dan terkenal dengan performanya yang luar biasa cepat.

Di dalam artikel ini, kita akan membahas Hive secara mendalam, mulai dari konsep dasar penyimpanan biner, perbedaan penting antara Regular Box dan Lazy Box, aturan ketat evolusi skema (schema evolution) menggunakan TypeAdapter, penanganan enkripsi AES-256 yang aman, hingga implementasi praktis sebagai lapisan caching offline yang terintegrasi dengan state management modern.

Pendahuluan & Mengapa Hive CE? #

Hive adalah sistem penyimpanan data NoSQL berkinerja tinggi yang dirancang khusus untuk Flutter dan Dart. Alih-alih menyimpan data dalam format teks terstruktur seperti JSON atau XML, Hive mengonversi objek Dart kita menjadi format biner terkompresi. Format biner ini ditulis langsung ke disk menggunakan struktur yang dioptimalkan, sehingga meminimalkan beban komputasi saat proses serialisasi dan deserialisasi berlangsung.

Ada satu sejarah penting yang harus kita ketahui tentang perkembangan Hive. Proyek asli Hive (package:hive) sempat mengalami stagnasi pengembangan dan ditinggalkan oleh pembuat aslinya selama beberapa waktu. Karena basis pengguna Hive di komunitas Flutter sangat besar, komunitas pengembang mengambil inisiatif untuk membuat cabang (fork) resmi yang aktif dirawat dan diperbarui secara berkala. Cabang ini dikenal sebagai Hive CE (Community Edition).

Untuk memastikan aplikasi kita mendapatkan perbaikan bug terbaru, performa optimal, dan kompatibilitas penuh dengan versi Flutter terbaru, kita wajib menggunakan paket-paket berbasis Hive CE berikut di proyek kita:

  • hive_ce sebagai inti mesin database Hive.
  • hive_ce_flutter untuk integrasi khusus Flutter (penyediaan path penyimpanan otomatis).
  • hive_ce_generator sebagai pustaka pembantu di sisi dev dependencies untuk menghasilkan TypeAdapter secara otomatis.

Secara performa, Hive melampaui SharedPreferences dan SQLite dalam banyak skenario operasi baca dan tulis dasar. Hal ini dapat dicapai karena dua hal utama: pertama, Hive meminimalkan overhead komunikasi native (Method Channel) dengan menulis data langsung melalui Dart VM; kedua, Hive (pada Regular Box) menahan indeks dan seluruh nilai data di memori RAM, sehingga operasi pembacaan data bersifat sinkron dan instan tanpa jeda I/O disk.

Inisialisasi & Konfigurasi Path #

Sebelum kita dapat melakukan operasi baca atau tulis di Hive, kita wajib melakukan inisialisasi mesin database tersebut saat aplikasi Flutter kita pertama kali dinyalakan. Langkah inisialisasi ini sangat penting karena Hive perlu mengetahui direktori fisik mana di dalam sistem penyimpanan perangkat yang diizinkan untuk digunakan sebagai tempat penulisan berkas database biner (.hive dan .hivec).

Langkah pertama adalah menambahkan dependensi yang diperlukan pada berkas pubspec.yaml kita:

dependencies:
  flutter:
    sdk: flutter
  hive_ce: ^2.9.0
  hive_ce_flutter: ^2.2.0

dev_dependencies:
  build_runner: ^2.4.13
  hive_ce_generator: ^1.8.0

Selanjutnya, kita lakukan inisialisasi di berkas main.dart sebelum aplikasi kita merender antarmuka pengguna:

import 'package:flutter/material.dart';
import 'package:hive_ce_flutter/hive_flutter.dart';

void main() async {
  // 1. Pastikan binding Flutter telah diinisialisasi
  WidgetsFlutterBinding.ensureInitialized();

  // 2. Inisialisasi Hive untuk Flutter
  // Metode initFlutter() secara otomatis mencari lokasi penyimpanan yang aman
  // di masing-masing platform (misal: Application Documents Directory)
  await Hive.initFlutter();

  // 3. (Opsional) Buka box awal yang dibutuhkan sejak startup
  await Hive.openBox('app_settings');

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      home: Scaffold(
        body: Center(child: Text('Inisialisasi Hive Sukses')),
      ),
    );
  }
}

Metode Hive.initFlutter() adalah pembungkus khusus yang mempermudah proses inisialisasi di aplikasi Flutter. Jika kita menulis kode Dart murni (misalnya untuk aplikasi backend Dart atau CLI script), kita harus menggunakan metode Hive.init() dan menyediakan jalur direktori fisik secara manual menggunakan pustaka path_provider atau pustaka standar dart:io.

Arsitektur Alur Data (Data Flow) #

Mari kita visualisasikan bagaimana data diproses di dalam Hive, mulai dari aplikasi Flutter (Dart), melalui proses konversi biner oleh TypeAdapter, hingga ditulis secara fisik ke dalam penyimpanan lokal perangkat. Selain itu, diagram di bawah ini menggambarkan perbedaan pemuatan memori antara Regular Box dan Lazy Box.

graph TD
    App["Aplikasi Flutter (Dart)"] -->|Menyimpan Objek| Adapter["TypeAdapter (Serializer)"]
    Adapter -->|Konversi ke Biner| Engine["Hive Storage Engine"]
    Engine -->|Tulis Asinkron| Disk["Penyimpanan Fisik (.hive / .hivec)"]
    
    Disk -. "Membaca Semua Data" .-> Box["Regular Box (RAM Cache)"]
    Disk -. "Hanya Membaca Kunci" .-> Lazy["Lazy Box (Kunci di RAM, Nilai di Disk)"]
    
    Box -->|Akses Sinkron (Instan)| App
    Lazy -->|Akses Asinkron (Await)| App

Dengan mengamati alur data di atas, kita dapat merancang arsitektur penyimpanan aplikasi kita dengan lebih bijak. Kapan kita menahan seluruh data di RAM (Regular Box) dan kapan kita membiarkan data tetap berada di disk untuk menghemat memori (Lazy Box).

Perbedaan Regular Box vs Lazy Box #

Dalam Hive, semua data disimpan di dalam wadah yang disebut Box. Box dapat dianggap seperti tabel dalam database tradisional, namun tanpa batasan skema kolom yang kaku. Hive menyediakan dua jenis Box yang memiliki karakteristik performa dan memori yang sangat kontras:

1. Regular Box (Box) #

Ketika kita membuka box biasa menggunakan await Hive.openBox('nama_box'), Hive akan membaca seluruh isi file biner tersebut dari disk dan memuat seluruh data pasangan kunci-nilai (key-value) langsung ke dalam memori RAM aplikasi.

  • Karakteristik: Operasi pembacaan data bersifat sinkron (final data = box.get('key')) tanpa perlu kata kunci await. Hal ini karena data dibaca langsung dari RAM cache.
  • Penggunaan Ideal: Data berukuran kecil hingga sedang yang sering diakses secara berulang-ulang, seperti data konfigurasi pengguna, status sesi login, dan cache data halaman beranda yang berukuran kecil.
  • Kekurangan: Mengonsumsi memori RAM dalam jumlah besar jika isi box sangat banyak atau memiliki ukuran data objek yang besar.

2. Lazy Box (LazyBox) #

Ketika kita membuka box dengan await Hive.openLazyBox('nama_box'), Hive hanya akan memuat daftar kunci (keys) ke dalam memori RAM, sedangkan nilai datanya (values) tetap dibiarkan berada di dalam berkas fisik di disk.

  • Karakteristik: Operasi pembacaan data bersifat asinkron (final data = await lazyBox.get('key')). Setiap kali kita meminta data, Hive akan melakukan operasi I/O disk untuk mengambil data biner tersebut lalu mendekodenya di tempat.
  • Penggunaan Ideal: Kumpulan data yang besar di mana kita hanya membutuhkan akses ke beberapa item secara acak, seperti log aktivitas, daftar artikel berita yang panjang, atau cache gambar biner.
  • Kekurangan: Operasi baca sedikit lebih lambat dibandingkan dengan Regular Box karena harus mengakses media penyimpanan fisik setiap kali dipanggil.

Berikut adalah tabel perbandingan teknis antara Regular Box dan Lazy Box:

Aspek KomparasiRegular BoxLazy Box
Metode PembukaanHive.openBox('name')Hive.openLazyBox('name')
Metode Akses Nilaibox.get('key') (Sinkron)await lazyBox.get('key') (Asinkron)
Konsumsi Memori RAMTinggi (Semua data disimpan di RAM)Sangat Rendah (Hanya kunci yang di RAM)
Kecepatan AksesInstan (Kecepatan RAM)Sedikit Lambat (Kecepatan Disk I/O)
Skalabilitas DataTerbatas pada ukuran RAM luangSangat Besar (Hingga batas kapasitas disk)

TypeAdapter & Aturan Schema Evolution #

Agar Hive dapat menyimpan objek buatan kita sendiri (custom Dart class), kita harus mendaftarkan sebuah TypeAdapter. TypeAdapter bertugas sebagai penerjemah yang memberi tahu Hive bagaimana cara mengubah objek Dart menjadi representasi biner saat ditulis, dan bagaimana cara menyusun kembali representasi biner tersebut menjadi objek Dart saat dibaca.

Cara paling aman dan direkomendasikan adalah dengan memanfaatkan generator kode otomatis. Kita hanya perlu menghiasi kelas model kita dengan anotasi @HiveType dan @HiveField.

Berikut adalah contoh model data Customer yang terstruktur:

// lib/features/customer/data/models/customer.dart

import 'package:hive_ce/hive.dart';

// Nama file generator yang akan dihasilkan secara otomatis oleh build_runner
part 'customer.g.dart';

@HiveType(typeId: 0) // typeId harus unik antara 0 hingga 223
class Customer extends HiveObject {
  @HiveField(0)
  late String id;

  @HiveField(1)
  late String fullName;

  @HiveField(2)
  late String emailAddress;

  @HiveField(3)
  late bool isActive;

  @HiveField(4, defaultValue: 0) // Menambahkan nilai default untuk kolom baru
  late int loyaltyPoints;
}

Untuk menghasilkan berkas customer.g.dart yang berisi kelas CustomerAdapter, jalankan perintah berikut di terminal proyek kita:

flutter pub run build_runner build --delete-conflicting-outputs

Setelah generator berhasil membuat berkas adapter, jangan lupa untuk mendaftarkan adapter tersebut sebelum kita membuka box yang akan menggunakan tipe data tersebut:

// Daftarkan di main.dart sebelum membuka box terkait
Hive.registerAdapter(CustomerAdapter());

Aturan Emas Evolusi Skema (Schema Evolution) #

Seiring berjalannya waktu, aplikasi kita pasti akan mengalami pembaruan yang menuntut adanya perubahan struktur data pada kelas model kita (misal: menambahkan kolom baru atau menghapus kolom lama). Hive mengizinkan modifikasi skema ini dengan aturan yang sangat ketat agar data lama yang tersimpan di perangkat pengguna tidak rusak (corrupt):

  1. Jangan Pernah Mengubah typeId: Nilai typeId pada anotasi @HiveType adalah identitas unik kelas tersebut di dalam database biner. Sekali kita merilis aplikasi dengan typeId: 0, kelas tersebut harus tetap menggunakan ID tersebut selamanya.
  2. Jangan Pernah Mengubah Indeks @HiveField Yang Sudah Ada: Indeks field (seperti @HiveField(0), @HiveField(1)) digunakan Hive untuk memetakan kolom biner ke properti kelas Dart. Jika kita mengubah indeks field fullName dari 1 menjadi 5, Hive tidak akan bisa membaca data nama yang sudah disimpan oleh pengguna versi lama.
  3. Menambahkan Field Baru: Kita bebas menambahkan field baru pada indeks berikutnya (yang belum pernah digunakan). Selalu sertakan nilai default (defaultValue) pada anotasi @HiveField untuk kolom baru tersebut, agar ketika aplikasi versi baru membaca data dari aplikasi versi lama, properti baru tersebut tidak bernilai null yang dapat memicu crash.
  4. Menghapus Field: Jika kita ingin menghapus suatu properti dari model kita, jangan hapus anotasi field tersebut dari kelas Dart. Biarkan anotasi tersebut tetap ada dengan status deprecated atau diubah namanya, namun jangan gunakan kembali indeks @HiveField tersebut untuk properti baru lainnya. Anggap indeks tersebut sebagai reserved index.

Bekerja dengan HiveObject #

Salah satu fitur paling hebat dari Hive adalah tersedianya kelas HiveObject. Dengan mewarisi kelas HiveObject pada model data kita, kita memberikan kemampuan bagi objek tersebut untuk berinteraksi secara mandiri dengan database tanpa perlu tahu secara detail di box mana ia disimpan atau apa kunci uniknya.

Mari kita lihat contoh implementasi model Note yang menggunakan HiveObject:

// lib/features/notes/data/models/note.dart

import 'package:hive_ce/hive.dart';

part 'note.g.dart';

@HiveType(typeId: 1)
class Note extends HiveObject {
  @HiveField(0)
  late String title;

  @HiveField(1)
  late String content;

  @HiveField(2)
  late DateTime createdAt;
}

Setelah mewarisi HiveObject, objek Note memiliki akses ke metode pembantu seperti save() dan delete(). Berikut adalah demonstrasi penggunaannya:

import 'package:hive_ce/hive.dart';
import 'features/notes/data/models/note.dart';

Future<void> demoHiveObject() async {
  final Box<Note> noteBox = await Hive.openBox<Note>('my_notes');

  // 1. Membuat objek baru
  final Note shoppingNote = Note()
    ..title = 'Belanja Bulanan'
    ..content = 'Membeli susu, keju, dan buah-buahan segar'
    ..createdAt = DateTime.now();

  // 2. Memasukkan objek ke dalam Box
  // Saat kita memanggil add(), Hive akan memberikan kunci integer auto-increment ke objek ini.
  await noteBox.add(shoppingNote);

  // Kita bisa memeriksa kunci unik yang diberikan oleh Hive
  debugPrint('Kunci unik objek: ${shoppingNote.key}'); // Output berupa indeks integer (misal: 0, 1, 2)

  // 3. Mengubah data menggunakan metode save() bawaan HiveObject
  // Kita tidak perlu memanggil noteBox.put(key, value) secara manual!
  shoppingNote.content = 'Membeli susu organik, keju cheddar, dan apel merah';
  await shoppingNote.save(); // Data otomatis terbarui di database fisik!

  // 4. Menghapus objek menggunakan metode delete() bawaan HiveObject
  await shoppingNote.delete(); // Objek otomatis terhapus dari Box fisik!

  // Memastikan status keberadaan objek di dalam Box
  debugPrint('Apakah objek masih ada di box? ${shoppingNote.isInBox}'); // Output: false
}

Penggunaan HiveObject sangat menyederhanakan kode logika bisnis kita, terutama ketika kita membangun aplikasi daftar tugas (to-do list), pencatatan keuangan, atau aplikasi bertipe CRUD lainnya di mana objek data sering kali perlu memperbarui atau menghapus dirinya sendiri langsung dari tampilan antarmuka.

Enkripsi Tingkat Tinggi AES-256 #

Untuk data yang bersifat rahasia, seperti riwayat pesan obrolan, informasi profil pengguna, atau token otentikasi, kita wajib mengaktifkan fitur enkripsi pada Hive. Hive mendukung enkripsi bawaan menggunakan algoritma AES-256 (Advanced Encryption Standard) dengan mode CBC.

Tantangan terbesar dalam mengenkripsi database lokal adalah: di mana kita harus menyimpan kunci enkripsi tersebut? Menyimpan kunci enkripsi secara langsung di dalam kode aplikasi Dart kita (hardcoded) adalah kesalahan fatal karena kode aplikasi dapat dibongkar (reverse engineering) dengan mudah.

Solusi terbaik adalah menghasilkan kunci enkripsi acak yang kuat menggunakan Hive, kemudian menyimpan kunci tersebut di dalam penyimpanan aman bawaan sistem operasi menggunakan pustaka flutter_secure_storage.

Berikut adalah implementasi kelas pembungkus untuk membuka box terenkripsi secara aman:

// lib/core/storage/encrypted_hive_helper.dart

import 'dart:convert';
import 'dart:typed_data';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:hive_ce/hive.dart';

class EncryptedHiveHelper {
  static const _secureStorage = FlutterSecureStorage();
  static const String _keyStorageName = 'hive_master_encryption_key';

  // Membuka box dengan proteksi enkripsi AES-256
  static Future<Box<T>> openEncryptedBox<T>(String boxName) async {
    // 1. Ambil kunci master terenkripsi dari secure storage
    String? base64Key = await _secureStorage.read(key: _keyStorageName);

    Uint8List encryptionKey;

    if (base64Key == null) {
      // 2. Jika belum ada, buat kunci acak baru yang kuat (256-bit / 32-byte)
      final List<int> generatedKey = Hive.generateSecureKey();
      
      // Ubah ke format Base64 agar dapat disimpan sebagai string di secure storage
      base64Key = base64UrlEncode(generatedKey);
      await _secureStorage.write(key: _keyStorageName, value: base64Key);
      
      encryptionKey = Uint8List.fromList(generatedKey);
    } else {
      // 3. Jika sudah ada, decode kembali dari Base64 ke Uint8List
      encryptionKey = base64Url.decode(base64Key);
    }

    // 4. Buka Box dengan menyematkan cipher AES
    return await Hive.openBox<T>(
      boxName,
      encryptionCipher: HiveAesCipher(encryptionKey),
    );
  }
}

Dengan menggunakan helper di atas, semua proses penulisan ke disk akan dienkripsi secara transparan oleh mesin Hive. Jika berkas database .hivec diambil secara ilegal oleh pihak luar, berkas tersebut tidak akan dapat dibaca karena isinya berupa sandi acak biner yang tidak dapat didekripsi tanpa kunci master yang tersimpan di Secure Storage perangkat.

Implementasi Cache Layer dengan TTL #

Salah satu pola penggunaan Hive yang paling populer di industri adalah sebagai lapisan cache offline untuk menyimpan data yang diperoleh dari server API. Dengan menerapkan cache, aplikasi kita dapat berjalan dengan sangat responsif karena langsung menampilkan data lama dari penyimpanan lokal saat aplikasi dibuka, sambil melakukan pengambilan data terbaru dari server di latar belakang.

Agar cache tidak menumpuk dan menampilkan data yang sudah usang selamanya, kita perlu menerapkan mekanisme TTL (Time To Live) atau masa kedaluwarsa data cache.

Berikut adalah implementasi lengkap pola cache produk dengan sistem TTL di Hive:

// lib/features/products/data/cache/product_cache.dart

import 'package:hive_ce/hive.dart';
import '../../domain/entities/product.dart'; // Asumsikan model Product telah terdaftar di Hive

class ProductCache {
  static const String _boxName = 'products_cache_box';
  static const String _metadataBoxName = 'cache_metadata_box';
  static const String _keyTimestamp = 'products_cached_at_timestamp';
  
  // Durasi validitas cache adalah 1 jam
  static const Duration _cacheTtl = Duration(hours: 1);

  // Getter instansiasi box secara asinkron
  Future<Box<Product>> get _productBox async => Hive.box<Product>(_boxName);
  Future<Box> get _metaBox async => Hive.box(_metadataBoxName);

  // Menyimpan daftar produk ke dalam cache lokal
  Future<void> saveProductsCache(List<Product> products) async {
    final box = await _productBox;
    final metaBox = await _metaBox;

    // Bersihkan data cache lama untuk mencegah redundansi
    await box.clear();

    // Map list produk menjadi format map [id: object] untuk efisiensi penyimpanan
    final Map<String, Product> productMap = {
      for (final product in products) product.id: product
    };

    // Simpan semua produk secara massal (bulk write)
    await box.putAll(productMap);

    // Simpan waktu penyimpanan saat ini
    await metaBox.put(_keyTimestamp, DateTime.now().millisecondsSinceEpoch);
  }

  // Memuat produk dari cache lokal jika belum kedaluwarsa
  Future<List<Product>?> getCachedProducts() async {
    final metaBox = await _metaBox;
    final int? cachedTimestamp = metaBox.get(_keyTimestamp) as int?;

    if (cachedTimestamp == null) {
      return null; // Cache belum pernah diisi
    }

    final DateTime cachedDateTime = DateTime.fromMillisecondsSinceEpoch(cachedTimestamp);
    final Duration ageOfCache = DateTime.now().difference(cachedDateTime);

    if (ageOfCache > _cacheTtl) {
      // Cache telah kedaluwarsa
      await invalidateCache();
      return null;
    }

    final box = await _productBox;
    return box.values.toList();
  }

  // Menghapus data cache secara manual
  Future<void> invalidateCache() async {
    final box = await _productBox;
    final metaBox = await _metaBox;

    await box.clear();
    await metaBox.delete(_keyTimestamp);
  }
}

Dengan memisahkan logika cache ini ke kelas khusus, kelas repositori kita dapat dengan mudah menentukan apakah ia harus memanggil fungsi API jarak jauh (Remote Data Source) atau cukup menyajikan data biner cepat dari Hive cache.

Integrasi State Management (Riverpod & BLoC) #

Menggunakan Hive bersama dengan sistem manajemen state memungkinkan kita untuk memperbarui tampilan aplikasi secara reaktif. Kelebihan utama Hive adalah akses sinkronnya yang instan. Kita bisa membaca data langsung di dalam fungsi build widget tanpa perlu membungkusnya dengan FutureBuilder yang melelahkan.

Integrasi Menggunakan Riverpod #

Kita dapat menyediakan instance Box via Provider, lalu membuat sebuah StateNotifier untuk mengelola aksi pembaruan state aplikasi.

// lib/features/products/presentation/providers/product_provider.dart

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:hive_ce/hive.dart';
import '../../domain/entities/product.dart';

// Provider untuk menyediakan Box Hive yang sudah dibuka saat startup
final productBoxProvider = Provider<Box<Product>>((ref) {
  return Hive.box<Product>('products_cache_box');
});

// Notifier yang mengelola list produk secara reaktif dari Hive
class ProductListNotifier extends Notifier<List<Product>> {
  late Box<Product> _box;

  @override
  List<Product> build() {
    _box = ref.watch(productBoxProvider);
    // Langsung kembalikan nilai awal dari Hive secara sinkron
    return _box.values.toList();
  }

  // Menambahkan produk baru secara reaktif
  Future<void> addProduct(Product product) async {
    // Tulis ke database Hive secara asinkron
    await _box.put(product.id, product);
    // Perbarui state lokal Riverpod untuk memicu pembangunan ulang UI
    state = _box.values.toList();
  }

  // Menghapus produk dari database
  Future<void> removeProduct(String productId) async {
    await _box.delete(productId);
    state = _box.values.toList();
  }
}

// Provider global untuk StateNotifier kita
final productListProvider = NotifierProvider<ProductListNotifier, List<Product>>(
  ProductListNotifier.new,
);

Integrasi Menggunakan BLoC/Cubit #

Jika kita menggunakan BLoC, kita dapat mengimplementasikan penanganan data reaktif dengan pola yang serupa. Instance Box disuntikkan ke dalam konstruktor Cubit untuk digunakan saat emisi state baru.

// lib/features/products/presentation/cubit/product_cubit.dart

import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:hive_ce/hive.dart';
import '../../domain/entities/product.dart';

class ProductState {
  final List<Product> products;
  const ProductState(this.products);
}

class ProductCubit extends Cubit<ProductState> {
  final Box<Product> _productBox;

  ProductCubit(this._productBox) : super(ProductState(_productBox.values.toList()));

  // Aksi menambahkan item baru
  Future<void> createProduct(Product product) async {
    await _productBox.put(product.id, product);
    emit(ProductState(_productBox.values.toList()));
  }

  // Aksi menghapus item
  Future<void> deleteProduct(String id) async {
    await _productBox.delete(id);
    emit(ProductState(_productBox.values.toList()));
  }
}

Melalui integrasi ini, kode pada lapisan antarmuka pengguna kita tetap bersih. Widget UI hanya perlu melakukan listening pada provider atau BLoC builder, tanpa perlu mengetahui bahwa di balik layar terjadi operasi pembacaan file biner Hive.

Kapan Beralih ke Database Lain? #

Meskipun Hive sangat cepat dan mudah digunakan, basis data NoSQL berbasis key-value memiliki batasan arsitektur tertentu. Kita harus bijak dalam memilih teknologi penyimpanan agar tidak mengalami kesulitan teknis di masa mendatang.

Kita disarankan untuk tetap menggunakan Hive jika:

  • Struktur data aplikasi kita cenderung mendatar (flat) dan tidak memiliki hubungan relasi yang kompleks antar objek.
  • Aplikasi kita membutuhkan lapisan cache yang cepat untuk menyimpan respon JSON mentah dari API server.
  • Aplikasi kita harus mendukung platform Web secara penuh (karena Hive CE memiliki dukungan Web yang stabil).
  • Kita membutuhkan fitur enkripsi database yang sangat mudah dikonfigurasi.

Sebaliknya, pertimbangkan untuk beralih ke basis data lain jika kita menghadapi situasi berikut:

  • ObjectBox: Jika data aplikasi kita memiliki relasi antar objek yang rumit (misal: satu User memiliki banyak Order, dan masing-masing Order memiliki banyak Product). ObjectBox menyediakan pemodelan relasi ToOne dan ToMany native yang jauh lebih efisien dan kueri pencarian multi-tabel yang sangat cepat.
  • Drift (SQLite): Jika kita membutuhkan kekuatan penuh dari database relasional (SQL) seperti operasi JOIN antartabel yang kompleks, fungsi agregasi (GROUP BY, SUM, AVG), atau jika kita membutuhkan pengelolaan migrasi skema database tingkat lanjut untuk sistem data transaksional yang kompleks.

Ringkasan #

  • Hive CE (Community Edition) adalah pustaka NoSQL berbasis biner yang ditulis murni dalam Dart. Sangat cepat, hemat sumber daya, dan aktif dirawat oleh komunitas.
  • Konsep Box: Wadah data Hive. Regular Box memuat seluruh data ke memori RAM untuk akses sinkron yang cepat. Lazy Box hanya memuat kunci ke RAM, membiarkan nilai tetap di disk untuk menghemat memori pada data besar.
  • TypeAdapter: Pustaka pembantu untuk menerjemahkan objek Dart kustom menjadi format biner. Gunakan @HiveType dan @HiveField serta generator build_runner untuk membuatnya secara otomatis.
  • Evolusi Skema: Saat memperbarui model data, jangan pernah mengubah typeId atau indeks @HiveField yang sudah ada agar tidak merusak data pengguna lama.
  • HiveObject: Warisi kelas ini pada model data kita untuk mengaktifkan metode interaksi database instan seperti save() dan delete() langsung pada objek model tersebut.
  • Enkripsi AES-256: Mengamankan data sensitif secara enkripsi biner. Kunci master harus disimpan di flutter_secure_storage untuk menjamin keamanan fisik perangkat.
  • Arsitektur Cache: Sangat baik diimplementasikan sebagai lapisan cache offline dengan menambahkan kontrol masa berlaku data menggunakan mekanisme TTL (Time To Live).

← Sebelumnya: SharedPreferences   Berikutnya: ObjectBox →

About | Author | Content Scope | Editorial Policy | Privacy Policy | Disclaimer | Contact