Comment supprimer entity with ManyToMany relationship dans JPA (et les lignes de jointure correspondantes)?

les travaux suivants pour moi. Ajoutez la méthode suivante à l'entité qui n'est pas le propriétaire de la relation (Groupe)

@PreRemove
private void removeGroupsFromUsers() {
    for (User u : users) {
        u.getGroups().remove(this);
    }
}

gardez à l'esprit que pour que cela fonctionne, le groupe doit avoir une liste mise à jour des utilisateurs (ce qui n'est pas fait automatiquement). ainsi, à chaque fois que vous ajoutez un groupe à la liste des groupes dans l'entité utilisateur, vous devriez aussi ajouter un utilisateur à la liste des utilisateurs dans l'entité groupe.

j'ai trouvé une solution possible, mais... Je ne sais pas si c'est une bonne solution.

@Entity
public class Role extends Identifiable {

    @ManyToMany(cascade ={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
    @JoinTable(name="Role_Permission",
            joinColumns=@JoinColumn(name="Role_id"),
            inverseJoinColumns=@JoinColumn(name="Permission_id")
        )
    public List<Permission> getPermissions() {
        return permissions;
    }

    public void setPermissions(List<Permission> permissions) {
        this.permissions = permissions;
    }
}

@Entity
public class Permission extends Identifiable {

    @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
    @JoinTable(name="Role_Permission",
            joinColumns=@JoinColumn(name="Permission_id"),
            inverseJoinColumns=@JoinColumn(name="Role_id")
        )
    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

j'ai essayé ceci et cela fonctionne. Lorsque vous supprimez le rôle, les relations sont également supprimées (mais pas les entités de Permission) et lorsque vous supprimez la Permission, les relations avec le rôle sont également supprimées (mais pas l'instance de rôle). Mais nous cartographions une relation unidirectionnelle deux fois et les deux entités sont les propriétaires de la relation. Cela pourrait-il causer des problèmes d'hibernation? Quel type de problèmes?

Merci!

le code ci-dessus est d'un autre post lié.

comme alternative aux solutions JPA / Hibernate : vous pouvez utiliser une clause de suppression en CASCADE dans la définition de base de données de votre clé foregin sur votre table de jointure, telle que (syntaxe Oracle) :

CONSTRAINT fk_to_group
     FOREIGN KEY (group_id)
     REFERENCES group (id)
     ON DELETE CASCADE

de cette façon le SGBD lui-même supprime automatiquement la ligne qui pointe vers le groupe lorsque vous supprimez le groupe. Et cela fonctionne que la suppression soit faite à partir de Hibernate/JPA, JDBC, manuellement dans le DB ou de toute autre manière.

la caractéristique de suppression en cascade est supporté par tous les principaux SGBD (Oracle, MySQL, SQL Server, PostgreSQL).

pour ce que ça vaut, J'utilise EclipseLink 2.3.2.v20111125-r10461 et si j'ai une relation unidirectionnelle avec @ManyToMany, j'observe le problème que vous décrivez. Cependant, si je le change pour être une relation bi-directionnelle @ManyToMany je suis en mesure de supprimer une entité du côté non-propriétaire et la table de jointure est mis à jour de manière appropriée. Tout cela sans l'utilisation d'attributs en cascade.

C'est une bonne solution. La meilleure partie est sur le côté SQL - peaufiner à n'importe quel niveau est facile.

j'ai utilisé MySql et MySql Workbench pour la Cascade sur Supprimer pour la clé étrangère requise.

ALTER TABLE schema.joined_table 
ADD CONSTRAINT UniqueKey
FOREIGN KEY (key2)
REFERENCES schema.table1 (id)
ON DELETE CASCADE;

ça marche pour moi:

@Transactional
public void remove(Integer groupId) {
    Group group = groupRepository.findOne(groupId);
    group.getUsers().removeAll(group.getUsers());

    // Other business logic

    groupRepository.delete(group);
}

aussi, marquez la méthode @Transactional (org.springframework.transaction.annotation.Transactionnel), cela fera tout le processus en une seule session, économise du temps.