LAB | Java Modelado de relaciones complejas

Introducción

Acabamos de aprender cómo usar el Mapeo de Relaciones para modelar relaciones 1 a 1 y relaciones 1 a muchos, así que practiquemos un poco más.

Requisitos

1. Haz un fork de este repositorio.
2. Clona este repositorio.
3. Añade a tu instructor y a los calificadores de la clase como colaboradores de tu repositorio. Si no estás seguro de quiénes son los calificadores de tu clase, pregunta a tu instructor o consulta la presentación del primer día.
4. En el repositorio, crea un proyecto de Java y añade el código para las siguientes tareas.

Entrega

Una vez que termines la tarea, envía un enlace URL a tu repositorio o tu solicitud de extracción en el campo de abajo.

Instrucciones

1. Utilizando el modelo Spring JPA, crea las relaciones para una aplicación para una Asociación de Enfermeras. La Asociación tiene 7 divisiones y cada

• División tiene las siguientes propiedades:

  • name: el nombre de la división
  • district: el distrito geográfico al que pertenece la división
  • president: un objeto Miembro que representa el presidente de la división
  • list: una lista de objetos Miembro que representan a los miembros de la división

• Cada Miembro tiene las siguientes propiedades:

  • name: el nombre del miembro
  • status: el estatus del miembro, que puede ser ACTIVE or LAPSED (ACTIVO o LAPSADO)
  • renewal date: la fecha en que se renovará la membresía del miembro

2. Utilizando el modelo Spring JPA, crear las relaciones para una aplicación de Gestión de Eventos. La aplicación necesita modelar eventos próximos, que pueden ser de dos tipos: Conferencias o Exposiciones.

• Cada evento tiene las siguientes propiedades:

  • date: la fecha en que se llevará a cabo el evento
  • duration: la duración del evento
  • location: la ubicación del evento
  • title: el título del evento
  • list: una lista de invitados a los que se les ha invitado al evento.

• Cada invitado tiene las siguientes propiedades:

  • name: el nombre del invitado
  • status: la respuesta del invitado, que puede ser ATTENDING, NOT_ATTENDING, or NO_RESPONSE (ASISTIENDO, NO ASISTIENDO, o SIN RESPUESTA)

Además de las propiedades típicas de eventos, las Conferencias también tienen una lista de Oradores.

• Cada Orador tiene las siguientes propiedades:

• name: el nombre del orador

• presentationDuration: la duración de la presentación.

FAQs (Preguntas frecuentes)

Estoy atascado y no sé cómo resolver el problema o por dónde empezar. ¿Qué debo hacer?

Si estás atascado en tu código y no sabes cómo resolver el problema o por dónde empezar, debes dar un paso atrás y tratar de formular una pregunta clara y directa sobre el problema específico que enfrentas. El proceso que seguirás al tratar de definir esta pregunta te ayudará a limitar el problema y a encontrar soluciones potenciales.

Por ejemplo, ¿estás enfrentando un problema porque no entiendes el concepto o estás recibiendo un mensaje de error que no sabes cómo arreglar? Por lo general, es útil intentar formular el problema de la manera más clara posible, incluyendo cualquier mensaje de error que estés recibiendo. Esto puede ayudarte a comunicar el problema a otras personas y, potencialmente, a obtener ayuda de tus compañeros o recursos en línea.

Una vez que tengas una comprensión clara del problema, deberías poder comenzar a trabajar hacia la solución.

¿Cómo creo un proyecto de Spring boot?

Spring boot es un framework para crear aplicaciones autónomas y de calidad de producción que son fáciles de lanzar y ejecutar. La mejor manera de crear un proyecto de Spring boot es usar el sitio web Spring Initializer. El sitio web proporciona una manera conveniente de generar una estructura básica de proyecto con todas las dependencias y configuraciones necesarias.

• Paso 1: Ve a start.spring.io
• Paso 2: Elige el tipo de proyecto que desea crear, como Maven o Gradle.
• Paso 3: Selecciona la versión de Spring Boot que deseas utilizar.
• Paso 4: Elige las dependencias que necesitas para su proyecto. Algunas dependencias comunes incluyen web, jpa y data-jpa.
• Paso 5: Haz clic en el botón "Generar" para descargar los archivos del proyecto.

Como alternativa, puedes usar un Entorno de Desarrollo Integrado (IDE) como Eclipse o IntelliJ IDEA. Estos IDEs tienen complementos para crear proyectos de Spring boot, lo que facilita la configuración del entorno y el inicio de la codificación.

¿Qué es JPA y cómo puedo usarlo en Java?

JPA significa Interfaz de Persistencia Java, que es una especificación Java para acceder, persistir y gestionar datos entre objetos Java y una base de datos relacional. JPA proporciona una interfaz estándar para acceder a bases de datos, reduciendo la necesidad de código personalizado de acceso a datos y permitiendo una gestión eficiente de las conexiones a la base de datos.

Para usar JPA en Java, necesitarás incluir las dependencias necesarias en tu proyecto, como la implementación JPA de Hibernate y crear clases de entidades para representar tus datos. Estas clases de entidades serán anotadas con anotaciones específicas de JPA, como @Entity y @Id, para indicar la asignación entre la clase Java y la tabla de la base de datos.

Aquí hay un fragmento de código para mostrar cómo crear una clase de entidad JPA en Java:

@Entity
public class Employee {
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  private int id;

  private String name;
  private int age;
  private String position;

  // Getters and Setters for the attributes
}  

¿Cuál es el propósito de usar las anotaciones "@Entity", "@Table" y "@Column" en JPA (Java Persistence API)?

Las anotaciones @Entity, @Table y @Column en JPA (Java Persistence API) se utilizan para mapear objetos Java a tablas de bases de datos relacionales.

@Entity se utiliza para marcar una clase como una entidad persistente. Esto significa que las instancias de la clase pueden almacenarse en una base de datos.

@Table se utiliza para definir el nombre de la tabla de base de datos a la que se asignará la entidad.

@Column se utiliza para definir las columnas en la tabla que corresponden a los atributos de la entidad.

Aquí hay un ejemplo de cómo usar estas anotaciones:

@Entity
@Table(name="employee")
public class Employee {

  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  @Column(name="id")
  private int id;

  @Column(name="first_name")
  private String firstName;

  @Column(name="last_name")
  private String lastName;

  //getters and setters
}

En este ejemplo, la clase Employee se marca como una entidad persistente usando la anotación @Entity. El nombre de la tabla de base de datos se define usando la anotación @Table como "employee" (empleado). Los atributos id, firstName y lastName se mapean a columnas en la tabla "employee" (empleado) usando la anotación @Column.

¿Cuál es la diferencia entre las estrategias de herencia "JOINED", "TABLE_PER_CLASS" y "SINGLE_TABLE" en JPA y cuándo utilizarlas?

La anotación @Inheritance en JPA se puede usar para especificar la estrategia de herencia para las entidades en JPA. Hay tres estrategias disponibles en JPA: SINGLE_TABLE, JOINED y TABLE_PER_CLASS. La estrategia de herencia se especifica utilizando el atributo de estrategia en la anotación @Inheritance.

Las estrategias de herencia en JPA determinan cómo se almacena los datos en la base de datos para las entidades que heredan de una entidad padre.

• Estrategia JOINED: crea tablas separadas para cada entidad concreta y se utiliza una unión entre ellas para recuperar los datos.

  @Inheritance(strategy=InheritanceType.JOINED)
  @Entity
  public class Parent {
  // ...
  }

• Estrategia TABLE_PER_CLASS: crea una tabla separada para cada entidad concreta e incluye todas las columnas de la entidad padre también.

  @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
  @Entity
  public class Parent {
  // ...
  }

• Estrategia SINGLE_TABLE: crea una única tabla para todas las entidades en la jerarquía, incluyendo una columna discriminadora para distinguir entre las entidades.

  @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
  @Entity
  public class Parent {
  // ...
  }

  La elección de la estrategia de herencia depende de los requisitos de la aplicación, como la necesidad de normalización, el número de columnas en la tabla y el número de uniónes requeridas para recuperar los datos. Por ejemplo, si las entidades tienen muchas columnas y es importante la normalización, entonces la estrategia JOINED es apropiada. Si hay menos columnas, la estrategia TABLE_PER_CLASS puede ser más adecuada. La estrategia SINGLE_TABLE es la más simple y compacta pero puede resultar en un modelo de datos menos flexible.

¿Qué es "JpaRepository" y cómo puedo usarlo en Java?

JpaRepository es una interfaz de Spring Data que extiende la interfaz PagingAndSortingRepository. Proporciona todas las operaciones básicas CRUD (Create, Read, Update, Delete) (Crear, Leer, Actualizar, Eliminar) y métodos adicionales para trabajar con JPA (Java Persistence API) para interactuar con la base de datos.

Para usar JpaRepository en su proyecto, siga los siguientes pasos:

Paso 1: Importa las bibliotecas necesarias

import org.springframework.data.jpa.repository.JpaRepository;

Paso 2: Crea una interfaz que extienda JpaRepository

public interface MyRepository extends JpaRepository<MyEntity, Long> {

}

Nota: En el código anterior, MyEntity es la clase de entidad con la que desea interactuar y Long es el tipo de la clave primaria de MyEntity.

Paso 3: Inyecta la interfaz en la clase donde la desees usar.

@Autowired
private MyRepository myRepository;

Paso 4: Ahora puedes usar los métodos proporcionados por JpaRepository para interactuar con la base de datos, por ejemplo:

MyEntity myEntity = new MyEntity();
myRepository.save(myEntity);

Con los pasos anteriores, ahora puedes usar JpaRepository para interactuar con la base de datos en tu proyecto de Java.

¿Cómo puedo usar las anotaciones JPA "@OneToOne", "@OneToMany", "@ManyToOne", "@ManyToMany", "@JoinColumn" y "@JoinTable" en Java?

La API de Persistencia de Java (JPA) proporciona varias anotaciones para mapear relaciones entre entidades en aplicaciones de Java. Estas anotaciones incluyen:

1. @OneToOne: Esta anotación se utiliza para definir una relación uno a uno entre dos entidades. El siguiente código muestra cómo usar la anotación @OneToOne:

@Entity
public class Employee {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;

  @OneToOne(cascade = CascadeType.ALL)
  @JoinColumn(name = "address_id", referencedColumnName = "id")
  private Address address;

  // Getters and setters ...
}

@Entity
public class Address {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String street;

  private String city;

  // Getters and setters ...
}

2. @OneToMany & @ManyToOne: Estas anotaciones se utilizan para definir relaciones uno a muchos y muchos a uno entre dos entidades.

El siguiente código muestra cómo usar la anotación @OneToMany y la anotación @ManyToOne:

@Entity
public class Department {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;

  @OneToMany(mappedBy = "department")
  private List<Employee> employees;

  // Getters and setters ...
}

@Entity
public class Employee {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;

  @ManyToOne
  @JoinColumn(name = "department_id", referencedColumnName = "id")
  private Department department;

  // Getters and setters ...
}

3. @ManyToMany & @JoinColumn & @JoinTable: La anotación @ManyToMany se utiliza en Java para definir una relación muchos a muchos entre dos entidades. Esto significa que múltiples instancias de una entidad pueden estar relacionadas con múltiples instancias de otra entidad.

La anotación @JoinColumn se utiliza en Java para especificar la columna de clave externa que se utilizará para unir las dos entidades. La columna de clave externa se utiliza para establecer una relación entre las entidades.

La anotación @JoinTable se utiliza en Java para definir una tabla de unión para una relación muchos a muchos. La tabla de unión se utiliza para almacenar la información de la relación entre las dos entidades.

El siguiente código muestra cómo usar las anotaciones @ManyToMany, @JoinColumn y @JoinTable:

@Entity
public class User {

    @ManyToMany
    @JoinTable(name = "user_role",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "role_id"))
    private List<Role> roles;

}

@Entity
public class Role {

    @ManyToMany(mappedBy = "roles")
    private List<User> users;

}

No puedo enviar cambios a mi repositorio. ¿Qué debo hacer?

Si no puedes enviar cambios a tu repositorio, aquí hay algunos pasos que puedes seguir:

1. Verifica tu conexión a internet: Asegúrate de que tu conexión a internet sea estable y funcione.
2. Verifica la URL de tu repositorio: Asegúrate de estar usando la URL correcta de tu repositorio para enviar tus cambios.
3. Revisa tus credenciales de Git: Asegúrate de que tus credenciales de Git estén actualizadas y correctas. Puedes revisar tus credenciales usando el siguiente comando:

git config --list

4. Actualiza tu repositorio local: Antes de enviar cambios, asegúrate de que tu repositorio local esté actualizado con el repositorio remoto. Puedes actualizar tu repositorio local usando el siguiente comando:

git fetch origin

5. Revisa posibles conflictos: Si hay conflictos entre tu repositorio local y el repositorio remoto, resuélvelos antes de enviar cambios.
6. Envía cambios: Una vez que hayas resuelto los conflictos y actualizado tu repositorio local, puedes intentar enviar cambios nuevamente usando el siguiente comando:

git push origin <branch_name>