Tutorial Hibernate: CRUD en Hibernate

Introducción

CRUD es un acrónimo para las cuatro operaciones básicas utilizadas en el manejo de bases de datos: Crear (Create), Leer (Read), Actualizar (Update), Eliminar (Delete). 

Estas operaciones son fundamentales para el manejo de datos en cualquier aplicación y forman la esencia del acceso a bases de datos en el desarrollo de software.

En el contexto de Hibernate y las bases de datos, CRUD se refiere a cómo estas operaciones pueden ser implementadas para interactuar con una base de datos relacional utilizando el paradigma orientado a objetos.

Gestion de sesiones

En Hibernate, el flujo de trabajo para realizar operaciones CRUD está estrechamente ligado al uso de dos componentes clave: SessionFactory y Session.

SessionFactory

SessionFactory es un objeto pesado, destinado a ser creado una sola vez durante la vida de la aplicación. Es responsable de iniciar la configuración de Hibernate y proporcionar instancias de Session. La creación de SessionFactory típicamente se realiza durante el inicio de la aplicación, y se basa en la configuración definida en el archivo hibernate.cfg.xml o mediante configuración programática. Este objeto mantiene servicios como conexiones a la base de datos, caché de segundo nivel y configuraciones de mapeo de entidades.

Session

Session es la principal interfaz a través de la cual se realizan las operaciones CRUD en Hibernate. Representa una conversación entre la aplicación y la base de datos, manteniendo un contexto de persistencia (caché de primer nivel) y ofreciendo métodos para realizar consultas y actualizar la base de datos. Las sesiones son livianas y están diseñadas para ser instanciadas por cada unidad de trabajo (por ejemplo, una solicitud HTTP en una aplicación web), y deben ser cerradas una vez que el trabajo ha sido completado.

Flujo de trabajo con Session

• Abrir una sesión: Se inicia obteniendo una nueva Session desde el SessionFactory usando el método openSession(). Este paso marca el inicio de una unidad de trabajo.

Session session = sessionFactory.openSession();

• Iniciar una transacción: Casi todas las operaciones CRUD requieren ser ejecutadas dentro de una transacción. Hibernate gestiona las transacciones a través de la Session, y se inician con beginTransaction().

session.beginTransaction();

• Realizar operaciones CRUD: Dentro de la transacción, se pueden realizar múltiples operaciones CRUD —crear, leer, actualizar, eliminar— sobre las entidades.
• Comprometer la transacción: Una vez completadas las operaciones CRUD, se debe finalizar la transacción para que los cambios sean persistidos en la base de datos. Esto se hace con commit().

session.getTransaction().commit();

• Cerrar la sesión: Finalmente, es importante cerrar la Session para liberar los recursos de la base de datos y mantener el rendimiento de la aplicación. Esto se realiza con close().

session.close();

Este flujo de trabajo es esencial para realizar operaciones de base de datos de manera segura y eficiente con Hibernate, aprovechando su gestión de transacciones y contexto de persistencia.

Por tanto, el orden de operaciones general sería:

Session session = sessionFactory.openSession();
session.beginTransaction();

/* Aquí todas las operaciones CRUD */

session.getTransaction().commit();
session.close();

Operaciones CRUD

Crear (Create)

La operación “Crear” implica la inserción de nuevos registros en la base de datos. En Hibernate, esto se realiza instanciando objetos de las clases de entidad, que son clases de Java anotadas que representan tablas en la base de datos, y luego persistiéndolas usando el método save() de la sesión de Hibernate.

Session session = sessionFactory.openSession();
session.beginTransaction();

// Crear instancia de la entidad
Usuario nuevoUsuario = new Usuario();
nuevoUsuario.setId(123);
nuevoUsuario.setNombre("Laura");
nuevoUsuario.setEmail("laura@example.com");

// Persistir la instancia en la base de datos
session.save(nuevoUsuario);

// Finalizar la transacción y cerrar la sesión
session.getTransaction().commit();
session.close();

Leer (Read)

Leer se refiere a la recuperación de datos de la base de datos. Hibernate facilita la lectura de registros mediante el uso de su API, permitiendo tanto la recuperación de entidades específicas mediante su clave primaria como la ejecución de consultas para recuperar múltiples entidades basadas en criterios específicos.

Para recuperar una entidad por su ID:

Session session = sessionFactory.openSession();

Usuario usuario = session.get(Usuario.class, 123);

if (usuario != null) {
    System.out.println(usuario.getNombre());
}

session.close();

Actualizar (Update)

Actualizar implica modificar los datos existentes en la base de datos. Con Hibernate, esto se logra modificando las instancias de las entidades recuperadas y luego aplicando estos cambios a la base de datos con el método update() o simplemente modificando la entidad dentro de una transacción, lo que Hibernate detectará y sincronizará automáticamente gracias a su característica de seguimiento de sesión.

Session session = sessionFactory.openSession();
session.beginTransaction();

Usuario usuario = session.get(Usuario.class, 123);
usuario.setEmail("nuevo.email@example.com");

// Hibernate detecta automáticamente los cambios y los sincroniza con la base de datos al comprometer la transacción
session.getTransaction().commit();
session.close();

Eliminar (Delete)

Eliminar es el proceso de remover registros de la base de datos. En Hibernate, se puede eliminar una entidad cargándola primero y luego utilizando el método delete() de la sesión.

Session session = sessionFactory.openSession();
session.beginTransaction();

Usuario usuario = session.get(Usuario.class, 123);

if (usuario != null) {
    session.delete(usuario);
}

session.getTransaction().commit();
session.close();