Supprimer l'enfant, des parents et des parents de l'enfant automatiquement avec les annotations JPA

Supposons que nous disposons de 3 Entités de la classe d'objet:

class Parent {
    String name;
    List<Child> children;
}

class Child {
    String name;
    Parent parent;
}

class Toy {
    String name;
    Child child;
}

Comment puis-je utiliser JPA2.x (ou veille prolongée) annotations:

Supprimer tous les enfants automatiquement lorsque le parent supprimer (un à plusieurs)
Supprimer l'enfant automatiquement à partir de la liste des enfants lorsqu'il est supprimé (beaucoup)
Supprimer jouet automatiquement lorsque l'enfant supprimer (un à un)

Je suis en utilisant Hibernate 4.3.5 et mysql 5.1.30.

Grâce

OriginalL'auteur user1079877 | 2014-05-29

17

Comme expliqué dans cet article, le remove entité de l'état de transition devrait cascade auprès des parents aux enfants, et non l'inverse.

Vous besoin de quelque chose comme ceci:
```
class Parent {
    String name;
    @OneToMany(mappedBy = "parent", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
    List<Child> children;

    public void addChild(Child child) {
        child.setParent(this);
        children.add(child);
    }

    public void removeChild(Child child) {
        children.remove(child);
        if (child != null) {
            child.setParent(null);
        }
    }
}

class Child {
    String name;
    @ManyToOne
    Parent parent;

    @OneToOne(mappedBy = "child", cascade = CascadeType.ALL, orphanRemoval = true)
    Toy toy;
}

class Toy {
    String name;

    @OneToOne
    Child child;
}
```
J'ai un problème bizarre. Nous je persistent ou supprimer quelque chose, c'est juste d'ajouter ou de supprimer mais la prochaine fois que je recharge la page (requête de nouveau), il est là, la prochaine fois disparaître de nouveau, et il continue de manière aléatoire! Quand je ferme les EntityManagerFactory (Redémarrez l'application), tout ira bien!
J'ai mis à jour ma réponse avec l'ajouter/retirer les enfants des méthodes. Assurez-vous de toujours synchroniser à la fois le parent et l'enfant, les associations, ainsi, lorsque vous ajoutez un nouvel enfant, le parent et l'enfant sont au courant de la nouvelle liaison. Assurez-vous de faire ces opérations à l'intérieur d'une Transaction et vous devriez être bien. L'EntityManagerFactory doit être fermée que lorsque votre application des arrêts de production.
Avec hibernate 3.5.6-Finale, pas de problème!!!!!
Cartographie sur List<Toy> toys dans Child est faux. Il devrait être OneToMany. La caisse de la commentaire par @JB Nizet dans ce post. Mise à jour ur réponse.
Il devrait être Toy toy et pas un one-to-many association. Vérifier la question.

OriginalL'auteur Vlad Mihalcea
7

Vous devez utiliser CascadeType.REMOVE. Ce qui est commun annotation pour les deux Hibernate et JPA. Hibernate a un autre type similaire CacadeType comme CascadeType.DELETE.
1. Supprimer tous les enfants automatiquement lorsque le parent supprimer (un à plusieurs)
```
class Parent {
  String name;

  @OneToMany(cascade = CascadeType.REMOVE)
  List<Child> children;
}
```
2. Supprimer l'enfant automatiquement à partir de la liste des enfants lorsqu'il est supprimé (beaucoup)
```
class Child {
 String name;
 @ManyToOne(cascade = CascadeType.REMOVE)
 Parent parent;
}
```
3. Supprimer jouet automatiquement lorsque l'enfant supprimer (un à un)
```
class Toy {
  String name;
  @OneToOne(cascade = CascadeType.REMOVE)
  Child child;
}
```
Pourquoi voulez-vous à la cascade de la retirer de l'Enfant de la Mère, ou à partir d'un Jouet à l'Enfant. Cela signifie que lorsque je supprime un jouet, j'enlève l'Enfant et du parent avec tous ses enfants.

OriginalL'auteur Masudul
0

orphanRemoval est de supprimer tous les orphelins de l'entité exemple: store (s) a des livres(b1,b2,b3) et b1 a la propriété(t) dans ce cas, si la banque supprimée(s) certains livres(b2,b3) sera supprimé. B2 et t existent encore. si vous utilisez "cascade= CascadeType.Remove" juste magasin(s) et tous les livres seront supprimés ("t").
```
s->b1,b2,b3 b2->t ------after(orphanRemoval = true)--------- b2->t

s->b1,b2,b3 b2->t ------ after(cascade=CascadeType.REMOVE)--------- t
```
Si orphanRemoval=true est spécifié, l'déconnecté de l'instance d'entité est automatiquement supprimé. Ceci est utile pour le nettoyage des objets dépendants qui ne devraient pas exister sans une référence à partir d'un propriétaire de l'objet.

Si seulement cascade=CascadeType.REMOVE est spécifié aucune action automatique est prise depuis la déconnexion d'une relation n'est pas une opération de suppression.

OriginalL'auteur Adiya Buyantogtokh

Vous devez vous connecter pour publier un commentaire.