Hive: o que é, armazenamento NoSQL e desenvolvimento sem código nativo

O que é Hive?

Hive é um banco de dados NoSQL escrito inteiramente em Dart que não requer bibliotecas nativas. Foi criado por Simon Leiter em 2019 como uma alternativa ao SQLite para projetos Flutter. O Hive armazena dados em formato binário .hive otimizado para leitura e escrita rápidas em dispositivos móveis. O formato .hive usa um esquema de serialização personalizado onde cada tipo de dado tem seu próprio prefixo de byte, permitindo a leitura do arquivo sem conhecimento prévio do esquema — ao contrário de Protocol Buffers ou FlatBuffers.

A ideia central do Hive é a máxima simplicidade. O banco de dados não requer inicialização de mecanismos nativos, não inclui analisador SQL e não usa reflexão. Todas as operações são chamadas diretas de funções Dart com serialização binária através de WriteBuffer e ReadBuffer.

De acordo com a pesquisa da Flutter Community (2023), o Hive está entre os 5 pacotes de armazenamento de dados mais usados no Flutter, perdendo apenas para o shared_preferences em popularidade, mas superando-o em funcionalidade e velocidade.

Arquitetura do Hive

Hive usa o conceito de Box — análogo a uma tabela em bancos de dados relacionais. Cada Box é um arquivo em disco com um conjunto de pares chave-valor. A chave pode ser int ou String, o valor pode ser qualquer tipo primitivo, lista, Map ou um objeto personalizado através de TypeAdapter. Os Boxes são isolados uns dos outros e abertos independentemente.

Vantagens sobre soluções nativas

Hive não requer canais de plataforma. Isso significa que funciona igualmente em Android, iOS, Web, macOS, Windows e Linux sem configuração adicional. Para projetos destinados à compilação web, o Hive continua sendo a única solução NoSQL leve — o SQLite não funciona em navegadores. O Hive usa IndexedDB como backend para web, garantindo a persistência de dados mesmo em ambiente de navegador.

Como o Hive funciona?

Hive serializa dados em formato binário ao escrever e desserializa ao ler. O mecanismo interno é baseado em BinaryWriter e BinaryReader, que empacotam dados em arrays de bytes compactos. O tamanho do armazenamento em disco é em média 2–3 vezes menor que a representação JSON dos mesmos dados.

Ao abrir um Box, o Hive carrega todo o arquivo na RAM. Isso proporciona alta velocidade de leitura (microssegundos), mas impõe uma limitação de tamanho: recomenda-se armazenar não mais que 50–100 MB por Box. Para volumes maiores, use LazyBox — carregamento preguiçoso de registros do disco.

Transações e concorrência

Hive trabalha em thread única dentro de um isolado Dart. As operações de escrita são realizadas de forma síncrona com bloqueio de arquivo. Para acesso assíncrono, use Hive.openBox() com await. O acesso concorrente de múltiplos isolados não é suportado diretamente — é necessário um mecanismo de sincronização separado.

Hive vs SharedPreferences vs SQLite

Hive ocupa um nicho entre SharedPreferences e SQLite. É mais complexo que SharedPreferences (suporta objetos personalizados) mas mais simples que SQLite (não requer consultas SQL). Vamos comparar as principais características.

Quando escolher Hive

Hive é ideal para pequenos volumes de dados: configurações de aplicativo, cache de respostas de API, fila de sincronização local, favoritos e histórico de navegação. Se os dados não excederem 50 MB e não exigirem consultas relacionais — o Hive é mais rápido e simples que o SQLite.

Quando o Hive não é adequado

Hive não suporta consultas com filtragem por múltiplos campos, JOIN ou funções agregadas. Se você precisa de consultas complexas como “selecionar todas as tarefas de hoje com prioridade acima de 3” — use SQLite com drift ou floor. O Hive também não é adequado para armazenar mais de 100 MB de dados devido ao carregamento em memória.

Exemplos de código com Hive

Hive começa com inicialização e abertura de um Box. Abaixo estão as operações básicas para um cenário típico — armazenar uma lista de tarefas em um aplicativo Flutter. Todos os exemplos funcionam sem chamadas nativas de plataforma.

Inicialização e abertura de Box

Antes de usar o Hive, você deve chamar Hive.initFlutter() na função main. Em seguida, abra um Box via Hive.openBox() — o resultado será uma instância de Box pronta para leitura e escrita.

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());
}

Operações CRUD

Box fornece os métodos put, get, delete e um iterador para percorrer todas as entradas. Chaves e valores são tipificados através de genéricos — por padrão Box<dynamic> aceita qualquer tipo, mas é recomendado especificar um tipo concreto.

// Escrever dados
final box = await Hive.openBox<String>('tasks');
await box.put('task_1', 'Comprar mantimentos');

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

// Todas as chaves
final allTasks = box.values.toList();

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

// Limpar Box
await box.clear();

Observação reativa via WatchBox

WatchBox é uma extensão do Box que notifica assinantes sobre alterações. No Flutter, isso se integra com ValueListenableBuilder: quando qualquer valor no Box muda, o widget é reconstruído automaticamente sem chamar setState.

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

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

TypeAdapter e objetos personalizados

TypeAdapter é o mecanismo do Hive para serializar objetos Dart personalizados. O adaptador descreve como converter um objeto para formato binário (write) e de volta (read). Ao contrário do json_serializable, o TypeAdapter não requer reflexão e é mais rápido.

Criando um TypeAdapter

O adaptador implementa a interface TypeAdapter com dois métodos: read e write. A classe é registrada através de Hive.registerAdapter() antes de abrir o Box. Cada adaptador recebe um ID numérico — ele é salvo no arquivo para identificação do tipo.

// Modelo de dados
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);
    }
}

Geração de adaptadores via geração de código

Para projetos com um grande número de modelos, o Hive fornece hive_generator e build_runner. A anotação @HiveType na classe e @HiveField nos campos geram o adaptador automaticamente. Isso é conveniente quando o modelo tem 10+ campos — a escrita manual de read/write se torna tediosa.

Otimização de desempenho do Hive

Hive lê da memória em vez do disco, proporcionando velocidades de até 30 000 operações por segundo. Para otimizar: abra um Box uma vez e reutilize-o em todo o aplicativo, não chame openBox repetidamente. Use Hive.box() (getter síncrono) após a inicialização — ele retorna um Box já aberto sem criar uma nova instância.

Hive com Provider e Riverpod

Hive integra-se facilmente com gerenciadores de estado populares do Flutter. Para Provider, use ChangeNotifierProvider que lê dados do Box na inicialização e atualiza via listenable. Para Riverpod, um StreamProvider inscrito no WatchBox funciona bem. Essa combinação fornece atualizações reativas da UI a cada mudança de dados no Hive sem chamadas manuais de setState. Em um projeto Flutter típico, essa arquitetura permite sincronizar o estado entre telas sem um singleton global.