Como você persiste dados localmente em Flutter?

Question

Accepted Answer

Apps frequentemente precisam **armazenar dados localmente** no dispositivo — preferências do usuário, dados em cache, conteúdo offline. Flutter oferece várias opções — **shared_preferences** (chave-valor), **SQLite** (relacional), e outras — cada uma adequada para necessidades diferentes.

## Opções de armazenamento local

```text
SHARED_PREFERENCES → simple KEY-VALUE storage (settings, flags, small data):
  → store primitives (strings, ints, bools) — like a simple persistent map
  → for: user preferences, tokens, simple flags (NOT large/structured data)
SQLITE (sqflite) → a full relational DATABASE on the device:
  → tables, SQL queries — for STRUCTURED, larger data; complex queries; relationships
HIVE / ISAR → fast NoSQL local databases (key-value/object stores) — popular, fast,
  Dart-native (no SQL); good for structured local data
FILE storage → read/write files directly (path_provider for directories)
SECURE storage → flutter_secure_storage for SENSITIVE data (tokens, credentials) —
  encrypted (keychain/keystore)
```

## Exemplo shared_preferences

```dart
final prefs = await SharedPreferences.getInstance();
await prefs.setString('username', 'Ann');      // store
final name = prefs.getString('username');        // retrieve
await prefs.setBool('darkMode', true);
```

## Escolhendo a opção certa

```text
Simple settings/flags → shared_preferences (easy key-value)
Structured/large data, queries → SQLite (sqflite) or Hive/Isar
Sensitive data (tokens, passwords) → flutter_secure_storage (ENCRYPTED — don't put
  secrets in shared_preferences, which is NOT secure)
Files → file storage (path_provider)
→ Match the storage to the data's size, structure, and sensitivity.
```

## Por que isso importa

Entender como persistir dados localmente é valioso porque **apps frequentemente precisam armazenar dados no dispositivo** — preferências do usuário, dados em cache, conteúdo offline, tokens de autenticação — então é conhecimento prático útil para construir apps reais.

Persistência local é uma necessidade quase universal (lembrar configurações, cache para uso offline, armazenar dados de sessão), e Flutter oferece várias opções adequadas para necessidades diferentes.

Entender as **opções** — **shared_preferences** (armazenamento simples chave-valor para configurações, flags e dados pequenos), **SQLite/sqflite** (um banco de dados relacional completo para dados estruturados e maiores com queries e relacionamentos), **Hive/Isar** (bancos de dados NoSQL rápidos nativos de Dart populares para dados estruturados locais), armazenamento de arquivos, e **armazenamento seguro** (`flutter_secure_storage` para dados sensíveis) — e **quando usar cada um** é o conhecimento-chave.

Escolher a **opção certa** importa: shared_preferences para configurações simples, SQLite ou Hive/Isar para dados estruturados/grandes, armazenamento de arquivos para arquivos, e crucialmente **armazenamento seguro para dados sensíveis** como tokens e credenciais (que devem ser criptografados via keychain/keystore da plataforma — um ponto de segurança importante, já que **shared_preferences não é seguro e não deve conter secrets**, um erro comum).

Alinhar o armazenamento ao tamanho, estrutura e sensibilidade dos dados reflete decisões sólidas e evita problemas (como usar a ferramenta errada para o trabalho ou armazenar credenciais inseguramente).

Já que apps frequentemente precisam de persistência local (configurações, cache, dados offline, tokens) e Flutter oferece várias opções para necessidades diferentes, e já que entender essas opções e escolher apropriadamente (especialmente usar armazenamento seguro para dados sensíveis) é valioso para construir apps reais corretamente, entender persistência de dados locais em Flutter é conhecimento valioso e praticamente relevante — uma necessidade comum em apps reais, importante tanto para funcionalidade (armazenar os dados certos da forma certa) quanto para segurança (proteger dados sensíveis com armazenamento seguro), e uma habilidade útil para construir apps que lembram estado e funcionam offline.