Hibernate

Hibernate

Uso

Hibernate es un framework de mapeo objeto-relacional (ORM) ampliamente utilizado en aplicaciones Java para interactuar con bases de datos. Su propósito principal es simplificar y optimizar el manejo de datos persistentes al permitir que los desarrolladores trabajen con objetos en lugar de escribir directamente consultas SQL. A continuación, se enumeran las principales razones para utilizar Hibernate:

1. Simplificación del manejo de datos persistentes Hibernate abstrae las complejidades del manejo de datos en bases de datos relacionales: No es necesario escribir código SQL explícito para operaciones comunes (inserción, actualización, eliminación, consulta). Se trabaja directamente con objetos Java (entidades), que Hibernate mapea automáticamente a tablas de la base de datos.
2. Portabilidad y soporte para múltiples bases de datos Hibernate es compatible con diferentes sistemas de bases de datos: Cambiar de una base de datos a otra requiere poco o ningún cambio en el código. La configuración del dialecto de base de datos (por ejemplo, MySQL, PostgreSQL, Oracle) permite a Hibernate generar automáticamente SQL adaptado a cada sistema.
3. Reducción de código repetitivo Hibernate gestiona operaciones repetitivas y tediosas: Generación automática de consultas SQL para CRUD. No es necesario escribir manualmente código para abrir y cerrar conexiones, manejar transacciones, etc.
4. Gestión automática de relaciones Hibernate soporta y simplifica relaciones entre tablas: Relaciones como uno a uno, uno a muchos y muchos a muchos se modelan como relaciones entre objetos. Maneja automáticamente las claves foráneas y las asociaciones.
5. Caché y optimización del rendimiento Hibernate utiliza mecanismos de caché para mejorar el rendimiento: Primer nivel de caché: Caché asociada a la sesión de Hibernate. Segundo nivel de caché: Caché compartida entre sesiones. Reduce la cantidad de consultas SQL enviadas al servidor, optimizando el uso de recursos.
6. Generación automática del esquema Hibernate puede generar y actualizar automáticamente el esquema de la base de datos basado en las entidades Java: Facilita el desarrollo rápido y reduce errores de sincronización entre el modelo de datos y el esquema de la base de datos.
7. Lenguaje de consultas HQL Hibernate Query Language (HQL) es un lenguaje orientado a objetos para escribir consultas: Similar a SQL pero centrado en objetos Java, lo que facilita el desarrollo. HQL abstrae las diferencias entre dialectos SQL de diferentes bases de datos.
8. Soporte para transacciones Hibernate integra fácilmente la gestión de transacciones: Proporciona control explícito sobre las transacciones (commit, rollback). Compatible con transacciones distribuidas a través de JTA (Java Transaction API).
9. Comunidad activa y extensibilidad Hibernate cuenta con una comunidad activa que ofrece soporte y documentación. Es extensible para cubrir necesidades específicas, como estrategias de mapeo personalizadas.
10. Integración con otros frameworks Hibernate se integra fácilmente con frameworks como: Spring Framework: Para gestionar la inyección de dependencias y transacciones. JPA (Java Persistence API): Hibernate implementa la especificación JPA, lo que lo hace ideal para proyectos que siguen estándares. Ventajas concretas Menor tiempo de desarrollo: Reduce la complejidad del código relacionado con bases de datos. Mantenimiento más sencillo: Cambios en el modelo de datos se reflejan automáticamente en el esquema de la base de datos. Flexibilidad: Soporte para consultas nativas SQL cuando es necesario. Consideraciones al usar Hibernate Curva de aprendizaje: Requiere tiempo para aprender su configuración y conceptos como lazy loading, transacciones y caché. Sobrecarga: En aplicaciones pequeñas, puede ser excesivo frente a soluciones más ligeras como JDBC. Configuración inicial: Aunque potente, puede ser complejo configurarlo correctamente en proyectos grandes. En general, Hibernate es una excelente opción para aplicaciones Java que requieren manejo eficiente de datos persistentes y buscan reducir el esfuerzo de desarrollo y mantenimiento.

Caso práctico

Con la siguiente estructura SQL:

CREATE DATABASE canciones;

CREATE TABLE `song` (
  `songId` int(11) NOT NULL AUTO_INCREMENT,
  `songName` varchar(25) NOT NULL,
  `singer` varchar(25) NOT NULL,
  PRIMARY KEY (`songId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

1. Añadimos las librerías, deben quedar de la siguiente manera:

2. Añadimos una clase con el siguiente contenido:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
// Seleccionamos el nombre de la tabla
@Table(name = "song")
 
// POJO class
public class Song {

    // Indicamos el tipo ID y le marcamos el nombre de la columna, en este caso songId. Después le marcamos el tipo de dato, en este caso **int** y el nombre de la variable id.
    @Id @Column(name = "songId") private int id;

    // Indicamos el nombre de la segunda columna **songName**. Después le marcamos el tipo de dato, en este caso **String** y el nombre de la variable songName.
    @Column(name = "songName") private String songName;
 
    // Indicamos el nombre de la tercera columna **singer**. Después le marcamos el tipo de dato, en este caso **String** y el nombre de la variable artist.
    @Column(name = "singer") private String artist;
 
    // Método con el cual devolvemos el ID
    public int getId() { return id; }
 
    // Método con el cual establecemos el ID
    public void setId(int id) { this.id = id; }
 
    // Método con el cual devolvemos el nombre de la canción
    public String getSongName() { return songName; }

    // Método con el cual establecemos el nombre de la canción 
    public void setSongName(String songName)
    {
        this.songName = songName;
    }

    // Método con el cual devolvemos el nombre del artista
    public String getArtist() { return artist; }

    // Método con el cual establecemos el nombre del artista 
    public void setArtist(String artist)
    {
        this.artist = artist;
    }
}

1. Los import:

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

1. Trabajando con las sesiones:

    void crearSession(){

        // Paso 1: Crear una instancia de la clase Configuration
        Configuration configuration = new Configuration();

        // Paso 2: Configurar Hibernate cargando la configuración desde "hibernate.cfg.xml"
        configuration.configure("hibernate.cfg.xml");

        // Paso 3: Agregar la clase Song como una clase anotada en la configuración de Hibernate
        configuration.addAnnotatedClass(Song.class);
        
        // Paso 4: Construir la fábrica de sesiones (SessionFactory) utilizando la configuración
        this.sessionFactory = configuration.buildSessionFactory();
    }

1. CRUD

Create

void crearCancion(String songName, String artist) {
    // Intenta abrir una sesión utilizando la fábrica de sesiones existente
    try (Session session = this.sessionFactory.openSession()) {
        // Inicia una transacción en la sesión
        session.beginTransaction();

        // Crea una nueva instancia de la clase Song y establece sus propiedades
        Song nuevo = new Song();
        nuevo.setSongName(songName);
        nuevo.setArtist(artist);

        // Guarda la nueva instancia de Song en la base de datos
        session.save(nuevo);

        // Realiza commit para confirmar la transacción
        session.getTransaction().commit();

        // Cierra la sesión después de completar las operaciones
        session.close();
    }
}

Read

void crearCancion(String songName, String artist) {
    // Intenta abrir una sesión utilizando la fábrica de sesiones existente
    try (Session session = this.sessionFactory.openSession()) {
        // Inicia una transacción en la sesión
        session.beginTransaction();

        // Crea una nueva instancia de la clase Song
        Song nuevo = new Song();

        // Establece el nombre de la canción y el artista en la instancia de Song
        nuevo.setSongName(songName);
        nuevo.setArtist(artist);

        // Guarda la nueva instancia de Song en la base de datos
        session.save(nuevo);

        // Realiza commit para confirmar la transacción
        session.getTransaction().commit();

        // Cierra la sesión después de completar las operaciones
        session.close();
    }
}

Update

void actualizarProducto(int id, String songName, String artist) {
    // Intenta abrir una sesión utilizando la fábrica de sesiones existente
    try (Session session = this.sessionFactory.openSession()) {
        // Inicia una transacción en la sesión
        session.beginTransaction();

        // Obtén el objeto Song de la base de datos con el id proporcionado
        Song cancion = session.get(Song.class, id);

        // Actualiza los campos si se encuentra el objeto Song
        if (cancion != null) {
            // Establece el nuevo nombre de la canción y artista
            cancion.setSongName(songName);
            cancion.setArtist(artist);
        }

        // Realiza commit para confirmar la transacción
        session.getTransaction().commit();

        // Cierra la sesión después de completar las operaciones
        session.close();
    }
}

Delete

void eliminarProducto(int id) {
    // Intenta abrir una sesión utilizando la fábrica de sesiones existente
    try (Session session = this.sessionFactory.openSession()) {
        // Inicia una transacción en la sesión
        session.beginTransaction();

        // Obtén el objeto Song de la base de datos con el id proporcionado
        Song cancion = session.get(Song.class, id);

        // Elimina el objeto Song si se encuentra
        if (cancion != null) {
            // Utiliza el método delete para eliminar la instancia de Song de la base de datos
            session.delete(cancion);
        }

        // Realiza commit para confirmar la transacción
        session.getTransaction().commit();

        // Cierra la sesión después de completar las operaciones
        session.close();
    }
}

Para finalizar la sesión:

void cerrar() {
    // Cierra la fábrica de sesiones
    this.sessionFactory.close();
}

1. Añadimos un archivo XML dento de nuestro proyecto, se debe llamar hibernate.cfg.xml con el siguiente contenido: ``` <?xml version = “1.0” encoding = “utf-8”?> <!DOCTYPE hibernate-configuration PUBLIC “-//Hibernate/Hibernate Configuration DTD 3.0//EN” “http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd”>

com.mysql.jdbc.Driver jdbc:mysql://localhost:3306/canciones //jdbc:mysql://**direccion_server**:**puerto**/**nombre_BBDD** 2DAM //**User_BBDD** 2DAM2023 //**Pass_BBDD** true

```

Esto es todo.