Discussion :

[Fractaliste]

Bonjour,


Dans le cadre d'un développement JAVA je me dois d'implémenter ce modèle de donnée (qui fait parti d'un plus gros ensemble) :



Ma relation ManyToMany possède des attributs.Je n'ai donc pas le droit d'utiliser l'annotation @ManyToMany. Je suis obligé de passer par une classe qui fera ma liaison avec deux annotations @ManyToOne

Mes classes sont donc :

Classe Prestation

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
 
@Entity
public class Prestation implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
 
    private String intitulé ;
 
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date date_début;
 
    @OneToMany(mappedBy = "prestation" )
    private List<Entity_Liaison_Intervenant_prestation> liaison_Intervenant = new ArrayList<Entity_Liaison_Intervenant_prestation> ();

Classe Intervenant

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
 
@Entity
public class Intervenant implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
 
    private String nom;
 
    private String prénom;
 
    @OneToMany(mappedBy = "intervenant")
    private List<Entity_Liaison_Intervenant_prestation> liaison_Prestation = new ArrayList<Entity_Liaison_Intervenant_prestation> ();

Classe Liaison

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
 
@Entity
public class Entity_Liaison_Intervenant_prestation implements Serializable {
 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
 
    private static final long serialVersionUID = 1L;
 
    @ManyToOne(fetch = FetchType.EAGER, optional = false)
    private Intervenant intervenant;
 
    @ManyToOne(fetch = FetchType.EAGER, optional = false)
    private Prestation prestation;
 
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date date;
 
    @Enumerated(EnumType.STRING)
    private Etat_Intervenant role_intervenant;

J'ajoute sans problème un nouvel intervenant à ma prestation :

Code :

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

1
2
3
4
5
6
 
Intervenant intervenant_à_ajouter = (Intervenant)comboIntervenants.getSelectedObjects()[0];
Entity_Liaison_Intervenant_Prestation liaison_à_ajouter = new Entity_Liaison_Intervenant_Prestation();
liaison_à_ajouter.setRole_intervenant(Etat_Intervenant.babysitter);
liaison_à_ajouter.setIntervenant(intervenant_à_ajouter);
liaison_à_ajouter.setPrestation(PrestationEnCours);

En revanche, quand je veux récupérer tous mes intervenants qui ont eu un rôle pendant ma prestation, et bien c'est le drame :

Code :

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

1
2
16 sept. 2011 14:04:02 org.hibernate.LazyInitializationException <init>
GRAVE: failed to lazily initialize a collection of role: application.entity.Prestation.liaison_Intervenant, no session or session was closed

Mon code qui appelle l'erreur :

Code :

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

1
2
for (Entity_Liaison_Intervenant_Prestation liaison : PrestationEnCours.getLiaison_Intervenant())
                    System.out.println(liaison.getId());

Bref je comprend pas pourquoi j'ai une erreur "Lazy" alors que ma relation est annotée FetchType.EAGER (qui d'ailleurs est le comportement par défaut) !

Merci d'avance pour vos conseils !

[Shinzul]

Le @ManyToOne est définit comme EAGER.

Mais le code posant problème concerne l'attribut liaison_Intervenant de la classe Prestation.
Or l'annotation @OneToMany concernant ce champs n'a pas l'attribut fetch définit. Par défaut pour l'annotation @OneToMany cet attribut est LAZY.

[Fractaliste]

Oh merci j'avais cru comprendre que les annotations de relations étaient par défaut EAGER, mais en fait ça dépend desquelles.

Un grand merci !



Sinon je me demandais : mon modèle de donnée forme une boucle. Si je met toutes mes relations en mode EAGER et que je récupère dans mon programme un élément de ce modèle, est-ce-qu'il va me charger toutes les relations annotées EAGER ?

Ou bien c'est uniquement juste les entitées immédiatement jointe qui sont chargées ? Parce qu'avec un gros modèle de donnée avec des relations dans tout les sens les performances vont très rapidement en prendre un coup j'ai bien peur...

[OButterlin]

Il traitera les FetchType.EAGER en cascade...

Le mieux (peut-être) serait de laisser le mode FetchType.LAZY et de gérer l'initialisation par la requête en utilisant un join fetch

[Fractaliste]

Ok merci, je vais faire comme tu conseilles. Je pensait qu'en mettant tout en EAGER ça me simplifierai la tâche, mais si je charge à chaque requête mon modèle dans son intégralité je vais exploser mes perf...