Josel Toro: 3. Relaciones entre entidades

¡Bienvenidos a todos! Esta publicación formará parte de una serie de 10 publicaciones que estaré desarrollando para aprender a crear una aplicación web en Java, bajo la plataforma JEE usando los frameworks de JPA y JSF. Este será un curso en forma de guía para todas aquellas personas que estén empezando en el mundo de la programación web.

En este curso aprenderemos a desarrollar aplicaciones web en N-CAPAS utilizando los patrones de diseño JEE, el estilo arquitectónico MVC y las funcionalidades provistas por los framework JSF (Java Server Faces) a nivel de vista-controlador y por JPA (Java Persistence API) a nivel de persistencia.

Este curso estará dividido en dos partes, En la primera parte, aprenderemos a configurar y utilizar el framework JPA mediante el desarrollo de aplicaciones Stand.Alone. En la segunda parte, aprenderemos a utilizar el framework JSF para desarrollar aplicaciones web. Por último, integraremos las funcionalidades de ambos frameworks en una aplicación final.

Aplicación STAND-ALONE

Continuando con el post anterior donde aprendimos a crear una clase EntityListener para monitorear el ciclo de vida de una entidad. Hoy aprenderemos a relacionar entidades según el modelo de datos.

OBJETIVOS

. Creación de nuevas entidades (Cargo y Casillero)

. Configuración ORM y relaciones entre entidades según el modelo de datos

. Mapeo lógico con (@OneToMany, @ManyToOne, @OneToOne)

. Mapeo físico con (@JoinColumn)

APLICACIÓN

1. Ejecutar el proyecto de la sesión anterior

Vamos a crear una copia del proyecto de la sesión anterior y le cambiaremos el nombre a "Aplicacion_JPA_03".

Después de importar nuestro proyecto compilamos el archivo "script2 y script3" que se encuentra dentro de la carpeta "bd". Asimismo, es opcional cambiar el nombre a la unidad de persistencia en el archivo "persistence.xml" y también la referencia a ella en el método "setup" de la clase "EmpleadoJPA", las cuales tienen el nombre del proyecto anterior "Aplicacion_JPA_02". Ustedes pueden ponerle el nombre que deseen a su unidad de persistencia, yo le pondré "Aplicacion_JPA_03" para que vaya acorde con el nombre del proyecto.

persistence.xml...
<persistence-unit name="Aplicacion_JPA_03">"

EmpleadoJPA
"emf =Persistence.createEntityManagerFactory("Aplicacion_JPA_03");"

Ver como importar un proyecto JPA aquí

El proyecto debe tener la siguiente estructura.

2. ORM y Anotaciones

Vamos a realizar nuevas configuraciones al proyecto

Paso 1: Crear las entidades Cargo y Casillero

Clase Empleado:

Añadir el nuevo campo “Fecha de Ingreso” a la clase "Empleado".

@Basic
@Column(name="FEC_ING_EMP", nullable=false, insertable=true, updatable=true)
private Date fechaIngreso;

Por ser "java.sql.Date", no requiere uso de anotación "@Temporal".

Añadir la siguiente línea de código en "EmpleadoTest".

entidadEmpleado.setFechaIngreso(new Date(Calendar.getInstance().getTime().getTime()));

Clase Cargo:

@Entity
@Table(name="tb_cargo")
public class Cargo implements Serializable{
 
 @Id
 @GeneratedValue(strategy=GenerationType.IDENTITY)
 @Column(name="COD_CAR")
 private int codigo;
  
 @Column(name="DES_CAR")
 private String descripcion;
  
}

Clase Casillero:

package edu.aprender.persistence.entity;
 
@Entity
@Table(name="tb_casillero")
public class Casillero implements Serializable{
 
 @Id
 @GeneratedValue(strategy=GenerationType.IDENTITY)
 @Column(name="COD_CAS")
 private int codigo;
  
 @Column(name="DES_CAS")
 private String descripcion;
  
}

Paso 2: Registrar las nuevas entidades en el archivo "persistence.xml"

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
 <persistence-unit name="Aplicacion_07_Mapping_con_JPA_Tablas_R">
  <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
  <class>edu.aprender.persistence.entity.Empleado</class>
  <class>edu.aprender.persistence.entity.Cargo</class>
  <class>edu.aprender.persistence.entity.Casillero</class>
  <properties>
   <property name="javax.persistence.jdbc.driver"  value="com.mysql.jdbc.Driver"/>
   <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/mysqljpa"/>
   <property name="javax.persistence.jdbc.user" value="root"/>
      <property name="javax.persistence.jdbc.password" value="mysql"/>
      <property name="eclipselink.logging.level" value="FINEST"/> 
  </properties>
 </persistence-unit>
</persistence>

Paso 3: Configurar ORM de Relaciones entre entidades según el modelo de Datos

Según el modelo lógico, la clase "Cargo" tiene relación con la clase "Empleado", por lo cual dependiendo de la navegabilidad definida en el diagrama de clases, se deberá representar dicha relación en una ó ambas clases relacionadas. En este caso como la navegabilidad es bidireccional, tenemos que representar la relación en ambas clases, basándonos en las multiplicidades definidas. En el gráfico, leer relación desde clase origen a clase destino.

Por ejemplo si origen = Cargo y destino = Empleado entonces se lee:

“Un Cargo lo pueden tener uno o muchos Empleados”. → OneToMany

Por ejemplo si origen = Empleado y destino = Cargo entonces se lee:
“Uno o Muchos Empleados pueden tener un mismo Cargo”. → ManyToOne

Relación ManyToOne
Se utiliza cuando la multiplicidad hacia la clase relacionada es 1.

Relación OneToMany
Se utiliza cuando la multiplicidad hacia la clase relacionada es de 0(1) a muchos.

Debemos añadir los campos que representan las relaciones según navegabilidad y multiplicidad.

Clase Empleado:

@ManyToOne
@JoinColumn(name="COD_CAR")
private Cargo cargo;
  
@OneToOne
@JoinColumn(name="COD_CAS")
private Casillero casillero;

No olvidar generar "getter/setter" y redefinir el método "toString()".

Clase Cargo:

@OneToMany(mappedBy="cargo")
private Collection<empleado> empleados;

No olvidar generar "getter/setter" y redefinir el método" toString()".

Clase Casillero:

@OneToOne(mappedBy="casillero")
private Empleado empleado; 

No olvidar generar "getter/setter" y redefinir el método "toString()".

Paso 4: Inicializar los objetos para realizar pruebas

package edu.aprender.test;
 
import java.sql.Date;
import java.util.Calendar;
import java.util.List;
 
import org.apache.log4j.Logger;
 
import edu.aprender.persistence.entity.Cargo;
import edu.aprender.persistence.entity.Casillero;
import edu.aprender.persistence.entity.Empleado;
import edu.aprender.persistence.jpa.EmpleadoJPA;
 
public class EmpleadoTest {
  
 static  Logger logger = Logger.getLogger(EmpleadoTest.class.getName());
  
 public static void main(String[] args) {
  EmpleadoJPA empleadoJPA = new EmpleadoJPA();
   
  // Entidades con datos estáticos
  Cargo cargo=new Cargo();
  cargo.setCodigo(1);
   
  // Entidades con datos estáticos
  Casillero casillero=new Casillero();
  casillero.setCodigo(1);
   
  ...
     
 }
  
 ...
 
}

Paso 5: Probar Aplicación

ESTRUCTURA FINAL DEL PROYECTO

NOTA:

No olvidemos que tenemos que crear las tablas "tb_cargo" y "tb_casillero" con sus registros y agregar la columna "FEC_ING_EMP" a la tabla "tb_empleado" en nuestra base de datos.

Pasos para Importar y ejecutar el proyecto

1. Descargar el proyecto finalizado desde aquí

2. Revisar proyecto en Github aquí
3. Ver como importar un proyecto JPA aquí