[JPA / Hibernate] Table avec des jointures non naturelles

Bon voilà j'ai réussi mon mapping
voici :
pour l'objet A on remarquera que de ce côté de l'objet on a que du JPA pur. L'annotation @MapKey nous permet de mapper directement un objet dans mon entité destination.

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MapKey;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
 
import fr.utbm.cri.pedago.jpa.utbm_pedago.Langue;
@Entity
@Table(name = "A",schema="UTBM_PEDAGO")
public class A implements Serializable {
	private static final long serialVersionUID = 1L;
 
	@Id
	@SequenceGenerator(name = "ID_A_GENERATOR", sequenceName = "UTBM_PEDAGO.A_SEQ", allocationSize = 1, initialValue = 1)
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ID_A_GENERATOR")
	@Column(name = "ID_A")
	private long idA;
 
	public A() {
	}
 
	@OneToMany(mappedBy="aLibelle")
	@MapKey(name="langue")
	private Map<Langue,TraductionTest> listeTraductionTestLibelle=new HashMap<>();
 
	@OneToMany(mappedBy="aLibelleCourt")
	@MapKey(name="langue")
	private Map<Langue,TraductionTest> listeTraductionTestLibelleCourt=new HashMap<>();
 
	public long getIdA() {
		return this.idA;
	}
 
	public void setIdA(long idA) {
		this.idA = idA;
	}
 
	public Map<Langue, TraductionTest> getListeTraductionTestLibelle() {
		return listeTraductionTestLibelle;
	}
 
	public void setListeTraductionTestLibelle(Map<Langue, TraductionTest> listeTraductionTestLibelle) {
		this.listeTraductionTestLibelle = listeTraductionTestLibelle;
	}
 
	public Map<Langue, TraductionTest> getListeTraductionTestLibelleCourt() {
		return listeTraductionTestLibelleCourt;
	}
 
	public void setListeTraductionTestLibelleCourt(Map<Langue, TraductionTest> listeTraductionTestLibelleCourt) {
		this.listeTraductionTestLibelleCourt = listeTraductionTestLibelleCourt;
	}
}

objet B (à peu près identique)=> je zappe les imports vu que c'est à peu près les mêmes

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
36
@Entity
public class B implements Serializable {
	private static final long serialVersionUID = 1L;
 
	@Id
	@SequenceGenerator(name="B_IDB_GENERATOR", sequenceName="B_SEQ", allocationSize = 1, initialValue = 1)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="B_IDB_GENERATOR")
	@Column(name="ID_B")
	private long idB;
 
	public B() {
	}
 
	@OneToMany(mappedBy="bLibelle")
	@MapKey(name="langue")
	private Map<Langue,TraductionTest> listeTraductionTestLibelle=new HashMap<>();
 
 
	public long getIdB() {
		return this.idB;
	}
 
	public void setIdB(long idB) {
		this.idB = idB;
	}
 
	public Map<Langue, TraductionTest> getListeTraductionTestLibelle() {
		return listeTraductionTestLibelle;
	}
 
	public void setListeTraductionTestLibelle(Map<Langue, TraductionTest> listeTraductionTestLibelle) {
		this.listeTraductionTestLibelle = listeTraductionTestLibelle;
	}
 
 
}

objet TraductionTest on remarquera l'utilisation de l'annotation @Where qui vient d'hibernate.
Cette annotation nous permet de faire une sélection précise et donc d'affiner notre mapping. il est important de noter le (insertable=false et updatable=false, sans quoi le mapping ne fonctionnera pas.

On remarquera le setter des différents objets permettant de ne pas faire d'erreurs sur les champs et libellés.

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
package fr.cri.pedago.jpa.special;
 
import java.io.Serializable;
import javax.persistence.*;
 
import org.hibernate.annotations.Where;
 
import fr.utbm.cri.pedago.jpa.utbm_pedago.Langue;
 
/**
 * The persistent class for the TRADUCTION_TEST database table.
 * 
 */
@Entity
@Table(name = "TRADUCTION_TEST")
public class TraductionTest implements Serializable {
	private static final long serialVersionUID = 1L;
 
	@Id
	@SequenceGenerator(name = "TRADUCTION_TEST_IDTRADUCTIONTEST_GENERATOR", sequenceName = "TRADUCTION_TEST_SEQ", allocationSize = 1, initialValue = 1)
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "TRADUCTION_TEST_IDTRADUCTIONTEST_GENERATOR")
	@Column(name = "ID_TRADUCTION_TEST")
	private Long id;
 
	@Column(name = "ID_DANS_TABLE")
	private Long idDansTable;
 
	@Column(name = "NOM_CHAMP")
	private String nomChamp;
 
	@Column(name = "NOM_TABLE")
	private String nomTable;
 
	@ManyToOne
	@JoinColumn(name = "ID_DANS_TABLE", referencedColumnName = "ID_A", insertable = false, updatable = false)
	@Where(clause = "NOM_TABLE='A' AND NOM_CHAMP='LIBELLE'")
	private A aLibelle;
 
 
	@ManyToOne
	@JoinColumn(name = "ID_DANS_TABLE", referencedColumnName = "ID_A", insertable = false, updatable = false)
	@Where(clause = "NOM_TABLE='A' AND NOM_CHAMP='LIBELLE_COURT'")
	private A aLibelleCourt;
 
	@ManyToOne
	@JoinColumn(name = "ID_DANS_TABLE", referencedColumnName = "ID_B", insertable = false, updatable = false)
	@Where(clause = "NOM_TABLE='B' AND NOM_CHAMP='LIBELLE'")
	private B bLibelle;
 
	@ManyToOne
	@JoinColumn(name = "ID_LANGUE")
	private Langue langue;
 
	private String texte;
 
	public TraductionTest() {
	}
 
	public Long getId() {
		return id;
	}
 
	public void setId(Long id) {
		this.id = id;
	}
 
	public Long getIdDansTable() {
		return this.idDansTable;
	}
 
	public void setIdDansTable(Long idDansTable) {
		this.idDansTable = idDansTable;
	}
 
	public String getNomChamp() {
		return this.nomChamp;
	}
 
	public void setNomChamp(String nomChamp) {
		this.nomChamp = nomChamp;
	}
 
	public String getNomTable() {
		return this.nomTable;
	}
 
	public void setNomTable(String nomTable) {
		this.nomTable = nomTable;
	}
 
	public String getTexte() {
		return this.texte;
	}
 
	public void setTexte(String texte) {
		this.texte = texte;
	}
 
	public Langue getLangue() {
		return langue;
	}
 
	public void setLangue(Langue langue) {
		this.langue = langue;
	}
 
	public A getaLibelle() {
		return aLibelle;
	}
 
	public void setaLibelle(A aLibelle) {
		this.aLibelle = aLibelle;
		nomTable = "A";
		nomChamp = "LIBELLE";
		idDansTable=aLibelle.getIdA();
		this.aLibelle = aLibelle;
 
	}
 
	public A getaLibelleCourt() {
		return aLibelleCourt;
	}
 
	public void setaLibelleCourt(A aLibelleCourt) {
		this.aLibelleCourt = aLibelleCourt;
		nomTable = "A";
		nomChamp = "LIBELLE_COURT";
		idDansTable=aLibelleCourt.getIdA();
		this.aLibelleCourt=aLibelleCourt;
	}
 
	public B getbLibelle() {
		return bLibelle;
	}
 
	public void setbLibelle(B bLibelle) {
		this.bLibelle = bLibelle;
		nomTable = "B";
		nomChamp = "LIBELLE";
		idDansTable=bLibelle.getIdB();
		this.bLibelle = bLibelle;
	}
 
 
}

Enfin voici comment il est possible d'utiliser nos objets très simplement

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
emf = Persistence.createEntityManagerFactory("pedago.jpa");
em = emf.createEntityManager();
 
Langue francais = em.createQuery("Select l from Langue l where code= :codeLangue", Langue.class).setParameter("codeLangue", "fr").getSingleResult();
Langue anglais = em.createQuery("Select l from Langue l where code= :codeLangue", Langue.class).setParameter("codeLangue", "en").getSingleResult();
 
em.getTransaction().begin();
 
System.out.println("id langue=" + francais.getId());
////////////////////////////////////
////début de la transaction/////////
////////////////////////////////////
 
// création de A
A a = new A();
em.persist(a);
// création de B
B b = new B();
em.persist(b);
 
// /////////////////////////////////////////////
// création de TraductionLibelle A en français//
// /////////////////////////////////////////////
 
TraductionTest traductionLibelleAFrancais = new TraductionTest();
traductionLibelleAFrancais.setaLibelle(a);
traductionLibelleAFrancais.setLangue(francais);
traductionLibelleAFrancais.setTexte("mon tailleur est riche");
francais.getListeTraductionTest().add(traductionLibelleAFrancais);
a.getListeTraductionTestLibelle().put(francais, traductionLibelleAFrancais);
em.persist(traductionLibelleAFrancais);
 
// //////////////////////////////////////////////////
// création de TraductionLibelleCourt A en français//
// //////////////////////////////////////////////////
TraductionTest traductionLibelleCourtAFrancais = new TraductionTest();
traductionLibelleCourtAFrancais.setaLibelleCourt(a);
traductionLibelleCourtAFrancais.setLangue(francais);
traductionLibelleCourtAFrancais.setTexte("mon tailleur");
 
francais.getListeTraductionTest().add(traductionLibelleCourtAFrancais);
a.getListeTraductionTestLibelleCourt().put(francais, traductionLibelleCourtAFrancais);
 
em.persist(traductionLibelleCourtAFrancais);
 
// ////////////////////////////////////////////
// création de TraductionLibelle A en anglais//
// ////////////////////////////////////////////
TraductionTest traductionLibelleAAnglais = new TraductionTest();
traductionLibelleAAnglais.setaLibelle(a);
traductionLibelleAAnglais.setLangue(anglais);
traductionLibelleAAnglais.setTexte("my taylor is rich");
anglais.getListeTraductionTest().add(traductionLibelleAAnglais);
a.getListeTraductionTestLibelle().put(anglais, traductionLibelleAAnglais);
 
em.persist(traductionLibelleAAnglais);
 
// ///////////////////////////////////////////////
// création de TraductionLibelleCourt en anglais//
// ///////////////////////////////////////////////
TraductionTest traductionLibelleCourtAAnglais = new TraductionTest();
traductionLibelleCourtAAnglais.setaLibelleCourt(a);
traductionLibelleCourtAAnglais.setLangue(anglais);
traductionLibelleCourtAAnglais.setTexte("my taylor");
 
anglais.getListeTraductionTest().add(traductionLibelleCourtAAnglais);
a.getListeTraductionTestLibelleCourt().put(anglais, traductionLibelleCourtAAnglais);
em.persist(traductionLibelleCourtAAnglais);
 
// /////////////////////////////////////////////
// création de TraductionLibelle B en français//
// /////////////////////////////////////////////
TraductionTest traductionLibelleBFrancais = new TraductionTest();
traductionLibelleBFrancais.setbLibelle(b);
traductionLibelleBFrancais.setLangue(francais);
traductionLibelleBFrancais.setTexte("vos fleurs sont belles");
francais.getListeTraductionTest().add(traductionLibelleBFrancais);
b.getListeTraductionTestLibelle().put(francais, traductionLibelleBFrancais);
em.persist(traductionLibelleBFrancais);
 
// ////////////////////////////////////////////
// création de TraductionLibelle B en anglais//
// ////////////////////////////////////////////
TraductionTest traductionLibelleBAnglais = new TraductionTest();
traductionLibelleBAnglais.setbLibelle(b);
traductionLibelleBAnglais.setLangue(anglais);
traductionLibelleBAnglais.setTexte("your flowers are beautiful");
anglais.getListeTraductionTest().add(traductionLibelleBAnglais);
b.getListeTraductionTestLibelle().put(anglais, traductionLibelleBAnglais);
em.persist(traductionLibelleBAnglais);
 
////////////////////////////
//fin de la transaction/////
////////////////////////////
em.getTransaction().commit();
 
// lecture d'un objet a
A aLu = em.createQuery("Select a from A a where id= :id", A.class).setParameter("id", a.getIdA()).getSingleResult();
for (Langue element : aLu.getListeTraductionTestLibelle().keySet()) {
	System.out.println("---> Langue : " + element.getLibelle() + " traduction A Libellé : " + aLu.getListeTraductionTestLibelle().get(element).getTexte());
}
for (Langue element : aLu.getListeTraductionTestLibelleCourt().keySet()) {
	System.out.println("---> Langue : " + element.getLibelle() + " traduction A LibelléCourt : " + aLu.getListeTraductionTestLibelleCourt().get(element).getTexte());
}
//lecture d'un objet B
B bLu = em.createQuery("Select b from B b where id= :id", B.class).setParameter("id", b.getIdB()).getSingleResult();
for (Langue element : bLu.getListeTraductionTestLibelle().keySet()) {
	System.out.println("---> Langue : " + element.getLibelle() + " traduction B Libellé : " + bLu.getListeTraductionTestLibelle().get(element).getTexte());
}
 
em.close();
emf.close();

il y a probablement moyen de faire mieux en utilisant des génériques et de l'héritage sur l'objet Traduction, il faut que je travaille ça, je posterai quand ce sera ok