Persistono entità 1-m con chiave primaria composita in ibernazione

Question

Ho meno di 1-m relazione su entità che Mentore agli studenti. Il tutore svolge chiave primaria composita che io uso come chiave esterna studente

@Entity 
public class Mentor implements Serializable { 
    private static final long serialVersionUID = 1L; 
    @Id 
    private MentorPK id; 
    private String email; 
    @OneToMany(mappedBy="mentor") 
    private Set<Student> students; 

    public MentorPK getId() { 
     return id; 
    }    
    //getters and setters 
} 

@Embeddable 
public class MentorPK implements Serializable { 

    private static final long serialVersionUID = 1L; 
    private String name; 
    private String add; 
    //getters and setters 
    //override equals and hashcode 
} 


@Entity 
public class Student implements Serializable{ 
    private static final long serialVersionUID = 1L; 
    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    private int id; 
    private String name;  

    @ManyToOne 
    @MapsId("id") 
    @JoinColumns({ 
     @JoinColumn(name="name_fk", referencedColumnName="name"), 
     @JoinColumn(name="address_fk", referencedColumnName="address") 
    }) 
    private Mentor mentor; 

    //Getters and setters 
} 

ho ancora insistere sopra come sotto ma solo la Mentor è persistito dove studente tavolo è vuota.

Come posso mantenere il mentore con gli studenti?

Set<Student> students = new HashSet<Student>(); 

Student s1 = new Student(); 
s1.setName("Student 1"); 

Student s2 = new Student(); 
s2.setName("Student 2"); 

students.add(s1); 
students.add(s2); 

MentorPK mpk = new MentorPK(); 
mpk.setAddress("C"); 
mpk.setName("D"); 

Mentor m = new Mentor(); 
m.setId(mpk); 
m.setEmail("emaill"); 
m.setStudents(students); 

studentManager.saveMentor(m); 

Answer 1

Prova a cambiare l'annotazione di campo agli studenti di

@OneToMany(mappedBy="mentor", cascade = CascadeType.PERSIST)

Answer 2

Quando si utilizza un composito-chiave, mappata come Embeddable è necessario utilizzare @EmbeddedId:

@Entity 
public class Mentor { 

    @EmbeddedId 
    private MentorPK id; 

    private String email; 
    @OneToMany(mappedBy="mentor") 
    private Set<Student> students; 

    public MentorPK getId() { 
     return id; 
    }    
    //getters and setters 
} 

e la Lo studente diventa:

@Entity 
public class Student { 

    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    private int id; 
    private String name;  

    @ManyToOne 
    @JoinColumns({ 
     @JoinColumn(name="name_fk", referencedColumnName="name"), 
     @JoinColumn(name="address_fk", referencedColumnName="address") 
    }) 
    private Mentor mentor; 

    //Getters and setters 
} 

Il @MapsId viene utilizzato quando sia lo @Id che lo @ManyToOne condividono le stesse colonne del database, che non è il tuo caso, poiché hai un identificatore numerico e una chiave esterna composita.

Answer 3

Come di cambiare:

@OneToMany(mappedBy="mentor") 
private Set<Student> students; 

a:

@OneToMany(mappedBy="mentor") 
private Set<Student> students = new HashSet(); 

o

@OneToMany(cascade=CascadeType.ALL) 
@JoinColumn(name="student_id") 
@org.hibernate.annotations.IndexColumn(name="idx") 
private Set<Student> students = new HashSet(); 

anche cercare di non saltare

= new HashSet(); 

parte

Answer 4

Potrebbe essere necessario creare il riferimento da studente a mentore in ogni studente.

Quindi, nel codice, dopo aver creato m è necessario:

s1.setMentor(m); 
s2.setMentor(m); 

Altrimenti Hibernate non può sapere che cosa per popolare le colonne name_fk e address_fk con.

Answer 5

Come ho capito la richiesta, vorresti che il mentore fosse il proprietario del rapporto. Non ottieni questo con la riga @OneToMany(mappedBy="mentor"). Questo in effetti mette lo studente come il proprietario della relazione.

Ho testato questo modello di dominio e ho apportato alcune modifiche alle annotazioni per fare in modo che il codice di test funzioni come previsto.

Student

public class Student implements Serializable { 
    private static final long serialVersionUID = 1L; 
    @Id 
    @GeneratedValue(strategy= GenerationType.AUTO) 
    private int id; 
    private String name; 

    @ManyToOne 
    @JoinColumns({ 
      @JoinColumn(name="name_fk", referencedColumnName="name", insertable = false, updatable = false), 
      @JoinColumn(name="address_fk", referencedColumnName="address", insertable = false, updatable = false) 
    }) 
    private Mentor mentor; 

//setters and getters 
} 

Mentor

public class Mentor implements Serializable { 
    private static final long serialVersionUID = 1L; 
    @Id 
    private MentorPK id; 
    private String email; 
    @OneToMany(cascade = CascadeType.ALL) 
    @JoinColumns({ 
      @JoinColumn(name="name_fk", referencedColumnName="name"), 
      @JoinColumn(name="address_fk", referencedColumnName="address") 
    }) 
    private Set<Student> students; 
//setters and getters 
} 

Funziona anche senza fare: s1.setMentor(m);s2.setMentor(m);. Non me l'aspettavo, ma sembra che l'ibernazione abbia a che fare con questo.

Un articolo correlato è here.

Attenzione: rilasciare le tabelle del database dopo aver modificato le annotazioni per consentire a Hibernate di ricreare le tabelle.