Java JPA坚持使用多个关联类？

我试图维持一种关系

@manytomy

。我使用

@IdClass

为关联创建了一个关联类，但使用

persist

无法工作，只能使用

merge

工作。 我需要添加其他寄存器，但使用合并不起作用，因为寄存器总是更新的

我希望数据库中的表如下所示

id_aluno  | id_graduacao  |  grau   |  date    
  1              1           FIRST    2014-08-02
  1              1           SECOND   2014-08-02
  1              1           THIRD    2014-08-02

我的实体

@Entity
@Table(name="aluno")
public class Aluno implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id @GeneratedValue
    private Integer id;

    //informacoes gerais
    @NotNull
    private String nome;

    //historico de graduacao
    @OneToMany(mappedBy = "aluno")
    private List<HistoricoDeGraduacao> listaHistoricoGraduacao;

    public Aluno(){}

    /** adiciona lista de HistoricoDeGraduacao para aluno */
    public void addListaHistoricoGraduacao(HistoricoDeGraduacao hdg){
        if(listaHistoricoGraduacao == null){
            listaHistoricoGraduacao = new ArrayList<HistoricoDeGraduacao>();
        }
        listaHistoricoGraduacao.add(hdg);        
    }

    public List<HistoricoDeGraduacao> getListaHistoricoGraduacao() {
        return listaHistoricoGraduacao;
    }
    ///gets e sets


@Entity
@Table(name="graduacao")
public class Graduacao implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id @GeneratedValue
    private Integer id;

    @NotNull @Column(unique = true)
    private String graduacao;

    @ElementCollection
    @CollectionTable(name="graus_graduacao", joinColumns=@JoinColumn(name="id_graduacao"))
    @Column(name="graus")
    private List<String> graus;

    @OneToMany(mappedBy = "graduacao")
    private List<HistoricoDeGraduacao> listaHistoricoGraduacao;

    public Graduacao() {
    }

    /** adiciona historicodegraduacao a graduacao */
    public void addHistoricoDeGraduacao(HistoricoDeGraduacao hdg){
        if(listaHistoricoGraduacao == null){
            listaHistoricoGraduacao = new ArrayList<HistoricoDeGraduacao>();
        }
        listaHistoricoGraduacao.add(hdg);
    }

    public List<HistoricoDeGraduacao> getListaHistoricoGraduacao() {
        return listaHistoricoGraduacao;
    }
    //gets e sets



public class HistoricoDeGraduacaoId implements Serializable {
    private static final long serialVersionUID = 1L;

    private Aluno aluno;    
    private Graduacao graduacao;

    public Aluno getAluno() {
        return aluno;
    }

    public void setAluno(Aluno aluno) {
        this.aluno = aluno;
    }

    public Graduacao getGraduacao() {
        return graduacao;
    }

    public void setGraduacao(Graduacao graduacao) {
        this.graduacao = graduacao;
    }



@Entity
@IdClass(HistoricoDeGraduacaoId.class)
public class HistoricoDeGraduacao implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @ManyToOne 
    @JoinColumn(name = "id_aluno")
    private Aluno aluno;

    @Id
    @ManyToOne
    @JoinColumn(name="id_graduacao")
    private Graduacao graduacao;

    private String grau;

    @Temporal(TemporalType.DATE)
    private Date dataGraduou;

    public HistoricoDeGraduacao() {
    }
    //gets e sets


    //persisting
    public void insert(){ 
        //doesn't work using persist, works only with merge but record is always updated and not added
        em.getTransaction().begin();

        Aluno a = new Aluno(); 
        a.setId(1); //aluno have Id

        Graduacao g = new Graduacao();
        g.setId(1); //graduacao have Id

        HistoricoDeGraduacao hdg1 = new HistoricoDeGraduacao();
        hdg1.setAluno(a);
        hdg1.setGraduacao(g);
        hdg1.setDataGraduou(new Date());
        hdg1.setGrau("FIRST");
        a.addHistoricoDeGraduacao(hdg1);
        g.addHistoricoDeGraduacao(hdg1);
        em.persist(hdg1); 
        em.getTransaction().commit();

        HistoricoDeGraduacao hdg2 = new HistoricoDeGraduacao();
        hdg2.setAluno(a);
        hdg2.setGraduacao(g);
        hdg2.setDataGraduou(new Date());
        hdg2.setGrau("SECOND");
        a.addHistoricoDeGraduacao(hdg2);
        g.addHistoricoDeGraduacao(hdg2);
        em.persist(hdg2); 
        em.getTransaction().commit();

        HistoricoDeGraduacao hdg3 = new HistoricoDeGraduacao();
        hdg3.setAluno(a);
        hdg3.setGraduacao(g);
        hdg3.setDataGraduou(new Date());
        hdg3.setGrau("THIRD");
        a.addHistoricoDeGraduacao(hdg3);
        g.addHistoricoDeGraduacao(hdg3);
        em.persist(hdg3); 
        em.getTransaction().commit();

        em.close();
    }

@实体
@表（name=“aluno”）
公共类Aluno实现可序列化{
私有静态最终长serialVersionUID=1L；
@Id@GeneratedValue
私有整数id；
//老年信息
@NotNull
私有字符串名称；
//渐变历史
@OneToMany（mappedBy=“aluno”）
私人名单；历史档案；
公共Aluno（）{}
/**阿迪西奥纳·利斯塔（adiciona lista de Historycodegraduaco para aluno）*/
公共无效地址列表历史记录渐变（历史代码渐变hdg）{
if（listaHistoricoGraduacao==null）{
listaHistoricoGraduacao=新ArrayList（）；
}
增加（hdg）；
}
公共列表getListaHistoricoGraduacao（）{
返回listaHistoricoGraduacao；
}
///获取e集
@实体
@表（name=“graduacao”）
公共类Graduacao实现了可序列化{
私有静态最终长serialVersionUID=1L；
@Id@GeneratedValue
私有整数id；
@NotNull@Column（unique=true）
私有字符串渐变；
@元素集合
@CollectionTable（name=“graus\u graduacao”，joinColumns=@JoinColumn（name=“id\u graduacao”））
@列（name=“graus”）
私人名单；
@OneToMany（mappedBy=“graduacao”）
私人名单；历史档案；
公共渐变{
}
/**adiciona Historycodegraduacao a graduacao*/
公共无效添加历史代码渐变段（历史代码渐变段）{
if（listaHistoricoGraduacao==null）{
listaHistoricoGraduacao=新ArrayList（）；
}
增加（hdg）；
}
公共列表getListaHistoricoGraduacao（）{
返回listaHistoricoGraduacao；
}
//获取e集
公共类HistoricCodeGraduaCaOID实现可序列化{
私有静态最终长serialVersionUID=1L；
私人阿鲁诺；
私人渐变；
公共Aluno getAluno（）{
返回aluno；
}
公共无效setAluno（Aluno Aluno）{
this.aluno=aluno；
}
公共渐变getGraduacao（）{
回归梯度；
}
公共无效setGraduacao（Graduacao Graduacao）{
this.graduacao=graduacao；
}
@实体
@IdClass（HistoricCodeGraduacaoId.class）
公共类HistoricCodeGraduacao实现可序列化{
私有静态最终长serialVersionUID=1L；
@身份证
@许多酮
@JoinColumn（name=“id\u aluno”）
私人阿鲁诺；
@身份证
@许多酮
@JoinColumn（name=“id\u graduacao”）
私人渐变；
私人字符串grau；
@时态（TemporalType.DATE）
私人日期数据；
公共历史代码渐进式（）{
}
//获取e集
//坚持
public void insert（）{
//使用“持久化”不起作用，仅与“合并”一起起作用，但记录总是更新而不是添加
em.getTransaction（）.begin（）；
Aluno a=新的Aluno（）；
a、 setId（1）；//没有Id
渐变g=新渐变（）；
g、 setId（1）；//渐变有Id
HistoricCodeGraduacao hdg1=新的HistoricCodeGraduacao（）；
hdg1.setAluno（a）；
hdg1.setGraduacao（g）；
hdg1.setDataGraduou（新日期（））；
hdg1.setGrau（“第一”）；
a、 添加历史代码梯度（hdg1）；
g、 添加历史代码梯度（hdg1）；
em.persist（hdg1）；
em.getTransaction（）.commit（）；
HistoricCodeGraduacao hdg2=新的HistoricCodeGraduacao（）；
hdg2.setAluno（a）；
hdg2.setGraduacao（g）；
hdg2.setDataGraduou（新日期（））；
hdg2.setGrau（“第二”）；
a、 添加历史代码梯度（hdg2）；
g、 添加历史代码梯度（hdg2）；
em.persist（hdg2）；
em.getTransaction（）.commit（）；
HistoricCodeGraduacao hdg3=新的HistoricCodeGraduacao（）；
hdg3.setAluno（a）；
hdg3.setGraduacao（g）；
hdg3.setDataGraduou（新日期（））；
hdg3.setGrau（“第三”）；
a、 AddHistoricCodeGraduacao（hdg3）；
g、 AddHistoricCodeGraduacao（hdg3）；
em.persist（hdg3）；
em.getTransaction（）.commit（）；
em.close（）；
}

有什么想法吗？

现在可以了

我是怎么做到的

@Entity
@Table(name="aluno")
public class Aluno implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id @GeneratedValue
    private Integer id;

    //informacoes gerais
    @NotNull
    private String nome;


    //historico de graduacao
    @OneToMany(mappedBy = "aluno", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<HistoricoDeGraduacao> listaHistoricoGraduacao;


    public Aluno() {
    }

    public void addListaHistoricoGraduacao(HistoricoDeGraduacao hdg){
        if(listaHistoricoGraduacao == null){
            listaHistoricoGraduacao = new ArrayList<HistoricoDeGraduacao>();
        }
        listaHistoricoGraduacao.add(hdg);        
    }


    public Integer getId() {
        return id;
    }

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

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public List<HistoricoDeGraduacao> getListaHistoricoGraduacao() {
        return listaHistoricoGraduacao;
    }

    public void setListaHistoricoGraduacao(List<HistoricoDeGraduacao> listaHistoricoGraduacao) {
        this.listaHistoricoGraduacao = listaHistoricoGraduacao;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Aluno other = (Aluno) obj;
        return true;
    }    
}


@Entity
@Table(name="graduacao")
public class Graduacao implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id @GeneratedValue
    private Integer id;

    @NotNull @Column(unique = true)
    private String graduacao;

    @ElementCollection
    @CollectionTable(name="graus_graduacao", joinColumns=@JoinColumn(name="id_graduacao"))
    @Column(name="graus")
    private List<String> graus;

    @OneToMany(mappedBy = "graduacao", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<HistoricoDeGraduacao> listaHistoricoGraduacao;

    public Graduacao() {
    }

    public Graduacao(Integer id, String graduacao, List<String> graus) {
        this.id = id;
        this.graduacao = graduacao;
        this.graus = graus;
    }   

    /** adiciona historicodegraduacao a graduacao */
    public void addHistoricoDeGraduacao(HistoricoDeGraduacao hdg){
        if(listaHistoricoGraduacao == null){
            listaHistoricoGraduacao = new ArrayList<HistoricoDeGraduacao>();
        }
        listaHistoricoGraduacao.add(hdg);
    }

    public Integer getId() {
        return id;
    }

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

    public String getGraduacao() {
        return graduacao;
    }

    public void setGraduacao(String graduacao) {
        this.graduacao = graduacao;
    }

    public List<String> getGraus() {
        return graus;
    }

    public void setGraus(List<String> graus) {
        this.graus = graus;
    }

    public List<HistoricoDeGraduacao> getListaHistoricoGraduacao() {
        return listaHistoricoGraduacao;
    }

    public void setListaHistoricoGraduacao(List<HistoricoDeGraduacao> listaHistoricoGraduacao) {
        this.listaHistoricoGraduacao = listaHistoricoGraduacao;
    }

    public String toString(){
        return graduacao;
    }
}


@Embeddable
public class HistoricoDeGraduacaoId implements Serializable {
    private static final long serialVersionUID = 1L;

    @JoinColumn(name="EMP_ID")
    private Integer id;

    public Integer getId() {
        return id;
    }

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


    @Override
    public boolean equals(Object obj) {
        return super.equals(obj); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public int hashCode() {
        return super.hashCode(); //To change body of generated methods, choose Tools | Templates.
    } 
}


@Entity
public class HistoricoDeGraduacao implements Serializable {
    private static final long serialVersionUID = 1L;

    @EmbeddedId
    HistoricoDeGraduacaoId pk;

    @ManyToOne(cascade = CascadeType.ALL) 
    @JoinColumn(name = "id_aluno")
    private Aluno aluno;    

    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name="id_graduacao")
    private Graduacao graduacao;

    private String grau;

    @Temporal(TemporalType.DATE)
    private Date dataGraduou;

    public HistoricoDeGraduacao() {
    }

    public void begin(){
        //instancia pk
        pk = new HistoricoDeGraduacaoId();
        //aqui insiro o id 
        pk.setId(new HistoricoDeGraduacaoDAO().getIndex());
    }


    public HistoricoDeGraduacaoId getPk() {
        return pk;
    }

    public void setPk(HistoricoDeGraduacaoId pk) {
        this.pk = pk;
    }

    public Aluno getAluno() {
        return aluno;
    }

    public void setAluno(Aluno aluno) {
        this.aluno = aluno;
    }

    public Graduacao getGraduacao() {
        return graduacao;
    }

    public void setGraduacao(Graduacao graduacao) {
        this.graduacao = graduacao;
    }

    public String getGrau() {
        return grau;
    }

    public void setGrau(String grau) {
        this.grau = grau;
    }

    public Date getDataGraduou() {
        return dataGraduou;
    }

    public void setDataGraduou(Date dataGraduou) {
        this.dataGraduou = dataGraduou;
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 59 * hash + Objects.hashCode(this.aluno);
        hash = 59 * hash + Objects.hashCode(this.graduacao);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final HistoricoDeGraduacao other = (HistoricoDeGraduacao) obj;
        if (!Objects.equals(this.aluno, other.aluno)) {
            return false;
        }
        if (!Objects.equals(this.graduacao, other.graduacao)) {
            return false;
        }
        return true;
    }    
}


//aqui meu jframe com seus componentes, pegando valores montando tudo para ser salvo
     historico.setDataGraduou(jdp_dataGraduou.getDate());
     historico.setGrau(jl_graus.getSelectedValue().toString());
     //pega graduacao do jcombobox
     Graduacao g = (Graduacao)cbx_graduacao.getSelectedItem();                                
     historico.setGraduacao(g);
     //bean aluno
     historico.setAluno(bean);
     //add a listas
     bean.addListaHistoricoGraduacao(historico);
     g.addHistoricoDeGraduacao(historico);
     //inicia instancia de pk e insere o proximo id     
     historico.begin(); 
     //salva tudo
     new HistoricoDeGraduacaoDAO().update(historico);


//aqui meu DAO
public class HistoricoDeGraduacaoDAO {
    private EntityManager em;

    public HistoricoDeGraduacaoDAO(){
        em = Persistencia.getEntityManager();
    }

    /** pega o ultimo valor da tabela HistoricoDeGraduacao e adiciona + 1 para o proximo indice */
    public Integer getIndex(){
        int count = 0;
        Query query = em.createQuery("SELECT MAX(hdg.pk.id) FROM HistoricoDeGraduacao hdg");
        if(query.getSingleResult() == null){
            ++count;
        }else{
            count = (int)query.getSingleResult() + 1;            
        }
        return count;
    }

    /** executa update */
    public void update(HistoricoDeGraduacao historico){
        try{
            em.getTransaction().begin();        
            em.merge(historico);
            em.getTransaction().commit();
        }catch(PersistenceException e){
            JOptionPane.showMessageDialog(null, e.getMessage(), "Erro", JOptionPane.ERROR_MESSAGE);
        }finally{
            em.close();
        }
    }
}

@实体
@表（name=“aluno”）
公共类Aluno实现可序列化{
私有静态最终长serialVersionUID=1L；
@Id@GeneratedValue
私有整数id；
//老年信息
@NotNull
私有字符串名称；
//渐变历史
@OneToMany（mappedBy=“aluno”，cascade=CascadeType.ALL，fetch=FetchType.LAZY）
私人名单；历史档案；
公共Aluno（）{
}
公共无效地址列表历史记录渐变（历史代码渐变hdg）{
if（listaHistoricoGraduacao==null）{
listaHistoricoGraduacao=新ArrayList（）；
}
增加（hdg）；
}
公共整数getId（）{
返回id；
}
公共无效集合id（整数id）{
this.id=id；
}
公共字符串getNome（）{
返回nome；
}
公共无效集合名称（字符串名称）{
this.nome=nome；
}
公共列表getListaHistoricoGraduacao（）{
返回listaHistoricoGraduacao；
}
公共无效设置列表历史记录渐变uacao（列表列表历史记录渐变uacao）{
this.listaHistoricoGraduacao=listaHistoricoGraduacao；
}
@凌驾
公共int hashCode（）{
int hash=7；
返回散列；
}
@凌驾
公共布尔等于（对象obj）{
if（obj==null）{
返回false；
}
如果（getClass（）！=obj.getClass（））{
返回false；
}
最终无其他=(