Table d'association avec attributs en plus des clés étrangères.

Version imprimable

Bonjour à tous, voici mon problème :
J'ai une table, par exemple Contrat, et une autre, CompagnieTransport.

Un contrat peur être lié a plusieurs compagnies, et une compagnie a plusieurs contrats. On a donc une relation de type manyToMany.

J'utilise donc une table d'association Contrat_CompagnieTransport, à l'intérieur de laquelle j'ai les clés de chaque table.
Le soucis, c'est que j'ai des champs en plus, on va dire dateDepart, dateArrivee, effectif, ces champs sont dans ma table d'association, ce qui donnerait donc par exemple :

idContrat 3
idCompTransport 19
dateDepart 22/10/2010
dateArrivee 23/10/2010
effectif 42

Comment implémenter ceci en JPA ?

Le code suivant fonctionnerait bien si si il'y avait pas d'autres attributs que les clés étrangères :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //Dans Table Convention @ManyToMany @JoinTable(name = "Convention_Compagnie", joinColumns = { @JoinColumn(name = "convention_id", unique = true)}, inverseJoinColumns = { @JoinColumn(name = "compagnie_id")}) private Set<Convention_Compagnie> compagnies = new HashSet<Convention_Compagnie>(); //Dans Table CompagnieTransport @OneToMany(mappedBy = "compagnie", cascade = { CascadeType.REMOVE }) private Set<Convention_Compagnie> conventions = new HashSet<Convention_Compagnie>();
Mais avec les attributs en plus, je ne sais pas...
Voila merci de votre aide !
@ + !

04/08/2010, 23h36
demanghonj

Il faut que tu créés une entité qui représente ta table de relation entre le contrat et le transport.

Un fois que tu as crées cette entité (Contrat_CompagnieTransport) tu fais la relation directement avec cette entité en OneToMany pour tes deux classes.

Ensuite tu peux ajouter tes attributs "dateDepart, dateArrivee, effectif" dans ton entité" Contrat_CompagnieTransport"

Est ce que la clé primaire de Contrat_CompagnieTransport est la composition des deux clé étrangère qui font la relation avec tes deux tables Contrat et CompagnieTransport?

Code:

Est ce que la clé primaire de Contrat_CompagnieTransport est la composition des deux clé étrangère qui font la relation avec tes deux tables Contrat et CompagnieTransport?

Oui sur le principe. ton idée est bonne, mais pas complète. Voila ce que je fais d'habitude dans ce cas là, tu crées effectivement une entité intermédiaire, et sa clé primaire est un EmbeddedId, une classe imbriquée, qui comportera 2 attributs (y compris les accesseurs) de même type que les attributs clés primaires de compagnie et transport). voila un exemple : Classe clé doublon :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class ClassDoublonIdEntity implements Serializable{
 
  /**
         * 
         */
	private static final long serialVersionUID = -1906922531810845505L;
	private Integer idAttr1;
    private Integer idAttr2;
  /**
   * @return the idAttr1
   */
  @Column(name = "id_attr_1", nullable = false)
  public Integer getIdAttr1() {
    return this.idAttr1;
  }
  /**
   * @param aIdSiteStat the idSiteStat to set
   */
  public void setIdSiteStat(Integer id) {
    this.idAttr2= id;
  }
  /**
   * @return the idAttr2
   */
  @Column(name = "id_attr2", nullable = false)
  public Integer getIdAttr2() {
    return this.idAttr12;
  }
  /**
   * @param idAttr12 the idAttr12to set
   */
  public void setIdAttr2(Integer id) {
    this.idAttr12= id;
  }

Son appel dans ta classe à mapper sur la table d'association:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
@Entity
@Table(name = "Table_association")
public class ClassAssoEntity implements Serializable{
 
  /**
         * 
         */
	private static final long serialVersionUID = 7554279265008007593L;
	private ClassDoublonIdEntity idDoublon;
 
  /**
   * @return the idDoublon
   */
  /**
   * @return : id retourné
   */
  @EmbeddedId
  @AttributeOverrides( {
          @AttributeOverride(name = "id_attr_1", column = @Column(name = "id_attr_1", nullable = false)),
          @AttributeOverride(name = "id_attr_2", column = @Column(name = "id_attr_2", nullable = false)) })
  public ClassDoublonIdEntity getIdDoublon() {
    return this.idDoublon;
  }
 
  /**
   * @param aIdDoublon the idDoublon to set
   */
  public void setIdDoublon(ClassDoublonIdEntity aIdDoublon) {
    this.idDoublon = aIdDoublon;
  }
...
Tes autres attributs
...
}

Voila voila, n'hesites pas si t'as d'autres questions.

05/08/2010, 23h55
demanghonj

Tu as raison de préciser le coup de la clé composé avec EmbeddedId. En fait c'est pour ca que je posait la question et j'attendais sa réponse pour proposer cette méthode.

Par contre pourquoi tu ajoute AttributeOverrides en plus. Je n'est jamais eu besoin de le faire. Moi je défini la clé composé comme Embedded et ca fonctionne.

En effet cet attribut n'est pas indispensable, c'est surtout utile si ta classe Embedded heritait d'une autre qui avait déjt déjà défini un tel attribut, en tout cas c'est comme ca que je concois cette déclaration, mais en revanche je te conseille vivement de redefinir les methodes hascode et equals sur ta classe Emebbed : Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 @Override public boolean equals(Object obj) { //Vérifie que l'objet passé en paramètre est de type ClassDoublonIdEntity if (obj instanceof ClassDoublonIdEntity ) { ClassDoublonIdEntity referenceId=(ClassDoublonIdEntity )obj; //Vérifie l'egalité des clés if (this.getIdAttr1().equals(referenceId.getIdAttr1())) { if (this.getIdAttr2().equals(referenceId.getIdAttr2())) { return true; } } } return false; } /** * */ @SuppressWarnings("boxing") @Override public int hashCode() { return (getIdAttr1()+getIdAttr2()+"").hashCode(); }
Ca permettra à ton framework de comparer de manière formelle 2 objets de type classe Doublon, c'est vivement conseillé pour ce type de mapping(classe d'association)