Discussion :

[CinePhil]

Comme je n'obtiens pas de réponse satisfaisante à mes divers message expliquant en détail mon problème réel et comme je ne trouve pas non plus de réponse après des jours de recherche sur Internet, je pose ici le cas général qui me préoccupe.

Soit le MCD suivant :
A -0,n----Associer----0,n- B

Dans le mapping, j'aurai deux entités A et B, chacune avec une propriété du type :

Code :

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

Set<autreEntite> autreEntites = new HashSet<autreEntite>(0);

et un @ManyToMany sur les getters et setters.

Comment lire les propriétés de B en partant de A et vice-versa ?
Autrement dit, à partir de cette requête :

Code :

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

1
2
Query q = entityManager.createQuery("FROM A WHERE condition");
A a = (A) q.getSingleResult();

Comment lire les propriétés de B correspondant à a ?

J'ai essayé ceci :

Code :

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

Set<B> bs = a.getBs();

Mais dès cette ligne j'ai une erreur (à partit d'un user (A), je cherche à savoir s'il est inscrit à un stage (B) :

16:26:14,740 INFO [Authenticator] authenticating - recherche session de stage
16:26:14,742 DEBUG [EntityTransaction] marking JPA resource-local transaction for rollback
16:26:14,743 WARN [SeamLoginModule] Error invoking login method
javax.el.ELException: java.lang.NullPointerException
at org.jboss.el.util.ReflectionUtil.invokeMethod(ReflectionUtil.java:339)
...
Caused by: java.lang.NullPointerException
at org.domain.stamas.session.Authenticator.authenticate(Authenticator.java:76)
...

La ligne 76 étant l'équivalent de celle du Set<B>.

C'est un problème simple et courant non ?

La requête SQL me prend 1 minute à écrire et en PHP je saurais la traiter je pense en moins d'un quart d'heure.

Sur la planète Seam, j'y suis depuis des jours. Ça doit être la gravité qui est plus forte, on avance moins vite !

[fr1man]

J'ai pas tout compris.
Le NullPointerException ne vient il pas simplement de ta requête qui ne te renvoie rien ?

Pour accéder à tes objets B à partir de A, il faut effectivement faire un a.getBs().

Quant aux requêtes, tu dois passer par une jointure :

Code :

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

1
2
3
 
from A a inner join a.bs b
where a.proprieteDeA = ? and b.proprieteDeB = ?

[CinePhil]

J'ai pas tout compris.
Le NullPointerException ne vient il pas simplement de ta requête qui ne te renvoie rien ?

La requête renvoie bien un résultat et l'étudiant qui se connecte est bel et bien inscrit à un stage dans la BDD.

Pour accéder à tes objets B à partir de A, il faut effectivement faire un a.getBs().

Quant aux requêtes, tu dois passer par une jointure :

Code :

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

1
2
3
 
from A a inner join a.bs b
where a.proprieteDeA = ? and b.proprieteDeB = ?

En l'occurrence, ce sera un LEFT JOIN puisque tous les étudiants ne sont pas inscrits à un stage.

Tu veux dire que sans la jointure, je ne peux pas récupérer B ? A quoi sert le mapping @ManyToMany alors ? Seulement pour aliementer la table associative ?

[fr1man]

La jointure sert à deux choses :
- pouvoir poser des contraintes sur les attributs de B
- pouvoir charger les éléments de B en utilisant le mot clef fetch sur ta jointure

Code :

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

1
2
3
 
from A a inner join FETCH a.bs b
where a.proprieteDeA = ? and b.proprieteDeB = ?

Si tu ne précises pas le fetch et que tu es en lazy loading, ta collection de B ne sera pas chargée. (d'où surement le nullPointerException)

[tchize_]

non non non

faut pas tous mélanger! fr1man

Le join, sert bien à ce que tu dit, seulement dans le deuxième cas, on l'utilise uniquement quand on veux EXPLICITEMENT demander à hibernate de charger MAINTENANT la collection. Dans les autres cas, hibernate la chargera sur une requete séparée, au moment opportun. C'est suffisant dans 99% des cas d'utilisation

cinephil: le @manytomany va demander à Hibernate de charger le Set automatiquement. On peux avoir le code EXACT à la ligne qui génère le nullpointerexception? (org.domain.stamas.session.Authenticator.authenticate(Authenticator.java:76)). C'est en général pas hibernate qui cause ça. Quand hibernate n'arrive pas à charger une collection reliée par un manytomany ou onetomany, il déclenche un LazyLoadingException, en général pour te dire que ta session est déjà fermée et qu'il est donc devenu impossible de charger la collection.

[fr1man]

@ tchize_
Merci mais je sais très bien comment fonction fetch et je ne mélange rien.

Cependant, mea culpa pour le nullPointerExeption, on aurait effectivement plutôt un lazyLoadingException.

[CinePhil]

On peux avoir le code EXACT à la ligne qui génère le nullpointerexception? (org.domain.stamas.session.Authenticator.authenticate(Authenticator.java:76)).

Code :

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

Set<TeSessionSsn> sessions = user.getThCandidatCnd().getTeSessionSsns();

ThCandidatCnd hérite de ThUtilisateurUti.

MCD :
TeSessionSsn -0,n----Inscrire----0,n- ThCandidatCnd -1,1----Etre----0,1- ThUtilisateurUti

Du coup j'ai essayé le LEFT JOIN dans la requête :

Code :

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

1
2
3
4
5
6
            Query query = entityManager.createQuery(
                    "FROM ThUtilisateurUti u " +
                    "LEFT JOIN u.thCandidatCnd c " +
                    "LEFT JOIN u.TeSessionSsns s " +
                    "WHERE u.utiLogin = :username " +
                        "AND u.utiMotPasse = :password");

Et j'obtiens cette erreur :

javax.el.ELException: java.lang.IllegalArgumentException: org.hibernate.QueryException: could not resolve property: thCandidatCnd of: org.domain.stamas.entity.ThUtilisateurUti [FROM org.domain.stamas.entity.ThUtilisateurUti u LEFT JOIN u.thCandidatCnd c LEFT JOIN u.TeSessionSsns s WHERE u.utiLogin = :username AND u.utiMotPasse = :password]

Encore un problème de mapping ?
Dans ThUtilisateurUti :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
    private ThCandidatCnd thCandidatCnd;
 
    @Transient
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="cnd_id_utilisateur", referencedColumnName="uti_id_personne")
    public ThCandidatCnd getThCandidatCnd() {
        return this.thCandidatCnd;
    }
 
    public void setThCandidatCnd(ThCandidatCnd thCandidatCnd) {
        this.thCandidatCnd = thCandidatCnd;
    }

Je me suis dit que peut-être il n'arrivait pas à écrire la condition de jointure car comme ThCandidatCnd hérite de ThUtilisateurUti qui hérite de TePersonnePrs, j'ai commenté les identifiants de ThCandidatCnd et de ThUtilisateurUti.

Dans ThUtilisateurUti, au départ généré par Seam Generate Entities puis modifié suite à une autre discussion où on m'avait conseillé de virer les identifiants des entités filles :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    //private int utiIdPersonne;
 
    /*@GenericGenerator(name = "genUtilisateur", strategy = "foreign", parameters = @Parameter(name = "property", value = "tePersonnePrs"))
    //@Id
    @GeneratedValue(generator = "genUtilisateur")
    //@Column(name = "uti_id_personne", unique = true, nullable = false)
    @Transient
    public int getUtiIdPersonne() {
        return this.utiIdPersonne;
    }
 
    public void setUtiIdPersonne(int utiIdPersonne) {
        this.utiIdPersonne = utiIdPersonne;
    }*/

Bref, je suis toujours perdu dans les méandres d'Hibernate !

[tchize_]

@ tchize_
Merci mais je sais très bien comment fonction fetch et je ne mélange rien.

Je n'en doute pas, et certainement mieux que moi. Je voulais dire qu'il fallait pas mélanger ce que fetch fait (du eager load et la possibiliter de mettre des contraintes dans le where) et le Null pointer obtenu Ton message avait l'air de sous entendre qu'on doit toujour mettre un fetch pour remplir les collection d'hibernate, ce qui n'est pas vrai. D'ailleur j'en ai jamais eu besoin :p

Code :

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

Set<TeSessionSsn> sessions = user.getThCandidatCnd().getTeSessionSsns();

ThCandidatCnd hérite de ThUtilisateurUti.

Code :

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

1
2
3
4
5
6
7
8
    private ThCandidatCnd thCandidatCnd;
 
    @Transient
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="cnd_id_utilisateur", referencedColumnName="uti_id_personne")
    public ThCandidatCnd getThCandidatCnd() {
        return this.thCandidatCnd;
    }

Le @Transient informe JPA (et donc hibernate) que cette propriété ne fait pas partie du mapping. Hibernate ne la gère donc pas, et ne la remplit pas! Donc user.getThCandidatCnd() retourne null (on a pas initialisé cette propriété) et tu ne peux pas appeler getTeSessionSsns sur un null

Bref, il y a incohérence. Soit c'est transient et tu le remplit toit même, pas hibernate. Soit c'est pas transient et donc tu supprime ce @Transient.

Ceci explique aussi pourquoi cette propriété ne peux pas appareitre dans une requete HQL, hibernate ne la connait pas.

[CinePhil]

Le @Transient informe JPA (et donc hibernate) que cette propriété ne fait pas partie du mapping. Hibernate ne la gère donc pas, et ne la remplit pas! Donc user.getThCandidatCnd() retourne null (on a pas initialisé cette propriété) et tu ne peux pas appeler getTeSessionSsns sur un null

Bref, il y a incohérence. Soit c'est transient et tu le remplit toit même, pas hibernate. Soit c'est pas transient et donc tu supprime ce @Transient.

Ceci explique aussi pourquoi cette propriété ne peux pas appareitre dans une requete HQL, hibernate ne la connait pas.

Le @Transient, je l'ai ajouté suite à cette discussion au sujet de l'héritage de mes tables qui n'avait pas été compris comme tel par Seam Generate Entities.
Dans ce message, tu m'as dit d'ajouter les @Inheritance et de supprimer les @OneToOne mais j'ai ensuite eu des problèmes avec l'ajout par Hibernate de colonnes dans ma BDD. Alors dans cet autre message, tu m'as dit d'ajouter les @Transient.
Peut-être ai-je mélangé un peu les choses ?

Je vais essayer d'enlever les @Transient mais je ne veux surtout pas que ça modifie la structure de mes tables !

EDIT :
J'ai enlevé, sans conséquence sur la structure des tables dans la BDD, les @Transient sur les propriétés des classes mères faisant référence aux classes filles, c'est à dire que maintenant j'ai ceci :
Dans TePersonnePrs :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    private ThUtilisateurUti thUtilisateurUti;
 
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="uti_id_personne", referencedColumnName="prs_id")
    public ThUtilisateurUti getThUtilisateurUti() {
        return this.thUtilisateurUti;
    }
 
    public void setThUtilisateurUti(ThUtilisateurUti thUtilisateurUti) {
        this.thUtilisateurUti = thUtilisateurUti;
    }

Dans ThUtilisateurUti :

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
    //private int utiIdPersonne;
    //private TePersonnePrs tePersonnePrs;
    private ThCandidatCnd thCandidatCnd;
 
    /*@GenericGenerator(name = "genUtilisateur", strategy = "foreign", parameters = @Parameter(name = "property", value = "tePersonnePrs"))
    //@Id
    @GeneratedValue(generator = "genUtilisateur")
    //@Column(name = "uti_id_personne", unique = true, nullable = false)
    @Transient
    public int getUtiIdPersonne() {
        return this.utiIdPersonne;
    }
 
    public void setUtiIdPersonne(int utiIdPersonne) {
        this.utiIdPersonne = utiIdPersonne;
    }*/
 
    /*@OneToOne(fetch = FetchType.LAZY)
    //@PrimaryKeyJoinColumn(name = "uti_id_personne")
    @NotNull
    public TePersonnePrs getTePersonnePrs() {
        return this.tePersonnePrs;
    }
 
    public void setTePersonnePrs(TePersonnePrs tePersonnePrs) {
        this.tePersonnePrs = tePersonnePrs;
    }*/
 
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="cnd_id_utilisateur", referencedColumnName="uti_id_personne")
    public ThCandidatCnd getThCandidatCnd() {
        return this.thCandidatCnd;
    }
 
    public void setThCandidatCnd(ThCandidatCnd thCandidatCnd) {
        this.thCandidatCnd = thCandidatCnd;
    }

Dans ThCandidatCnd :

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
    //private int cndIdUtilisateur;
    //private ThUtilisateurUti thUtilisateurUti;
    private ThEtudiantEtu thEtudiantEtu;
 
    /*@Transient
    @GenericGenerator(name = "genCandidat", strategy = "foreign", parameters = @Parameter(name = "property", value = "thUtilisateurUti"))
    @Id
    @GeneratedValue(generator = "genCandidat")
    @Column(name = "cnd_id_utilisateur", unique = true, nullable = false)
    public int getCndIdUtilisateur() {
        return this.cndIdUtilisateur;
    }
 
    public void setCndIdUtilisateur(int cndIdUtilisateur) {
        this.cndIdUtilisateur = cndIdUtilisateur;
    }*/
 
    /*@Transient
    @OneToOne(fetch = FetchType.LAZY)
    //@PrimaryKeyJoinColumn(name = "cnd_id_utilisateur")
    @NotNull
    public ThUtilisateurUti getThUtilisateurUti() {
        return this.thUtilisateurUti;
    }
 
    public void setThUtilisateurUti(ThUtilisateurUti thUtilisateurUti) {
        this.thUtilisateurUti = thUtilisateurUti;
    }*/
 
    @Transient
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="etu_id_candidat", referencedColumnName="cnd_id_utilisateur")
    public ThEtudiantEtu getThEtudiantEtu() {
        return this.thEtudiantEtu;
    }
 
    public void setThEtudiantEtu(ThEtudiantEtu thEtudiantEtu) {
        this.thEtudiantEtu = thEtudiantEtu;
    }

Dans ThEtudiantEtu :

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 int etuIdCandidat;
    //private ThCandidatCnd thCandidatCnd;
 
    /*@GenericGenerator(name = "genEtudiant", strategy = "foreign", parameters = @Parameter(name = "property", value = "thCandidatCnd"))
    //@Id
    @GeneratedValue(generator = "genEtudiant")
    //@Column(name = "etu_id_candidat", unique = true, nullable = false)
    @Transient
    public int getEtuIdCandidat() {
        return this.etuIdCandidat;
    }
 
    public void setEtuIdCandidat(int etuIdCandidat) {
        this.etuIdCandidat = etuIdCandidat;
    }*/
 
    /*@OneToOne(fetch = FetchType.LAZY)
    //@PrimaryKeyJoinColumn(name = "etu_id_candidat")
    @NotNull
    public ThCandidatCnd getThCandidatCnd() {
        return this.thCandidatCnd;
    }
 
    public void setThCandidatCnd(ThCandidatCnd thCandidatCnd) {
        this.thCandidatCnd = thCandidatCnd;
    }*/

Et au déploiement, j'ai cette erreur :

org.jboss.seam.InstantiationException: Could not instantiate Seam component: entityManagerFactory
...
Caused by: javax.persistence.PersistenceException: [PersistenceUnit: stamas] Unable to configure EntityManagerFactory
...
Caused by: org.hibernate.AnnotationException: referencedColumnNames(uti_id_personne) of org.domain.stamas.entity.ThUtilisateurUti.thCandidatCnd referencing org.domain.stamas.entity.ThCandidatCnd not mapped to a single property

En tête de ThCandidatCnd, j'ai ceci pour l'héritage :

Code :

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

1
2
3
4
5
@Entity
@Table(name = "th_candidat_cnd")
@Inheritance(strategy=InheritanceType.JOINED)
@PrimaryKeyJoinColumn(name = "cnd_id_utilisateur", referencedColumnName = "uti_id_personne")
public class ThCandidatCnd extends ThUtilisateurUti implements java.io.Serializable {

Je trouve bizarre la manière dont est tournée la phrase puisqu'on dirait que ThCandidatCnd s'auto-référence !

La referencedColumnName s'appelle bien uti_id_personne dans la table th_utilisateur_uti mais comme cette table hérite de te_personne_prs, son entité Java a l'identifiant généré commenté. Je sens que si je le remets, Hibernate va de nouveau tripatouiller ma BDD !

[tchize_]

oui enfin, y a beaucoup de problèmes à gauche et à droite. J'ai bien dit de mettre le @transient, oui, pour que hibernate ne le gère pas, puisque ca n'avais plus lieur d'être. Je reste perperplexe sur toute ta structure, tu fais à la fois de l'héritage et de la relation manytomany entre les même instance, j'ai du mal à voir la cohérence dans tout ce truc. Et comme je l'ai dit dans un message; hibernate, pour faire du legacy, tu va galérer si ta structure de tables lui conviens pas!

[CinePhil]

Je reste perperplexe sur toute ta structure, tu fais à la fois de l'héritage et de la relation manytomany entre les même instance,

Pas manytomany mais onetoone !

j'ai du mal à voir la cohérence dans tout ce truc.

MCD :
th_etudiant_etu -(1,1)----Etre----1,1- th_candidat_cnd -(1,1)----Etre----0,1- th_utilisateur_uti (1,1)----Etre----0,1- te_personne_prs

Le seul truc un peu bizarre là dedans, c'est l'étage th_candidat_cnd mais ce n'est qu'un niveau d'héritage de plus. Ça se modélise sans problème et ça s'implémente en BDD sans problème :
te_personne_prs (prs_id...)
th_utilisateur_uti (uti_id_personne...)
th_candidat_cnd (cnd_it_utilisateur...)
th_etudiant_etu (etu_id_candidat...)

Comme l'héritage est un concept qui vient de la programmation objet, ça ne devrait pas poser de problème à un outil comme Hibernate qui est justement basé là-dessus !

Et comme je l'ai dit dans un message; hibernate, pour faire du legacy, tu va galérer si ta structure de tables lui conviens pas!

Ça j'ai remarqué ! Et je trouve que ce n'est pas normal !
Je ne veux pas ouvrir ici un débat parce que ce n'est pas le sujet de la discussion mais la structure des données et les contraintes sur les données, c'est le boulot du SGBD. Hibernate ne devrait en quelque sorte être qu'un "traducteur" entre le monde relationnel et le monde objet.

Bon je fais quoi maintenant ?

[tchize_]

ben tu prend déjà une décision

Soit tu fais de l'héritage -> alors il n'est pas normal que utilisateur aie une propriété getCandidat, et tu la vire

Soit tu ne fais plus d'héritage, et tu mappe alors les one-to-one. Mais faire les deux en même temps, ca n'a pas de sens, puisque utilisateur.getCandidat retournerais de toute facons "this". Donc à la base, je comprend pas trop le besoin derrière de faire les deux en meme temps.

[CinePhil]

Mon besoin est de vérifier si l'utilisateur étudiant est inscrit à un stage donc de pouvoir accéder aux propriétés de l'entité fille (ThCandidatCnd) à partir de l'entité mère (ThUtilisateurUti).
Simple mais apparemment, sans le getCandidat, c'est impossible.
On tourne en rond non ?

[tchize_]

Ben t'es en héritage, donc

Code :

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

1
2
3
if (utilisateur instanceof candidat){
  candidat = (candidat)utilisateur;
}

si t'as deux instances séparée (candidat et utilisateur) c'est que t'es parti sans prendre en compte l'héritage. Dans ce cas tu retire tous l'héritage (plus de candidat extends utilisateur et plus de mapping "héritage" dans hibernate, juste des onetoone).

[CinePhil]

Ben t'es en héritage, donc

Code :

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

1
2
3
if (utilisateur instanceof candidat){
  candidat = (candidat)utilisateur;
}

C'est ThCandidatCnd qui hérite de (qui extends) ThUtilisateurUti. D'après ce que j'ai lu, c'est donc plutôt dans l'autre sens non ?

Code :

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

1
2
3
4
if (candidat instanceof utilisateur)
{
// résultat true
}

Je ne comprends pas la suite :

si t'as deux instances séparée (candidat et utilisateur) c'est que t'es parti sans prendre en compte l'héritage.

Pas plus que le bout de code que tu as mis dans le if :

Code :

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

candidat = (candidat)utilisateur;

Et là si je comprends bien tu me dis de revenir au mapping original sans héritage alors que mon modèle de données est bien basé sur de l'héritage ?

Dans ce cas tu retire tous l'héritage (plus de candidat extends utilisateur et plus de mapping "héritage" dans hibernate, juste des onetoone).

Je clarifie une nouvelle fois mon besoin concret...
À partir de ce MCD :
th_etudiant_etu -(1,1)----Etre----1,1- th_candidat_cnd -(1,1)----Etre----0,1- th_utilisateur_uti (1,1)----Etre----0,1- te_personne_prs

Et de cet autre extrait :
th_candidat_cnd -0,n----Inscrire----0,n- te_session_ssn -1,1----Etre----(1,1)- th_stage_stg

Et de ce MPD :
te_personne_prs (prs_id...)
th_utilisateur_uti (uti_id_personne...)
th_candidat_cnd (cnd_it_utilisateur...)
th_etudiant_etu (etu_id_candidat...)
te_session_ssn (ssn_id...)
th_stage_stg (stg_id_session...)
tj_cnd_inscrire_stg_cis (cis_id_candidat, cis_id_session)

Je veux pouvoir afficher une page AccueilEtudiant modifiée si l'utilisateur étudiant (donc candidat) qui s'authentifie (Authenticator.java) est déjà inscrit à une session de stage.

L'authentification se fait logiquement en interrogeant l'entité ThUtilisateurUti et je dois donc accéder d'un moyen ou d'un autre à ThStageStg à partir de ThUtilisateurUti donc en passant par ThCandidatCnd.

En SQL, ça donne ça :

Code :

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

1
2
3
4
5
SELECT u.uti_login, s.ssn_libelle
FROM th_utilisateur_uti u
LEFT OUTER JOIN th_candidat_cnd c ON c.cnd_id_utilisateur = u.uti_id_personne
    LEFT OUTER JOIN tj_cnd_inscrire_ssn_cis cis ON cis.cis_id_candidat = c.cnd_id_utilisateur
        LEFT OUTER JOIN th_session_ssn s ON s.ssn_id = cis.cis_id_session

J'ai simplifié mais je dois récupérer aussi des colonnes de te_personne_prs, de th_stage_stg et d'autres tables associées à th_stage_stg. Ce qui veut dire au passage que le même problème se pose pour lire les propriétés de ThStageStg à partir de sa classe mère TeSessionSsn.

J'ai essayé une autre requête dans le bean de la page AccueilEtudiant, ce qui a donné une autre discussion + le début de celle-ci, ça n'a pas marché. J'ai essayé dans Authenticator.java, ça ne fonctionne pas non plus.
C'est pourtant simple comme problème !

[Rei Ichido]

Il a juste simplifié.

Code :

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

1
2
3
4
5
 
if (utilisateur instanceof ThCandidatCnd) { // vérifie que l'utilisateur est en fait un candidat)
  ThCandidatCnd candidat = (ThCandidatCnd) utilisateur; // cast
  // on peut maintenant manipuler l'utilisateur comme le candidat qu'il est.
}

[tchize_]

C'est ThCandidatCnd qui hérite de (qui extends) ThUtilisateurUti. D'après ce que j'ai lu, c'est donc plutôt dans l'autre sens non ?

Code :

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

if (candidat instanceof utilisateur)

Houla, tu a l'air de mélanger tes base de POO toi
candidat est un utilisateur (il hérite d'utilisateur) donc le instanceof ne sert à rien (par définition il retournera toujours vrai) Le but de tester c'est que, quand tu as un "utilisateur" , ici, tu veux savoir si, en plus, cet utilisateur est un candidat! Et comme tu as
Candidat extends Utilisateur
ce n'est pas nécessairement vrai pour le compilateur.

Pas plus que le bout de code que tu as mis dans le if :

Code :

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

candidat = (candidat)utilisateur;

Heu non, c'est toujours la même instance, juste que maintenant j'ai deux références dessus, dont une bien typée pour sa manipulation. Là soudain, j'ai l'impression que tu fais du hibernate et du dev web alors que tu ne maitrise pas les bases du java , je me trompe? Si c'est le cas, prépare toi à encore ramer très longtemps.

Et là si je comprends bien tu me dis de revenir au mapping original sans héritage alors que mon modèle de données est bien basé sur de l'héritage ?

Non, je te dis que tu dois choisir. Soit tu fais de l'héritage, et alors tu joue avec les typecasting.
Soit tu fait un modèle plat, et alors tu joue avec les onetoone et les getter/setter

Mais on ne fait pas les deux en même temps, ca n'a pas de sens et hibernate n'appréciera pas.

C'est pourtant simple comme problème !

Oui, seulement t'essaie de le résoudre de deux manières en même temps (getter/setter + héritage objet), et faudra se contenter d'une seule.

Exemple ici de mapping par héritage, sous le format "une table par classe concrète"
http://docs.jboss.org/hibernate/stab...ingle/#d0e1168 section 2.2.4.3, un exemple avec un "boat" et deux sous classes "ferry" et "americacupclass". Comme tu peux le constater, effectivement, le problème est simple.


Exemple avec deux de tes tables:

Code :

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

1
2
3
4
5
6
7
8
9
@Entity
@Inheritance(strategy=InheritanceType.JOINED)
@Table(name="te_personne_prs")
public class Personne implements Serializable { ... 
 
   /** Et ça, on ne veux pas voir dedans!
   public Utilisateur getUtilisateur() {....}
   */
}

Code :

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

1
2
3
4
5
6
7
8
@Entity
@PrimaryKeyJoinColumn(name="uti_id_personne")
@Table(name="th_utilisateur_uti")
public class  Utilisateur extends Personne { ... 
   /** Et ça, on ne veux pas voir dedans!
   public Personne getPersonne() {....}
   */
}

[CinePhil]

Houla, tu a l'air de mélanger tes base de POO toi
candidat est un utilisateur (il hérite d'utilisateur) donc le instanceof ne sert à rien (par définition il retournera toujours vrai) Le but de tester c'est que, quand tu as un "utilisateur" , ici, tu veux savoir si, en plus, cet utilisateur est un candidat! Et comme tu as
Candidat extends Utilisateur
ce n'est pas nécessairement vrai pour le compilateur.

Heu non, c'est toujours la même instance, juste que maintenant j'ai deux références dessus, dont une bien typée pour sa manipulation. Là soudain, j'ai l'impression que tu fais du hibernate et du dev web alors que tu ne maitrise pas les bases du java , je me trompe? Si c'est le cas, prépare toi à encore ramer très longtemps.

Effectivement, je sais que j'ai des grosses lacunes en Java pour attaquer Seam mais c'est la vie !
Ma formation Java se limite à un cours CNAM de 3h par semaine pendant 4 mois + encore quelques semaines pour les servlets + un projet réalisé à 4, et c'était il y a environ 5 ans ! Autant dire que instanceof, je l'ai vu pour la première fois dans ton message !
Bref...

Non, je te dis que tu dois choisir. Soit tu fais de l'héritage, et alors tu joue avec les typecasting.
Soit tu fait un modèle plat, et alors tu joue avec les onetoone et les getter/setter

Mais on ne fait pas les deux en même temps, ca n'a pas de sens et hibernate n'appréciera pas.

J'ai mis une heure à remettre l'appli à plat pour aller dans le sens de l'héritage et avoir un début d'appli qui fonctionne en ne prenant en compte que l'authentification de l'utilisateur et la redirection sur la page AccueilEtudiant.

Merci pour les autres explications. y compris à Rei Ichido. Quand on m'explique en détail je comprends !

Maintenant je commence à tester ton truc :

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
        try
        {
            log.info("authenticating {0}", credentials.getUsername());
 
            Query query = entityManager.createQuery(
                    "FROM ThUtilisateurUti u " +
                    /*"LEFT JOIN u.thCandidatCnd c " +
                    "LEFT JOIN u.TeSessionSsns s " +*/
                    "WHERE u.utiLogin = :username " +
                        "AND u.utiMotPasse = :password");
            query.setParameter("username", credentials.getUsername());
            String passwd = MD5.generateMD5passwd(credentials.getPassword());
            query.setParameter("password", passwd);
            log.info("authenticating - après paramètre password");
 
 
            setUser ((ThUtilisateurUti) query.getSingleResult());
 
            int typeUtilisateur = user.getTeTypeUtilisateurTu().getTuId();
 
            if (user instanceof ThCandidatCnd)
            {
                ThCandidatCnd candidat = (ThCandidatCnd) user;
                String utilogin = candidat.getUtiLogin();
                log.info("authenticating {0} - utilogin = ", utilogin);
            }

Et dans le log, j'ai ça, à partir de la fin de la requête Hibernate :

where
thutilisat0_.uti_login=?
and thutilisat0_.uti_mot_passe=? limit ?
16:10:23,668 DEBUG [AbstractBatcher] about to open ResultSet (open ResultSets: 0, globally: 0)
16:10:23,671 DEBUG [Loader] result row: EntityKey[org.domain.stamas.entity.ThUtilisateurUti#2]
16:10:23,679 DEBUG [AbstractBatcher] about to close ResultSet (open ResultSets: 1, globally: 1)
16:10:23,679 DEBUG [AbstractBatcher] about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
16:10:23,681 DEBUG [TwoPhaseLoad] resolving associations for [org.domain.stamas.entity.ThEtudiantEtu#2]
16:10:23,692 DEBUG [TwoPhaseLoad] done materializing entity [org.domain.stamas.entity.ThEtudiantEtu#2]
16:10:23,693 DEBUG [StatefulPersistenceContext] initializing non-lazy collections
16:10:23,693 INFO [Authenticator] authenticating etutest - utilogin =
16:10:23,693 INFO [Authenticator] authenticating etutest - Authentifié en tant qu'étudiant
16:10:23,706 DEBUG [Identity] Login successful for: etutest
16:10:23,712 DEBUG [ResourceLoader] resource bundle missing: login

=> getUtiLogin est bien sûr dans ThUtilisateurUti dont hérite ThCandidatCnd.
=> On voit qu'on entre bien dans le if mais utilogin ne s'affiche pas.

Dans la page AccueilEtudiant, j'ai aussi ajouté un test pour vérifier que le user importé depuis Authenticator.java vers AccueilEtudiant.java n'était pas vide :

Code :

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

            <p>Bonjour&nbsp; <h:outputText value=" #{accueilEtudiant.prenom} #{accueilEtudiant.nom}. => #{accueilEtudiant.user.utiLogin}"/></p>

=> Résultat : Bonjour Test Test. => etutest

Une explication claire sur la raison de utilogin vide ?

Est-ce qu'ensuite, là démarche ci-dessous serait correcte pour accéder à la session de stage de l'étudiant ?

Code :

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

1
2
3
4
5
6
7
8
                Set<TeSessionSsn> sessions = candidat.getTeSessionSsns();
                log.info("authenticating - ravant for");
                for (Iterator<TeSessionSsn> iter = sessions.iterator(); iter.hasNext();)
                {
                    log.info("authenticating - dans for");
                    setSession((TeSessionSsn) iter.next());
                    log.info("authenticating - après setSession");
                }*/

[tchize_]

pour le login vide, tu pourrais redonner tes mappings (utilisateur/candidat) remis à plat qu'on y voie clair?

pour le code de la fin, il y a plus facile à coder depuis java5

Code :

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

1
2
3
4
5
6
7
8
                Set<TeSessionSsn> sessions = candidat.getTeSessionSsns();
                log.info("authenticating - ravant for");
                for (TeSessionSsn sess : sessions)
                {
                    log.info("authenticating - dans for");
                    setSession(sess);
                    log.info("authenticating - après setSession");
                }*/

[CinePhil]

pour le login vide, tu pourrais redonner tes mappings (utilisateur/candidat) remis à plat qu'on y voie clair?

Dans ThUtilisateurUti :

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
57
58
59
60
61
62
63
64
65
66
67
68
@Entity
@Table(name = "th_utilisateur_uti")
@Inheritance(strategy=InheritanceType.JOINED)
@PrimaryKeyJoinColumn(name = "uti_id_personne", referencedColumnName = "prs_id")
public class ThUtilisateurUti extends TePersonnePrs /*implements java.io.Serializable*/ {
 
    //private int utiIdPersonne;
    //private TePersonnePrs tePersonnePrs;
    private TeTypeUtilisateurTu teTypeUtilisateurTu;
    private String utiLogin;
    private String utiMotPasse;
    //private ThCandidatCnd thCandidatCnd;
 
    public ThUtilisateurUti() {
    }
 
    public ThUtilisateurUti(/*TePersonnePrs tePersonnePrs,*/
            TeTypeUtilisateurTu teTypeUtilisateurTu, String utiLogin,
            String utiMotPasse) {
        //this.tePersonnePrs = tePersonnePrs;
        this.teTypeUtilisateurTu = teTypeUtilisateurTu;
        this.utiLogin = utiLogin;
        this.utiMotPasse = utiMotPasse;
    }
 
    /*public ThUtilisateurUti(/*TePersonnePrs tePersonnePrs,*/
            //TeTypeUtilisateurTu teTypeUtilisateurTu, String utiLogin,
            //String utiMotPasse/*, ThCandidatCnd thCandidatCnd*/) {
        //this.tePersonnePrs = tePersonnePrs;
        /*this.teTypeUtilisateurTu = teTypeUtilisateurTu;
        this.utiLogin = utiLogin;
        this.utiMotPasse = utiMotPasse;
        //this.thCandidatCnd = thCandidatCnd;
    }*/
 
    /*@GenericGenerator(name = "genUtilisateur", strategy = "foreign", parameters = @Parameter(name = "property", value = "tePersonnePrs"))
    @Id
    @GeneratedValue(generator = "genUtilisateur")
    @Column(name = "uti_id_personne", unique = true, nullable = false)
    //@Transient
    public int getUtiIdPersonne() {
        return this.utiIdPersonne;
    }
 
    public void setUtiIdPersonne(int utiIdPersonne) {
        this.utiIdPersonne = utiIdPersonne;
    }*/
 
    /*@OneToOne(fetch = FetchType.LAZY)
    //@PrimaryKeyJoinColumn(name = "uti_id_personne")
    @NotNull
    public TePersonnePrs getTePersonnePrs() {
        return this.tePersonnePrs;
    }
 
    public void setTePersonnePrs(TePersonnePrs tePersonnePrs) {
        this.tePersonnePrs = tePersonnePrs;
    }*/
 
    /*@OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="cnd_id_utilisateur", referencedColumnName="uti_id_personne")
    public ThCandidatCnd getThCandidatCnd() {
        return this.thCandidatCnd;
    }
 
    public void setThCandidatCnd(ThCandidatCnd thCandidatCnd) {
        this.thCandidatCnd = thCandidatCnd;
    }*/

Dans thCandidatCnd :

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
57
58
59
60
61
62
63
64
65
66
67
@Entity
@Table(name = "th_candidat_cnd")
@Inheritance(strategy=InheritanceType.JOINED)
@PrimaryKeyJoinColumn(name = "cnd_id_utilisateur", referencedColumnName = "uti_id_personne")
public class ThCandidatCnd extends ThUtilisateurUti /*implements java.io.Serializable*/ {
 
    //private int cndIdUtilisateur;
    //private ThUtilisateurUti thUtilisateurUti;
    //private ThEtudiantEtu thEtudiantEtu;
    private Set<TeSessionSsn> teSessionSsns = new HashSet<TeSessionSsn>(0);
 
    public ThCandidatCnd() {
    }
 
    /*public ThCandidatCnd(ThUtilisateurUti thUtilisateurUti) {
        this.thUtilisateurUti = thUtilisateurUti;
    }*/
 
    public ThCandidatCnd(/*ThUtilisateurUti thUtilisateurUti,
            ThEtudiantEtu thEtudiantEtu,*/ Set<TeSessionSsn> teSessionSsns) {
        //this.thUtilisateurUti = thUtilisateurUti;
        //this.thEtudiantEtu = thEtudiantEtu;
        this.teSessionSsns = teSessionSsns;
    }
 
    /*@GenericGenerator(name = "genCandidat", strategy = "foreign", parameters = @Parameter(name = "property", value = "thUtilisateurUti"))
    @Id
    @GeneratedValue(generator = "genCandidat")
    @Column(name = "cnd_id_utilisateur", unique = true, nullable = false)
    public int getCndIdUtilisateur() {
        return this.cndIdUtilisateur;
    }
 
    public void setCndIdUtilisateur(int cndIdUtilisateur) {
        this.cndIdUtilisateur = cndIdUtilisateur;
    }*/
 
    /*@OneToOne(fetch = FetchType.LAZY)
    //@PrimaryKeyJoinColumn(name = "cnd_id_utilisateur")
    @NotNull
    public ThUtilisateurUti getThUtilisateurUti() {
        return this.thUtilisateurUti;
    }
 
    public void setThUtilisateurUti(ThUtilisateurUti thUtilisateurUti) {
        this.thUtilisateurUti = thUtilisateurUti;
    }*/
 
    /*@OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="etu_id_candidat", referencedColumnName="cnd_id_utilisateur")
    public ThEtudiantEtu getThEtudiantEtu() {
        return this.thEtudiantEtu;
    }
 
    public void setThEtudiantEtu(ThEtudiantEtu thEtudiantEtu) {
        this.thEtudiantEtu = thEtudiantEtu;
    }*/
 
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "tj_cnd_inscrire_ssn_cis", joinColumns = { @JoinColumn(name = "cis_id_candidat", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "cis_id_session", nullable = false, updatable = false) })
    public Set<TeSessionSsn> getTeSessionSsns() {
        return this.teSessionSsns;
    }
 
    public void setTeSessionSsns(Set<TeSessionSsn> teSessionSsns) {
        this.teSessionSsns = teSessionSsns;
    }

pour le code de la fin, il y a plus facile à coder depuis java5

Code :

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

1
2
3
4
5
6
7
8
                Set<TeSessionSsn> sessions = candidat.getTeSessionSsns();
                log.info("authenticating - ravant for");
                for (TeSessionSsn sess : sessions)
                {
                    log.info("authenticating - dans for");
                    setSession(sess);
                    log.info("authenticating - après setSession");
                }*/

Effectivement, j'avais précédemment vu cette forme.

Je ne sais pas pourquoi ma variable de test utilogin est vide mais en tout cas j'ai mis mon code et ça fonctionne !
Authenticator.java :

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
    @Out(required = false, scope = ScopeType.SESSION)
    private TeSessionSsn sess;
 
            if (user instanceof ThCandidatCnd)
            {
                ThCandidatCnd candidat = (ThCandidatCnd) user;
                // TEST
                String utilogin = candidat.getUtiLogin();
                log.info("authenticating {0} - utilogin = ", utilogin);
 
                log.info("authenticating - recherche session de stage");
                Set<TeSessionSsn> sessions = candidat.getTeSessionSsns();
                log.info("authenticating - avant for");
                for (TeSessionSsn ses : sessions)
                {
                    log.info("authenticating - dans for");
                    setSess(ses);
 
                    log.info("authenticating - après setSession");
                }
            }

J'importe sess dans AccueilEtudiant.java et dans AcueilEtudiant.xhtml, j'ai ajouté ceci :

Code :

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

=> #{accueilEtudiant.sess.ssnLibelle}

=> Résultat : Bonjour Test Test. => etutest => Histoire

Grand merci pour ton aide ! Je vais maintenant essayer de récupérer de la même manière, à partir de la session, les infos du stage et de l'établissement où il a lieu.

J'espère qu'on est pas loin du !