2011-11-02 22 views
24

Ho bisogno di creare una tabella di unirsi nel mio database utilizzando JPA le annotazioni in modo che il risultato sarà questo:Come creare una tabella di join con annotazioni JPA?

enter image description here

Finora ho appena implementato 2 entità:

@Entity 
@Table(name="USERS", schema="ADMIN") 
public class User implements Serializable { 

    private static final long serialVersionUID = -1244856316278032177L; 
    @Id 
    @Column(nullable = false) 
    private String userid; 

    @Column(nullable = false) 
    private String password; 

    public String getUserid() { 
     return userid; 
    } 

    public void setUserid(String userid) { 
     this.userid = userid; 
    } 

    public String getPassword() { 
     return password; 
    } 

    public void setPassword(String password) { 
     this.password = password; 
    } 

} 

@Entity 
@Table(name="GROUPS", schema="ADMIN") 
public class Group implements Serializable { 

    private static final long serialVersionUID = -7274308564659753174L; 
    @Id 
    @Column(nullable = false) 
    private String groupid; 

    public String getGroupid() { 
     return groupid; 
    } 
    public void setGroupid(String groupid) { 
     this.groupid = groupid; 
    } 
} 

Devo creare un'altra entità chiamata USER_GROUP o posso semplicemente aggiungere alcune annotazioni, quindi t la tabella di join verrà creata automaticamente quando eseguo le tabelle create da entità (ORM)?

Come devo annotare le mie entità per ottenere lo stesso come nell'immagine?

+2

Che cos'è la cardinalità tra entità Gruppo e Utente? È @OneToMany, quindi ogni gruppo ha 0 .. * utenti? O è ManyToMany? – jFrenetic

+1

È un @OneToMany, in modo che ogni gruppo abbia utenti 0 .. *, come hai detto. Un utente deve appartenere a uno e solo a un gruppo, ma un gruppo può avere molti (0 .. *) utenti. – sfrj

risposta

28

Non è assolutamente necessario creare entità User_Group poiché è più la rappresentazione del database sottostante rispetto a quella orientata agli oggetti.

È possibile ottenere la tabella di join definendo qualcosa come:

@Entity 
@Table(name="USERS", schema="ADMIN") 
public class User implements Serializable { 
//... 

@ManyToOne 
@JoinTable(name="USER_GROUP") 
Group group; 

@Entity 
@Table(name="GROUPS", schema="ADMIN") 
public class Group implements Serializable { 
//... 

@OneToMany(mappedBy="group") 
Set<User> users; 

Edit: Se si desidera impostare esplicitamente i nomi delle colonne che si potrebbe usare @JoinColumn elementi come mostrato di seguito:

@ManyToOne 
@JoinTable(name="USER_GROUP", 
    joinColumns = @JoinColumn(name = "userid", 
           referencedColumnName = "userid"), 
    inverseJoinColumns = @JoinColumn(name = "groupid", 
           referencedColumnName = "groupid")) 
Group group; 
+0

Intendevi @ManyToMany? http://download.oracle.com/javaee/5/api/javax/persistence/ManyToMany.html – Jonathan

+1

@Jonathan no Intendo '@ OneToMany' e' @ ManyToOne' come mostrato nell'esempio. Perché? –

+0

@PedroKowalski Che ha funzionato perfettamente. Grazie mille :) – sfrj

6

Vorrei implementarlo questo w ay:

@Entity 
@Table(name="GROUPS", schema="ADMIN") 
public class Group implements Serializable { 
    @OneToMany 
    @JoinTable(name = "USER_GROUP", 
      joinColumns = @JoinColumn(name = "groupid"), 
      inverseJoinColumns = @JoinColumn(name = "userid")) 
    private List<User> users; 
} 

soluzione suggerita da @PedroKowalski dovrebbe funzionare anche, ma poi si dovrà mantenere un riferimento a Gruppo entità nel tuo utente entità che non è sempre possibile.

+0

Beh, dipende davvero se vuoi avere una relazione uni- o bidirezionale. Ho pensato che fosse bidirezionale, poiché sembrava ragionevole che l'Utente sapesse a quale Gruppo appartenesse e per il Gruppo sapere quali sono gli Utenti al suo interno. Naturalmente se è necessaria una relazione unidirezionale, allora questa soluzione va bene. –

4

di avere le stesse annotazioni come nel diagramma si può fare questo nella classe User:

@ManyToMany(fetch = FetchType.LAZY) 
@JoinTable(name = "USER_GROUP", 
      joinColumns = { @JoinColumn(name = "userid") }, 
      inverseJoinColumns = { @JoinColumn(name = "groupid") }) 
private List<Group> grups; 

nella classe gruppo

@ManyToMany(fetch = FetchType.LAZY) 
@JoinTable(name = "USER_GROUP", 
      joinColumns = { @JoinColumn(name = "groupid") }, 
      inverseJoinColumns = { @JoinColumn(name = "userid") }) 
private List<User> users; 
+0

Perché molti per molti? Un utente deve appartenere a uno e solo a un gruppo? Ma un gruppo può avere più di un utente. So che sembra raro, ma deve essere così. Non è come Facebook dove un utente può essere in molti gruppi, il gruppo indica il ruolo di quell'utente nel sistema. E un utente può avere solo un ruolo. – sfrj

+0

mea culpa, pensavo che l'obiettivo fosse avere molti2many relation – user902383

+0

Domanda: cosa succede se ho già questo tavolo aggiuntivo? JoinTable non sovrascriverà quello esistente giusto? – TheWandererr

1

Mi chiedo qual è il punto di creare una tabella di join in questo modo, considerando che non è possibile accedere direttamente alle query? JPA non permette di fare domande direttamente al Tavolo Join, quindi se l'utente vuole fare un'operazione su USER_GROUP, deve Creare un normale query di join tra utenti e gruppi; a causa di ciò, la tabella di join USER_GROUP è inutile.

+0

Angel, questo è il punto principale di JPA. In questo caso non è necessario scrivere la query per questo, poiché tutto è rappresentato come un oggetto. Supponiamo che tu abbia un'entità UTENTE e un'entità CORSO. Un utente può avere più corsi e un corso può essere assegnato a più utenti. (Da molti a Molti, giusto?) Quindi vuoi elencare i corsi di un utente specifico che è definito come una variabile (probabilmente Elenco) nell'Entità Utente. In questo caso devi solo cercare l'utente, e puoi chiamare il getter() dell'elenco, che ti restituirà i loro corsi. Puoi vedere che la tabella di join è in uso. –

Problemi correlati