Efficacité en cascade Hibernate One-to-Many

Question

J'ai appris Hibernate ces dernières semaines, j'ai appris la plupart de ce que j'ai appris à travailler mais j'ai une question sur l'efficacité d'une cartographie One-to-Many. Cela fonctionne, mais je suis à peu près sûr qu'il pourrait être modifié un peu. Lors de l'enregistrement, je remarque que trois requêtes sont exécutées, une insertion pour l'objet "Parent", une insertion pour l'objet "Child" et une requête de mise à jour pour l'enfant qui met à jour la clé étrangère de l'objet parent. Mon hypothèse est qu'il existe un moyen plus efficace de mapper cette relation afin qu'il n'y ait que les deux inserts. Suis-je en train de manquer quelque chose d'assez évident dans ma cartographie?

Voici mon code:

Parent:

@Entity 
@Table(name="Punch") 
public class Punch implements Serializable 
{ 
    private Long id; 
    private DateTime punchDate; 
    private Integer userId; 
    private List<PunchTimes> punches= new ArrayList<PunchTimes>(); 
    private static final long serialVersionUID=2010010611; 
    ...Various getters & setters... 
    @OneToMany 
    @JoinColumn(name="punchId_fk") 
    @OrderBy("pid") 
    @Cascade(org.hibernate.annotations.CascadeType.ALL) 
    public List<PunchTimes> getPunches() 
    { 
     return punches; 
    } 
} 

enfant:

@Entity 
@Table(name = "PunchTimes") 
public class PunchTimes implements Serializable{ 
    private Long id; 
    private Long pid; 
    private DateTime inTime; 
    private DateTime outTime; 
    private Double adjustedTime; 
    private static final long serialVersionUID = 20100106; 
    private Punch punch; 
    ...Various getters & setters... 
    @ManyToOne 
    @JoinColumn(name = "punchId_fk", insertable = false, updatable = false) 
    public Punch getPunch(){ 
     return punch; 
    } 
} 

Sortie SQL:

insert into Punch (punchDate, employeeId) 
values (?, ?) 

insert into PunchTimes (adjusted, inTime, outTime, punchId_fk) 
values (?, ?, ?, ?) 

update PunchTimes 
set punchId_fk=? 
where inoutId=? 

Answer 1

import java.io.Serializable; 
import javax.persistence.*; 
import org.hibernate.annotations.Type; 
import org.joda.time.DateTime; 

@Entity 
@Table(name = "PunchTimes") 
public class PunchTimes implements Serializable 
{ 
    private static final long serialVersionUID = 20100106; 
    private Long id; 
    private Long pid; 
    private DateTime inTime; 
    private DateTime outTime=null; 
    private Double adjustedTime=null; 
    private Boolean adjustedByOperator=false; 
    private Boolean overtimeAuthorized; 
    private Punch punch; 

    public PunchTimes() 
    { 
    } 

    @Column(name = "adjusted") 
    public Double getAdjustedTime() 
    { 
     return adjustedTime; 
    } 

    public void setAdjustedTime(Double adjustedTime) 
    { 
     this.adjustedTime = adjustedTime; 
    } 

    @Id 
    @GeneratedValue 
    @Column(name = "inoutId") 
    public Long getId() 
    { 
     return id; 
    } 

    public void setId(Long id) 
    { 
     this.id = id; 
    } 

    @Column(name = "inTime") 
    @Type(type = "org.joda.time.contrib.hibernate.PersistentDateTime") 
    public DateTime getInTime() 
    { 
     return inTime; 
    } 

    public void setInTime(DateTime inTime) 
    { 
     this.inTime = inTime; 
    } 

    @Column(name = "outTime") 
    @Type(type = "org.joda.time.contrib.hibernate.PersistentDateTime") 
    public DateTime getOutTime() 
    { 
     return outTime; 
    } 

    public void setOutTime(DateTime outTime) 
    { 
     this.outTime = outTime; 
    } 

    @Column(name = "punchId_fk" ,insertable = false, updatable = false) 
    public Long getPid() 
    { 
     return pid; 
    } 

    public void setPid(Long pid) 
    { 
     this.pid = pid; 
    } 

    @ManyToOne 
    @JoinColumn(name = "punchId_fk") 
    public Punch getPunch() 
    { 
     return punch; 
    } 

    public void setPunch(Punch punch) 
    { 
     this.punch = punch; 
    } 

Pour se débarrasser de la mise à jour, j'ai dû faire la clé étrangère (pid) insérable = false, updatable = false