Bonjour,

Pour commencer, voici un extrait de mon schéma de base de donnée:



Pour chaque table "chevaux", "personnes", "enum_typeRelation", j'ai un EJB Entity (Cheval, Personne, TypeRelation).

La table enum_typeRelation est comme son nom l'indique, une énumération de relation possible entre une personne et un cheval (ex: gérant, propriétaire,...)

Les régles métiers sont les suivantes:
- un cheval peut appartenir à une ou plusieurs personnes
- un cheval peut être géré par une ou plusieurs personnes
et la réciproque
- une personne peut posséder plusieurs chevaux
- une personne peut gérer plusieurs chevaux
et bien évidemment une personne peut être à la fois gérante et propriétaire d'un cheval.

Je cherche à obtenir:
-à partir d'un cheval, la liste des personnes associés et leurs relations.
-à partir d'une personne, la liste des chevaux associés et leurs relations.

C'est mon premier projet avec des EJB, je tâtonne donc en terme de conception et du mapping.
Je me suis dit que pour arriver à mon objectif je pouvais rajouter dans l'EJB entite TypeRelation deux attributs Cheval et Personne et par la suite mettre une collection de TypeRelation dans chaque EJB Cheval et Personne.
Classes pour illustrer:

EJB Cheval
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
@Entity
@Table(name="chevaux")
public class Cheval implements Serializable {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
	//Déclarations des attributs
	private int id = 0;
 
	@Temporal(TemporalType.DATE)
	@Column(name="datDateNaissance")
	private Calendar dateNaissance = null;
 
	private List<TypeRelation> relations = null;
 
 
	//Constructeur
	public Cheval() {
		super();
	}
 
	//Getters and Setters
	@Id
	@Column(name ="intIdCheval")
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
 
	public Calendar getDateNaissance() {
		return dateNaissance;
	}
	public void setDateNaissance(Calendar dateNaissance) {
		this.dateNaissance = dateNaissance;
	}
 
 
 
 
 
	@OneToMany
	@JoinTable(name="ref_chevaux_personnes",
			joinColumns = @JoinColumn(name="intIdCheval"),
			inverseJoinColumns = @JoinColumn(name="intIdTypeRelation")
	)
	public List<TypeRelation> getRelations() {
		return relations;
	}
 
	public void setRelations(List<TypeRelation> relations) {
		this.relations = relations;
	}
EJB Personne
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
@Entity
@Table(name="personnes")
public class Personne implements Serializable {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
	//Déclaration attributs
 
	private int id = 0;
 
	private List<TypeRelation> relations = null;
 
	//Constructeur
	public Personne() {
		super();
	}
 
	//Getters and Setters
	@Id
	@Column(name="intIdPersonne")
	public int getId() {
		return id;
	}
 
 
	public void setId(int id) {
		this.id = id;
	}
 
	@OneToMany
	@JoinTable(name="ref_chevaux_personnes",
			joinColumns = @JoinColumn(name="intIdPersonne"),
			inverseJoinColumns = @JoinColumn(name="intIdTypeRelation")
	)
	public List<TypeRelation> getRelations() {
		return relations;
	}
 
	public void setRelations(List<TypeRelation> relations) {
		this.relations = relations;
	}
EJB TypeRelation
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
@Entity
@AttributeOverride( name="id", column = @Column(name="intIdTypeRelation")) 
@Table(name="enum_relation")
public class TypeRelation extends DefaultEnumeration {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
 
	private Cheval cheval;
	private Personne personne;
 
	public TypeRelation() {
		// TODO Auto-generated constructor stub
	}
 
	public TypeRelation(int id, String libelle) {
		super(id, libelle);
		// TODO Auto-generated constructor stub
	}
 
	@ManyToOne
	@JoinTable(name="ref_chevaux_personnes",
			joinColumns = @JoinColumn(name="intIdCheval", insertable=false, updatable=false)
			inverseJoinColumns = @JoinColumn(name="intIdPersonne")
	)
	public Cheval getCheval() {
		return cheval;
	}
 
	public void setCheval(Cheval cheval) {
		this.cheval = cheval;
	}
 
	@ManyToOne
	@JoinTable(name="ref_chevaux_personnes",
			joinColumns = @JoinColumn(name="intIdTypeRelation"),
			inverseJoinColumns = @JoinColumn(name="intIdPersonne")
	)
	public Personne getPersonne() {
		return personne;
	}
 
	public void setPersonne(Personne personne) {
		this.personne = personne;
	}
 
 
 
}
Ma question est double, en vue de la structure de ma base de donnée (SQL server pour info) est-il possible de mettre en oeuvre mon idée, c'est à dire comment mettre en place une relation bidirectionnelle avec une table de jointure?
Jugez vous pertinente ma façon de procéder?

Merci de m'avoir lu et de m'aider à surpasser ce point bloquant.