Duda | Crear POST y DELETE tablas intermedias Spring JPA

Intencity #1 Oct '17

Hola, estoy empezando con Spring Boot en un sistema RESTful. Tengo dos tablas "usuarios" y "permisos" las cuales tienen una relación de muchos a muchos con una tabla intermedia "usuario_permiso" que solo tiene las llaves foraneas de id_usuario y id_permiso.

Ya he conseguido hacer que me muestre que permisos tiene el usuario desde un GET a "usuarios/{id}/permisos", pero aun no se como hacer para agregar una relación con un POST o borrarla con un DELETE. He probado hacerlo con Querys nativas pero he visto que no se puede hacer INSERT en JPA. ¿Alguna sugerencia de como implementarlo?

Esta es mi entidad Usuario:

spoiler

import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
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.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

@Entity
@Table(name = "usuario")
@NamedQueries({
@NamedQuery(name = "Usuario.findAll", query = "SELECT u FROM Usuario u")})
public class Usuario implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)

@Column(name = "id_usuario")
private Integer idUsuario;
@Size(max = 75)
@Column(name = "nombre")
private String nombre;
@Basic(optional = false)
@NotNull
@Column(name = "status")
private int status;
@ManyToMany
@JoinTable(name = "usuario_permiso", joinColumns = {
    @JoinColumn(name = "id_usuario", referencedColumnName = "id_usuario")}, inverseJoinColumns = {
    @JoinColumn(name = "id_permiso", referencedColumnName = "id_permiso")})
private Collection<Permiso> permisoCollection;

public Usuario() {
}

public Usuario(Integer idUsuario) {
    this.idUsuario = idUsuario;
}

public Usuario(Integer idUsuario, int status) {
    this.idUsuario = idUsuario;
    this.status = status;
}

public Integer getIdUsuario() {
    return idUsuario;
}

public void setIdUsuario(Integer idUsuario) {
    this.idUsuario = idUsuario;
}

public String getNombre() {
    return nombre;
}

public void setNombre(String nombre) {
    this.nombre = nombre;
}

public int getStatus() {
    return status;
}

public void setStatus(int status) {
    this.status = status;
}

public Collection<Permiso> getPermisoCollection() {
    return permisoCollection;
}

public void setPermisoCollection(Collection<Permiso> permisoCollection) {
    this.permisoCollection = permisoCollection;
}

@Override
public int hashCode() {
    int hash = 0;
    hash += (idUsuario != null ? idUsuario.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    // TODO: Warning - this method won't work in the case the id fields are not set
    if (!(object instanceof Usuario)) {
        return false;
    }
    Usuario other = (Usuario) object;
    if ((this.idUsuario == null && other.idUsuario != null) || (this.idUsuario != null && !this.idUsuario.equals(other.idUsuario))) {
        return false;
    }
    return true;
}

@Override
public String toString() {
    return "mx.lania.mca.entidades.Usuario[ idUsuario=" + idUsuario + " ]";
}

}

Esta es mi entidad Permiso

spoiler

import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
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.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.validation.constraints.Size;

import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
@Table(name = "permiso")
@NamedQueries({
@NamedQuery(name = "Permiso.findAll", query = "SELECT p FROM Permiso p")})
public class Permiso implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_permiso")
private Integer idPermiso;
@Size(max = 75)
@Column(name = "nombre")
private String nombre;
@JsonIgnore
@ManyToMany(mappedBy = "permisoCollection")
private Collection<Usuario> usuarioCollection;
@JoinColumn(name = "id_modulo", referencedColumnName = "id_modulo")
@ManyToOne(optional = false)
private Modulo idModulo;

public Permiso() {
}

public Permiso(Integer idPermiso) {
    this.idPermiso = idPermiso;
}

public Integer getIdPermiso() {
    return idPermiso;
}

public void setIdPermiso(Integer idPermiso) {
    this.idPermiso = idPermiso;
}

public String getNombre() {
    return nombre;
}

public void setNombre(String nombre) {
    this.nombre = nombre;
}

public Collection<Usuario> getUsuarioCollection() {
    return usuarioCollection;
}

public void setUsuarioCollection(Collection<Usuario> usuarioCollection) {
    this.usuarioCollection = usuarioCollection;
}

public Modulo getIdModulo() {
    return idModulo;
}

public void setIdModulo(Modulo idModulo) {
    this.idModulo = idModulo;
}

@Override
public int hashCode() {
    int hash = 0;
    hash += (idPermiso != null ? idPermiso.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    // TODO: Warning - this method won't work in the case the id fields are not set
    if (!(object instanceof Permiso)) {
        return false;
    }
    Permiso other = (Permiso) object;
    if ((this.idPermiso == null && other.idPermiso != null) || (this.idPermiso != null && !this.idPermiso.equals(other.idPermiso))) {
        return false;
    }
    return true;
}

@Override
public String toString() {
    return "mx.lania.mca.entidades.Permiso[ idPermiso=" + idPermiso + " ]";
}

}

Ambas las he mapeado con el NetBeans.

Este es mi controlador del Usuario:

spoiler

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import com.lania.permisos.model.Usuario;
import com.lania.permisos.model.Permiso;
import com.lania.permisos.repository.UsuarioRepository;

import javax.validation.Valid;

import java.util.Collection;
import java.util.List;

@RestController
@RequestMapping("/permisos-api")
public class UsuarioController {

@Autowired
UsuarioRepository userRepository;

@GetMapping("/usuarios")
public List<Usuario> getAllUsuarios() {
    return userRepository.findAll();
}

@GetMapping("/usuarios/{id}")
public ResponseEntity<Usuario> getUsuarioById(@PathVariable(value = "id") Integer userId) {
    Usuario user = userRepository.findOne(userId);
    if(user == null) {
        return ResponseEntity.notFound().build();
    }
    return ResponseEntity.ok().body(user);
}

@PostMapping("/usuarios")
public Usuario createUsuario(@Valid @RequestBody Usuario user) {
    return userRepository.save(user);
}

@PutMapping("/usuarios/{id}")
public ResponseEntity<Usuario> updateUsuario(@PathVariable(value = "id") Integer userId,
                                       @Valid @RequestBody Usuario userDetails) {
    Usuario user = userRepository.findOne(userId);
    if(user == null) {
        return ResponseEntity.notFound().build();
    }
    user.setNombre(userDetails.getNombre());
    user.setStatus(userDetails.getStatus());

    Usuario updatedUser = userRepository.save(user);
    return ResponseEntity.ok(updatedUser);
}

@DeleteMapping("/usuarios/{id}")
public ResponseEntity<Usuario> deleteUusario(@PathVariable(value = "id") Integer userId) {
    Usuario user = userRepository.findOne(userId);
    if(user == null) {
        return ResponseEntity.notFound().build();
    }

    userRepository.delete(user);
    return ResponseEntity.ok().build();
}

@GetMapping("/usuarios/{id}/permisos")
public ResponseEntity<Collection<Permiso>> getPermisosOfUsuario(@PathVariable(value = "id") Integer userId) {
    Usuario user = userRepository.findOne(userId);
    if(user == null) {
        return ResponseEntity.notFound().build();
    }
    return ResponseEntity.ok().body(user.getPermisoCollection());
}

}

}

Script de la base de datos:

spoiler

Gracias de antemano. Saludos.

desu #2 Oct '17

1º Veo muchas anotaciones para algo tan sencillo, definir tu las query tampoco lo entiendo.
https://stackoverflow.com/questions/42394095/many-to-many-relationship-between-two-entities-in-spring-boot
2º

#1Intencity:
he visto que no se puede hacer INSERT en JPA

Me perdí.
3º Usa un @JoinTable o crea otra tabla, yo empezaría creando una tabla y hacer los @RequestMapping tranquilamente ahí.
4º Tienes dudas con Spring o como va Rest?

ElCavernero #3 Oct '17

O dios mio! un @ManyToMany!.

Como consejo, nunca uses ManyToMany es mas engorrosso de manejar.

Por lo que veo quieres hacer que un usuario pueda tener muchos permisos, yo lo haría de la siguiente forma:
En las tablas permisos y usuario no crearía referencias y crearía de manera manual la tabla intermedia llamada por ejemplo PermisosUsuarios, le añadiría como clave primaria un ID que podría ser un Long incremental, además de idUsuario e idPermiso que estarían relacionadas en @ManyToOne cada una con su entidad.

De esta forma si por ejemplo tienes los permisos "Invitado", "Registrado" y "Moderador" con ids 1, 2 y 3 y quieres asignar al usuario con id 1 los permisos 2 y 3 tendrás que crear las tuplas en PermisosUsuarios con idUsuario 1 e idPermisos 2 y otra tupla con el 3.

Para hacer el GET deberás buscar todas las tuplas cuyo idUsuario sea 1.
Con @Query y JPQL sería algo así:
@Query("SELECT DISTINCT p from Permisos p, PermisosUsuarios pu where pu.idPUsuario= ?1")

Espero que te sirva.

Saludos.

1 respuesta

JackSparow #4 Oct '17

#1 Si la declaras como @ManyToMany, el hecho de agregar/quitar relaciones entre usuario y permisos vienen determinados por los PUT/POST que hagas sobre usuario. (tabla propietaria de la relación).
Es decir, siempre que hagas un PUT/POST sobre usuario, tendrás que pasarle la lista de permisos tal y como la quieres en ese momento.

PUT/POST sobre el recurso usuario:
{
idUsuario : 1,
nombre: "pepito",
permisoCollection : [
 {  idPermiso : 2 },
 {  idPermiso : 3},
 {  idPermiso : 5 } ],
..otros atributos de usuario...
}

En los objetos de permiso, sólo hace falta que pases los id_permiso. Si no existen permisos con esos identificadores, te saltará la excepción de integridad de datos. (ya que tienes declarado la relación implicitamente como CascadeType=[] (cosa que veo ideal en tu caso).

Como comenta #3, las ManyToMany "implica" que no tienes un servicio para la tabla intermedia (cosa que veo normal en tu caso), por lo que no veo mal que lo tengas tal y como lo tienes.

Intencity #5 Oct '17

Muchas gracias por sus respuestas, al final lo he resuelto de la siguiente manera utilizando los objetos:

@PostMapping("/usuarios/{idUsuario}/permisos")
 public Usuario addPermisoUsuario(@PathVariable(value = "idUsuario") Integer 
    userId, @RequestBody Permiso permiso) {
       Usuario user = userRepository.findOne(userId);
       Permiso permisoExistente = 
       permisoRepository.findOne(permiso.getIdPermiso());
       user.getPermisoCollection().add(permisoExistente);
       return userRepository.save(user);
 }

 @DeleteMapping("/usuarios/{idUsuario}/permisos/{idPermiso}")
 public Usuario deletePermisoUsuario(@PathVariable(value = "idUsuario") 
    Integer userId, @PathVariable(value = "idPermiso") 
    Integer permisoId, @RequestBody Permiso permiso) {
       Usuario user = userRepository.findOne(userId);
       Permiso permisoEliminar = permisoRepository.findOne(permisoId);
       user.getPermisoCollection().remove(permisoEliminar);
       return userRepository.save(user);
 }

Saludos!

1 respuesta

JackSparow #6 Oct '17

#5 Perfecto.
Cuidado con el NullPointException cuando el usuario no existe. (deberías volver el notFound()).

Duda | Crear POST y DELETE tablas intermedias Spring JPA

Usuarios habituales

Tags