JPA Persister le parent et l'enfant avec l'un de relation

Je veux persister entité mère avec 20 enfants,
mon code est ci-dessous

Classe Parent

@OneToMany(mappedBy = "parentId")
private Collection<Child> childCollection;

Enfant De La Classe

@JoinColumn(name = "parent_id", referencedColumnName = "parent_id")
@ManyToOne(optional=false)
private Parent parent;

String jsonString = "json string containing parent properties and child  collection" 

ObjectMapper mapper = new ObjectMapper();
Parent parent = mapper.readValue(jsonString, Parent.class);

public void save(Parent parent) {
    Collection<Child> childCollection = new ArrayList<>() ;

    for(Child tha : parent.getChildCollection()) { 
        tha.setParent(parent);
        childCollection.add(tha);
    }

    parent.setChildCollection(childCollection);
    getEntityManager().persist(parent);
 }

Donc si il y a 20 tables enfants alors je dois mettre le parent de référence dans chacun d'eux pour ce que j'ai à écrire 20 pour les boucles?
Est-il possible? est-il un autre moyen ou une configuration où je peux automatiquement persister le parent et l'enfant?

Cela semble de plus d'un JSON question que JPA question. Si votre JSON est unmarshalled de sorte que les relations sont définies, puis d'avoir les enfants ont persisté lors de l'enregistrement parent est simplement une question de l'ajout de la pertinente cascade d'options pour le @OneToMany (en supposant que votre mappages sont corrects)
Si vous n'êtes pas envoyer l'Enfant->relation Parent en arrière, ou il n'est pas défini dans ce qui se construit à partir de JSON, alors oui, vous devez le paramétrer manuellement dans chaque entité enfant. L'alternative est de faire de la relation d'uni-directionnelle: supprimer le mappedby="parent" de la OneToMany et, au lieu de spécifier un JoinColumn. Ce sera la cause de la OneToMany pour définir la clé étrangère dans la table enfant au lieu de l'être par la référence de l'enfant à son parent (ensuite, vous devez supprimer le parent de l'Enfant de l'attribut et de la cartographie)

OriginalL'auteur Gora | 2016-02-04

jpa one-to-many

6

Fixer votre classe Parent:
```
@OneToMany(mappedBy = "parent")
```
mappedBy propriété doit pointer vers le terrain de l'autre côté de la relation. Comme JavaDoc dit:

Le terrain que possède la relation. À moins que la relation est à sens unique.

Aussi, vous devez explicitement persistent entité Enfant dans le cycle:
```
for(Child tha : parent.getChildCollection()) { 
    ...
    getEntityManager().persist(tha);
    ...
}
```
Comme Alan Foin remarqué dans un commentaire, vous pouvez utiliser cascade d'installations et de laisser l'EntityManager automatiquement persistent tout votre Enfant entités:
```
@OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST)
```
Plus de détails à propos de cascades (et JPA lui-même) que vous pouvez trouver dans Vlad Mihalcea blog.

Va-t-il besoin de cascade options de ce @OneToMany ainsi?
mais pour 20 différent de l'enfant collections, je vais avoir à écrire de 20 pour les boucles?
Reddy, je pense que oui, cos de 20 différent de l'enfant collections est de 20 différents objets Parents et vous permettra d'appeler la méthode save(...) 20 fois.
J'ai mis à jour ma réponse.
j'avais utilisé cascade = CascadeType.PERSISTER, mais je suis étrangers ont à clé null

OriginalL'auteur Ivan Babanin
5

Généralement, les annotations @JoinColumn indique que l'entité est le propriétaire de la relation & mappedBy indique que l'entité est le inverse de la relation.

Donc, si vous êtes comme suit
```
@OneToMany(mappedBy = "parent")
private Collection<Child> childCollection;
```
Qui signifie qu'il est inverse de la relation et il ne sera pas mis en référence du parent à son enfant.

Pour définir la référence du parent à son enfant, vous devez vous rendre cette entité propriétaire de la relation de la manière suivante.
```
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn
private Collection<Child> childCollection;
```
Vous n'avez pas besoin de définir toute de référence de l'enfant parce que le code ci-dessus va créer une colonne dans la table enfant.

ce n'est pas une meilleure façon qu'il a appelé Unidirectional @OneToMany et puis, Hibernate va créer deux fois plus de requêtes SQL DB vladmihalcea.com/2017/03/29/...

OriginalL'auteur maruf571

Je laisserais le parent persister propres enfants

package com.greg;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
@Entity(name = "PARENT")
public class Parent {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column(name = "NAME")
private String name;
@Column(name = "DESCRIPTION")
private String description;
@OneToMany(cascade = CascadeType.ALL, fetch=FetchType.EAGER)
@JoinColumn(name = "parent", referencedColumnName = "id", nullable = false)
private List<Child> children = new ArrayList<Child>();
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public List<Child> getChildren() {
return children;
}
public void setChildren(List<Child> children) {
this.children = children;
}
}

Est l'aide de l' FetchType.EAGER nécessaire dans le cas où nous voulons seulement le parent pour conserver les enfants ?
non, je pense que je l'ai fait pour des raisons de test

OriginalL'auteur Essex Boy

2

Comme l'a souligné dans les commentaires, vous devez prendre soin de l'objet graphique en cohérence avec l'enfant/relation parent. Cette cohérence ne viendra pas libre quand JSON est venue directement à partir de c'est à dire une requête POST.

Vous devez annoter le parent et l'enfant de terrain avec @JsonBackReference et @JsonManagedReference.

Classe Parent:
```
@OneToMany(mappedBy = "parentId")
@JsonBackReference
private Collection<Child> childCollection;
```
Enfant de la classe:
```
@JoinColumn(name = "parent_id", referencedColumnName = "parent_id")
@ManyToOne(optional=false)
@JsonManagedReference
private Parent parent;
```
Même question avec réponse est ici

En outre, si vous utilisez @JsonBackReference/@JsonManagedReference sur javax.persistence annoté classes en combinaison avec de Lombok @ToString annotation que vous devrez engager dans stackoverflow erreur.

Juste exclure childCollection et parent champ de la @ToString annotation avec @ToString( exclude = ...)

La même chose se produira avec Lombok est généré equals() méthode (@Data, @EqualsAndHashCode). Juste implémente ces méthodes à la main ou à l'utilisation @Getter et @Setter annotations.

Comment pouvons-nous gérer si la demande d'entrée est au format XML ?

OriginalL'auteur s17t.net

Vous devez vous connecter pour publier un commentaire.