JPA - @ManyToMany 双向关系，删除反向侧的实体和 JoinTable 中剩余关系的错误

Question

I have two entities defined in JPA: Employee and Skill .

Between this entities is defined relationship @ManyToMany .

public class Employee { 

     @ManyToMany(fetch = FetchType.LAZY)
     @JoinTable(name = "employee_skill",
        joinColumns = @JoinColumn(name = "employee_id"),
        inverseJoinColumns = @JoinColumn(name = "skill_id")
     )
     private Set<Skill> skills = new HashSet<>();
}

public class Skill { 

     @ManyToMany(mappedBy = "skills", fetch = FetchType.LAZY)
     private Set<Employee> skilledEmployees = new HashSet<>(); 
}

Now I have such problem: If I remove Skill entity using entity manager. It removes ok. But in @JoinTable in database employee_skill there remains associations with this removed entity (its id).

I do not want to remove Employee when I am removing Skill so all CASCADE REMOVING or orphanRemoval are not useful here.

I consider why this relationship isn't automagically removed from database. When this association in join table remains it gives me javax.persistence.EntityNotFoundException: Unable to find...

So I could remove this associations manually, before removing Skill entity. But is it really the best practice?

What will be the best practice to remove entities in @ManyToMany bidirectional relationships? When removing one entity like Employee or Skill shouldn't effect the other entity?

Answer 1

Since Employee is the owning side (based on your mappedBy value) of the relationship, any update on its relationship with Skill objects would update the database associations. That's the responsibility of the owning side and it would fulfill that. But the other way around is not gonna happen. One of your possible solutions is to define database cascade rules manually, something like following in the join table:

FOREIGN KEY (skill_id) REFERENCES skills (id)
  MATCH SIMPLE ON UPDATE CASCADE ON DELETE CASCADE

This way, any update to Skill s would update the associations in database.

The other approach is to change the owning side to Skill by defining a mappedBy in Employee , which does not feel that natural based on Employee/Skill stereotypical relationships.

Answer 2

6 años despues traigo tu respuesta. Si utilizasel mappedBy y borras desde Skill te dara problemas de contraints. Utiliza lo siguiente:

public class Employee { 

     @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.REFRESH)
     @JoinTable(name = "employee_skill",
        joinColumns = @JoinColumn(name = "employee_id"),
        inverseJoinColumns = @JoinColumn(name = "skill_id")
     )
     private Set<Skill> skills = new HashSet<>();
}

public class Skill { 

     @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.REFRESH)
     @JoinTable(name = "employee_skill",
        joinColumns = @JoinColumn(name = "skill_id"),
        inverseJoinColumns = @JoinColumn(name = "employee_id")
     )
     private Set<Employee> skilledEmployees = new HashSet<>(); 
}