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

Usando Room para la gestión de bases de datos

Siguiente ►
►

Room es una biblioteca de persistencia de datos que proporciona una capa de abstracción sobre SQLite para permitir un acceso más fluido a la base de datos. Room maneja muchas de las tareas repetitivas y propensas a errores asociadas con SQLite, como la creación y actualización de esquemas, y proporciona una API robusta para interactuar con la base de datos.

Contenido

  1. Introducción a Room
  2. Configuración de Room en tu proyecto
  3. Definición de entidades
  4. Creación de DAOs (Data Access Objects)
  5. Configuración de la base de datos
  6. Operaciones básicas con Room
  7. Ejercicio práctico
  8. Conclusión

Introducción a Room

Room es parte de la suite de componentes de arquitectura de Android y facilita el trabajo con bases de datos SQLite al proporcionar:

  • Entidades: Representan las tablas de la base de datos.
  • DAOs: Contienen los métodos utilizados para acceder a la base de datos.
  • Base de datos: Contiene la base de datos y sirve como el principal punto de acceso a los datos persistidos.

Configuración de Room en tu proyecto

Para usar Room, primero debes agregar las dependencias necesarias en tu archivo build.gradle:

dependencies {
    implementation "androidx.room:room-runtime:2.4.2"
    annotationProcessor "androidx.room:room-compiler:2.4.2"
    // Para usar Kotlin
    kapt "androidx.room:room-compiler:2.4.2"
}

Definición de entidades

Una entidad en Room representa una tabla en la base de datos. Cada campo en la clase de entidad corresponde a una columna en la tabla.

import androidx.room.Entity;
import androidx.room.PrimaryKey;

@Entity(tableName = "users")
public class User {
    @PrimaryKey(autoGenerate = true)
    public int id;

    public String name;
    public String email;
}

Creación de DAOs (Data Access Objects)

Los DAOs son interfaces que definen los métodos para interactuar con la base de datos. Room genera automáticamente la implementación de estos métodos.

import androidx.room.Dao;
import androidx.room.Delete;
import androidx.room.Insert;
import androidx.room.Query;
import androidx.room.Update;

import java.util.List;

@Dao
public interface UserDao {
    @Insert
    void insert(User user);

    @Update
    void update(User user);

    @Delete
    void delete(User user);

    @Query("SELECT * FROM users")
    List<User> getAllUsers();
}

Configuración de la base de datos

La clase de base de datos debe ser una clase abstracta que extiende RoomDatabase y debe estar anotada con @Database.

import androidx.room.Database;
import androidx.room.RoomDatabase;

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

Para crear una instancia de la base de datos:

import android.content.Context;
import androidx.room.Room;

public class DatabaseClient {
    private Context context;
    private static DatabaseClient instance;

    private AppDatabase appDatabase;

    private DatabaseClient(Context context) {
        this.context = context;
        appDatabase = Room.databaseBuilder(context, AppDatabase.class, "MyDatabase").build();
    }

    public static synchronized DatabaseClient getInstance(Context context) {
        if (instance == null) {
            instance = new DatabaseClient(context);
        }
        return instance;
    }

    public AppDatabase getAppDatabase() {
        return appDatabase;
    }
}

Operaciones básicas con Room

Insertar un usuario

User user = new User();
user.name = "John Doe";
user.email = "[email protected]";

DatabaseClient.getInstance(context).getAppDatabase().userDao().insert(user);

Obtener todos los usuarios

List<User> users = DatabaseClient.getInstance(context).getAppDatabase().userDao().getAllUsers();
for (User user : users) {
    Log.d("User", "ID: " + user.id + ", Name: " + user.name + ", Email: " + user.email);
}

Actualizar un usuario

User user = ... // Obtener el usuario de alguna manera
user.name = "Jane Doe";
DatabaseClient.getInstance(context).getAppDatabase().userDao().update(user);

Eliminar un usuario

User user = ... // Obtener el usuario de alguna manera
DatabaseClient.getInstance(context).getAppDatabase().userDao().delete(user);

Ejercicio práctico

Ejercicio

  1. Crear una nueva entidad: Define una nueva entidad llamada Product con los campos id, name, y price.
  2. Crear un DAO para Product: Define un DAO que permita insertar, actualizar, eliminar y obtener todos los productos.
  3. Configurar la base de datos: Añade la entidad Product a la base de datos.
  4. Realizar operaciones CRUD: Implementa un ejemplo en el que se inserte un nuevo producto, se actualice, se obtengan todos los productos y se elimine un producto.

Solución

Definición de la entidad Product

@Entity(tableName = "products")
public class Product {
    @PrimaryKey(autoGenerate = true)
    public int id;

    public String name;
    public double price;
}

Creación del DAO para Product

@Dao
public interface ProductDao {
    @Insert
    void insert(Product product);

    @Update
    void update(Product product);

    @Delete
    void delete(Product product);

    @Query("SELECT * FROM products")
    List<Product> getAllProducts();
}

Configuración de la base de datos

@Database(entities = {User.class, Product.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
    public abstract ProductDao productDao();
}

Realización de operaciones CRUD

// Insertar un producto
Product product = new Product();
product.name = "Laptop";
product.price = 999.99;
DatabaseClient.getInstance(context).getAppDatabase().productDao().insert(product);

// Obtener todos los productos
List<Product> products = DatabaseClient.getInstance(context).getAppDatabase().productDao().getAllProducts();
for (Product p : products) {
    Log.d("Product", "ID: " + p.id + ", Name: " + p.name + ", Price: " + p.price);
}

// Actualizar un producto
Product productToUpdate = ... // Obtener el producto de alguna manera
productToUpdate.price = 899.99;
DatabaseClient.getInstance(context).getAppDatabase().productDao().update(productToUpdate);

// Eliminar un producto
Product productToDelete = ... // Obtener el producto de alguna manera
DatabaseClient.getInstance(context).getAppDatabase().productDao().delete(productToDelete);

Conclusión

En esta sección, hemos aprendido cómo usar Room para la gestión de bases de datos en Android. Hemos cubierto desde la configuración inicial hasta la realización de operaciones CRUD básicas. Room simplifica significativamente el trabajo con bases de datos SQLite, proporcionando una API robusta y fácil de usar. En el siguiente módulo, exploraremos componentes avanzados de la interfaz de usuario para mejorar la experiencia de usuario en nuestras aplicaciones Android.

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