Java Spring Boot

3.6

Implementación
Relaciones
Base de Datos

Ciclo 4a
Programación Web
Universidad Nacional
de Colombia
Contenido

Introducción ........................................................................................................................................ 2
Relación uno a muchos ....................................................................................................................... 3
Implementación .............................................................................................................................. 3
Pruebas .......................................................................................................................................... 5
Implementación relación muchos a muchos ...................................................................................... 8
Implementación .............................................................................................................................. 8
Pruebas.......................................................................................................................................... 14
Descarga repositorio de código ........................................................................................................ 17
Referencias ........................................................................................................................................ 17
Introducción
En el presente tutorial se explicará una de las tantas maneras como se pueden
representar las relaciones de los modelos en las bases de datos. En primer lugar es
importante aclarar que para este ejemplo se utilizarán y se simularán las reglas que
se utilizan normalmente en el contexto de las bases de datos relacionales,
específicamente con la propagación de las llaves primarias de cada entidad según
el tipo de relación. Es de aclarar que las bases de datos no relacionales tales como
Mongo DB se aplican para tipos de problemas donde no es relevante que existan
datos duplicados, o que si existe una alteración de un registro necesariamente se
tenga que actualizar la información en la relación.
Pero este ejercicio servirá como ejemplo para mostrar como una base de datos no
relacional también puede servir para tipos de problemas en los cuales es necesario
utilizar un modelo relacional, para esto existen diversas maneras tal como se
expone en la documentación oficial de mongo db [1].
Es momento de recordar el esquema de base de datos que se diseñó previamente
para esquematizar los modelos que se gestionarán desde Java. En el tutorial
anterior se mostró como llevar a cabo todas las operaciones de CRUD para el
modelo de los usuarios. Para este tutorial se partirá que los modelos tales como rol
y permiso ya están construidos de la misma manera como se hizo con los usuarios,
pero se realizará énfasis especialmente en la forma como se implementa la relación
1 a muchos específicamente entre rol y usuario, y en la relación muchos a muchos
en la relación entre rol y permiso.
Según lo anterior se partirá del siguiente código, que se recomienda tener
implementado el código antes de continuar de:
 Modelos: rol y permiso
 Repositorios: rol y permiso
 Controladores: rol y permiso. Nota: El controlador de la clase intermedia
“PermisosRol” se implementará y explicará en el presente tutorial.
Relación uno a muchos
Implementación
En esta sección se abordará como realizar la implementación de la relación uno a
muchos, la cual para este ejemplo se evidencia entre el modelo rol y usuario. Según
cuando se trabajaba con bases de datos relacionales la entidad “uno” (Rol)
propagaba el identificador a la entidad “muchos” (Usuario), es por esto que la
implementación de código que se llevará a cabo mas adelante se realizará en el
controlador de usuario. En mongo db una de las manera de simular este tipo de
comportamientos es con los denominados “DBRef” los cuales según la
documentación oficial “Son una convención para representar un documento , en
lugar de un tipo de referencia específico. Incluyen el nombre de la colección y, en
algunos casos, el nombre de la base de datos, además del valor del campo _id.”
Los cuales para ampliar más información al respecto se puede ampliar en la
documentación oficial [2].
Para este caso la Spring Boot internamente se encargará de colaborar con la
gestión de dicho concepto, para mostrar como se puede llevar a cabo dicho proceso
se deberán seguir los siguientes pasos:
En primer lugar es necesario modificar la clase “Usuario” creando un parámetro de
clase de tipo “Rol” con la notación “@DBRef” para indicar que este campo debe ser
referenciado en Mongo DB. Recuerde llevar a cabo la implementación de los
métodos get y set para el atributo correspondiente
Luego es necesario continuar la implementación en el controlador de usuario, el
cual deberá exponer un método para llevar a cabo la relación.
Para esto en primer lugar se debe crear una variable de tipo “RepositorioRol” tal
como se muestra a continuación

Luego de esto, es necesario implementar la siguiente función en la misma clase de

controlador materia.
/**
* Relación (1 a n) entre rol y usuario
* @param id
* @param id_rol
* @return
*/
@PutMapping("{id}/rol/{id_rol}")
public Usuario asignarRolAUsuario(@PathVariable String id,@PathVariable
String id_rol){
Usuario
usuarioActual=this.miRepositorioUsuario.findById(id).orElseThrow(RuntimeE
xception::new);
Rol
rolActual=this.miRepositorioRol.findById(id_rol).orElseThrow(RuntimeExcep
tion::new);
usuarioActual.setRol(rolActual);
return this.miRepositorioUsuario.save(usuarioActual);
}
En la línea 63 se encuentra el decorador para los métodos “PUT” y luego se define
la estructura de la ruta para activar el método, en este caso será de la siguiente
manera: “url-server/usuarios/id_usuario/rol/id_rol. El valor resaltado en amarillo será
el identificador del usuario al cual se le quiere asignar el rol, y el campo en azul será
el identificador del rol en cuestión. Luego en la línea 64 se encuentra la definición
del método el cual retornará un usuario (con la información del rol asignado), en los
parámetros del método se encuentra los identificadores anteriormente
mencionados. Luego de la línea 65 a 67 se realiza la búsqueda del usuario en la
base de datos que le corresponde el identificador y de la línea 68 a 70 se encuentra
la búsqueda del rol que se quiere asignar. En la línea 91 se realiza una validación
para verificar si el usuario y rol existe, Luego en la línea 72 para efectuar la relación
será necesario actualizar el atributo “rol” del usuario encontrado, para esto se hace
uso del método “setRol” y asignar el rol encontrado anteriormente. Luego en la línea
73 se le solicita al repositorio volver a almacenar el usuario pero ya con la relación
efectuada.

Pruebas
En primer lugar es necesario crear un rol en el proyecto que se viene trabajando,
para esto se ejecutará el llamado al siguiente servicio.

En la base de datos de mongo debe aparecer la información del rol creado de la

siguiente manera:
Luego se rectificará la información de algún usuario para asignarle el rol
anteriormente creado, para esto se utilizará el siguiente usuario registrado en la
base de datos previamente.
Luego de tener un rol y un usuario es necesario llevar a cabo la asociación entre
estos 2 modelos, para esto será necesario tener en cuenta los respectivos
identificadores. Para este ejemplo se asociará el rol “Administrador” con id
“626d9aabcfd4e30a9fa69bc0” al usuario consultado anteriormente con id
“626d6a2d3a5e697a7f6020e4” utilizando la ruta previamente programada de la
siguiente manera:

Como se puede observar, al momento de ejecutarse la transacción, se retorna la

información del usuario junto con el rol al cual pertenece de ahora en adelante.
En la base de datos debe aparecer de la siguiente manera:
Como se puede observar en la base de datos se almacena la referencia la cual se
compone de la colección a la que hace referencia y el identificador del documento
correspondiente. De esta manera si en algún momento algún dato del rol llegara a
cambiar de nombre, el usuario tendrá la información actualizada ya que posee una
referencia. De igual manera si es el caso, de eliminar la relación, se deberá igualar
este campo en nulo. A su vez es importante tener cuidado con los procesos de
eliminación por ejemplo de los roles, ya que de ellos dependen otros registros como
lo es para este ejemplo los usuarios, esto generaría un gran problema.

Implementación relación muchos a muchos

Implementación
En esta sección se abordará como realizar la implementación de la relación muchos
a muchos, la cual para este ejemplo se evidencia entre los modelos rol y permiso.
Según cuando se trabajaba con bases de datos relacionales se debía crear una
tabla intermedia la cual debe contener los identificadores de las tablas implicadas y
en caso de existir los atributos que se puedan desprender de la relación. Para este
caso en mongo db, se creará una colección intermedia llamada “permisosRoles”, la
cual tendrá básicamente las referencias correspondientes al rol y permiso que se
requieren relacionar.
En primer lugar será necesario crear una nueva clase llamada “PermisosRoles”
dentro del paquete “Modelos” tal como se muestra a continuación:

Luego dentro de esta clase será necesario pegar las siguientes líneas de código
package tutorial.misionTIC.seguridad.Modelos;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;

@Data
@Document
public class PermisosRoles {
@Id
private String _id;
@DBRef
private Rol rol;
@DBRef
private Permiso permiso;

public PermisosRoles() {
}

public String get_id() {

return _id;
}

public Rol getRol() {

return rol;
}
 public Permiso getPermiso() {
return permiso;
}

public void setRol(Rol rol) {

this.rol = rol;
}

public void setPermiso(Permiso permiso) {

this.permiso = permiso;
}
}

Como se puede evidenciar, posee los mismos decoradores ya mencionados

anteriormente, pero sobresalen 2 atributos en la línea 14 y 16 tales como el rol y el
permiso respectivamente, los cuales están antecedidos del decorador “@DBRef”
para esquematizar las relaciones en la base de datos de mongo db. Las demás
líneas corresponden al constructor (el cual es sin ningún parámetro) y luego los
métodos get y set para cada uno de los atributos.

En segundo lugar es necesario crear un repositorio para la clase correspondiente

llamado “RepositorioPermisosRoles” de igual manera como se ha realizado en los
tutoriales anteriores. Luego de llevar a cabo esta tarea debe tener algo similar a lo
siguiente:
En tercer lugar es necesario crear un controlador para la clase correspondiente
llamado “ControladorPermisosRoles” , allí deberán estar todos los métodos
estándar para el proyecto para llevar a cabo las tareas de CRUD.

package tutorial.misionTIC.ModuloSeguridad.Controladores;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import tutorial.misionTIC.ModuloSeguridad.Modelos.Permiso;
import tutorial.misionTIC.ModuloSeguridad.Modelos.PermisosRoles;
import tutorial.misionTIC.ModuloSeguridad.Modelos.Rol;
import
tutorial.misionTIC.ModuloSeguridad.Repositorios.RepositorioPermiso;
import
tutorial.misionTIC.ModuloSeguridad.Repositorios.RepositorioPermisosRoles;
import tutorial.misionTIC.ModuloSeguridad.Repositorios.RepositorioRol;
import java.util.List;

@CrossOrigin
@RestController
@RequestMapping("/permisos-roles")
public class ControladorPermisosRoles {
@Autowired
private RepositorioPermisosRoles miRepositorioPermisoRoles;

@Autowired
private RepositorioPermiso miRepositorioPermiso;

@Autowired
private RepositorioRol miRepositorioRol;

@GetMapping("")
public List<PermisosRoles> index(){
return this.miRepositorioPermisoRoles.findAll();
}

/**
 * Asignación rol y permiso
* @param id_rol
* @param id_permiso
* @return
*/
@ResponseStatus(HttpStatus.CREATED)
@PostMapping("rol/{id_rol}/permiso/{id_permiso}")
public PermisosRoles create(@PathVariable String id_rol,@PathVariable
String id_permiso){
PermisosRoles nuevo=new PermisosRoles();
Rol elRol=this.miRepositorioRol.findById(id_rol).get();
Permiso
elPermiso=this.miRepositorioPermiso.findById(id_permiso).get();
if (elRol!=null && elPermiso!=null){
nuevo.setPermiso(elPermiso);
nuevo.setRol(elRol);
return this.miRepositorioPermisoRoles.save(nuevo);
}else{
return null;
}
}
@GetMapping("{id}")
public PermisosRoles show(@PathVariable String id){
PermisosRoles permisosRolesActual=this.miRepositorioPermisoRoles
.findById(id)
.orElse(null);
return permisosRolesActual;
}

/**
* Modificación Rol y Permiso
* @param id
* @param id_rol
* @param id_permiso
* @return
*/
@PutMapping("{id}/rol/{id_rol}/permiso/{id_permiso}")
public PermisosRoles update(@PathVariable String id,@PathVariable
String id_rol,@PathVariable String id_permiso){
PermisosRoles permisosRolesActual=this.miRepositorioPermisoRoles
.findById(id)
.orElse(null);
Rol elRol=this.miRepositorioRol.findById(id_rol).get();
Permiso
elPermiso=this.miRepositorioPermiso.findById(id_permiso).get();
if(permisosRolesActual!=null && elPermiso!=null && elRol!=null){
permisosRolesActual.setPermiso(elPermiso);
permisosRolesActual.setRol(elRol);
return
this.miRepositorioPermisoRoles.save(permisosRolesActual);
}else{
return null;
}
}

@ResponseStatus(HttpStatus.NO_CONTENT)
@DeleteMapping("{id}")
public void delete(@PathVariable String id){
PermisosRoles permisosRolesActual=this.miRepositorioPermisoRoles
 .findById(id)
.orElse(null);
if (permisosRolesActual!=null){
this.miRepositorioPermisoRoles.delete(permisosRolesActual);
}
}
}

De la línea 1 a 11 se realizan las respectivas importaciones, de la línea 13 a 15 se

encuentran los decoradores ya explicados en los tutoriales anteriores, donde se
resalta que para activar cada uno de los métodos del controlador que se está
implementando será con la url “url-servidor/permisos-roles”

Luego en las líneas 18, 21 y 24 se encuentran definidas las variables de clase cada
uno de los repositorios que se requieren implementar para llevar a cabo las
transacciones en el presente controlador antecedidos del decorador “@Autowired”.
Luego se encuentra en la línea 28 la definición del método “index” para listar todos
los permisos y roles configurados hasta el momento.
En la línea 39 se encuentra la definición de la ruta con la que se permitirá crear un
nuevo permiso para el rol. En la línea 40 se encuentra se define el método el cual
recibe como parámetros los identificadores del rol y del permiso que se quiere
relacionar. Luego en la línea 41 se elabora la instancia del “PermisosRoles” que se
quiere almacenar en la base de datos, luego de esto en la línea 42 y 43 se realiza
la búsqueda de el rol y permiso en cuestión. En la línea 44 se valida que el rol y
permiso existan. Luego se aplica el método set permiso y set rol a la instancia
creada en la línea 41 y que servirá para representar la relación. Por último en la
línea 47 se solicita al repositorio almacenar la instancia que contiene las relaciones.

En las demás líneas se encuentran los métodos correspondientes a la actualización

y eliminación de las relaciones que funcionan de igual manera a como se ha
explicado en anteriores tutoriales.

Pruebas
Para el proceso de pruebas se partirá en ya se tiene un rol y un tipo de permiso
creado previamente en la base de datos, para este ejemplo tenemos los siguientes
registros: rol “Administrador” con identificador “626d9aabcfd4e30a9fa69bc0” y un
permiso con identificador “624b4735babfbd1e8786c878” para acceder a la ruta
/usuarios y llevar a cabo procesos de eliminación.
A continuación se creará la asociación con los datos correspondientes y llamando
a la ruta previamente configurada de la siguiente manera.

Luego se puede observar el resultado correspondiente en la base de datos

obteniendo los siguientes resultados. Como se puede observar en el registro se
guarda la información correspondiente a la relación entre rol y permiso, de esta
manera se esquematiza que el administrador tendrá la potestad para activar el
método de eliminación de usuarios.
Descarga repositorio de código
En el siguiente enlace puede encontrar el repositorio de código de lo trabajado en
el presente tutorial: https://github.com/tutoriales-mision-tic-2022-unal-
ciclo4/tutorial-3-c

Referencias

[1] MongoDB, «Database References,» [En línea]. Available:

https://www.mongodb.com/docs/manual/reference/database-references/. [Último acceso:
25 04 2022].

[2] MongoDB, «DBRefs,» [En línea]. Available:

https://www.mongodb.com/docs/manual/reference/database-references/#dbrefs. [Último
acceso: 25 04 2022].