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.
¿Te está gustando esta lección?
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
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 elSessionFactory
usando el métodoopenSession()
. 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 conbeginTransaction()
.
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 conclose()
.
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();
Aprendizajes de esta lección
- Comprender el significado y la importancia de las operaciones CRUD en el manejo de bases de datos.
- Entender el concepto y la importancia de
SessionFactory
ySession
en la gestión de sesiones y transacciones con Hibernate. - Familiarizarse con el flujo de trabajo estándar para realizar operaciones CRUD, que incluye abrir una sesión, iniciar una transacción, ejecutar operaciones CRUD, comprometer la transacción y cerrar la sesión.
- Conocer cómo crear, leer, actualizar y eliminar registros en una base de datos utilizando los métodos proporcionados por la
Session
de Hibernate.
Completa Hibernate y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs