El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Usando Hive para Almacenamiento Local

Siguiente ►
►

Hive es una base de datos rápida y ligera para Flutter que permite almacenar datos de manera local en el dispositivo. Es una excelente opción para aplicaciones que necesitan persistencia de datos sin la complejidad de una base de datos SQL.

¿Qué es Hive?

Hive es una base de datos NoSQL para Flutter que se destaca por su simplicidad y rendimiento. Es ideal para almacenar datos estructurados y no estructurados, y es fácil de usar con una API intuitiva.

Características de Hive:

  • Rápido y ligero: Hive es conocido por su velocidad y bajo consumo de recursos.
  • NoSQL: Al ser una base de datos NoSQL, no requiere un esquema fijo.
  • Soporte para Flutter y Dart: Hive está diseñado específicamente para Flutter y Dart.
  • Fácil de usar: La API de Hive es simple y fácil de aprender.

Configuración de Hive

Paso 1: Agregar Dependencias

Primero, necesitas agregar las dependencias de Hive en tu archivo pubspec.yaml:

dependencies:
  hive: ^2.0.0
  hive_flutter: ^1.0.0

dev_dependencies:
  hive_generator: ^1.0.0
  build_runner: ^2.0.0

Paso 2: Inicializar Hive

Antes de usar Hive, debes inicializarlo. Esto generalmente se hace en el método main de tu aplicación:

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

void main() async {
  await Hive.initFlutter();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Hive Example')),
        body: Center(child: Text('Hello, Hive!')),
      ),
    );
  }
}

Paso 3: Definir un Modelo

Para almacenar datos en Hive, necesitas definir un modelo. Puedes usar anotaciones para generar el código necesario:

import 'package:hive/hive.dart';

part 'person.g.dart';

@HiveType(typeId: 0)
class Person extends HiveObject {
  @HiveField(0)
  String name;

  @HiveField(1)
  int age;

  Person({required this.name, required this.age});
}

Luego, ejecuta el siguiente comando para generar el archivo person.g.dart:

flutter packages pub run build_runner build

Paso 4: Registrar el Adaptador

Antes de usar el modelo, debes registrar el adaptador:

void main() async {
  await Hive.initFlutter();
  Hive.registerAdapter(PersonAdapter());
  runApp(MyApp());
}

Uso de Hive

Abrir una Caja

En Hive, los datos se almacenan en cajas. Debes abrir una caja antes de poder usarla:

void main() async {
  await Hive.initFlutter();
  Hive.registerAdapter(PersonAdapter());
  var box = await Hive.openBox('myBox');
  runApp(MyApp());
}

Operaciones CRUD

Crear y Leer Datos

void addPerson(Box box) {
  var person = Person(name: 'John Doe', age: 30);
  box.add(person);
}

void getPerson(Box box) {
  var person = box.getAt(0) as Person;
  print('Name: ${person.name}, Age: ${person.age}');
}

Actualizar Datos

void updatePerson(Box box) {
  var person = box.getAt(0) as Person;
  person.name = 'Jane Doe';
  person.save();
}

Eliminar Datos

void deletePerson(Box box) {
  box.deleteAt(0);
}

Ejercicio Práctico

Ejercicio 1: Crear una Aplicación de Lista de Tareas

  1. Objetivo: Crear una aplicación simple de lista de tareas usando Hive para almacenar las tareas.
  2. Requisitos:
    • Definir un modelo Task con campos title y isCompleted.
    • Implementar funciones para agregar, leer, actualizar y eliminar tareas.
    • Mostrar las tareas en una lista en la interfaz de usuario.

Solución

Definir el Modelo

import 'package:hive/hive.dart';

part 'task.g.dart';

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

  @HiveField(1)
  bool isCompleted;

  Task({required this.title, this.isCompleted = false});
}

Registrar el Adaptador y Abrir la Caja

void main() async {
  await Hive.initFlutter();
  Hive.registerAdapter(TaskAdapter());
  var box = await Hive.openBox('taskBox');
  runApp(MyApp());
}

Implementar la Interfaz de Usuario

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: TaskPage(),
    );
  }
}

class TaskPage extends StatefulWidget {
  @override
  _TaskPageState createState() => _TaskPageState();
}

class _TaskPageState extends State<TaskPage> {
  final _taskBox = Hive.box('taskBox');
  final _controller = TextEditingController();

  void _addTask(String title) {
    final task = Task(title: title);
    _taskBox.add(task);
  }

  void _toggleTaskCompletion(int index) {
    final task = _taskBox.getAt(index) as Task;
    task.isCompleted = !task.isCompleted;
    task.save();
  }

  void _deleteTask(int index) {
    _taskBox.deleteAt(index);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Task List')),
      body: Column(
        children: [
          TextField(
            controller: _controller,
            decoration: InputDecoration(labelText: 'New Task'),
            onSubmitted: (value) {
              _addTask(value);
              _controller.clear();
            },
          ),
          Expanded(
            child: ValueListenableBuilder(
              valueListenable: _taskBox.listenable(),
              builder: (context, Box box, _) {
                if (box.isEmpty) {
                  return Center(child: Text('No tasks yet.'));
                }

                return ListView.builder(
                  itemCount: box.length,
                  itemBuilder: (context, index) {
                    final task = box.getAt(index) as Task;
                    return ListTile(
                      title: Text(
                        task.title,
                        style: TextStyle(
                          decoration: task.isCompleted
                              ? TextDecoration.lineThrough
                              : TextDecoration.none,
                        ),
                      ),
                      trailing: Checkbox(
                        value: task.isCompleted,
                        onChanged: (_) => _toggleTaskCompletion(index),
                      ),
                      onLongPress: () => _deleteTask(index),
                    );
                  },
                );
              },
            ),
          ),
        ],
      ),
    );
  }
}

Conclusión

Hive es una herramienta poderosa y fácil de usar para el almacenamiento local en aplicaciones Flutter. En este módulo, aprendiste cómo configurar Hive, definir modelos, realizar operaciones CRUD y crear una aplicación práctica de lista de tareas. Con estos conocimientos, puedes implementar almacenamiento local eficiente en tus aplicaciones Flutter.

En el próximo módulo, exploraremos conceptos avanzados de Flutter, incluyendo animaciones y optimización de rendimiento. ¡Sigue adelante y sigue aprendiendo!

◄ Anterior
◄
Siguiente ►
►

Curso de Desarrollo con Flutter

Módulo 1: Introducción a Flutter

Módulo 2: Conceptos Básicos de Programación en Dart

Módulo 3: Widgets en Flutter

Módulo 4: Gestión de Estado

Módulo 5: Navegación y Enrutamiento

Módulo 6: Redes y APIs

Módulo 7: Persistencia y Almacenamiento

Módulo 8: Conceptos Avanzados de Flutter

Módulo 9: Pruebas y Depuración

Módulo 10: Despliegue y Mantenimiento

Módulo 11: Flutter para Web y Escritorio

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados