PROYECTO ESCUELA EN HIBERNATE

Mapeo ORM de las tablas

Ejercicio 1

Ejercicio ORM con Hibernate Clase Director Objetivo: Mapear las entidades Director y Escuela utilizando Hibernate con una relación uno a uno. Requisitos: Entidad Director: Atributos: id, nombre, correo, escuela. Relación uno a uno con la entidad Escuela. Entidad Escuela: Atributos: id, nombre, director. Relación uno a uno con la entidad Director. Operaciones: Crear un director con su escuela asociada. Consultar un director y su escuela. Eliminar un director y su escuela (usando cascada). Tareas: Crea las clases Director y Escuela, mapeándolas a las tablas correspondientes. Configura la relación uno a uno entre Director y Escuela. Realiza operaciones CRUD con Hibernate. Consejo: Utiliza CascadeType.ALL y FetchType.LAZY en la relación entre las entidades.

package es.pulsoft.mapeo;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;


@Entity
@Table(name = "director")
public class Director {

    /**
     * Identificador único del director.
     * Este campo es generado automáticamente por la base de datos.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    /**
     * Nombre del director.
     */
    @Column(name = "nombre")
    private String nombre;

    /**
     * Correo electrónico del director.
     */
    @Column(name = "correo")
    private String correo;

    /**
     * Relación uno a uno con la entidad Escuela.
     * Un director está asociado a una única escuela.
     * La relación es mapeada por el campo "director" en la entidad Escuela.
     */
    @OneToOne(mappedBy = "director", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Escuela escuela;

    /**
     * Constructor por defecto de la clase Director.
     * Requerido por JPA.
     */
    public Director() {
    }

    /**
     * Constructor que inicializa un director con nombre y correo.
     *
     * @param nombre El nombre del director.
     * @param correo El correo electrónico del director.
     */
    public Director(String nombre, String correo) {
        this.nombre = nombre;
        this.correo = correo;
    }

    /**
     * Obtiene el identificador único del director.
     *
     * @return El identificador del director.
     */
    public int getId() {
        return id;
    }

    /**
     * Establece el identificador único del director.
     *
     * @param id El identificador del director.
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * Obtiene el nombre del director.
     *
     * @return El nombre del director.
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * Establece el nombre del director.
     *
     * @param nombre El nombre del director.
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    /**
     * Obtiene el correo electrónico del director.
     *
     * @return El correo electrónico del director.
     */
    public String getCorreo() {
        return correo;
    }

    /**
     * Establece el correo electrónico del director.
     *
     * @param correo El correo electrónico del director.
     */
    public void setCorreo(String correo) {
        this.correo = correo;
    }

    /**
     * Obtiene la escuela asociada al director.
     *
     * @return La escuela asociada al director.
     */
    public Escuela getEscuela() {
        return escuela;
    }

    /**
     * Establece la escuela asociada al director.
     *
     * @param escuela La escuela asociada al director.
     */
    public void setEscuela(Escuela escuela) {
        this.escuela = escuela;
    }

    /**
     * Devuelve una representación en cadena de texto del objeto Director.
     *
     * @return Una cadena que representa al director, incluyendo su ID, nombre y correo.
     */
    @Override
    public String toString() {
        return "\nId=" + id + "\nNombre=" + nombre + "\nCorreo=" + correo;
    }
}

Ejercicio 2

Ejercicio ORM con Hibernate - Entidad Escuela Objetivo: Crear la entidad Escuela y mapearla a la tabla correspondiente en la base de datos utilizando Hibernate. Requisitos: Entidad Escuela: Atributos: id: Clave primaria (autogenerada). nombre: Nombre de la escuela. direccion: Dirección de la escuela. Relación: La entidad Escuela debe tener una relación uno a uno con la entidad Director mediante la anotación @OneToOne. Instrucciones: Implementa la clase Escuela y mapea los atributos a la base de datos utilizando anotaciones de JPA. Configura la relación con la entidad Director usando la anotación @OneToOne y @JoinColumn.

package es.pulsoft.mapeo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;


@Entity
@Table(name = "escuela")
public class Escuela {

    /**
     * Identificador único de la escuela.
     * Este campo es generado automáticamente por la base de datos.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    /**
     * Nombre de la escuela.
     */
    @Column(name = "nombre")
    private String nombre;

    /**
     * Dirección de la escuela.
     */
    @Column(name = "direccion")
    private String direccion;

    /**
     * Relación uno a uno con la entidad Director.
     * Cada escuela tiene un director asociado.
     */
    @OneToOne
    @JoinColumn(name = "director_id", unique = true, nullable = false)
    private Director director;

    /**
     * Constructor por defecto de la clase Escuela.
     * Requerido por JPA.
     */
    public Escuela() {
    }

    /**
     * Constructor que inicializa una escuela con nombre, dirección y director.
     *
     * @param nombre El nombre de la escuela.
     * @param direccion La dirección de la escuela.
     * @param director El director asociado a la escuela.
     */
    public Escuela(String nombre, String direccion, Director director) {
        this.nombre = nombre;
        this.direccion = direccion;
        this.director = director; // Asociamos el director directamente
    }

    /**
     * Obtiene el identificador único de la escuela.
     *
     * @return El identificador de la escuela.
     */
    public int getId() {
        return id;
    }

    /**
     * Establece el identificador único de la escuela.
     *
     * @param id El identificador de la escuela.
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * Obtiene el nombre de la escuela.
     *
     * @return El nombre de la escuela.
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * Establece el nombre de la escuela.
     *
     * @param nombre El nombre de la escuela.
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    /**
     * Obtiene la dirección de la escuela.
     *
     * @return La dirección de la escuela.
     */
    public String getDireccion() {
        return direccion;
    }

    /**
     * Establece la dirección de la escuela.
     *
     * @param direccion La dirección de la escuela.
     */
    public void setDireccion(String direccion) {
        this.direccion = direccion;
    }

    /**
     * Obtiene el director asociado a la escuela.
     *
     * @return El director asociado.
     */
    public Director getDirector() {
        return director;
    }

    /**
     * Establece el director asociado a la escuela.
     *
     * @param director El director asociado a la escuela.
     */
    public void setDirector(Director director) {
        this.director = director;
    }

    /**
     * Devuelve una representación en cadena de texto de la escuela,
     * incluyendo su ID, nombre, dirección y los datos del director asociado.
     *
     * @return Una cadena que representa la escuela y su director.
     */
    @Override
    public String toString() {
        return "Id=" + id + "\nNombre=" + nombre + "\nDireccion=" + direccion + "\nDatos del Director: " + director;
    }
}

Ejercicio 3

Enunciado del ejercicio ORM con Hibernate - Entidad Estudiante Objetivo: Crear la entidad Estudiante y mapearla a la tabla correspondiente en la base de datos utilizando Hibernate. Esta entidad representará a un estudiante, con información sobre su nombre y edad. Requisitos: Entidad Estudiante: Atributos: id: Clave primaria autogenerada. nombre: Nombre del estudiante. edad: Edad del estudiante. Operaciones: La clase debe estar mapeada a la tabla estudiante de la base de datos. Implementar un constructor por defecto y otro que permita inicializar el nombre y la edad del estudiante. Implementar los métodos getter y setter para los atributos id, nombre y edad. Representación del Estudiante: Sobrescribir el método toString() para que devuelva una cadena que contenga el id, nombre y edad del estudiante. Instrucciones: Implementa la clase Estudiante con los atributos mencionados y mapea los datos a la base de datos utilizando anotaciones de JPA. Asegúrate de incluir el constructor por defecto y el constructor con parámetros. Añade los métodos getter y setter necesarios y sobrescribe el método toString() para representar adecuadamente al estudiante. Notas: Utiliza las anotaciones de Hibernate para mapear los atributos a las columnas de la base de datos. Asegúrate de que la clase esté correctamente anotada como entidad con @Entity y que esté mapeada a la tabla estudiante.

package es.pulsoft.mapeo;

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


@Entity
@Table(name = "estudiante")
public class Estudiante {

    /**
     * Identificador único del estudiante.
     * Este campo es generado automáticamente por la base de datos.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    /**
     * Nombre del estudiante.
     */
    @Column(name = "nombre")
    private String nombre;
    
    /**
     * Edad del estudiante.
     */
    @Column(name = "edad")
    private int edad;

    /**
     * Constructor por defecto de la clase Estudiante.
     * Requerido por JPA.
     */
    public Estudiante() {
    }

    /**
     * Constructor que inicializa un estudiante con nombre y edad.
     *
     * @param nombre El nombre del estudiante.
     * @param edad La edad del estudiante.
     */
    public Estudiante(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    /**
     * Obtiene el identificador único del estudiante.
     *
     * @return El identificador del estudiante.
     */
    public int getId() {
        return id;
    }

    /**
     * Establece el identificador único del estudiante.
     *
     * @param id El identificador del estudiante.
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * Obtiene el nombre del estudiante.
     *
     * @return El nombre del estudiante.
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * Establece el nombre del estudiante.
     *
     * @param nombre El nombre del estudiante.
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    /**
     * Obtiene la edad del estudiante.
     *
     * @return La edad del estudiante.
     */
    public int getEdad() {
        return edad;
    }

    /**
     * Establece la edad del estudiante.
     *
     * @param edad La edad del estudiante.
     */
    public void setEdad(int edad) {
        this.edad = edad;
    }

    /**
     * Devuelve una representación en cadena de texto del objeto Estudiante.
     *
     * @return Una cadena que representa al estudiante, incluyendo su ID, nombre y edad.
     */
    @Override
    public String toString() {
        return "Estudiante \nId=" + id + "\nNombre=" + nombre + "\nEdad=" + edad;
    }
}

Ejercicio 4

Enunciado: Gestión de Cursos en una Escuela Desarrolla una entidad Curso que represente los cursos de una escuela. La entidad debe estar mapeada a la tabla curso en la base de datos. Los atributos de la entidad deben incluir: id: Un identificador único para el curso, generado automáticamente. nombre: El nombre del curso (debe ser único dentro de una misma escuela). escuela: Una relación muchos a uno con la entidad Escuela, que indica a qué escuela pertenece el curso. La tabla curso debe tener una restricción de unicidad que asegure que la combinación de nombre y escuela_id sea única, es decir, no puede haber dos cursos con el mismo nombre en la misma escuela. Además, implementa los métodos necesarios para acceder y modificar los atributos de la clase (getters y setters), y sobrecarga el método toString para mostrar la información relevante de un curso, incluyendo el nombre y los datos de la escuela asociada.

package es.pulsoft.mapeo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;


@Entity
@Table(
    name = "curso",
    uniqueConstraints = {
        @UniqueConstraint(name = "UK_nombre_escuela", columnNames = {"nombre", "escuela_id"})
    }
)
public class Curso {

    /**
     * Identificador único del curso.
     * Este campo es generado automáticamente por la base de datos.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    /**
     * Nombre del curso.
     */
    @Column(name = "nombre")
    private String nombre;

    /**
     * Relación muchos a uno con la entidad Escuela.
     * Un curso está asociado a una escuela específica.
     */
    @ManyToOne
    @JoinColumn(name = "escuela_id", nullable = false)
    private Escuela escuela;

    /**
     * Constructor por defecto de la clase Curso.
     * Requerido por JPA.
     */
    public Curso() {

    }

    /**
     * Constructor que inicializa un curso con nombre y escuela.
     *
     * @param nombre Nombre del curso.
     * @param escuela Escuela asociada al curso.
     */
    public Curso(String nombre, Escuela escuela) {
        this.nombre = nombre;
        this.escuela = escuela;
    }

    /**
     * Obtiene el identificador único del curso.
     *
     * @return El identificador del curso.
     */
    public int getId() {
        return id;
    }

    /**
     * Establece el identificador único del curso.
     *
     * @param id El identificador del curso.
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * Obtiene el nombre del curso.
     *
     * @return El nombre del curso.
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * Establece el nombre del curso.
     *
     * @param nombre El nombre del curso.
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    /**
     * Obtiene la escuela asociada al curso.
     *
     * @return La escuela asociada al curso.
     */
    public Escuela getEscuela() {
        return escuela;
    }

    /**
     * Establece la escuela asociada al curso.
     *
     * @param escuela La escuela asociada al curso.
     */
    public void setEscuela(Escuela escuela) {
        this.escuela = escuela;
    }

    /**
     * Devuelve una representación en cadena de texto del objeto Curso.
     * Incluye el ID del curso, su nombre y los datos de la escuela asociada.
     *
     * @return Una cadena que representa al curso.
     */
    @Override
    public String toString() {
        return "Id=" + id + "\nNombre=" + nombre + "\nDatos Escuela=" + escuela;
    }
}

Ejercicio 5

Enunciado: Relación Estudiante-Curso Crea una clase CursoEstudiante que mapea la relación muchos a muchos entre Estudiante y Curso, representando la inscripción de un estudiante en un curso. La clase debe contener: Atributos: estudiante_id: Relación ManyToOne con la entidad Estudiante. curso_id: Relación ManyToOne con la entidad Curso. fecha_inscripcion: Fecha de inscripción del estudiante en el curso. La clave primaria debe ser compuesta por estudiante_id y curso_id. La tabla resultante será curso_estudiante, con las columnas estudiante_id, curso_id y fecha_inscripcion.

package es.pulsoft.mapeo;

import java.time.LocalDate;
import javax.persistence.*;


@Entity
@Table(name = "curso_estudiante")
@IdClass(CursoEstudianteId.class)  // Se usa una clave compuesta con la clase CursoEstudianteId
public class CursoEstudiante {

    /**
     * Identificador del estudiante que se inscribe en un curso.
     * Este campo está asociado con la clave primaria de la entidad Estudiante.
     * Se define como parte de la clave primaria compuesta.
     */
    @Id
    @ManyToOne
    @JoinColumn(name = "estudiante_id", nullable = false)
    private Estudiante estudiante;

    /**
     * Identificador del curso al que el estudiante se inscribe.
     * Este campo está asociado con la clave primaria de la entidad Curso.
     * Se define como parte de la clave primaria compuesta.
     */
    @Id
    @ManyToOne
    @JoinColumn(name = "curso_id", nullable = false)
    private Curso curso;

    /**
     * Fecha de inscripción del estudiante al curso.
     * Este campo almacena la fecha en que el estudiante se inscribe al curso.
     */
    @Column(name = "fecha_inscripcion")
    private LocalDate fechaInscripcion;

    /**
     * Constructor por defecto de la clase CursoEstudiante.
     * Requerido por JPA.
     */
    public CursoEstudiante() {
    }

    /**
     * Constructor que inicializa un curso de estudiante con los datos proporcionados.
     *
     * @param estudiante      El estudiante que se inscribe en el curso.
     * @param curso          El curso en el que el estudiante se inscribe.
     * @param fechaInscripcion La fecha en la que el estudiante se inscribe al curso.
     */
    public CursoEstudiante(Estudiante estudiante, Curso curso, LocalDate fechaInscripcion) {
        this.estudiante = estudiante;
        this.curso = curso;
        this.fechaInscripcion = fechaInscripcion;
    }

    // Métodos getters y setters

    /**
     * Obtiene el estudiante asociado a esta inscripción.
     *
     * @return El estudiante inscrito.
     */
    public Estudiante getEstudiante() {
        return estudiante;
    }

    /**
     * Establece el estudiante asociado a esta inscripción.
     *
     * @param estudiante El estudiante a asignar.
     */
    public void setEstudiante(Estudiante estudiante) {
        this.estudiante = estudiante;
    }

    /**
     * Obtiene el curso asociado a esta inscripción.
     *
     * @return El curso al que el estudiante está inscrito.
     */
    public Curso getCurso() {
        return curso;
    }

    /**
     * Establece el curso asociado a esta inscripción.
     *
     * @param curso El curso al que inscribir al estudiante.
     */
    public void setCurso(Curso curso) {
        this.curso = curso;
    }

    /**
     * Obtiene la fecha de inscripción del estudiante en el curso.
     *
     * @return La fecha en la que el estudiante se inscribió al curso.
     */
    public LocalDate getFechaInscripcion() {
        return fechaInscripcion;
    }

    /**
     * Establece la fecha de inscripción del estudiante en el curso.
     *
     * @param fechaInscripcion La fecha de inscripción.
     */
    public void setFechaInscripcion(LocalDate fechaInscripcion) {
        this.fechaInscripcion = fechaInscripcion;
    }

    /**
     * Devuelve una representación en cadena de texto del objeto CursoEstudiante,
     * mostrando los datos del estudiante, curso y la fecha de inscripción.
     *
     * @return Una cadena que representa la inscripción del estudiante en el curso.
     */
    @Override
    public String toString() {
        return "CursoEstudiante Estudiante" + estudiante + "\nCurso" + curso + "\nFecha Inscripcion="
                + fechaInscripcion;
    }
}

Ejercicio 6

Enunciado: Se requiere implementar una clase CursoEstudianteId que sirva como clave primaria compuesta para una tabla puente que relaciona las entidades Estudiante y Curso. Esta clase debe contener dos atributos: el identificador del estudiante y el identificador del curso, ambos como enteros. Además, la clase debe implementar los métodos equals y hashCode para asegurar el correcto funcionamiento en estructuras de datos como mapas o conjuntos.

package es.pulsoft.mapeo;

import java.io.Serializable;


public class CursoEstudianteId implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * Identificador del estudiante. Representa la relación con la entidad `Estudiante`.
     */
    private int estudiante;

    /**
     * Identificador del curso. Representa la relación con la entidad `Curso`.
     */
    private int curso;

    /**
     * Constructor por defecto.
     * Inicializa los campos con los valores predeterminados.
     */
    public CursoEstudianteId() {
    }

    /**
     * Constructor con parámetros.
     * Inicializa la clave compuesta con los identificadores del estudiante y el curso.
     * 
     * @param idCurso El identificador del curso.
     * @param idEstudiante El identificador del estudiante.
     */
    public CursoEstudianteId(int idCurso, int idEstudiante) {
        this.curso = idCurso;
        this.estudiante = idEstudiante;
    }

    /**
     * Obtiene el identificador del estudiante.
     * 
     * @return El identificador del estudiante.
     */
    public int getEstudiante() {
        return estudiante;
    }

    /**
     * Establece el identificador del estudiante.
     * 
     * @param estudiante El identificador del estudiante.
     */
    public void setEstudiante(int estudiante) {
        this.estudiante = estudiante;
    }

    /**
     * Obtiene el identificador del curso.
     * 
     * @return El identificador del curso.
     */
    public int getCurso() {
        return curso;
    }

    /**
     * Establece el identificador del curso.
     * 
     * @param curso El identificador del curso.
     */
    public void setCurso(int curso) {
        this.curso = curso;
    }

    /**
     * Método `equals` para comparar dos instancias de `CursoEstudianteId`.
     * Dos objetos son iguales si ambos identificadores (estudiante y curso) son iguales.
     * 
     * @param o El objeto con el que se va a comparar.
     * @return `true` si ambos objetos son iguales, `false` en caso contrario.
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CursoEstudianteId that = (CursoEstudianteId) o;
        return estudiante == that.estudiante && curso == that.curso;
    }

    /**
     * Método `hashCode` que genera un código hash basado en los identificadores del estudiante y del curso.
     * 
     * @return El código hash calculado para esta clave primaria compuesta.
     */
    @Override
    public int hashCode() {
        return 31 * estudiante + curso;
    }
}

Operaciones CRUD para Director

Ejercicio 7

Enunciado: Esta clase permite agregar un director a la base de datos utilizando Hibernate. Se solicita al usuario el nombre y correo del director, y se valida dicha información antes de almacenarla. Si ocurre algún error durante la operación de inserción, se maneja mediante transacciones de Hibernate y se asegura que la sesión se cierre adecuadamente.

package es.pulsoft.director;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Director;
import es.pulsoft.validaciones.Validacion;


public class AgregarDirector {

    /*
     * Agrega un director a la base de datos.
     * 
     * Este método solicita al usuario que ingrese el nombre y correo del director,
     * valida los datos proporcionados, y luego crea un objeto Director para guardarlo en la base de datos.
     * Si se produce algún error, la transacción es revertida y se imprime el error en consola.
     * Finalmente, se cierra la sesión de Hibernate.
     * 
     * @param entrada El objeto Scanner utilizado para leer la entrada del usuario.
     * @param sessionFactory El objeto SessionFactory para obtener la sesión de Hibernate.
     */
    public void agregarDirector(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Se abre una sesión para interactuar con la base de datos */
        Session session = sessionFactory.openSession();
        
        /* Comienza la transacción */
        session.beginTransaction();
        
        /* Finaliza la transacción (esto es innecesario y se eliminó en la mejora del código) */
        session.getTransaction().commit();
        
        try {
            /* Crear instancia de validación */
            Validacion validacion = new Validacion();
            
            /* Solicitar al usuario que ingrese el nombre y correo del director */
            String nombre = validacion.campoTexto(entrada, "nombre", "director");
            String correo = "";
            
            while (true) {
                correo = validacion.campoTexto(entrada, "correo", "director");
                
                if (validacion.esEmailValido(correo)) {
                    break;
                } else {
                    System.out.println("No es un correo válido, introdúcelo de nuevo");
                }
            }
            
            /* Crear un objeto Director con los datos proporcionados */
            Director director = new Director(nombre, correo);
            
            /* Inicia una nueva transacción para guardar el director */
            session.beginTransaction();
            
            /* Guarda el objeto director en la base de datos */
            session.save(director);
            
            /* Confirma la transacción */
            session.getTransaction().commit();
            
            /* Imprime mensaje de éxito */
            System.out.println("Director agregado a la BBDD correctamente");
        } catch (Exception e) {
            /* En caso de error, muestra el mensaje de error y la traza de la excepción */
            System.err.println("Error al agregar al director:");
            e.printStackTrace();
            
            /* Si la transacción está activa, la revierte */
            if (session.getTransaction() != null) {
                session.getTransaction().rollback();
            }
        } finally {
            /* Cierra la sesión de Hibernate si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 8

Ejercicio: Actualizar Director en la Base de Datos Descripción: Implementa un método para actualizar los datos de un director en la base de datos utilizando Hibernate. El usuario ingresará el ID del director a modificar y podrá cambiar su nombre y correo. Antes de actualizar, se validará que el correo tenga un formato válido. Si ocurre un error, la transacción se debe revertir para mantener la consistencia de los datos. Requisitos: - Solicitar el ID del director y verificar que exista en la base de datos. - Permitir la actualización del nombre y correo, validando este último. - Usar Hibernate para manejar la transacción y asegurar la persistencia de los cambios.


package es.pulsoft.director;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Director;
import es.pulsoft.validaciones.Validacion;

public class ActualizarDirector {

    /*
     * Método para actualizar la información de un director en la base de datos.
     * 
     * @param entrada Scanner para leer la entrada del usuario.
     * @param sessionFactory SessionFactory de Hibernate para gestionar la sesión.
     */
    public void actualizarDirector(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Abrir una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        Validacion valido = new Validacion();
        MostrarDirector view = new MostrarDirector();
        view.mostrarDirectores(sessionFactory);
        
        /* Solicitar el ID del director a actualizar */
        int idDirector = valido.campoEntero(entrada, "id", "director");
        
        /* Obtener el director de la base de datos */
        Director director = session.get(Director.class, idDirector);
        
        /* Verificar si el director existe */
        if (director == null) {
            System.out.println("No hay ningún director con ese id");
        } else {
            /* Mostrar los datos actuales del director */
            System.out.println("Datos actuales del director");
            System.out.println(director);
            
            /* Solicitar el nuevo nombre del director */
            String nombre = valido.campoTexto(entrada, "nombre", "director");
            String correo = "";
            
            /* Validar el correo electrónico */
            while (true) {
                correo = valido.campoTexto(entrada, "correo", "director");
                
                /* Asegurar que el correo sea válido */
                if (valido.esEmailValido(correo)) {
                    break;
                } else {
                    System.out.println("No es un correo válido, introdúcelo de nuevo");
                }
            }
            
            /* Actualizar los datos del director */
            director.setNombre(nombre);
            director.setCorreo(correo);
            
            /* Realizar la actualización en la base de datos */
            try {
                session.beginTransaction();
                
                /* Ejecutar la consulta de actualización */
                session.createQuery("update Director set nombre=:nombre, correo=:correo where id=:id")
                    .setParameter("nombre", director.getNombre())
                    .setParameter("correo", director.getCorreo())
                    .setParameter("id", director.getId())
                    .executeUpdate();
                
                /* Confirmar la transacción */
                session.getTransaction().commit();
                System.out.println("Director actualizado correctamente");
            } catch (Exception e) {
                /* Si ocurre un error, imprimir la traza y revertir la transacción */
                System.err.println("Error al actualizar al director:");
                e.printStackTrace();
                
                if (session.getTransaction() != null) {
                    session.getTransaction().rollback();
                }
            } finally {
                /* Cerrar la sesión de Hibernate */
                if (session.isOpen()) {
                    session.close();
                }
            }
        }
    }
}

Ejercicio 9

EJERCICIO: Implementar un método en Java utilizando Hibernate que permita borrar un director de la base de datos mediante su ID. Se debe solicitar al usuario el ID del director, verificar su existencia en la base de datos y confirmar la eliminación antes de proceder. En caso de error, se debe manejar la excepción adecuadamente y realizar rollback de la transacción. La eliminación debe realizarse utilizando Hibernate y una sesión de base de datos. NOTA: Si el director no existe, se debe informar al usuario sin realizar cambios en la base de datos. Si el usuario cancela la eliminación, el programa debe mostrar un mensaje indicando que la operación se abortó.

package es.pulsoft.director;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Director;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que permite borrar un director de la base de datos mediante su ID.
 * Se utiliza Hibernate para gestionar la transacción.
 */
public class BorrarDirector {

    /**
     * Método para borrar un director de la base de datos.
     * 
     * @param entrada Scanner para la entrada de datos del usuario.
     * @param sessionFactory SessionFactory de Hibernate para gestionar la conexión con la base de datos.
     */
    public void borrarDirector(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Abrir una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();

        /* Crear una instancia de Validacion para gestionar entradas del usuario */
        Validacion valido = new Validacion();
        
        MostrarDirector view = new MostrarDirector();
        view.mostrarDirectores(sessionFactory);
        
        /* Solicitar el ID del director al usuario */
        int idDirector = valido.campoEntero(entrada, "id", "director");

        /* Buscar el director en la base de datos por su ID */
        Director director = session.get(Director.class, idDirector);

        if (director == null) {
            /* Si el director no existe, mostrar un mensaje al usuario */
            System.out.println("El ID no corresponde a ningún director en la base de datos.");
        } else {
            /* Mostrar los datos del director encontrado */
            System.out.println("Datos del director a borrar:");
            System.out.println(director);

            /* Confirmar si el usuario realmente desea eliminar al director */
            boolean confirmacion = valido.confirmacion(entrada, "director");
            if (confirmacion) {
                try {
                    /* Iniciar la transacción */
                    session.beginTransaction();
                    
                    /* Eliminar el director de la base de datos */
                    session.delete(director);
                    
                    /* Confirmar la transacción */
                    session.getTransaction().commit();
                    
                    System.out.println("Director borrado correctamente.");
                } catch (Exception e) {
                    /* Manejo de errores: imprimir la traza del error y realizar rollback */
                    System.err.println("Error al borrar al director:");
                    e.printStackTrace();
                    
                    if (session.getTransaction() != null) {
                        session.getTransaction().rollback();
                    }
                } finally {
                    /* Cerrar la sesión de Hibernate */
                    if (session.isOpen()) {
                        session.close();
                    }
                }
            } else {
                System.out.println("Operación de borrado del director abortada.");
            }
        }
    }
}

Ejercicio 10

EJERCICIO: Implementar un método en Java que permita listar todos los directores almacenados en una base de datos utilizando Hibernate. Si no hay directores en la base de datos, se debe notificar al usuario. Requisitos: - Usar Hibernate para la gestión de la base de datos. - No iniciar una transacción, ya que solo se realizará una consulta SELECT. - Manejar posibles excepciones y cerrar la sesión de Hibernate correctamente.

Ejercicio 11

Clase que permite buscar directores en una base de datos por un campo específico (nombre o correo). Ejercicio: Buscar Directores en una base de datos. Desarrolla un programa en Java que permita buscar directores en una base de datos a partir de un campo especificado, como el nombre o el correo. El usuario debe poder ingresar el valor de búsqueda, y el sistema devolverá una lista de directores cuyos campos coincidan con el valor ingresado, utilizando una consulta en Hibernate. Requisitos: - El programa debe permitir al usuario ingresar el valor de búsqueda para el campo seleccionado (nombre o correo). - El valor de búsqueda debe ser procesado con un patrón que busque coincidencias que empiecen con el valor ingresado. - Los resultados de la consulta deben ser mostrados al usuario. Si no se encuentran coincidencias, debe mostrarse un mensaje informando al usuario.

package es.pulsoft.director;

import java.util.List;
import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.mapeo.Director;
import es.pulsoft.validaciones.Validacion;


public class BuscarDirector {

    /**
     * Método para buscar directores en la base de datos por un campo específico (nombre o correo).
     * El patrón de búsqueda se construye concatenando el valor ingresado por el usuario con el comodín '%'.
     *
     * @param entrada Scanner para obtener la entrada del usuario.
     * @param sessionFactory SessionFactory para gestionar las sesiones de Hibernate.
     * @param campo El campo por el que se realizará la búsqueda (puede ser "nombre" o "correo").
     */
    public void buscarDirector(Scanner entrada, SessionFactory sessionFactory, String campo) {

        /* Crear una instancia de la clase Validacion para validar el campo ingresado. */
        Validacion valido = new Validacion();

        /* Obtener el valor del patrón de búsqueda del usuario, se obtiene mediante la validación. */
        String patron = valido.campoTexto(entrada, campo, "director");
        
        /* Concatenar el comodín '%' al final del patrón de búsqueda para hacer que busque coincidencias parciales. */
        patron += "%";

        /* Abrir una sesión de Hibernate para interactuar con la base de datos. */
        Session session = sessionFactory.openSession();
        List<Director> listaDirectores = null;

        try {
            /* Realizamos la consulta dependiendo del campo seleccionado (nombre o correo). */
            switch (campo) {
                case "nombre":
                    /* Consultamos por el nombre del director. */
                    listaDirectores = session.createQuery("from Director where nombre like :patron", Director.class)
                            .setParameter("patron", patron)
                            .getResultList();
                    break;
                case "correo":
                    /* Consultamos por el correo del director. */
                    listaDirectores = session.createQuery("from Director where correo like :patron", Director.class)
                            .setParameter("patron", patron)
                            .getResultList();
                    break;
                default:
                    /* Si el campo no es válido, se lanza una excepción. */
                    throw new IllegalArgumentException("Campo no válido para la búsqueda.");
            }

            /* Si la lista de directores está vacía, mostramos un mensaje indicando que no se encontró ningún director. */
            if (listaDirectores.isEmpty()) {
                System.out.println("No hay ningún director que coincida con tu búsqueda.");
            } else {
                /* Si hay resultados, mostramos la lista de directores. */
                System.out.println("Lista de directores cuyo " + campo + " coincida con '" + patron + "':");
                System.out.println(String.format("%5s %25s %25s",
                        "ID", "NOMBRE", "CORREO"));

                for (Director director : listaDirectores) {
                    System.out.println(String.format("%5d %25s %25s",
                            director.getId(),
                            director.getNombre(),
                            director.getCorreo()));
                }
            }

        } catch (Exception e) {
            /* Manejo de errores en caso de fallo en la consulta */
            System.err.println("Error al listar los directores:");
            e.printStackTrace();
        } finally {
            /* Cerrar la sesión de Hibernate para liberar recursos */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Operaciones CRUD para Escuela

Ejercicio 12

Enunciado del ejercicio: Este ejercicio tiene como objetivo implementar un método que permita agregar una nueva escuela a la base de datos utilizando Hibernate. El sistema debe validar que el director proporcionado exista en la base de datos y no esté asignado a otra escuela. Si el director es válido y no está asignado a otra escuela, se agrega la escuela con el director correspondiente. Si el director ya está asignado, se mostrará un mensaje informando al usuario.

package es.pulsoft.escuela;

import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.director.MostrarDirector;
import es.pulsoft.mapeo.Director;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.validaciones.Validacion;

public class AgregarEscuela {

    

    /**
     * Método que agrega una nueva escuela a la base de datos.
     * 
     * @param entrada El objeto Scanner para leer los datos de entrada del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate para interactuar con la base de datos.
     */
    public void agregarEscuela(Scanner entrada, SessionFactory sessionFactory) {
        
        /** Abrir una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        /** Iniciar la transacción */
        session.beginTransaction();
        
        /** Confirmar la transacción (se realiza una operación de commit vacía, se movería más tarde si es necesario) */
        session.getTransaction().commit();
        
        try {
            
            /** Crear una instancia de la clase de validaciones */
            Validacion validacion = new Validacion();
            
            /** Validar el nombre de la escuela */
            String nombre = validacion.campoTexto(entrada, "nombre", "escuela");
            
            /** Validar la dirección de la escuela */
            String direccion = validacion.campoTexto(entrada, "direccion", "escuela");
            
            MostrarDirector view = new MostrarDirector();
            view.mostrarDirectores(sessionFactory);
            
            /** Validar el ID del director y obtener el director de la base de datos */
            int idDirector = validacion.campoEntero(entrada, "id", "director");
            Director director = session.get(Director.class, idDirector);
            
            /** Si el director no existe, mostrar un mensaje de error */
            if (director == null) {
                System.out.println("El id no corresponde con ningun director dado de alta");
            } else {
                /** Crear una nueva escuela con los datos proporcionados */
                Escuela escuela = new Escuela(nombre, direccion, director);
                
                /** Verificar si el director ya tiene asignada una escuela */
                if (comprueboDirector(escuela, session)) {
                    /** Iniciar una nueva transacción para guardar la escuela */
                    session.beginTransaction();
                    
                    /** Guardar la nueva escuela en la base de datos */
                    session.save(escuela);
                    
                    /** Confirmar la transacción */
                    session.getTransaction().commit();
                    
                    /** Imprimir mensaje de éxito */
                    System.out.println("Escuela agregada a la BBDD correctamente");
                }
            }
            
        } catch (Exception e) {
            /** Controlar otras excepciones generales */
            System.err.println("Error inesperado al ejecutar la consulta:");
            e.printStackTrace();
        } finally {
            /** Asegúrate de cerrar la sesión de Hibernate */
            if (session != null && session.isOpen()) {
                session.close();
            }
        }
    }

    /**
     * Método que verifica si el director ya está asignado a otra escuela.
     * 
     * @param escuela La escuela que se está intentando agregar.
     * @param session La sesión de Hibernate.
     * @return true si el director no tiene otra escuela asignada, false en caso contrario.
     */
    private boolean comprueboDirector(Escuela escuela, Session session) {
        /** Obtener el director de la base de datos utilizando su ID */
        Director directorExistente = session.get(Director.class, escuela.getDirector().getId());
        
        /** Verificar si el director ya tiene asignada una escuela */
        if (directorExistente != null && directorExistente.getEscuela() != null) {
            /** Si el director ya tiene una escuela asignada, mostrar mensaje y devolver false */
            System.out.println("Este director ya está asignado a otra escuela.");
            return false; /** El director ya tiene escuela asignada */
        } else {
            /** Si el director no tiene escuela asignada, devolver true */
            return true;
        }
    }
}

Ejercicio 13

Enunciado del ejercicio: Este ejercicio tiene como objetivo implementar un método que permita actualizar los datos de una escuela en la base de datos, incluyendo su nombre, dirección y director. El sistema debe verificar que el director no esté asignado a otra escuela antes de realizar la actualización. Si el director ya está asignado a otra escuela, no se permitirá la actualización. Si el director es válido, se actualizan los datos de la escuela.


package es.pulsoft.escuela;

import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.mapeo.Director;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.validaciones.Validacion;

public class ActualizarEscuela {

    /**
     * Método que actualiza los datos de una escuela en la base de datos.
     * 
     * @param entrada El objeto Scanner para leer los datos de entrada del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate para interactuar con la base de datos.
     */
    public void actualizarEscuela(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Abrir una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        /* Crear una instancia de la clase de validaciones */
        Validacion valido = new Validacion();
        
        /* Solicitar el ID de la escuela a actualizar */
        int idEscuela = valido.campoEntero(entrada, "id", "escuela");
        
        /* Obtener la escuela de la base de datos */
        Escuela escuela = session.get(Escuela.class, idEscuela);
        
        if (escuela == null) {
            /* Si la escuela no existe, mostrar un mensaje */
            System.out.println("No hay ninguna escuela con ese id");
        } else {
            
            /* Mostrar los datos actuales de la escuela */
            System.out.println("Datos actuales de la escuela");
            System.out.println(escuela);
            
            /* Solicitar los nuevos datos para la escuela */
            String nombre = valido.campoTexto(entrada, "nombre", "escuela");
            String direccion = valido.campoTexto(entrada, "direccion", "escuela");
            
            /* Solicitar el ID del director */
            int idDirector = valido.campoEntero(entrada, "id", "director");
            
            /* Obtener el director de la base de datos */
            Director director = session.get(Director.class, idDirector);
            
            if (director != null) {
                /* Si el director existe, actualizar los datos de la escuela */
                escuela.setNombre(nombre);
                escuela.setDireccion(direccion);
                escuela.setDirector(director);
                
                try {
                    /* Verificar si el director ya está asignado a otra escuela */
                    if (comprueboDirector(escuela, session)) {
                        /* Iniciar una transacción */
                        session.beginTransaction();
                        
                        /* Guardar o actualizar la escuela en la base de datos */
                        session.saveOrUpdate(escuela);
                        
                        /* Confirmar la transacción */
                        session.getTransaction().commit();
                        
                        /* Imprimir mensaje de éxito */
                        System.out.println("Escuela actualizada correctamente");
                    } else {
                        /* Si el director ya está asignado a otra escuela, no actualizar */
                        System.out.println("El director ya tiene una escuela asignada, no se actualizará");
                    }
                    
                } catch (Exception e) {
                    /* Manejo de excepciones */
                    System.err.println("Error al actualizar la escuela:");
                    e.printStackTrace();
                    
                    /* Deshacer la transacción si ocurre un error */
                    if (session.getTransaction() != null) {
                        session.getTransaction().rollback();
                    }
                } finally {
                    /* Asegurarse de cerrar la sesión */
                    if (session.isOpen()) {
                        session.close();
                    }
                }
            } else {
                /* Si el director no existe, mostrar un mensaje */
                System.out.println("Ningún director dado de alta con ese id, no se actualizará la escuela");
            }
        }
    }

    /**
     * Método que verifica si el director ya está asignado a otra escuela.
     * 
     * @param escuela La escuela que se está intentando actualizar.
     * @param session La sesión de Hibernate.
     * @return true si el director no tiene otra escuela asignada, false en caso contrario.
     */
    private boolean comprueboDirector(Escuela escuela, Session session) {
        /* Obtener el director de la base de datos utilizando su ID */
        Director directorExistente = session.get(Director.class, escuela.getDirector().getId());
        
        /* Verificar si el director ya tiene asignada una escuela */
        if (directorExistente != null && directorExistente.getEscuela() != null) {
            /* Si el director ya tiene una escuela asignada, mostrar mensaje y devolver false */
            System.out.println("Este director ya está asignado a otra escuela.");
            return false; /* El director ya tiene escuela asignada */
        } else {
            /* Si el director no tiene escuela asignada, devolver true */
            return true;
        }
    }
}

Ejercicio 14

Enunciado del ejercicio: Este ejercicio tiene como objetivo implementar un sistema para eliminar una escuela de la base de datos. Antes de proceder con la eliminación, se debe asegurar que no existan referencias inconsistentes. La eliminación se debe hacer solo después de que el usuario confirme la acción. Si la escuela tiene un director asignado, se debe desvincular antes de eliminarla para evitar problemas de integridad referencial en la base de datos. Requisitos: - Utiliza Hibernate para gestionar la base de datos. - La clase `Validacion` se utiliza para validar las entradas del usuario. - La eliminación de la escuela solo se realiza si el usuario confirma la acción. - Se debe asegurar que el director se desvincule correctamente antes de eliminar la escuela.

package es.pulsoft.escuela;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que gestiona la eliminación de una escuela en la base de datos utilizando Hibernate.
 * Antes de eliminar la escuela, verifica si tiene un director asociado y lo desvincula 
 * para evitar problemas de integridad referencial.
 */
public class BorrarEscuela {

    /**
     * Método que permite eliminar una escuela de la base de datos.
     * Se solicita al usuario el ID de la escuela, se muestra su información 
     * y se requiere confirmación antes de proceder con la eliminación.
     *
     * @param entrada         Scanner para la entrada de datos del usuario.
     * @param sessionFactory  SessionFactory para gestionar la sesión con Hibernate.
     */
    public void borrarEscuela(Scanner entrada, SessionFactory sessionFactory) {
        /** Se abre una sesión con la base de datos */
        Session session = sessionFactory.openSession();
        Validacion valido = new Validacion();

        /** Se muestra la información de las escuelas */
        MostrarEscuela view = new MostrarEscuela();
        view.mostrarEscuela(sessionFactory);

        /** Se solicita al usuario el ID de la escuela a eliminar */
        int idEscuela = valido.campoEntero(entrada, "id", "escuela");

        /** Se busca la escuela en la base de datos */
        Escuela escuela = session.get(Escuela.class, idEscuela);

        /** Si la escuela existe, se procede con la eliminación */
        if (escuela != null) {
            /** Muestra los datos de la escuela a eliminar */
            System.out.println("Datos de la escuela a borrar:");
            System.out.println(escuela);

            /** Se solicita confirmación al usuario para proceder con la eliminación */
            boolean confirmacion = valido.confirmacion(entrada, "escuela");

            if (confirmacion) {
                try {
                    /** Inicia una transacción de Hibernate */
                    session.beginTransaction();

                    /** Verifica si la escuela tiene un director asociado */
                    if (escuela.getDirector() != null) {
                        /** Desvincula al director de la escuela antes de eliminarla */
                        escuela.getDirector().setEscuela(null);
                        escuela.setDirector(null);
                        /** Guarda los cambios en la base de datos */
                        session.update(escuela); 
                        /** Muestra mensaje informando que se liberó al director */
                        System.out.println("Se liberó al director de la escuela.");
                    }

                    /** Elimina la escuela de la base de datos */
                    session.delete(escuela);
                    /** Confirma la transacción de Hibernate */
                    session.getTransaction().commit();

                    /** Muestra mensaje de confirmación */
                    System.out.println("Escuela borrada correctamente.");
                } catch (Exception e) {
                    /** Si ocurre un error, se imprime un mensaje de error */
                    System.err.println("Error al borrar la escuela:");
                    e.printStackTrace();

                    /** Revierte la transacción en caso de error */
                    if (session.getTransaction() != null) {
                        session.getTransaction().rollback();
                    }
                } finally {
                    /** Asegura que la sesión se cierre para liberar recursos */
                    if (session.isOpen()) {
                        session.close();
                    }
                }
            } else {
                /** Si el usuario no confirma la eliminación, muestra mensaje de cancelación */
                System.out.println("Operación de borrado de escuela abortada.");
            }
        } else {
            /** Si no se encuentra la escuela en la base de datos, se informa al usuario */
            System.out.println("El ID no corresponde a ninguna escuela en la base de datos.");
        }
    }
}

Ejercicio 15

Ejercicio: Visualización de Escuelas con Hibernate Objetivo: Crear un programa que permita mostrar la lista de escuelas almacenadas en la base de datos. Para ello, deberás utilizar Hibernate para realizar la consulta a la base de datos y mostrar la información de cada escuela. Descripción: En este ejercicio se requiere implementar una clase que, al ejecutarse, se conecte a una base de datos utilizando Hibernate y recupere todas las escuelas almacenadas en la tabla Escuela. Posteriormente, deberá mostrar la información de cada escuela por consola. Si no hay escuelas registradas en la base de datos, deberá informarlo al usuario. Requisitos: Conexión a la base de datos: Utilizar Hibernate para establecer la conexión a la base de datos. Obtener la lista de todas las escuelas almacenadas en la base de datos utilizando la consulta from Escuela. Visualización de los resultados: Si la lista de escuelas está vacía, deberá mostrarse el mensaje: "No hay escuelas dadas de alta aún en la BBDD". Si hay escuelas registradas, deberás imprimir la información de cada una. La representación de las escuelas debe ser la proporcionada por el método toString() de la clase Escuela. Manejo de excepciones: Si ocurre un error durante la consulta a la base de datos, deberá mostrarse un mensaje de error detallado en la consola. Cierre de la sesión: Asegúrate de cerrar la sesión de Hibernate al finalizar la operación, sin importar si la operación fue exitosa o no. Instrucciones: Utiliza la clase SessionFactory de Hibernate para abrir una sesión. Asegúrate de manejar correctamente las excepciones que puedan surgir al consultar las escuelas en la base de datos. El código debe estar organizado en un método que muestre las escuelas, siguiendo el ejemplo proporcionado en la clase MostrarEscuela. Consideraciones adicionales: Escuelas en la base de datos: Debes asegurarte de que la tabla Escuela esté correctamente poblada con datos en la base de datos para poder probar el ejercicio. Clase Escuela: La clase Escuela debe tener una implementación del método toString() para que la visualización de la escuela sea clara y detallada en la consola.

package es.pulsoft.escuela;

import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Escuela;



/**
 * Clase que gestiona la visualización de las escuelas almacenadas en la base de datos.
 * Utiliza Hibernate para obtener las escuelas y mostrarlas en la consola.
 */
public class MostrarEscuela {

    /**
     * Muestra la lista de escuelas almacenadas en la base de datos.
     * Si no hay escuelas registradas, se muestra un mensaje indicándolo.
     * Si hay escuelas, se muestra la información de cada una.
     * 
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para abrir la sesión y realizar la consulta.
     */
    public void mostrarEscuela(SessionFactory sessionFactory) {

        /** Abrir sesión de Hibernate */
        Session session = sessionFactory.openSession();

        try {
            /** Obtener la lista de escuelas de la base de datos */
            List<Escuela> listaEscuelas = session.createQuery("from Escuela", Escuela.class).getResultList();

            /** Mostrar el mensaje de la lista de escuelas */
            System.out.println("La lista de escuelas actuales:");
            
            /** Verificar si la lista está vacía */
            if (listaEscuelas.isEmpty()) {
                System.out.println("No hay escuelas dadas de alta aún en la BBDD");
            } else {
                /** Mostrar los encabezados de las columnas */
                System.out.println(String.format("%5s %25s %25s %25s",
                        "ID", "NOMBRE", "DIRECCION", "DIRECTOR"));

                /** Iterar sobre la lista de escuelas y mostrar la información de cada una */
                for (Escuela escuela : listaEscuelas) {
                    System.out.println(String.format("%5d %25s %25s %25s",
                    		escuela.getId(),
                    		escuela.getNombre(),
                            escuela.getDireccion(),
                            escuela.getDirector().getNombre()));
                }
                
            }

        } catch (Exception e) {
            /** Manejo de excepciones en caso de error al consultar las escuelas */
            System.err.println("Error al listar las escuelas:");
            e.printStackTrace();
        } finally {
            /** Cerrar la sesión de Hibernate si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 16

Ejercicio: Implementar búsqueda de escuelas en la base de datos Objetivo: Implementar una funcionalidad para buscar escuelas en la base de datos usando Hibernate. La búsqueda debe poder realizarse sobre el campo nombre o direccion de la entidad Escuela, utilizando un patrón de búsqueda proporcionado por el usuario. Requisitos: Crear un método que permita buscar escuelas basándose en un campo especificado (ya sea nombre o direccion) y un patrón de búsqueda. El patrón de búsqueda debe permitir coincidencias parciales, por lo que debe añadirse un símbolo % al final del patrón. El método debe utilizar Hibernate para consultar la base de datos. El resultado debe mostrar una lista de las escuelas que coinciden con el patrón de búsqueda. Si no se encuentran resultados, debe mostrar un mensaje indicando que no se encontraron escuelas. La búsqueda debe manejar excepciones, mostrando un mensaje adecuado en caso de error. Se deben seguir buenas prácticas en cuanto al manejo de sesiones de Hibernate y validación de la entrada del usuario.

package es.pulsoft.escuela;

import java.util.List;
import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que gestiona la búsqueda de escuelas en la base de datos utilizando Hibernate.
 * Permite buscar por nombre o dirección utilizando un patrón de búsqueda proporcionado por el usuario.
 */
public class BuscarEscuela {

    /**
     * Realiza la búsqueda de escuelas en la base de datos según el campo y patrón proporcionados.
     * El campo de búsqueda puede ser "nombre" o "direccion", y el patrón se utiliza para
     * buscar escuelas cuyo valor de ese campo coincida parcialmente con el patrón.
     * 
     * @param entrada La instancia de Scanner utilizada para leer la entrada del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para abrir la sesión y realizar la consulta.
     * @param campo El campo de búsqueda, puede ser "nombre" o "direccion".
     */
    public void buscarEscuela(Scanner entrada, SessionFactory sessionFactory, String campo) {

        /** Instanciar la clase de validación */
        Validacion valido = new Validacion();

        /** Solicitar al usuario el patrón de búsqueda */
        String patron = valido.campoTexto(entrada, campo, "escuela");

        /** Agregar el símbolo '%' para hacer la búsqueda parcial */
        patron += "%";

        /** Abrir sesión de Hibernate */
        Session session = sessionFactory.openSession();
        List<Escuela> listaEscuelas = null;

        try {
            /** Realizar la consulta según el campo de búsqueda */
            switch (campo) {
                case "nombre":
                    /** Buscar escuelas por nombre */
                    listaEscuelas = session.createQuery("from Escuela where nombre like :patron", Escuela.class)
                            .setParameter("patron", patron)
                            .getResultList();
                    break;
                case "direccion":
                    /** Buscar escuelas por dirección */
                    listaEscuelas = session.createQuery("from Escuela where direccion like :patron", Escuela.class)
                            .setParameter("patron", patron)
                            .getResultList();
                    break;
                default:
                    /** Si el campo no es válido, lanzar una excepción */
                    throw new IllegalArgumentException("Campo no válido para la búsqueda.");
            }

            /** Mostrar los resultados de la búsqueda */
            if (listaEscuelas.isEmpty()) {
                System.out.println("No hay ninguna escuela que coincida con tu búsqueda.");
            } else {
                /** Mostrar las escuelas encontradas */
                System.out.println("Lista de escuelas cuyo " + campo + " coincida con '" + patron + "':");
                System.out.println(String.format("%5s %25s %25s %25s",
                        "ID", "NOMBRE", "DIRECCION", "DIRECTOR"));

                
                for (Escuela escuela : listaEscuelas) {
                    System.out.println(String.format("%5d %25s %25s %25s",
                    		escuela.getId(),
                    		escuela.getNombre(),
                            escuela.getDireccion(),
                            escuela.getDirector().getNombre()));
                }
            }

        } catch (Exception e) {
            /** Manejo de excepciones */
            System.err.println("Error al listar las escuelas:");
            e.printStackTrace();
        } finally {
            /** Cerrar la sesión de Hibernate si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Operaciones CRUD para Curso

Ejercicio 17

Enunciado: Este ejercicio permite agregar un curso a una escuela en la base de datos utilizando Hibernate. El sistema valida que el curso no esté ya asignado a la misma escuela antes de agregarlo. Si el curso ya existe, no se permitirá la inserción. Requisitos: - El curso debe ser único por escuela. - Se debe validar tanto el nombre del curso como el ID de la escuela. - El programa maneja las excepciones de manera adecuada y asegura el cierre de la sesión de Hibernate tras la operación.

package es.pulsoft.curso;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.escuela.MostrarEscuela;
import es.pulsoft.mapeo.Curso;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.validaciones.Validacion;



public class AgregarCurso {

    /*
     * Método principal para agregar un curso a una escuela.
     * Valida que el curso no exista en la misma escuela y maneja las transacciones de Hibernate para guardar el curso.
     *
     * @param entrada Un objeto Scanner para la entrada de datos del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para interactuar con la base de datos.
     */
    public void agregarCurso(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Inicia una nueva sesión con la fábrica de sesiones */
        Session session = sessionFactory.openSession();

        try {
            /* Crea un objeto de validación para obtener los datos del usuario */
            Validacion validacion = new Validacion();
            
            /* Solicita el nombre del curso */
            String nombre = validacion.campoTexto(entrada, "nombre", "curso");
            
            /* Muestra la lista de escuelas para seleccionar una */
            MostrarEscuela view = new MostrarEscuela();
            view.mostrarEscuela(sessionFactory);
            
            /* Solicita el ID de la escuela */
            int idEscuela = validacion.campoEntero(entrada, "id", "escuela");
            Escuela escuela = session.get(Escuela.class, idEscuela);
            
            /* Verifica que la escuela existe en la base de datos */
            if (escuela == null) {
                System.out.println("El id no corresponde a ninguna escuela registrada.");
            } else {
                /* Crea el curso con el nombre y la escuela */
                Curso curso = new Curso(nombre, escuela);

                /* Verifica si el curso ya está asignado a esta escuela */
                if (comprueboEscuela(curso, session)) {
                    /* Inicia la transacción para guardar el curso */
                    session.beginTransaction();
                    
                    /* Guarda el curso en la base de datos */
                    session.save(curso);
                    
                    /* Confirma la transacción */
                    session.getTransaction().commit();
                    
                    /* Mensaje de éxito */
                    System.out.println("Curso agregado a la BBDD correctamente.");
                }
            }
            
        } catch (Exception e) {
            /* Manejo de excepciones */
            System.err.println("Error inesperado al ejecutar la consulta:");
            e.printStackTrace();
        } finally {
            /* Cierra la sesión si está abierta */
            if (session != null && session.isOpen()) {
                session.close();
            }
        }
    }

    /**
     * Método que verifica si un curso con el mismo nombre ya está asignado a la misma escuela.
     * Utiliza Hibernate para consultar si ya existe un curso con el mismo nombre en la escuela indicada.
     *
     * @param curso El curso que se desea agregar.
     * @param session La sesión de Hibernate utilizada para realizar la consulta.
     * @return true si el curso no existe en la escuela, false si ya existe.
     */
    private boolean comprueboEscuela(Curso curso, Session session) {
        
        /* Consulta HQL para verificar si ya existe un curso con el mismo nombre y escuela */
        Curso cursoExistente = session.createQuery("FROM Curso WHERE nombre = :nombre AND escuela.id = :escuelaId", Curso.class)
                                     .setParameter("nombre", curso.getNombre())
                                     .setParameter("escuelaId", curso.getEscuela().getId())
                                     .uniqueResult();
        
        /* Si el curso ya existe, imprimir mensaje y devolver false */
        if (cursoExistente != null) {
            System.out.println("Este curso ya está asignado en esta escuela.");
            return false;
        } else {
            return true; /* El curso puede ser agregado */
        }
    }
}

Ejercicio 18

Enunciado: Este ejercicio permite actualizar un curso en la base de datos. El usuario debe ingresar el ID del curso, el nuevo nombre del curso y el ID de la escuela a asociar. El sistema verifica que el curso no esté ya asignado a la misma escuela antes de realizar la actualización. Si el curso ya está asignado a la escuela, no se actualizará. El sistema maneja errores con transacciones de Hibernate y confirma la actualización al final. Requisitos: - Validar que el ID del curso y la escuela existen en la base de datos. - Permitir modificar el nombre del curso y la escuela asociada. - Si el curso ya está asignado a la escuela, no se actualizará. - Utilizar transacciones de Hibernate para actualizar los datos. - Manejar correctamente excepciones durante la transacción.

package es.pulsoft.curso;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Curso;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.validaciones.Validacion;

public class ActualizarCurso {

    

    /* @param entrada Un objeto Scanner para la entrada de datos del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para interactuar con la base de datos.
     */
    public void actualizarCurso(Scanner entrada, SessionFactory sessionFactory) {
        
        /** Abrir una nueva sesión con la fábrica de sesiones */
        Session session = sessionFactory.openSession();
        
        /** Crear un objeto de validación para obtener los datos del usuario */
        Validacion valido = new Validacion();
        
        MostrarCurso view= new MostrarCurso();
        view.mostrarCurso(sessionFactory);
        /** Solicitar el ID del curso a actualizar */
        int idCurso = valido.campoEntero(entrada, "id", "curso");
        
        /** Obtener el curso de la base de datos usando el ID proporcionado */
        Curso curso = session.get(Curso.class, idCurso);
        
        /** Verificar si el curso existe */
        if (curso == null) {
            System.out.println("No hay ningun curso con ese id");
        } else {
            /** Mostrar los datos actuales del curso */
            System.out.println("Datos actuales del curso");
            System.out.println(curso);
            
            /** Solicitar el nuevo nombre del curso */
            String nombre = valido.campoTexto(entrada, "nombre", "curso");
            
            /** Solicitar el ID de la nueva escuela */
            int idEscuela = valido.campoEntero(entrada, "id", "escuela");
            Escuela escuela = session.get(Escuela.class, idEscuela);
            
            /** Verificar si la escuela existe */
            if (escuela != null) {
                
                /** Actualizar el nombre del curso y la escuela */
                curso.setNombre(nombre);
                curso.setEscuela(escuela);
                
                try {
                    /** Verificar si el curso ya está asignado a esta escuela */
                    if (comprueboEscuela(curso, session)) {
                        /** Iniciar una transacción */
                        session.beginTransaction();
                        
                        /** Actualizar el curso en la base de datos */
                        session.saveOrUpdate(curso);
                        
                        /** Confirmar la transacción */
                        session.getTransaction().commit();
                        
                        /** Mensaje de éxito */
                        System.out.println("Curso actualizado correctamente");
                    } else {
                        /** Si el curso ya está asignado a la escuela, no se realiza la actualización */
                        System.out.println("El curso ya se imparte en esta escuela, no se actualizará");
                    }
                } catch (Exception e) {
                    /** Manejo de excepciones */
                    System.err.println("Error al actualizar el curso:");
                    e.printStackTrace();
                    
                    /** Deshacer la transacción si ocurre un error */
                    if (session.getTransaction() != null) {
                        session.getTransaction().rollback();
                    }
                } finally {
                    /** Cerrar la sesión si está abierta */
                    if (session.isOpen()) {
                        session.close();
                    }
                }
            } else {
                /** Si no se encuentra la escuela con el ID proporcionado */
                System.out.println("Ningúna escuela dada de alta con ese id, no se actualizará el curso");
            }
        }
    }

    /**
     * Método que verifica si un curso con el mismo nombre ya está asignado a la misma escuela.
     * Utiliza Hibernate para consultar si ya existe un curso con el mismo nombre en la escuela indicada.
     *
     * @param curso El curso que se desea actualizar.
     * @param session La sesión de Hibernate utilizada para realizar la consulta.
     * @return true si el curso no existe en la escuela, false si ya existe.
     */
    private boolean comprueboEscuela(Curso curso, Session session) {
        
        /** Consulta HQL para verificar si ya existe un curso con el mismo nombre y escuela */
        Curso cursoExistente = session.createQuery("FROM Curso WHERE nombre = :nombre AND escuela.id = :escuelaId", Curso.class)
                                     .setParameter("nombre", curso.getNombre())
                                     .setParameter("escuelaId", curso.getEscuela().getId())
                                     .uniqueResult();
        
        /** Si el curso ya existe, imprimir mensaje y devolver false */
        if (cursoExistente != null) {
            System.out.println("Este curso ya está asignado en esta escuela.");
            return false;
        } else {
            return true; /** El curso puede ser actualizado */
        }
    }
}

Ejercicio 19

Enunciado: Este ejercicio permite borrar un curso de la base de datos utilizando Hibernate. El objetivo es aprender cómo manejar la eliminación de un curso con una validación de si tiene estudiantes asociados, pidiendo confirmación antes de proceder con el borrado. Pasos a seguir: 1. Solicitar al usuario el ID del curso que desea eliminar. 2. Verificar si el curso existe en la base de datos. 3. Comprobar si hay estudiantes asociados al curso. 4. Si el curso tiene estudiantes, eliminar las relaciones con ellos antes de borrarlo. 5. Pedir confirmación antes de proceder con la eliminación del curso. 6. Si el curso no tiene estudiantes, se puede borrar directamente después de la confirmación. 7. Si se confirma el borrado, eliminar el curso y mostrar un mensaje de éxito. 8. En caso de error, realizar un rollback y mostrar un mensaje de error detallado. Requisitos: - Utilizar Hibernate para gestionar la base de datos. - Validar que el ID del curso y la confirmación de eliminación sean correctos. - Realizar la operación de borrado dentro de una transacción para asegurar la integridad de los datos. - Utilizar la clase `Validacion` para manejar la entrada del usuario.

package es.pulsoft.curso;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Curso;
import es.pulsoft.validaciones.Validacion;



public class BorrarCurso {

    /**
     * Borra un curso de la base de datos luego de verificar si tiene estudiantes 
     * asociados y pedir confirmación al usuario.
     * 
     * @param entrada Scanner para la entrada de datos del usuario.
     * @param sessionFactory SessionFactory para abrir una sesión con Hibernate.
     */
    public void borrarCurso(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Abrir una sesión con Hibernate */
        Session session = sessionFactory.openSession();
        Validacion valido = new Validacion();

        MostrarCurso view = new MostrarCurso();
        view.mostrarCurso(sessionFactory);
        
        /* Solicitar el ID del curso al usuario */
        int idCurso = valido.campoEntero(entrada, "id", "curso");

        /* Obtener el curso con el ID proporcionado */
        Curso curso = session.get(Curso.class, idCurso);

        /* Verificar si el curso existe */
        if (curso != null) {
            System.out.println("Datos del curso a borrar:");
            System.out.println(curso);

            /* Verificar si hay estudiantes asociados a este curso */
            long estudiantesCount = session.createQuery("SELECT COUNT(ce.estudiante) FROM CursoEstudiante ce WHERE ce.curso.id = :cursoId", Long.class)
                                           .setParameter("cursoId", idCurso)
                                           .getSingleResult();

            /* Iniciar la transacción antes de realizar cualquier operación de base de datos */
            session.beginTransaction();

            if (estudiantesCount > 0) {
                System.out.println("Este curso tiene " + estudiantesCount + " estudiantes asociados.");
                
                /* Solicitar confirmación antes de proceder con el borrado */
                boolean confirmacion = valido.confirmacion(entrada, "curso");
                
                if (!confirmacion) {
                    System.out.println("Operación de borrado de curso abortada.");
                    session.getTransaction().rollback(); /* Deshacer cualquier cambio si no se confirma */
                    return;
                }
                
                /* Si hay estudiantes asociados, eliminar la relación con los estudiantes */
                session.createQuery("DELETE FROM CursoEstudiante ce WHERE ce.curso.id = :cursoId")
                       .setParameter("cursoId", idCurso)
                       .executeUpdate();
                System.out.println("Se eliminaron las relaciones con los estudiantes.");
            } else {
                System.out.println("No hay estudiantes asociados a este curso.");
            }

            /* Confirmar el borrado del curso */
            try {
                boolean confirmacionBorrado = valido.confirmacion(entrada, "curso");
                
                if (!confirmacionBorrado) {
                    System.out.println("Operación de borrado de curso abortada.");
                    session.getTransaction().rollback(); /* Deshacer cualquier cambio si no se confirma */
                    return;
                }

                /* Borrar el curso de la base de datos */
                session.delete(curso);
                session.getTransaction().commit(); /* Confirmar los cambios realizados */
                System.out.println("Curso borrado correctamente.");
            } catch (Exception e) {
                System.err.println("Error al borrar el curso:");
                e.printStackTrace();
                
                /* Si ocurre un error, revertir los cambios realizados durante la transacción */
                if (session.getTransaction() != null) {
                    session.getTransaction().rollback();
                }
            } finally {
                /* Asegurarse de que la sesión se cierra correctamente */
                if (session.isOpen()) {
                    session.close(); /* Cerrar la sesión al final del proceso */
                }
            }
        } else {
            System.out.println("El ID no corresponde a ningún curso en la base de datos.");
        }
    }
}

Ejercicio 20

Ejercicio: Mostrar la Lista de Cursos Descripción: Desarrolla un método que obtenga y muestre en la consola todos los cursos almacenados en la base de datos utilizando Hibernate. Si no hay cursos registrados, muestra un mensaje indicándolo. Requisitos: Implementa un método que reciba un SessionFactory y utilice Hibernate para obtener la lista de todos los cursos. Si la lista está vacía, imprime el mensaje: "No hay cursos dados de alta aún en la BBDD" Si existen cursos, imprime la información de cada uno en la consola. Pistas: Utiliza Hibernate para realizar la consulta from Curso. Asegúrate de gestionar correctamente la sesión de Hibernate.

package es.pulsoft.curso;

import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Curso;



public class MostrarCurso {

    /**
     * Muestra la lista de cursos almacenados en la base de datos.
     * Si no hay cursos registrados, se muestra un mensaje indicándolo.
     * Si hay cursos, se muestra la información de cada uno.
     * 
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para abrir la sesión y realizar la consulta.
     */
    public void mostrarCurso(SessionFactory sessionFactory) {
        
        /* Abrir sesión de Hibernate */
        Session session = sessionFactory.openSession();

        try {
            /* Obtener la lista de cursos de la base de datos */
            List<Curso> listaCursos = session.createQuery("from Curso", Curso.class).getResultList();

            /* Mostrar el mensaje de la lista de cursos */
            System.out.println("La lista de cursos actuales:");
            
            /* Verificar si la lista está vacía */
            if (listaCursos.isEmpty()) {
                System.out.println("No hay cursos dados de alta aún en la BBDD");
            } else {
                /* Mostrar la cabecera de la tabla de cursos */
                System.out.println(String.format("%5s %25s %25s", "ID", "NOMBRE", "ESCUELA"));

                /* Iterar sobre la lista de cursos y mostrar cada uno */
                for (Curso curso : listaCursos) {
                    System.out.println(String.format("%5d %25s %25s",
                            curso.getId(),
                            curso.getNombre(),
                            curso.getEscuela().getNombre()));
                }
                
            }

        } catch (Exception e) {
            /* Manejo de excepciones en caso de error al consultar los cursos */
            System.err.println("Error al listar los cursos:");
            e.printStackTrace();
        } finally {
            /* Cerrar la sesión de Hibernate si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 21

Enunciado del ejercicio: Implementa una clase en Java llamada BuscarCurso que permita buscar cursos en una base de datos utilizando Hibernate. La búsqueda debe realizarse por el nombre del curso, utilizando un patrón de búsqueda con "like". El método buscarCurso debe: Recibir un Scanner para la entrada del usuario, una SessionFactory para la conexión con la base de datos y el campo a buscar (en este caso, "nombre"). Validar la entrada del usuario utilizando una clase Validacion. Realizar la consulta en la base de datos para obtener los cursos cuyo nombre coincida parcialmente con el texto ingresado. Mostrar los cursos encontrados o un mensaje indicando que no hay coincidencias. Manejar posibles excepciones y cerrar la sesión de Hibernate correctamente. Restricciones: Usa Hibernate para la consulta. El patrón de búsqueda debe incluir el comodín % para buscar coincidencias parciales. Maneja la sesión de Hibernate dentro de un bloque try-finally.

package es.pulsoft.curso;

import java.util.List;
import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.mapeo.Curso;
import es.pulsoft.validaciones.Validacion;


public class BuscarCurso {

    /**
     * Busca cursos en la base de datos según el nombre ingresado por el usuario.
     * Muestra los resultados en la consola.
     *
     * @param entrada        Scanner para la entrada del usuario.
     * @param sessionFactory Fábrica de sesiones de Hibernate para la conexión a la base de datos.
     * @param campo          Campo de búsqueda, en este caso "nombre".
     */
    public void buscarCurso(Scanner entrada, SessionFactory sessionFactory, String campo) {

        /* Instancia de la clase Validacion para validar la entrada del usuario */
        Validacion valido = new Validacion();

        /* Obtener el patrón de búsqueda validado */
        String patron = valido.campoTexto(entrada, campo, "curso");

        /* Agregar comodín para realizar la búsqueda con "like" */
        patron += "%";

        /* Abrir una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        List<Curso> listaCursos = null;

        try {
            /* Realizar la consulta a la base de datos buscando por nombre */
            listaCursos = session.createQuery("from Curso where nombre like :patron", Curso.class)
                    .setParameter("patron", patron)
                    .getResultList();

            /* Verificar si la lista de cursos está vacía */
            if (listaCursos.isEmpty()) {
                System.out.println("No hay ningún curso que coincida con tu búsqueda.");
            } else {
                /* Mostrar la lista de cursos encontrados */
                System.out.println("Lista de cursos cuyo nombre coincide con '" + patron + "':");
                System.out.println(String.format("%5s %25s %25s", "ID", "NOMBRE", "ESCUELA"));

                /* Iterar sobre los cursos encontrados y mostrar sus detalles */
                for (Curso curso : listaCursos) {
                    System.out.println(String.format("%5d %25s %25s",
                            curso.getId(),
                            curso.getNombre(),
                            curso.getEscuela().getNombre()));
                }
            }

        } catch (Exception e) {
            /* Capturar y mostrar cualquier error durante la consulta */
            System.err.println("Error al listar los cursos:");
            e.printStackTrace();
        } finally {
            /* Cerrar la sesión de Hibernate si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Operaciones CRUD para Estudiante

Ejercicio 22

Enunciado del ejercicio: Gestión de estudiantes en una base de datos con Hibernate Implementa una clase en Java llamada AgregarEstudiante que permita registrar nuevos estudiantes en una base de datos utilizando Hibernate. La clase debe: Solicitar al usuario el nombre y la edad del estudiante. Validar que la edad esté entre 18 y 99 años, pidiendo que se reingrese en caso de error. Crear un objeto Estudiante con los datos ingresados. Guardar el estudiante en la base de datos dentro de una transacción de Hibernate. Manejar posibles excepciones y hacer rollback si ocurre algún error. Cerrar la sesión de Hibernate correctamente.

package es.pulsoft.estudiante;

import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.mapeo.Estudiante;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que permite agregar estudiantes a la base de datos utilizando Hibernate.
 * Solicita el nombre y la edad del estudiante, valida los datos y guarda el estudiante en la base de datos.
 */
public class AgregarEstudiante {

    /**
     * Método que permite agregar un estudiante a la base de datos.
     *
     * @param entrada Scanner para la entrada de datos del usuario.
     * @param sessionFactory Objeto SessionFactory para gestionar sesiones de Hibernate.
     */
    public void agregarEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        /** Abre una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        /** Inicia una transacción (aunque no se hace nada en este punto, puede eliminarse) */
        session.beginTransaction();
        session.getTransaction().commit();
        
        try {
            /** Crea un objeto de validación para verificar los datos de entrada */
            Validacion validacion = new Validacion();
            
            /** Solicita al usuario ingresar el nombre del estudiante */
            String nombre = validacion.campoTexto(entrada, "nombre", "estudiante");
            
            /** Variable para almacenar la edad */
            int edad = 0;
            
            /** Bucle para validar que la edad esté entre 18 y 99 años */
            do {
                edad = validacion.campoEntero(entrada, "edad", "estudiante");
                if (edad < 18) {
                    System.out.println("Los cursos son para mayores de 18 años, introduce la edad de nuevo");
                } else if (edad > 99) {
                    System.out.println("Los cursos son para menores de 99 años, introduce la edad de nuevo");
                }
            } while (edad < 18 || edad > 99);
            
            /** Crea un objeto Estudiante con los datos validados */
            Estudiante estudiante = new Estudiante(nombre, edad);
            
            /** Inicia una transacción para guardar el estudiante en la base de datos */
            session.beginTransaction();
            session.save(estudiante);
            session.getTransaction().commit();
            
            /** Confirma que el estudiante fue agregado correctamente */
            System.out.println("Estudiante agregado a la BBDD correctamente");
        } catch (Exception e) {
            /** Captura cualquier error y muestra un mensaje */
            System.err.println("Error al agregar al estudiante:");
            e.printStackTrace();
            
            /** Si hay una transacción activa, se revierte para evitar datos inconsistentes */
            if (session.getTransaction() != null) {
                session.getTransaction().rollback();
            }
        } finally {
            /** Cierra la sesión de Hibernate si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 23

Enunciado del ejercicio: Implementa una clase en Java llamada ActualizarEstudiante que permita modificar los datos de un estudiante en una base de datos utilizando Hibernate. La clase debe: 1. Solicitar al usuario el ID del estudiante a actualizar. 2. Verificar si el estudiante con el ID dado existe en la base de datos. 3. Si el estudiante existe, permitir la actualización de su nombre y edad, donde la edad debe estar entre 18 y 99 años. Si la edad es inválida, se debe pedir que se ingrese nuevamente. 4. Si el estudiante no existe, mostrar un mensaje indicando que no se encontró ningún estudiante con ese ID. 5. Guardar los cambios en la base de datos dentro de una transacción de Hibernate. 6. Manejar posibles excepciones y realizar un rollback si ocurre algún error durante la actualización. 7. Cerrar la sesión de Hibernate correctamente.

package es.pulsoft.estudiante;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Estudiante;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que permite actualizar los datos de un estudiante en la base de datos utilizando Hibernate.
 * Solicita el ID, nombre y edad del estudiante, valida los datos y actualiza la información en la base de datos.
 */
public class ActualizarEstudiante {

    /**
     * Método que permite actualizar los datos de un estudiante en la base de datos.
     *
     * @param entrada Scanner para la entrada de datos del usuario.
     * @param sessionFactory SessionFactory de Hibernate para gestionar la sesión con la base de datos.
     */
    public void actualizarEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        /** Abre una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        /** Crea un objeto de validación para verificar los datos de entrada */
        Validacion valido = new Validacion();
        
        /** Muestra los estudiantes actuales en la base de datos */
        MostrarEstudiante view = new MostrarEstudiante();
        view.mostrarEstudiantes(sessionFactory);
        
        /** Solicita el ID del estudiante a actualizar */
        int idEstudiante = valido.campoEntero(entrada, "id", "estudiante");
        
        /** Busca el estudiante en la base de datos */
        Estudiante estudiante = session.get(Estudiante.class, idEstudiante);
        
        /** Si no se encuentra, muestra un mensaje y finaliza */
        if (estudiante == null) {
            System.out.println("No hay ningún estudiante con ese ID.");
        } else {
            
            /** Muestra los datos actuales del estudiante */
            System.out.println("Datos actuales del estudiante:");
            System.out.println(estudiante);
            
            /** Solicita el nuevo nombre del estudiante */
            String nombre = valido.campoTexto(entrada, "nombre", "estudiante");
            
            /** Solicita y valida la nueva edad del estudiante */
            int edad = 0;
            do {
                edad = valido.campoEntero(entrada, "edad", "estudiante");
                if (edad < 18) {
                    System.out.println("Los cursos son para mayores de 18 años, introduce la edad de nuevo.");
                } else if (edad > 99) {
                    System.out.println("Los cursos son para menores de 99 años, introduce la edad de nuevo.");
                }
            } while (edad < 18 || edad > 99);
            
            /** Actualiza los datos del estudiante */
            estudiante.setNombre(nombre);
            estudiante.setEdad(edad);
            
            try {
                /** Inicia una transacción para actualizar la información en la base de datos */
                session.beginTransaction();
                
                /** Guarda los cambios en la base de datos */
                session.update(estudiante);
                
                /** Confirma la transacción */
                session.getTransaction().commit();
                
                System.out.println("Estudiante actualizado correctamente.");
            } catch (Exception e) {
                /** Manejo de errores */
                System.err.println("Error al actualizar al estudiante:");
                e.printStackTrace();
                
                /** Revierte la transacción en caso de error */
                if (session.getTransaction() != null) {
                    session.getTransaction().rollback();
                }
            } finally {
                /** Cierra la sesión de Hibernate */
                if (session.isOpen()) {
                    session.close();
                }
            }
        }
    }
}

Ejercicio 24

Enunciado del ejercicio: Desarrolla una clase en Java llamada BorrarEstudiante que permita gestionar la eliminación de estudiantes de una base de datos utilizando Hibernate. La clase debe: 1. Solicitar al usuario el ID del estudiante que desea eliminar. 2. Verificar si el estudiante con el ID dado existe en la base de datos. 3. Si el estudiante existe, mostrar sus datos y pedir confirmación para proceder con su eliminación. 4. Si el usuario confirma, eliminar el estudiante de la base de datos y mostrar un mensaje de éxito. En caso de error, manejar la excepción y realizar un rollback de la transacción. 5. Si el usuario no confirma, cancelar la operación y mostrar un mensaje indicando que la eliminación fue abortada. 6. Utilizar Hibernate para gestionar la sesión de la base de datos y realizar las operaciones necesarias.

package es.pulsoft.estudiante;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Estudiante;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que permite eliminar un estudiante de la base de datos utilizando Hibernate.
 * Solicita el ID del estudiante, verifica su existencia y maneja la eliminación con confirmación del usuario.
 */
public class BorrarEstudiante {

    /**
     * Método para borrar un estudiante de la base de datos.
     *
     * @param entrada El objeto Scanner para leer la entrada del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate para interactuar con la base de datos.
     */
    public void borrarEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        /** Inicia la sesión de Hibernate */
        Session session = sessionFactory.openSession();

        /** Crea una instancia de la clase de validaciones */
        Validacion valido = new Validacion();

        /** Muestra los estudiantes actuales en la base de datos */
        MostrarEstudiante view = new MostrarEstudiante();
        view.mostrarEstudiantes(sessionFactory);
        
        /** Solicita el ID del estudiante que se desea eliminar */
        int idEstudiante = valido.campoEntero(entrada, "id", "estudiante");

        /** Obtiene el objeto Estudiante de la base de datos */
        Estudiante estudiante = session.get(Estudiante.class, idEstudiante);

        /** Verifica si el estudiante existe en la base de datos */
        if (estudiante == null) {
            /** Si no existe el estudiante, muestra un mensaje */
            System.out.println("El ID no corresponde a ningún estudiante en la base de datos.");
        } else {
            /** Si existe, muestra los datos del estudiante a borrar */
            System.out.println("Datos del estudiante a borrar:");
            System.out.println(estudiante);

            /** Solicita confirmación para proceder con el borrado */
            boolean confirmacion = valido.confirmacion(entrada, "estudiante");
            if (confirmacion) {
                try {
                    /** Inicia la transacción para borrar el estudiante */
                    session.beginTransaction();
                    
                    /** Elimina al estudiante de la base de datos */
                    session.delete(estudiante);
                    
                    /** Realiza el commit de la transacción */
                    session.getTransaction().commit();
                    
                    /** Muestra un mensaje indicando que el estudiante fue borrado correctamente */
                    System.out.println("Estudiante borrado correctamente.");
                } catch (Exception e) {
                    /** Si ocurre un error, imprime el error y realiza un rollback de la transacción */
                    System.err.println("Error al borrar al estudiante:");
                    e.printStackTrace();
                    
                    /** Realiza el rollback si la transacción no fue exitosa */
                    if (session.getTransaction() != null) {
                        session.getTransaction().rollback();
                    }
                } finally {
                    /** Cierra la sesión de Hibernate */
                    if (session.isOpen()) {
                        session.close();
                    }
                }
            } else {
                /** Si el usuario cancela la operación, muestra un mensaje */
                System.out.println("Operación de borrado del estudiante abortada.");
            }
        }
    }
}

Ejercicio 25

Enunciado del ejercicio: Desarrolla una clase en Java llamada MostrarEstudiante que permita consultar y mostrar la lista de estudiantes almacenados en la base de datos utilizando Hibernate. La clase debe: 1. Obtener todos los estudiantes registrados en la base de datos. 2. Mostrar un mensaje indicando si no hay estudiantes dados de alta. 3. Si existen estudiantes, imprimir sus datos en consola. 4. Si ocurre un error durante la consulta, mostrar el mensaje correspondiente y manejar la excepción adecuadamente. 5. Utilizar Hibernate para realizar la consulta y asegurarse de manejar posibles errores durante la operación.

package es.pulsoft.estudiante;

import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Estudiante;



/**
 * Clase que permite mostrar la lista de estudiantes almacenados en la base de datos.
 * Utiliza Hibernate para obtener los estudiantes y mostrar sus detalles.
 */
public class MostrarEstudiante {

    /**
     * Método que muestra la lista de estudiantes almacenados en la base de datos.
     * 
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para interactuar con la base de datos.
     */
    public void mostrarEstudiantes(SessionFactory sessionFactory) {
        
        /** Inicia la sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        try {
            /** Ejecuta una consulta para obtener todos los estudiantes */
            List<Estudiante> listaEstudiantes = session.createQuery("from Estudiante", Estudiante.class).getResultList();
            
            /** Muestra un mensaje informando sobre los estudiantes obtenidos */
            System.out.println("La lista de estudiantes actuales:");
            if (listaEstudiantes.isEmpty()) {
                /** Si no hay estudiantes en la base de datos, muestra un mensaje indicando que no hay datos */
                System.out.println("No hay estudiantes dados de alta aún en la BBDD");
            } else {
                /** Si hay estudiantes, muestra los detalles de cada uno */
                System.out.println(String.format("%5s %25s %25s", "ID", "NOMBRE", "EDAD"));

                for (Estudiante estudiante : listaEstudiantes) {
                    System.out.println(String.format("%5d %25s %25d",
                            estudiante.getId(),
                            estudiante.getNombre(),
                            estudiante.getEdad()));
                }
            }
            
        } catch (Exception e) {
            /** Si ocurre un error durante la consulta, muestra un mensaje de error */
            System.err.println("Error al listar los estudiantes:");
            e.printStackTrace();
        } finally {
            /** Asegura que la sesión se cierre al finalizar la operación */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 26

Enunciado del ejercicio: Crea una clase llamada BuscarEstudiante que permita buscar estudiantes en una base de datos utilizando Hibernate. El programa permitirá al usuario buscar estudiantes según dos criterios: 1. **Por nombre**: El usuario deberá ingresar un nombre o parte del mismo, y el programa listará todos los estudiantes cuyo nombre contenga el texto ingresado. 2. **Por edad**: El usuario deberá ingresar un rango de edades (edad mínima y edad máxima), y el programa listará los estudiantes cuya edad esté dentro de este rango. Las edades deben estar entre 18 y 99 años. El programa debe validar las entradas del usuario y manejar los siguientes casos: - Si el usuario ingresa un rango de edad no válido (fuera del rango 18-99), deberá ser informado y solicitar la corrección. - Si no se encuentran estudiantes que coincidan con los criterios de búsqueda, deberá mostrar un mensaje indicando que no hay resultados. Además, el programa debe manejar errores durante la consulta a la base de datos, y asegurarse de cerrar la sesión de Hibernate una vez finalizada la operación.

package es.pulsoft.estudiante;

import java.util.List;
import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.Estudiante;
import es.pulsoft.validaciones.Validacion;



/**
 * Clase que permite buscar estudiantes en la base de datos según nombre o edad.
 * Utiliza Hibernate para realizar la consulta y mostrar los resultados al usuario.
 */
public class BuscarEstudiante {

    /**
     * Método que permite buscar estudiantes en la base de datos según el campo especificado (nombre o edad).
     * 
     * @param entrada Objeto Scanner para recibir la entrada del usuario.
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para interactuar con la base de datos.
     * @param campo El campo por el cual se realizará la búsqueda ("nombre" o "edad").
     */
    public void buscarEstudiante(Scanner entrada, SessionFactory sessionFactory, String campo) {

        /** Instancia de la clase de validación para manejar la entrada del usuario */
        Validacion valido = new Validacion();

        /** Abre una sesión con la base de datos utilizando Hibernate */
        Session session = sessionFactory.openSession();
        List<Estudiante> listaEstudiantes = null;
        String patron = "";

        try {
            /** Realiza la búsqueda según el campo especificado (nombre o edad) */
            switch (campo) {
                case "nombre":
                    /** Busca por nombre y utiliza un comodín '%' para que la búsqueda sea más flexible */
                    patron = valido.campoTexto(entrada, campo, "estudiante");
                    patron += "%";
                    listaEstudiantes = session.createQuery("from Estudiante where nombre like :patron", Estudiante.class)
                            .setParameter("patron", patron)
                            .getResultList();
                    break;
                case "edad":
                    /** Valida que la edad mínima esté dentro de un rango adecuado */
                    int edadMinima = 0;
                    do {
                        edadMinima = valido.campoEntero(entrada, "edad", "estudiante minima");
                        if (edadMinima < 18) {
                            System.out.println("Los cursos son para mayores de 18 años, introduce la edad de nuevo");
                        } else if (edadMinima > 99) {
                            System.out.println("Los cursos son para menores de 99 años, introduce la edad de nuevo");
                        }
                    } while (edadMinima < 18 || edadMinima > 99);

                    /** Valida que la edad máxima sea mayor o igual que la mínima */
                    int edadMaxima = 0;
                    do {
                        edadMaxima = valido.campoEntero(entrada, "edad", "estudiante maxima");
                        if (edadMaxima < edadMinima) {
                            System.out.println("El segundo rango de edad tiene que ser mayor o igual que el primero " + edadMinima );
                        } else if (edadMaxima > 99) {
                            System.out.println("Los cursos son para menores de 99 años, introduce la edad de nuevo");
                        }
                    } while (edadMaxima < edadMinima || edadMaxima > 99);

                    /** Realiza la búsqueda por el rango de edades */
                    patron = edadMinima + "-" + edadMaxima;
                    listaEstudiantes = session.createQuery("from Estudiante where edad between :edadMinima and :edadMaxima", Estudiante.class)
                            .setParameter("edadMinima", edadMinima)
                            .setParameter("edadMaxima", edadMaxima)
                            .getResultList();
                    break;
                default:
                    /** Si el campo no es válido, lanza una excepción */
                    throw new IllegalArgumentException("Campo no válido para la búsqueda.");
            }

            /** Si no se encuentran estudiantes, muestra un mensaje adecuado */
            if (listaEstudiantes.isEmpty()) {
                System.out.println("No hay ningún estudiante que coincida con tu búsqueda.");
            } else {
                /** Muestra la lista de estudiantes que coinciden con la búsqueda */
                System.out.println("Lista de estudiantes cuyo " + campo + " coincida con '" + patron + "':");
                System.out.println(String.format("%5s %25s %25s %25s", "ID", "NOMBRE", "EDAD"));

                for (Estudiante estudiante : listaEstudiantes) {
                    System.out.println(String.format("%5d %25s %25s",
                            estudiante.getId(),
                            estudiante.getNombre(),
                            estudiante.getEdad()));
                }
            }

        } catch (Exception e) {
            /** Manejo de errores si ocurre una excepción durante la consulta */
            System.err.println("Error al listar los estudiantes:");
            e.printStackTrace();
        } finally {
            /** Cierra la sesión de Hibernate al finalizar */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Operaciones CRUD para Curso-Estudiante

Ejercicio 27

Enunciado del ejercicio: Implementa una funcionalidad en Java que permita asignar estudiantes a cursos en una base de datos utilizando Hibernate. La clase debe: Listar los estudiantes y cursos disponibles. Permitir seleccionar un estudiante y un curso por su ID. Registrar la inscripción del estudiante en el curso con la fecha actual. Manejar errores y evitar inscripciones duplicadas.

package es.pulsoft.cursoestudiante;

import java.time.LocalDate;
import java.util.List;
import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.curso.MostrarCurso;
import es.pulsoft.estudiante.MostrarEstudiante;
import es.pulsoft.mapeo.Curso;
import es.pulsoft.mapeo.CursoEstudiante;
import es.pulsoft.mapeo.Estudiante;
import es.pulsoft.validaciones.Validacion;


public class AgregarCursoEstudiante {
    
    /**
     * Método para agregar un estudiante a un curso.
     * 
     * @param entrada Scanner para la entrada de datos del usuario.
     * @param sessionFactory SessionFactory de Hibernate para la gestión de sesiones.
     */
    public void agregarCursoEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        
        /* Obtener listas de estudiantes y cursos disponibles */
        List<Estudiante> listaEstudiantes = session.createQuery("from Estudiante", Estudiante.class).getResultList();
        List<Curso> listaCursos = session.createQuery("from Curso", Curso.class).getResultList();
        
        /* Verificar si hay estudiantes registrados */
        if (listaEstudiantes.isEmpty()) {
            System.out.println("No hay estudiantes dados de alta aún");
            return;
        }
        
        /* Verificar si hay cursos registrados */
        if (listaCursos.isEmpty()) {
            System.out.println("No hay cursos dados de alta aún");
            return;
        }
        
        Validacion valido = new Validacion();
        MostrarEstudiante view = new MostrarEstudiante();
        Estudiante estudiante = null;
        Curso curso = null;
        
        try {
            /* Mostrar la lista de estudiantes disponibles */
            view.mostrarEstudiantes(sessionFactory);
            int idEstudiante = 0;
            
            /* Solicitar al usuario que ingrese un ID de estudiante válido */
            while (true) {
                idEstudiante = valido.campoEntero(entrada, "id", "estudiante");
                estudiante = session.get(Estudiante.class, idEstudiante);
                
                if (estudiante == null) {
                    System.out.println("No hay ningún estudiante con ese ID.");
                    view.mostrarEstudiantes(sessionFactory);
                } else {
                    break;
                }
            }
            
            MostrarCurso viewCurso = new MostrarCurso();
            viewCurso.mostrarCurso(sessionFactory);
            int idCurso = 0;
            
            /* Solicitar al usuario que ingrese un ID de curso válido */
            while (true) {
                idCurso = valido.campoEntero(entrada, "id", "curso");
                curso = session.get(Curso.class, idCurso);
                
                if (curso == null) {
                    System.out.println("No hay ningún curso con ese ID.");
                    viewCurso.mostrarCurso(sessionFactory);
                } else {
                    break;
                }
            }
            
            /* Crear un nuevo registro de inscripción del estudiante en el curso */
            CursoEstudiante cursoEstudiante = new CursoEstudiante(estudiante, curso, LocalDate.now());
            
            session.beginTransaction();
            session.save(cursoEstudiante);
            session.getTransaction().commit();
            
            System.out.println("Estudiante agregado al curso registrado en la BBDD correctamente");
        } catch (Exception e) {
            /* Capturar y mostrar cualquier error al agregar el estudiante al curso */
            System.err.println("Error al agregar al estudiante al curso:");
            e.printStackTrace();
            
            /* Revertir la transacción en caso de error */
            if (session.getTransaction() != null) {
                session.getTransaction().rollback();
            }
        } finally {
            /* Cerrar la sesión si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 28

Enunciado del ejercicio: Actualización de la relación entre un Estudiante y un Curso Objetivo: Actualizar la relación entre un estudiante y un curso en la base de datos utilizando Hibernate. El programa debe permitir seleccionar un nuevo curso y un nuevo estudiante, y actualizar la relación en la base de datos. Requisitos: Obtener datos actuales: El usuario introduce los IDs de un curso y un estudiante para encontrar la relación existente entre ellos en la base de datos. Mostrar datos actuales: Si la relación existe, mostrar los datos del curso y estudiante actuales. Seleccionar nuevo curso y estudiante: Permitir al usuario seleccionar un nuevo curso y un nuevo estudiante de listas disponibles, verificando que los IDs sean válidos. Actualizar la relación: Eliminar la relación actual y crear una nueva con los nuevos valores de curso y estudiante, asignando la fecha de inscripción actual. Manejo de errores: Si ocurre un error (como un ID inválido), revertir la transacción y mostrar un mensaje de error.

package es.pulsoft.cursoestudiante;

import java.time.LocalDate;
import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.curso.MostrarCurso;
import es.pulsoft.estudiante.MostrarEstudiante;
import es.pulsoft.mapeo.Curso;
import es.pulsoft.mapeo.CursoEstudiante;
import es.pulsoft.mapeo.CursoEstudianteId;
import es.pulsoft.mapeo.Estudiante;
import es.pulsoft.validaciones.Validacion;


public class ActualizarCursoEstudiante {

    /**
     * Actualiza la relación entre un curso y un estudiante en la base de datos.
     * Solicita al usuario los IDs de curso y estudiante, muestra los datos actuales,
     * y permite modificar dicha relación.
     *
     * @param entrada Scanner para capturar la entrada del usuario
     * @param sessionFactory Factoría de sesiones de Hibernate para interactuar con la base de datos
     */
    public void actualizarCursoEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Abre una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        /* Instancia de la clase de validación para controlar entradas del usuario */
        Validacion valido = new Validacion();
        
        /* Solicita los IDs de curso y estudiante al usuario */
        MostrarCurso view = new MostrarCurso();
        view.mostrarCurso(sessionFactory);
        int idCurso = valido.campoEntero(entrada, "id", "Curso");
        MostrarEstudiante viewEstudiante = new MostrarEstudiante();
        viewEstudiante.mostrarEstudiantes(sessionFactory);
        int idEstudiante = valido.campoEntero(entrada, "id", "Estudiante");
        
        /* Crea el identificador compuesto para la relación CursoEstudiante */
        CursoEstudianteId id = new CursoEstudianteId(idCurso, idEstudiante);
        
        /* Obtiene la relación CursoEstudiante desde la base de datos */
        CursoEstudiante cursoEstudiante = session.get(CursoEstudiante.class, id);

        /* Verifica si la relación existe */
        if (cursoEstudiante == null) {
            System.out.println("No hay ningún curso de ese estudiante en la BBDD");
        } else {
            
            /* Muestra los datos actuales de la relación CursoEstudiante */
            System.out.println("Datos actuales del curso");
            System.out.println(cursoEstudiante);
            
            /* Instancia de la clase para mostrar estudiantes y cursos disponibles */
            
            Estudiante estudiante = null;
            Curso curso = null;
            
            try {
                /* Muestra los cursos disponibles */
                MostrarCurso viewCurso = new MostrarCurso();
                viewCurso.mostrarCurso(sessionFactory);
                
                int idCursoActualizo = 0;
                
                /* Solicita al usuario un ID de curso válido */
                while (true) {
                    idCursoActualizo = valido.campoEntero(entrada, "id", "curso");
                    curso = session.get(Curso.class, idCursoActualizo);
                    
                    /* Verifica si el curso existe */
                    if (curso == null) {
                        System.out.println("No hay ningún curso con ese ID.");
                        viewCurso.mostrarCurso(sessionFactory);
                    } else {
                        break;
                    }
                }

                /* Muestra la lista de estudiantes disponibles */
                viewEstudiante.mostrarEstudiantes(sessionFactory);
                int idEstudianteActualizo = 0;
                
                /* Solicita al usuario un ID de estudiante válido */
                while (true) {
                    idEstudianteActualizo = valido.campoEntero(entrada, "id", "estudiante");
                    estudiante = session.get(Estudiante.class, idEstudianteActualizo);
                    
                    /* Verifica si el estudiante existe */
                    if (estudiante == null) {
                        System.out.println("No hay ningún estudiante con ese ID.");
                        viewEstudiante.mostrarEstudiantes(sessionFactory);
                    } else {
                        break;
                    }
                }
                
                /* Inicia una transacción para eliminar la relación existente */
                session.beginTransaction();
                session.delete(cursoEstudiante); /* Elimina la relación existente */
                session.getTransaction().commit();
                
                /* Establece los nuevos valores en el objeto cursoEstudiante */
                cursoEstudiante.setCurso(curso);
                cursoEstudiante.setEstudiante(estudiante);
                cursoEstudiante.setFechaInscripcion(LocalDate.now());
                
                /* Inicia una nueva transacción para guardar la relación actualizada */
                session.beginTransaction();
                session.save(cursoEstudiante); /* Guarda la nueva relación */
                session.getTransaction().commit();
                
                System.out.println("Estudiante, curso y fecha actualizados en la BBDD correctamente");
            } catch (Exception e) {
                /* Maneja las excepciones en caso de error */
                System.err.println("Error al actualizar la BBDD:");
                e.printStackTrace();
                
                /* Revierte la transacción en caso de error */
                if (session.getTransaction() != null) {
                    session.getTransaction().rollback();
                }
            } finally {
                /* Cierra la sesión si está abierta */
                if (session.isOpen()) {
                    session.close();
                }
            }
        }
    }
}

Ejercicio 29

Enunciado del ejercicio: Objetivo: Eliminar la inscripción de un estudiante en un curso de una base de datos utilizando Hibernate. Descripción: El objetivo de este ejercicio es implementar una función que permita eliminar una relación existente entre un estudiante y un curso en una base de datos. La función debe: 1. Solicitar al usuario los identificadores del curso y del estudiante. 2. Verificar si existe una inscripción con esos identificadores. 3. Si la inscripción existe, mostrar los detalles del estudiante y el curso. 4. Preguntar al usuario si está seguro de que desea eliminar esta inscripción. 5. Si el usuario confirma, eliminar la relación de la base de datos. 6. Si la inscripción no existe o el usuario cancela, mostrar un mensaje apropiado. Requisitos: - La relación entre el curso y el estudiante se identifica por su clave primaria compuesta (ID de curso e ID de estudiante). - La operación de eliminación debe realizarse en una transacción. - En caso de error, la transacción debe revertirse correctamente.

package es.pulsoft.cursoestudiante;

import java.util.Scanner;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import es.pulsoft.mapeo.CursoEstudiante;
import es.pulsoft.mapeo.CursoEstudianteId;
import es.pulsoft.validaciones.Validacion;


public class BorrarCursoEstudiante {

    /**
     * Método para eliminar una relación entre un curso y un estudiante en la base de datos.
     * 
     * @param entrada Scanner para la entrada de datos del usuario.
     * @param sessionFactory Objeto SessionFactory de Hibernate para la gestión de sesiones.
     */
    public void borrarCursoEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        /* Abre una nueva sesión de Hibernate */
        Session session = sessionFactory.openSession();
        
        /* Objeto de validación para capturar y validar entradas del usuario */
        Validacion valido = new Validacion();
        MostrarCursoEstudiante view =new MostrarCursoEstudiante();
        
        /* Muestra los cursos y estudiantes registrados */
        view.mostrarCursosEstudiantes(sessionFactory);
        
        /* Solicita el ID del curso y del estudiante al usuario */
        int idCurso = valido.campoEntero(entrada, "id", "curso");
        int idEstudiante = valido.campoEntero(entrada, "id", "estudiante");
        
        /* Crea la clave compuesta para buscar la inscripción */
        CursoEstudianteId id = new CursoEstudianteId(idCurso, idEstudiante);
        CursoEstudiante cursoEstudiante = session.get(CursoEstudiante.class, id);
        
        /* Verifica si la inscripción existe */
        if (cursoEstudiante == null) {
            System.out.println("El ID no corresponde a ningún estudiante cursado en la base de datos.");
        } else {
            
            /* Muestra los datos del registro que se eliminará */
            System.out.println("Datos del estudiante-curso a borrar:");
            System.out.println(cursoEstudiante);
            
            /* Solicita confirmación del usuario antes de proceder con la eliminación */
            boolean confirmacion = valido.confirmacion(entrada, "estudiante del curso");
            if (confirmacion) {
                try {
                    /* Inicia una transacción para eliminar el registro */
                    session.beginTransaction();
                    session.delete(cursoEstudiante);
                    session.getTransaction().commit();
                    
                    System.out.println("Estudiante borrado correctamente del curso.");
                } catch (Exception e) {
                    /* Manejo de errores en caso de fallo durante la eliminación */
                    System.err.println("Error al borrar al estudiante del curso:");
                    e.printStackTrace();
                    
                    if (session.getTransaction() != null) {
                        session.getTransaction().rollback();
                    }
                } finally {
                    /* Cierra la sesión de Hibernate si está abierta */
                    if (session.isOpen()) {
                        session.close();
                    }
                }
            } else {
                System.out.println("Operación de borrado del estudiante del curso abortada.");
            }
        }
    }
}

Ejercicio 30

Enunciado del ejercicio: Objetivo: Mostrar la lista de estudiantes inscritos en cursos en una base de datos utilizando Hibernate. Descripción: El objetivo de este ejercicio es implementar una clase en Java que recupere y muestre la lista de estudiantes inscritos en cursos desde una base de datos utilizando Hibernate. La función debe: 1. Consultar la base de datos para obtener la lista de todos los estudiantes inscritos en los cursos. 2. Mostrar los detalles de cada estudiante, como su nombre, edad, el curso en el que está inscrito, la escuela, la dirección de la escuela, el nombre del director y la fecha de inscripción. 3. La salida debe estar formateada en columnas alineadas para mejorar la legibilidad. 4. Asegúrate de manejar cualquier excepción que pueda ocurrir durante la ejecución y de cerrar la sesión de Hibernate correctamente. Requisitos: - Se debe utilizar Hibernate para realizar la consulta y recuperar los datos desde la base de datos. - Se debe manejar correctamente cualquier error o excepción que se produzca. - La salida de los datos debe estar bien formateada, alineando las columnas adecuadamente.

package es.pulsoft.cursoestudiante;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.mapeo.CursoEstudiante;


public class MostrarCursoEstudiante {

    /**
     * Método que obtiene y muestra la lista de estudiantes y sus cursos desde la base de datos.
     *
     * @param sessionFactory La fábrica de sesiones de Hibernate utilizada para obtener la sesión.
     */
    public void mostrarCursosEstudiantes(SessionFactory sessionFactory) {

        /* Se abre una nueva sesión con Hibernate */
        Session session = sessionFactory.openSession();

        try {
            /* Se ejecuta la consulta para obtener todos los registros de CursoEstudiante */
            List<CursoEstudiante> listaCursosEstudiantes = session.createQuery("from CursoEstudiante", CursoEstudiante.class).getResultList();

            /* Mensaje inicial de la lista de estudiantes y cursos */
            System.out.println("La lista de los estudiantes y sus cursos actuales:");

            /* Verifica si hay registros en la base de datos */
            if (listaCursosEstudiantes.isEmpty()) {
                System.out.println("No hay estudiantes cursados dados de alta aún en la BBDD.");
            } else {
                /* Imprime el encabezado de la tabla con formato alineado */
                System.out.println(String.format("%5s %15s %8s %15s %10s %10s %12s %10s %10s",
                       "ID ESTUDIANTE", "ESTUDIANTE", "EDAD","ID CURSO", "CURSO", "ESCUELA", "DIRECCION", "DIRECTOR", "FECHA INSCRIPCIÓN"));

                /* Itera sobre la lista de estudiantes y muestra sus datos con formato alineado */
                for (CursoEstudiante cursoEstudiante : listaCursosEstudiantes) {
                    System.out.println(String.format("%5d %20s %10d %15s %10s %10s %12s %10s %10s",
                    		cursoEstudiante.getEstudiante().getId(),
                            cursoEstudiante.getEstudiante().getNombre(),
                            cursoEstudiante.getEstudiante().getEdad(),
                            cursoEstudiante.getCurso().getId(),
                            cursoEstudiante.getCurso().getNombre(),
                            cursoEstudiante.getCurso().getEscuela().getNombre(),
                            cursoEstudiante.getCurso().getEscuela().getDireccion(),
                            cursoEstudiante.getCurso().getEscuela().getDirector().getNombre(),
                            cursoEstudiante.getFechaInscripcion().toString() // Se convierte la fecha a String
                    ));
                }
            }

        } catch (Exception e) {
            /* Captura y muestra cualquier error que ocurra durante la ejecución de la consulta */
            System.err.println("Error al listar los estudiantes y sus cursos:");
            e.printStackTrace();
        } finally {
            /* Cierra la sesión si está abierta */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Ejercicio 31

Enunciado del ejercicio: Descripción: Desarrolla una clase en Java llamada BuscarCursoEstudiante que permita realizar búsquedas de cursos de estudiantes en una base de datos utilizando Hibernate. La búsqueda puede realizarse por tres campos diferentes: 1. Estudiante: Buscar los cursos en los que está matriculado un estudiante cuyo nombre coincida parcialmente con el patrón ingresado por el usuario. 2. Escuela: Buscar los cursos pertenecientes a una escuela cuyo nombre coincida parcialmente con el patrón ingresado por el usuario. 3. Curso: Buscar los estudiantes matriculados en un curso cuyo nombre coincida parcialmente con el patrón ingresado por el usuario. Requisitos: - El método debe permitir al usuario ingresar el patrón de búsqueda para cada uno de los tres campos. - La consulta se debe realizar a través de Hibernate. - Los resultados deben mostrarse en un formato organizado y alineado. - Si no se encuentran resultados, el sistema debe mostrar un mensaje indicándolo. - La sesión de Hibernate debe cerrarse correctamente después de realizar la consulta. Instrucciones: 1. Crear una clase BuscarCursoEstudiante con un método llamado buscarCursoEstudiante. 2. El método debe aceptar un objeto Scanner, una sesión de Hibernate y el campo por el cual se realizará la búsqueda (estudiante, escuela o curso). 3. Dependiendo del campo proporcionado, realizar la consulta adecuada utilizando Hibernate. 4. Mostrar los resultados de la búsqueda en un formato de tabla.

package es.pulsoft.cursoestudiante;

import java.util.List;
import java.util.Scanner;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import es.pulsoft.mapeo.CursoEstudiante;
import es.pulsoft.validaciones.Validacion;


public class BuscarCursoEstudiante {

    /**
     * Método para realizar la búsqueda de cursos de estudiantes en la base de datos
     * utilizando Hibernate. Dependiendo del campo proporcionado (estudiante, escuela,
     * o curso), se realiza una consulta adecuada.
     *
     * @param entrada        Objeto Scanner para obtener la entrada del usuario.
     * @param sessionFactory Factoria de sesiones de Hibernate para interactuar con la base de datos.
     * @param campo          Campo por el cual se realizará la búsqueda (estudiante, escuela, o curso).
     */
    public void buscarCursoEstudiante(Scanner entrada, SessionFactory sessionFactory, String campo) {
        
        /** Instanciamos el objeto de validación para recibir entradas válidas. */
        Validacion valido = new Validacion();

        /** Obtenemos el patrón de búsqueda del usuario. */
        String patron = valido.campoTexto(entrada, campo, "curso");

        /** Agregamos el comodín '%' para la búsqueda parcial. */
        patron += "%";

        /** Abrimos una sesión de Hibernate para realizar la consulta. */
        Session session = sessionFactory.openSession();
        List<CursoEstudiante> listaCursosEstudiantes = null;

        try {
            /** Según el campo proporcionado, realizamos la consulta correspondiente. */
            switch (campo) {
                /** Búsqueda por nombre de estudiante. */
                case "estudiante" -> {
                    listaCursosEstudiantes = session.createQuery(
                            "select ce from CursoEstudiante ce " +
                                    "join ce.estudiante e " +
                                    "where e.nombre like :patron", 
                            CursoEstudiante.class
                    ).setParameter("patron", patron).getResultList();
                }

                /** Búsqueda por nombre de escuela. */
                case "escuela" -> {
                    listaCursosEstudiantes = session.createQuery(
                            "select ce from CursoEstudiante ce " +
                                    "join ce.curso e " +
                                    "join e.escuela es " + /** Join con la escuela a través del curso */
                                    "where es.nombre like :patron", 
                            CursoEstudiante.class
                    ).setParameter("patron", patron).getResultList();
                }

                /** Búsqueda por nombre de curso. */
                case "curso" -> {
                    listaCursosEstudiantes = session.createQuery(
                            "select ce from CursoEstudiante ce " +
                                    "join ce.curso e " +
                                    "where e.nombre like :patron", 
                            CursoEstudiante.class
                    ).setParameter("patron", patron).getResultList();
                }
            }

            /** Si no se encuentran resultados, mostramos un mensaje informando al usuario. */
            if (listaCursosEstudiantes.isEmpty()) {
                System.out.println("No hay ningún curso que coincida con tu búsqueda.");
            } else {
                /** Si hay resultados, mostramos los detalles en un formato organizado. */
            	System.out.println(String.format("%5s %15s %8s %15s %10s %10s %12s %10s %10s",
                        "ID ESTUDIANTE", "ESTUDIANTE", "EDAD","ID CURSO", "CURSO", "ESCUELA", "DIRECCION", "DIRECTOR", "FECHA INSCRIPCIÓN"));

                 /** Itera sobre la lista de estudiantes y muestra sus datos con formato alineado */
                 for (CursoEstudiante cursoEstudiante : listaCursosEstudiantes) {
                     System.out.println(String.format("%5d %20s %10d %15s %10s %10s %12s %10s %10s",
                     		cursoEstudiante.getEstudiante().getId(),
                             cursoEstudiante.getEstudiante().getNombre(),
                             cursoEstudiante.getEstudiante().getEdad(),
                             cursoEstudiante.getCurso().getId(),
                             cursoEstudiante.getCurso().getNombre(),
                             cursoEstudiante.getCurso().getEscuela().getNombre(),
                             cursoEstudiante.getCurso().getEscuela().getDireccion(),
                             cursoEstudiante.getCurso().getEscuela().getDirector().getNombre(),
                             cursoEstudiante.getFechaInscripcion().toString() /** Se convierte la fecha a String */
                     ));
                 }
            }

        } catch (Exception e) {
            /** Manejo de excepciones en caso de error en la consulta. */
            System.err.println("Error al listar los cursos:");
            e.printStackTrace();
        } finally {
            /** Cerramos la sesión de Hibernate si está abierta para liberar recursos. */
            if (session.isOpen()) {
                session.close();
            }
        }
    }
}

Validaciones

Ejercicio 32

Ejercicio: Clase de Validación Objetivo: Crear una clase llamada `Validacion` que facilite la validación de datos introducidos por el usuario a través de la consola. Requisitos: 1. Implementar un método que solicite al usuario un campo de texto y valide que no se quede vacío. Si el dato es inválido, se debe pedir nuevamente. 2. Implementar un método que solicite un número entero al usuario y valide que sea mayor que cero. En caso de recibir un dato no numérico o menor que uno, se debe pedir nuevamente. 3. Implementar un método que valide si una dirección de correo electrónico es válida utilizando una expresión regular. El correo debe cumplir con un formato básico como "usuario@dominio.com". 4. Implementar un método que pida al usuario una confirmación para realizar una acción (por ejemplo, eliminar un dato). El usuario deberá ingresar 's' (sí) o 'n' (no) para confirmar o cancelar la acción. La clase `Validacion` debe permitir realizar las siguientes operaciones: - Solicitar y validar un campo de texto (como el nombre de una persona o un producto). - Solicitar y validar un número entero (como una edad o cantidad). - Validar la validez de un correo electrónico. - Confirmar una acción mediante una respuesta simple de sí o no.

package es.pulsoft.validaciones;

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Validacion {

    /** 
     * Solicita un dato de tipo texto al usuario y lo valida para asegurarse de que no esté vacío.
     * 
     * @param entrada El objeto Scanner para leer la entrada del usuario.
     * @param campo El nombre del campo que se solicita (ej. "nombre").
     * @param tabla El nombre de la tabla o entidad (ej. "estudiante").
     * @return El dato ingresado por el usuario, si es válido.
     */
    public String campoTexto(Scanner entrada, String campo, String tabla) {
        
        String dato = "";

        /** Bucle de validación para asegurar que el campo no esté vacío. */
        while (true) {
            System.out.println("Introduce el " + campo + " del " + tabla + ":");
            dato = entrada.nextLine();

            /** Si el dato está vacío, se muestra un mensaje de error. */
            if (dato.trim().isBlank() || dato == null) {
                System.out.println("El " + campo + " del  " + tabla + " no puede quedar vacio, introducelo de nuevo");
            } else {
                return dato;
            }
        }
    }

    /** 
     * Solicita un dato de tipo entero al usuario y lo valida para asegurarse de que sea un número mayor que 0.
     * 
     * @param entrada El objeto Scanner para leer la entrada del usuario.
     * @param campo El nombre del campo que se solicita (ej. "edad").
     * @param tabla El nombre de la tabla o entidad (ej. "estudiante").
     * @return El dato ingresado por el usuario, si es válido.
     */
    public int campoEntero(Scanner entrada, String campo, String tabla) {

        int dato = 0;

        /** Bucle de validación para asegurarse de que el dato ingresado sea un entero mayor que 0. */
        while (true) {

            try {
                System.out.println("Introduce el " + campo + " del " + tabla + ":");
                dato = Integer.parseInt(entrada.nextLine());

                /** Si el número es menor que 1, se muestra un mensaje de error. */
                if (dato < 1) {
                    System.out.println("El " + campo + " del  " + tabla + " no puede ser menor que 1, introducelo de nuevo");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                /** Si el formato no es válido, se muestra un mensaje de error. */
                System.err.println("Formato de " + campo + " no valido, introducelo de nuevo");
            }
        }
    }

    /** 
     * Verifica si un correo electrónico es válido según un patrón común.
     * 
     * @param email El correo electrónico que se desea validar.
     * @return true si el correo electrónico es válido, false en caso contrario.
     */
    public boolean esEmailValido(String email) {
        /* Expresión regular para validar un correo electrónico básico*/
        String regex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
        
        /* Compila la expresión regular*/
        Pattern pattern = Pattern.compile(regex);
        
        /* Si el email es nulo o vacío, lo consideramos inválido*/
        if (email == null || email.isEmpty()) {
            return false;
        }
        
        /* Crea un objeto Matcher para hacer coincidir el patrón con el correo proporcionado*/
        Matcher matcher = pattern.matcher(email);
        
        /* Devuelve si el correo electrónico cumple con la expresión regular*/
        return matcher.matches();
    }

    /** 
     * Solicita una confirmación de acción al usuario.
     * 
     * @param entrada El objeto Scanner para leer la entrada del usuario.
     * @param campo El nombre del campo o entidad que se está procesando (ej. "producto").
     * @return true si el usuario confirma la acción, false si la cancela.
     */
    public boolean confirmacion(Scanner entrada, String campo) {
        char respuesta = ' ';
        while (true) {
            System.out.println("¿Estás seguro de querer borrar al " + campo + "?(s/n)");
            respuesta = entrada.nextLine().toLowerCase().charAt(0);

            /** Si la respuesta es inválida, se muestra un mensaje de error. */
            if (respuesta != 's' && respuesta != 'n') {
                System.out.println("La respuesta tiene que ser sí(s) o no(n), introdúcela de nuevo");
            } else {
                if (respuesta == 's') {
                    return true;
                } else {
                    return false;
                }
            }
        }
    }
}

Clase Principal

Ejercicio 33

Ejercicio para estudiantes: Gestión de una Escuela con Hibernate Este programa permite gestionar una escuela mediante un menú interactivo que permite realizar operaciones CRUD (Crear, Leer, Actualizar, Borrar) sobre entidades como Directores, Escuelas, Cursos, Estudiantes y las relaciones entre Cursos y Estudiantes. Utiliza Hibernate para la persistencia de datos y ofrece un menú de consola para interactuar con las diferentes funcionalidades. El programa está diseñado para que los estudiantes practiquen el uso de Hibernate, la gestión de entidades y la interacción con bases de datos relacionales.


package es.pulsoft.principal;

import java.util.Scanner;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import es.pulsoft.curso.ActualizarCurso;
import es.pulsoft.curso.AgregarCurso;
import es.pulsoft.curso.BorrarCurso;
import es.pulsoft.curso.BuscarCurso;
import es.pulsoft.curso.MostrarCurso;
import es.pulsoft.cursoestudiante.ActualizarCursoEstudiante;
import es.pulsoft.cursoestudiante.AgregarCursoEstudiante;
import es.pulsoft.cursoestudiante.BorrarCursoEstudiante;
import es.pulsoft.cursoestudiante.BuscarCursoEstudiante;
import es.pulsoft.cursoestudiante.MostrarCursoEstudiante;
import es.pulsoft.director.ActualizarDirector;
import es.pulsoft.director.AgregarDirector;
import es.pulsoft.director.BorrarDirector;
import es.pulsoft.director.BuscarDirector;
import es.pulsoft.director.MostrarDirector;
import es.pulsoft.escuela.ActualizarEscuela;
import es.pulsoft.escuela.AgregarEscuela;
import es.pulsoft.escuela.BorrarEscuela;
import es.pulsoft.escuela.BuscarEscuela;
import es.pulsoft.escuela.MostrarEscuela;
import es.pulsoft.estudiante.ActualizarEstudiante;
import es.pulsoft.estudiante.AgregarEstudiante;
import es.pulsoft.estudiante.BorrarEstudiante;
import es.pulsoft.estudiante.BuscarEstudiante;
import es.pulsoft.estudiante.MostrarEstudiante;
import es.pulsoft.mapeo.Curso;
import es.pulsoft.mapeo.CursoEstudiante;
import es.pulsoft.mapeo.Director;
import es.pulsoft.mapeo.Escuela;
import es.pulsoft.mapeo.Estudiante;

/**
 * Clase principal que contiene el método main y gestiona el menú de la aplicación.
 */
public class Main {

    /**
     * Método principal que inicia la aplicación.
     * 
     * @param args Argumentos de la línea de comandos (no se utilizan en este programa).
     */
    public static void main(String[] args) {
        
        Scanner entrada = new Scanner(System.in);
        
        /* Configuración de la SessionFactory de Hibernate */
        SessionFactory sessionFactory = new Configuration()
                .configure("hibernate.cfg.xml")
                .addAnnotatedClass(Curso.class)
                .addAnnotatedClass(CursoEstudiante.class)
                .addAnnotatedClass(Director.class)
                .addAnnotatedClass(Escuela.class)
                .addAnnotatedClass(Estudiante.class)
                .buildSessionFactory();
        
        int opcionMenu = 0;
        
        /* Bucle principal del menú */
        do {
            System.out.println("******** MENU ESCUELA ********");
            System.out.println("1.Menu Directores");
            System.out.println("2.Menu Escuela");
            System.out.println("3.Menu Curso");
            System.out.println("4.Menu Estudiante");
            System.out.println("5.Menu Inscripciones");
            System.out.println("6.Salir");
            System.out.println("Escoge opcion:");
            
            try {
                opcionMenu = Integer.parseInt(entrada.nextLine());
                gestionoMenuPrincipal(entrada, sessionFactory, opcionMenu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion menu no valido, introducelo de nuevo");
            }
        } while (opcionMenu != 6);

    }
    
    /**
     * Gestiona la opción seleccionada en el menú principal.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcionMenu Opción seleccionada por el usuario.
     */
    private static void gestionoMenuPrincipal(Scanner entrada, SessionFactory sessionFactory, int opcionMenu) {
        
        switch (opcionMenu) {
            case 1 -> menuDirector(entrada, sessionFactory);
            case 2 -> menuEscuela(entrada, sessionFactory);
            case 3 -> menuCurso(entrada, sessionFactory);
            case 4 -> menuEstudiante(entrada, sessionFactory);
            case 5 -> menuCursoEstudiante(entrada, sessionFactory);
            case 6 -> {
                System.out.println("Saliendo del programa ...");
                entrada.close();
                sessionFactory.close();
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
        }
    }
    
    /**
     * Muestra el menú de gestión de Directores.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuDirector(Scanner entrada, SessionFactory sessionFactory) {
        
        int opcionMenu = 0;
        
        do {
            System.out.println("******** MENU DIRECTOR ********");
            System.out.println("1.Agregar Director");
            System.out.println("2.Actualizar Director");
            System.out.println("3.Borrar Director");
            System.out.println("4.Mostrar todos los  Directores");
            System.out.println("5.Busqueda de Directores");
            System.out.println("6.Volver al menu principal");
            System.out.println("Escoge opcion:");
            
            try {
                opcionMenu = Integer.parseInt(entrada.nextLine());
                gestionoMenuDirector(entrada, sessionFactory, opcionMenu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
            }
        } while (opcionMenu != 6);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de Directores.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcionMenu Opción seleccionada por el usuario.
     */
    private static void gestionoMenuDirector(Scanner entrada, SessionFactory sessionFactory, int opcionMenu) {
        
        switch (opcionMenu) {
            case 1 -> {
                AgregarDirector add = new AgregarDirector();
                add.agregarDirector(entrada, sessionFactory);
            }
            case 2 -> {
                ActualizarDirector update = new ActualizarDirector();
                update.actualizarDirector(entrada, sessionFactory);
            }
            case 3 -> {
                BorrarDirector delete = new BorrarDirector();
                delete.borrarDirector(entrada, sessionFactory);
            }
            case 4 -> {
                MostrarDirector view = new MostrarDirector();
                view.mostrarDirectores(sessionFactory);
            }
            case 5 -> menuBusquedaDirector(entrada, sessionFactory);
            case 6 -> System.out.println("Volviendo al menu principal");
            default -> System.out.println("Opcion no contemplada en el menu de director, introducelo de nuevo");
        }
    }
    
    /**
     * Muestra el menú de búsqueda de Directores.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuBusquedaDirector(Scanner entrada, SessionFactory sessionFactory) {
        int opcionBusqueda = 0;
        do {
            System.out.println("******** MENU BUSQUEDA DIRECTOR ********");
            System.out.println("1.Buscar por nombre");
            System.out.println("2.Buscar por correo");
            System.out.println("3.Volver al menu de director");
            System.out.println("Escoge opcion:");
            
            try {
                opcionBusqueda = Integer.parseInt(entrada.nextLine());
                gestionoMenuBusquedaDirector(entrada, sessionFactory, opcionBusqueda);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu de busqueda incorrecto, introducelo de nuevo");
            }
        } while (opcionBusqueda != 3);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de búsqueda de Directores.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcion Opción seleccionada por el usuario.
     */
    private static void gestionoMenuBusquedaDirector(Scanner entrada, SessionFactory sessionFactory, int opcion) {
        BuscarDirector search = new BuscarDirector();
        switch (opcion) {
            case 1 -> search.buscarDirector(entrada, sessionFactory, "nombre");
            case 2 -> search.buscarDirector(entrada, sessionFactory, "correo");
        }
    }
    
    /**
     * Muestra el menú de gestión de Escuelas.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuEscuela(Scanner entrada, SessionFactory sessionFactory) {
        
        int opcionMenu = 0;
        
        do {
            System.out.println("******** MENU ESCUELA ********");
            System.out.println("1.Agregar Escuela");
            System.out.println("2.Actualizar Escuela");
            System.out.println("3.Borrar Escuela");
            System.out.println("4.Mostrar todas las  Escuelas");
            System.out.println("5.Busqueda de Escuelas");
            System.out.println("6.Volver al menu principal");
            System.out.println("Escoge opcion:");
            
            try {
                opcionMenu = Integer.parseInt(entrada.nextLine());
                gestionoMenuEscuela(entrada, sessionFactory, opcionMenu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
            }
        } while (opcionMenu != 6);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de Escuelas.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcionMenu Opción seleccionada por el usuario.
     */
    private static void gestionoMenuEscuela(Scanner entrada, SessionFactory sessionFactory, int opcionMenu) {
        
        switch (opcionMenu) {
            case 1 -> {
                AgregarEscuela add = new AgregarEscuela();
                add.agregarEscuela(entrada, sessionFactory);
            }
            case 2 -> {
                ActualizarEscuela update = new ActualizarEscuela();
                update.actualizarEscuela(entrada, sessionFactory);
            }
            case 3 -> {
                BorrarEscuela delete = new BorrarEscuela();
                delete.borrarEscuela(entrada, sessionFactory);
            }
            case 4 -> {
                MostrarEscuela view = new MostrarEscuela();
                view.mostrarEscuela(sessionFactory);
            }
            case 5 -> menuBusquedaEscuela(entrada, sessionFactory);
            case 6 -> System.out.println("Volviendo al menu principal");
            default -> System.out.println("Opcion no contemplada en el menu de escuela, introducelo de nuevo");
        }
    }
    
    /**
     * Muestra el menú de búsqueda de Escuelas.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuBusquedaEscuela(Scanner entrada, SessionFactory sessionFactory) {
        int opcionBusqueda = 0;
        do {
            System.out.println("******** MENU BUSQUEDA ESCUELA ********");
            System.out.println("1.Buscar por nombre");
            System.out.println("2.Buscar por direccion");
            System.out.println("3.Volver al menu de escuela");
            System.out.println("Escoge opcion:");
            
            try {
                opcionBusqueda = Integer.parseInt(entrada.nextLine());
                gestionoMenuBusquedaEscuela(entrada, sessionFactory, opcionBusqueda);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu de busqueda incorrecto, introducelo de nuevo");
            }
        } while (opcionBusqueda != 3);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de búsqueda de Escuelas.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcion Opción seleccionada por el usuario.
     */
    private static void gestionoMenuBusquedaEscuela(Scanner entrada, SessionFactory sessionFactory, int opcion) {
        BuscarEscuela search = new BuscarEscuela();
        switch (opcion) {
            case 1 -> search.buscarEscuela(entrada, sessionFactory, "nombre");
            case 2 -> search.buscarEscuela(entrada, sessionFactory, "direccion");
        }
    }
    
    /**
     * Muestra el menú de gestión de Cursos.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuCurso(Scanner entrada, SessionFactory sessionFactory) {
        
        int opcionMenu = 0;
        
        do {
            System.out.println("******** MENU CURSO ********");
            System.out.println("1.Agregar Curso");
            System.out.println("2.Actualizar Curso");
            System.out.println("3.Borrar Curso");
            System.out.println("4.Mostrar todos los Cursos");
            System.out.println("5.Busqueda de Cursos por nombre");
            System.out.println("6.Volver al menu principal");
            System.out.println("Escoge opcion:");
            
            try {
                opcionMenu = Integer.parseInt(entrada.nextLine());
                gestionoMenuCurso(entrada, sessionFactory, opcionMenu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
            }
        } while (opcionMenu != 6);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de Cursos.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcionMenu Opción seleccionada por el usuario.
     */
    private static void gestionoMenuCurso(Scanner entrada, SessionFactory sessionFactory, int opcionMenu) {
        
        switch (opcionMenu) {
            case 1 -> {
                AgregarCurso add = new AgregarCurso();
                add.agregarCurso(entrada, sessionFactory);
            }
            case 2 -> {
                ActualizarCurso update = new ActualizarCurso();
                update.actualizarCurso(entrada, sessionFactory);
            }
            case 3 -> {
                BorrarCurso delete = new BorrarCurso();
                delete.borrarCurso(entrada, sessionFactory);
            }
            case 4 -> {
                MostrarCurso view = new MostrarCurso();
                view.mostrarCurso(sessionFactory);
            }
            case 5 -> {
                BuscarCurso search = new BuscarCurso();
                search.buscarCurso(entrada, sessionFactory, "nombre");
            }
            case 6 -> System.out.println("Volviendo al menu principal");
            default -> System.out.println("Opcion no contemplada en el menu de curso, introducelo de nuevo");
        }
    }
    
    /**
     * Muestra el menú de gestión de Estudiantes.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        int opcionMenu = 0;
        
        do {
            System.out.println("******** MENU ESTUDIANTE ********");
            System.out.println("1.Agregar Estudiante");
            System.out.println("2.Actualizar Estudiante");
            System.out.println("3.Borrar Estudiante");
            System.out.println("4.Mostrar todos los Estudiantes");
            System.out.println("5.Busqueda de Estudiantes");
            System.out.println("6.Volver al menu principal");
            System.out.println("Escoge opcion:");
            
            try {
                opcionMenu = Integer.parseInt(entrada.nextLine());
                gestionoMenuEstudiante(entrada, sessionFactory, opcionMenu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
            }
        } while (opcionMenu != 6);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de Estudiantes.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcionMenu Opción seleccionada por el usuario.
     */
    private static void gestionoMenuEstudiante(Scanner entrada, SessionFactory sessionFactory, int opcionMenu) {
        
        switch (opcionMenu) {
            case 1 -> {
                AgregarEstudiante add = new AgregarEstudiante();
                add.agregarEstudiante(entrada, sessionFactory);
            }
            case 2 -> {
                ActualizarEstudiante update = new ActualizarEstudiante();
                update.actualizarEstudiante(entrada, sessionFactory);
            }
            case 3 -> {
                BorrarEstudiante delete = new BorrarEstudiante();
                delete.borrarEstudiante(entrada, sessionFactory);
            }
            case 4 -> {
                MostrarEstudiante view = new MostrarEstudiante();
                view.mostrarEstudiantes(sessionFactory);
            }
            case 5 -> menuBusquedaEstudiante(entrada, sessionFactory); 
            case 6 -> System.out.println("Volviendo al menu principal");
            default -> System.out.println("Opcion no contemplada en el menu de curso, introducelo de nuevo");
        }
    }
    
    /**
     * Muestra el menú de búsqueda de Estudiantes.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuBusquedaEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        int opcionBusqueda = 0;
        do {
            System.out.println("******** MENU BUSQUEDA ESCUELA ********");
            System.out.println("1.Buscar por nombre");
            System.out.println("2.Buscar por direccion");
            System.out.println("3.Volver al menu de escuela");
            System.out.println("Escoge opcion:");
            
            try {
                opcionBusqueda = Integer.parseInt(entrada.nextLine());
                gestionoMenuBusquedaEstudiante(entrada, sessionFactory, opcionBusqueda);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu de busqueda incorrecto, introducelo de nuevo");
            }
        } while (opcionBusqueda != 3);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de búsqueda de Estudiantes.
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcion Opción seleccionada por el usuario.
     */
    private static void gestionoMenuBusquedaEstudiante(Scanner entrada, SessionFactory sessionFactory, int opcion) {
        BuscarEstudiante search = new BuscarEstudiante();
        switch (opcion) {
            case 1 -> search.buscarEstudiante(entrada, sessionFactory, "nombre");
            case 2 -> search.buscarEstudiante(entrada, sessionFactory, "edad");
        }
    }
    
    /**
     * Muestra el menú de gestión de Inscripciones (Curso-Estudiante).
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuCursoEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        
        int opcionMenu = 0;
        
        do {
            System.out.println("******** MENU INSCRIPCIONES ********");
            System.out.println("1.Apuntar Estudiante a Curso");
            System.out.println("2.Actualizar Curso-Estudiante");
            System.out.println("3.Borrar Curso-Estudiante");
            System.out.println("4.Mostrar todos los Cursos-Estudiantes");
            System.out.println("5.Busqueda de Cursos");
            System.out.println("6.Volver al menu principal");
            System.out.println("Escoge opcion:");
            
            try {
                opcionMenu = Integer.parseInt(entrada.nextLine());
                gestionoMenuCursoEstudiante(entrada, sessionFactory, opcionMenu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu no valido, introducelo de nuevo");
            }
        } while (opcionMenu != 6);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de Inscripciones (Curso-Estudiante).
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcionMenu Opción seleccionada por el usuario.
     */
    private static void gestionoMenuCursoEstudiante(Scanner entrada, SessionFactory sessionFactory, int opcionMenu) {
        
        switch (opcionMenu) {
            case 1 -> {
                AgregarCursoEstudiante add = new AgregarCursoEstudiante();
                add.agregarCursoEstudiante(entrada, sessionFactory);
            }
            case 2 -> {
                ActualizarCursoEstudiante update = new ActualizarCursoEstudiante();
                update.actualizarCursoEstudiante(entrada, sessionFactory);
            }
            case 3 -> {
                BorrarCursoEstudiante delete = new BorrarCursoEstudiante();
                delete.borrarCursoEstudiante(entrada, sessionFactory);
            }
            case 4 -> {
                MostrarCursoEstudiante view = new MostrarCursoEstudiante();
                view.mostrarCursosEstudiantes(sessionFactory);
            }
            case 5 -> menuBusquedaCursoEstudiante(entrada, sessionFactory); 
            case 6 -> System.out.println("Volviendo al menu principal");
            default -> System.out.println("Opcion no contemplada en el menu de curso, introducelo de nuevo");
        }
    }
    
    /**
     * Muestra el menú de búsqueda de Inscripciones (Curso-Estudiante).
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     */
    private static void menuBusquedaCursoEstudiante(Scanner entrada, SessionFactory sessionFactory) {
        int opcionBusqueda = 0;
        do {
            System.out.println("******** MENU BUSQUEDA ESCUELA ********");
            System.out.println("1.Buscar por estudiante");
            System.out.println("2.Buscar por escuela");
            System.out.println("3.Buscar por curso");
            System.out.println("4.Volver al menu de escuela");
            System.out.println("Escoge opcion:");
            
            try {
                opcionBusqueda = Integer.parseInt(entrada.nextLine());
                gestionoMenuBusquedaCursoEstudiante(entrada, sessionFactory, opcionBusqueda);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opcion de menu de busqueda incorrecto, introducelo de nuevo");
            }
        } while (opcionBusqueda != 4);
    }
    
    /**
     * Gestiona la opción seleccionada en el menú de búsqueda de Inscripciones (Curso-Estudiante).
     * 
     * @param entrada Scanner para la entrada de datos.
     * @param sessionFactory SessionFactory de Hibernate.
     * @param opcion Opción seleccionada por el usuario.
     */
    private static void gestionoMenuBusquedaCursoEstudiante(Scanner entrada, SessionFactory sessionFactory, int opcion) {
        BuscarCursoEstudiante search = new BuscarCursoEstudiante();
        switch (opcion) {
            case 1 -> search.buscarCursoEstudiante(entrada, sessionFactory, "estudiante");
            case 2 -> search.buscarCursoEstudiante(entrada, sessionFactory, "escuela");
            case 3 -> search.buscarCursoEstudiante(entrada, sessionFactory, "curso");
        }
    }
}