Discussion :

[Lovegiver]

Bonjour,

j'ai 2 entités : User et Group
Chaque User peut appartenir à 0,n Group
Chaque Group comporte 1,n User

Pour gérer la relation ManyToMany résultante, JPA doit créer une troisième entité : User-Group qui contiendra les ID de chacune des entités User et Group

La difficulté réside dans le fait d'attribuer un rôle à un User donné dans un Group donné.
Normalement, la propriété "role" devrait être stockée dans la table User-Group dans une nouvelle colonne.

-> comment puis-je manipuler cette propriété "role" qui ne se trouve dans aucune de mes classes "entité" mais dans une entité créée automatiquement par JPA ?

-> à quel endroit je dois la déclarer ?

Merci d'avance pour votre aide.

[tchize_]

Tu n'es plus dans un many to many user group mais dans deux one to many: user role et role groupe. Tu dois donc créer cette entité.

[Lovegiver]

Bonjour tchize_ et merci d'avoir pris le temps de me répondre.

Selon toi il faudrait que je crée une relation supplémentaire User-Role en plus de User-Group ce qui est une solution que je n'avais pas envisagée en effet.
J'ai plus de mal à comprendre pourquoi la relation devient OneToMany.
En effet, je vais avoir quelque chose de ce genre :

Dans la classe User :
@ManyToMany(mappedBy="groupes")
private List<Group> groupes; -> chaque User peut appartenir à N Group

Dans la classe Group :
@ManyToMany
private List<User> membres; -> chaque Group peut contenir N User et JPA va créer une entité User-Group contenant User PK + Group PK
@ManyToMany
private List<Role> roles; -> chaque Group contiendra autant de Role que de User et JPA va créer une entité Role-Group contenant Role PK + Group PK, mais à ce moment-là comment associer ce Role à un User en particulier ?

Plus de difficulté pour la classe que tu suggères d'ajouter et que je nomme RoleUserInGroup (j'avais fait une classe Role mais il s'agissait d'une simple "Enum" permettant de lister un nombre fini de valeurs) :
private Role role; -> une Enum de roles possibles
private Group groupe; ?
private User user; ?

J'ai du mal à structurer cet objet qui doit faire la relation entre un User, un Group et un Role pour ce User dans ce Group. J'ai l'impression que cette relation supplémentaire ne fait que repousser le problème plus loin et que je me retrouve au même point.

Comment le ferais-tu ?

[tchize_]

Actuellement tu as ça:


User 0..*<---->0..* Group

Note que JPA ne crée pas d'entité User-Group contenant User PK + Group PK, il crée juste la table de stockage, il n'y a pas d'entité associée

Et tu cherche à ajouter une propriété comme ceci:

User 0..*<--(role)-->0..* Group


Mais cette propriété, il n'y a pas de choix, il faut la poser dans une entité. Ce qui deviens:


User 0..*<--1 UserGroup 1-->0..* Group

avec UserGroup ayant comme clé composite (Role,Group) et comme unique propriété Role


En terme de code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Class User {
 
List<UserGroup> groups
 
 
Class Group {
List<UserGroup> users
 
 
Class UserGroup {
User user;
Group group;
Role role;

[Lovegiver]

Merci tchize_

Note que JPA ne crée pas d'entité User-Group contenant User PK + Group PK, il crée juste la table de stockage, il n'y a pas d'entité associée

-> j'ai très mal expliqué ma pensée. Tu as raison, il n'y a pas création d'une nouvelle entité mais juste d'une table de stockage. Dans ma réflexion, je pensais pouvoir m'appuyer dessus avec JPA comme j'aurais pu le faire directement en SQL, en y ajoutant une propriété ROLE justement.

Donc si je comprends bien ce que tu dis, ce n'est pas 2 entités dont j'ai besoin (USER et GROUP) mais 3 (ajout d'une entité USERGROUP) ce qui implique de repenser les relations.

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
 
 
@Entity 
Class User {
 
@ManyToMany(mappedBy="users")  //côté esclave de la relation
List<UserGroup> groups
 
@Entity  
Class Group {
 
@ManyToMany  //côté maître de la relation
List<UserGroup> users
 
@Entity 
Class UserGroup {
 
@OneToMany
User user;
 
@OneToMany
Group group;
 
Role role;

J'ai bien compris ?

[tchize_]

oui. Ceci dit ça influence ton mapping, mais a priori pas trop ton code.

[Lovegiver]

Merci pour tout, c'est vraiment sympa de ta part.

Bonne fin de journée.

[ryosaeba37]

Bonjour, j'ai un souci avec la mise en cache de ce concept. (je me cale a cette exemple mes objets sont différent mais le concept et le même)

J'ai 2 écrans un pour user l'autre pour groupe avec dans le premier la liste des groupes et de l'autre la liste des users et la possibilité dans les 2 d'ajouter à la liste

Si j'ajoute ou supprime un user a groupe, alors dans la page groupe je ne le retrouve pas et vis versa.
alors qu'en base OK et si je redémarre mon wildfly c'est ok dans les 2 pages.

Bref il ne recharge pas a partir de la BDD mais du cache.
J'utilise EclipseLink comme JPA.

J'ai jouter @Cache(alwaysRefresh=true) sur les 3 tables, cela fonctionne pour groupe mais pas pour user (j'ajoute un groupe a user, je regarde la page groupe ok. j'ajoute un user a un groupe je regarde la page user ko j'ai pas mon groupe)

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
 
@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
@JoinColumn(name = "Id_User")
protected List<UserGroup> users= new ArrayList<UserGroup>();
 
@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
@JoinColumn(name = "Id_Group")
protected List<UserGroup> groupes= new ArrayList<UserGroup>();
 
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "Id_User")
private User user;
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "Id_Group")
private Group group;

Si quelqu'un peux m'aider merci.

[Lovegiver]

Bonjour,

à tout hasard, as-tu testé avec le mode EAGER au lieu de LAZY ?

[ryosaeba37]

Idem même symptôme.

Est ce que je suis obligé lors de l'ajout d'un user a un groupe via usergroup d'aller dans user et ajouter le usergroup aussi à l'autre liste.
Mais du coup je sauvegarde quoi user, groupe ou les 2

[ryosaeba37]

En fouillant un peu sur le net il y a une solution je sais si elle fonctionnerai.
En modifiant ma table de jointure qui possède sont propre id par un clef composé UserGroupPK (idUser et idGroup)

[Lovegiver]

Tu veux dire que ta table de jointure n'a pas de clé composite ? Arf, j'aurais dû te poser cette question pour commencer.

Dis-moi si tu peux accéder à ce lien qui t'explique comment créer une clé composite avec Hibernate.

-> Cherche cette section : "Gestion d’un identifiant composé"

L'exemple est basé sur une laison entre une table "acteur" et une table "film" qui nécessitent qu'existe, comme pour toi, une table intermédiaire qui s'appellerait "Role". En effet, cette donnée n'est pertinente ni dans la table "Acteur" ,ni dans la table "Film", mais bien dans celle du milieu ^^


Ensuite, il faudra regarder la requête que tu effectues.

Normalement tu as une requête de type "save" pour sauvegarder ta nouvelle relation "User-Group" (ta relation est-elle bidirectionnelle ?).
Tu devrais également avoir une requête qui envoie des données fraîches à ta page.

Tu es en Java pour l'affichage (JSP) ou tu as du Ajax qui se charge de rafraîchir tes pages sans faire appel au serveur ?

[ryosaeba37]

J'ai remplacer mon Id par un Objet

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
@Embeddable
public class InscriptionId implements Serializable
{
	@Column(name = "Id_Session")
	private Long sessionId;
	@Column(name = "Id_Stagiaire")
	private Long stagiaireId;
	...
}
 
public class Inscription 
{
	@EmbeddedId
	private InscriptionId id;
 
	public InscriptionId getId() {return id;}
	public void setId(InscriptionId id) {this.id = id;}
 
	@ManyToOne(cascade = CascadeType.MERGE)
	@JoinColumn(name = "Id_Session")
	@MapsId("sessionId")
	private Session session;
 
	@ManyToOne(cascade = CascadeType.MERGE)
	@JoinColumn(name = "Id_Stagiaire")
	@MapsId("stagiaireId")
	private Stagiaire stagiaire;
 
...
}

Dans Stagiaire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE},fetch=FetchType.LAZY)
@JoinColumn(name = "Id_Stagiaire")
private List<Inscription> inscriptions = new ArrayList<Inscription>();

Dans Session

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE},fetch=FetchType.LAZY)
@JoinColumn(name = "Id_Session")
private List<Inscription> inscriptions = new ArrayList<Inscription>();

Du coup j'ai bien du bidirectionnel entre Stagiaire <=> Inscription <=> Session

Que ce soit stagiaire ou session je fait em.findById(Long id).
et em.merge(object) stagiaire ou session;


J'utilise du JSF avec un findById au lancement et le merge sur le bouton save.
Si j'ouvre la page Session et Stagiaire et que j'ajoute une inscription a Stagiaire, je sauve stagiaire, je rafraîchie la page session c'est ok.
L'inverse ne fonctionne pas, je redémarre mon serveur et c'est ok.

J'avais dans l'idée de ne plus utiliser stagiaire et session pour mes inscriptions et passer les listes en @transient et les charger à la main.
Et enregistrer mes inscriptions directement em.merge(Inscription)

[Lovegiver]

Bonjour j'ai l'impression que tu as bien avancé,

dans ce que tu me dis, je comprends que tu as à présent 3 entités :
- stagiaire (classe)
- session (classe)
- inscriptionid (clé composite)

Ta relation est bi-directionnelle, ce qui implique que :
- tu as dans ta classe Stagiaire un attribut qui pourrait ressembler à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

List<Session> sessions

- tu as dans ta classe Session un attribut qui pourrait ressembler à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

List<Stagiaire> stagiaires

Tu as également 2 écrans (donc 2 JSF si j'ai compris -> je n'en ai jamais utilisé) :
- un écran Session : tu pars de cet écran pour ajouter des stagiaires à une session donnée
- un écran Stagiaire : tu pars de cet écran pour ajouter des sessions pour un stagiaire donné

A partir de là quand tu valides dans ta page l'ajout d'une session à un stagiaire ou d'un stagiaire à une session, que se passe-t-il ?

A ce que je lis, tout semble se passer entre ta servlet et ta session hibernate dans laquelle se trouvent toutes tes requêtes. Je me trompe ?

Ce que je voudrais savoir c'est si tu mets à jour les listes de chacune des classes Stagiaire et Session ou juste celle par laquelle la modification a eu lieu ?
Par exemple; quand tu ajoutes un stagiaire à une session, tu devrais faire quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

stagiaires.add(stagiaire)

pour la session concernée, mais également, pour ton stagiaire, tu dois réaliser un :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sessions.add(session)

Ensuite, tu persistes en base et Hibernate se charge de l'aspect technique. Après quoi, tu dois acheminer des données fraîches à ta page.

Est-ce bien ce que tu fais ?

[ryosaeba37]

Alors justement j'ai pas ajouté de List<Session> ou de List<Stagiaire> puisque c'est la table de jointure Inscription qui fait le job.
Mais j'ai une List<Inscription> dans les 2.

Mes écrans en fait ajoutent un objet Inscription à la liste et c'est tout.
Ensuite je sauve en BDD (pour info c'est EclipseLink et pas Hibernate)

Et non je ne met pas a jour les 2 listes une selon l’écran c'est la question que je posais plus tôt:

Est ce que je suis obligé lors de l'ajout d'un user a un groupe via usergroup d'aller dans user et ajouter le usergroup aussi à l'autre liste.
Mais du coup je sauvegarde quoi user, groupe ou les 2

Ce qui me déroute le plus c'est que cela fonctionne à moitié.
Ecran Stagaire1 => AddInscription(New Inscription(Session1,Stagiaire1) => Merge(Stagiaire1) => Ecrans Session1 OK j'ai bien mon Stagiaire1.
Ecran Session1 =>AddInscription(New Inscription(Session1,Stagiaire2) => Merge(Session1) => Ecran Stagaire2 KO j'ai pas ma Session1.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
//Cote stagiaire
private void AddInscription(Inscription objectToAdd)
{
if(!this.list.contains(objectToAdd))
{
      this.list.add(objectToAdd);
}
}

Si encore cela ne fonctionnait pas dans les 2 sens mais non.

Si je devait mettre à jour les 2 Listes le code ressemblerai à ça?:

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
 
private void AddInscription(Inscription objectToAdd)
{
 
if(!this.list.contains(objectToAdd))
{
      this.list.add(objectToAdd);
}
List<Inscription> remoteList = objectToAdd.getSession().getInscriptions();
if(!remoteList.contains(objectToAdd))
{
      remoteList.add(objectToAdd);
}
 
}
 
private void save(Stagiaire stagiaire)
{
 
em.merge(stagiaire);
for(Session s in stagiaire.getSession)
{
     em.merge(s);
}
 
}
 
 
//Cote session
private void AddInscription(Inscription objectToAdd)
{
if(!this.list.contains(objectToAdd))
{
      this.list.add(objectToAdd);
}
}

Si encore cela ne fonctionnait pas dans les 2 sens mais non.

Si je devait mettre à jour les 2 Listes le code ressemblerai à ça?:

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
 
private void AddInscription(Inscription objectToAdd)
{
 
if(!this.list.contains(objectToAdd))
{
      this.list.add(objectToAdd);
}
List<Inscription> remoteList = objectToAdd.getStagiaire().getInscriptions();
if(!remoteList.contains(objectToAdd))
{
      remoteList.add(objectToAdd);
}
 
}
 
private void save(Session session)
{
 
em.merge(session);
for(Stagiaire s in session.getStagiaire())
{
     em.merge(s);
}
 
}

[Lovegiver]

Oui je pense que tu devrais faire ton ajout de chaque côté. Il n'y a rien d'automatique avec les ORM. Leur principe est de prendre en charge le mapping entre tes objets et ta BDD mais pas de gérer le rafraîchissement des données de façon automatique.

[ryosaeba37]

J'aurai cru qu'il recharge les données si modifié en bdd.
J'ai ajouter @Cache(alwaysRefresh=true) mais rien y fait.

C'est quoi le mieux au final, la solution que j'ai mis dans le post précédent.
Lors du AddInscritpions l'ajouter au 2 et faire un merge
De tout
Un object suffit

[Lovegiver]

Ton addInscription se trouve dans chacune de tes classes Session et Stagiaire. Il faut donc faire la mise à jour de ta Liste<AddInscription> de chaque côté PUIS sauvegarder (persister) PUIS refresh ta requête qui alimente tes pages.
Et là normalement l'afficahge devrait être mis à jour de chaque côté.

[ryosaeba37]

Ca marche.
En ajoutant au 2 listes et un seul merge cela fonctionne.

J'ai test la MAJ des données inscriptions ok des 2 cotés

Poussons jusqu'au bout meme si j'en ai pas besoin dans ce cas.
Quid de la suppression?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
@OneToMany(cascade = CascadeType.ALL,fetch=FetchType.LAZY,orphanRemoval=true)
@JoinColumn(name = "Id_Stagiaire")
protected List<Inscription> inscriptions = new ArrayList<Inscription>();

public void removeObject(Inscription object) 
{
		object.getSession().getInscriptions().remove(object);
		object.getStagiaire().getInscriptions().remove(object);
		object.setStagiaire(null);
		object.setSession(null);
}

C'est effacé en base et sur un cote mais pas de l'autre

[Lovegiver]

Je pense qu'il est bon de conserver la même logique : tu ajoutes des 2 côtés, donc tu delete de la même façon.
Heureux que ça fonctionne

Bon weekend