RELACIONES EN TABLAS EN JPA

La entidad o entidad extendida será la clase con la que realmente trabajemos, ya que tiene las columnas de la clase que hereda y la funcionalidad que añadamos según nuestras necesidades. Al igual que con las super clases, se recomienda crear un paquete dentro del proyecto donde guardar todas nuestras entidades.

La principal diferencia es que esta clase si estará marcada con la anotación @Entity y tendrá que extender de la super clase e implementar Serializable:

@Entity

@Table(name = "TABLA_EJEMPLO")

public class TablaEjemploExtends extends TablaEjemplo implements Serializable {...}

Figura 14. Entidad extendida de ejemplo

El punto más importante que vamos a desarrollar de la lógica que se puede añadir en las clases extendidas son las relaciones Hibernate entre entidades:

@OneToOne

@OneToOne(cascade = CascadeType.ALL, mappedBy = "nombreAtributo",

fetch = FetchType.LAZY)

Figura 15. Relación @OneToOne

La anotación @OneToOne tiene los siguientes atributos:

1.- Cascade: es tarea del programador acertar en el uso de este atributo ya que no hay una regla universal. En este caso se ha usado CascadeType.ALL para darle legibilidad del código y para que se actualice la tabla destino ante cualquier operación. No se recomiendo usar como comodín.

2.- MappedBy: entre comillas se debe insertar el nombre del atributo que deseemos relacionar en la tabla destino.

3.- Fetch: no carga la relación a menos que se invoque el getter. Para realizar lo contrario, marcar como EAGER.

@OneToMay

A diferencia de la anterior, si se marca una relación como @OneToMany debe existir otra que sea @ManyToOne

@OneToMany(cascade = CascadeType.ALL, mappedBy = "test",

FetchType.LAZY)

protected List<CfgTestOpcionExtends> cfgTestOpcionExtendsList;

Figura 16. Relación @OneToMany

Identica a la anterior salvo porque declara una lista como atributo. Es olbigatorio el mappedBy.

@JoinColumn(name = "ID_TEST" referencedColumnName = "ID",

nullable = false, insertable = false, updatable = false)

@ManyToOne(opcional = false, fetch = FetchTye.LAZY)

protected CfgTestExtends test;

Figura 17. Relación @ManyToOne para satisfacer @OneToMany

A destacar, la anotación @JoinColumn. Puede confundirse con @Column, pero esta anotación nos permite definir el nombre exacto de la columna, si debe insertable, actualizable y nulo. En este caso, el atributo name hace referencia al nombre que deseemos que tenga la columna de esa clase, pero el atributo referencedColumnName es el nombre que le hemos puesto en la clase destino.

@ManyToOne

Realmente ya estaría explicada con lo mencionada anteriormente, pero se va a profundizar en el caso de que la relación una dos columnas:

@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)

@JoinColumns({@JoinColumn(name = "COLUMNA_UNO",

@JoinColumn(name = "COLUMNA_DOS")})

private ClaseRelacionada nombreClaseRelacionada;

Figura 18. Múltiples columnas en una unión

Gracias a la anotación @JoinColumns podremos crear múltiples columnas de la unión.

@ManyToMany

Para entender este caso, vamos a plantear la situación en la que un usuario puede tener diversos roles y los roles pueden estar asignados a más de un usuario. La forma en la que podemos relacionar ambas entidades es la siguiente:

En la clase Usuarios:

@JoinTable(name = "ROL_USUARIOS", joinColumns = {

@JoinColumn(name = "USUARIO", referencedColumnName = "USUARIO",

nullable = false) },

inverseJoinColumns = {

@JoinColumn(name = "ID_ROL", referencedColumnName = "ID",

nullable = false})

@ManyToMany(fetch = FetchType.LAZY)

private List<RolesExtends> rolesList;

Figura 19. Relación @ManyToMany en usuarios

La forma en la que hemos orientado la solución es la de crear una tercera tabla adicional que reúna una columna de cada tabla. La anotación @JoinTable realiza dicha acción en la nueva tabla ROL_USUARIOS uniendo el identificador del usuario y el identificador del rol. Se usa inverseJoinColumns para establecer la columna que no pertenece a la clase donde se implementa.

En este caso, se llama a la ajena Roles desde la clase Usuarios.

En la clase Roles:

@ManyToMany(mappedBy = "rolesList", fetch = FetchType.LAZY)

private List<UsuariosExtends> usuariosList;

Dado que se ha realizado el proceso principal en la clase Usuarios, en ésta solo necesitamos indicar en el mappedBy el nombre del atributo al cual hace referencia.