JPA + Postgresql: LazyInitializationException

Version imprimable

Bonjour je travail sur un projet JEE et j'ai besoin de tester mon session bean depuis un projet clienEJB le probleme est que lorsque je fait un mise à jour ou une suppression tout se passe bien mais lors de l'ajout cette erreur est généré:

Code:

1
2
3
4
5
6
7
8
Exception in thread "main" org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: persistence.Site.utilisateurs, no session or session was closed
    at org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:380)
    at org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationExceptionIfNotConnected(AbstractPersistentCollection.java:372)
    at org.hibernate.collection.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:365)
    at org.hibernate.collection.AbstractPersistentCollection.write(AbstractPersistentCollection.java:205)
    at org.hibernate.collection.PersistentBag.add(PersistentBag.java:297)
    at persistence.Site.ajouterUser(Site.java:57)
    at test.Test.main(Test.java:70)

voila mon fichier persistence.xml:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
    <persistence-unit name="BaseEcuEJB">
 
    <jta-data-source>java:/BaseEcuDS</jta-data-source>    
 
    <properties>
 
            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
            <property name="hibernate.show_sql" value="true"/>                     
            <property name="hibernate.jdbc.batch_size" value="0"/>
 
        </properties>
 
    </persistence-unit>
</persistence>

voila mon session bean:

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
package services;
 
import java.util.List;
 
import javax.annotation.Resource;
import javax.ejb.SessionContext;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
 
import persistence.Site;
import persistence.Utilisateur;
 
/**
 * Session Bean implementation class UsersManagerBean
 */
 
@Stateless
public class UsersManagerBean implements UsersManagerBeanRemote, UsersManagerBeanLocal {
 
    @PersistenceContext(unitName="BaseEcuEJB")
    private EntityManager em;    
    //@Resource
    //SessionContext sc;
 
    public boolean utilisateurExist(int id)
    {
        Utilisateur u = em.find(Utilisateur.class, id);
 
        if (u == null) 
        {
            return false;
        }
        else
            return true;
    }
    public Site getSiteById(int id){
        Site s = em.find(Site.class, id);
        return s;
    }
 
    public List<Utilisateur> getUsersList()
    {        
        Query q=em.createQuery("select u from Utilisateur u");
        List users = q.getResultList();
        return users;
    }    
 
    public void maj(Site site){
        em.merge(site);
    }
    public void ajout(Utilisateur u) 
    {
        em.persist(u);
 
        System.out.println("***************************User adde*****************************");
    }
 
    public void supp(Utilisateur u)
    {        
            em.remove(em.merge(u));            
    }    
}

et en fin la classe main de test:

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
package test;
 
import java.util.List;
 
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.transaction.SystemException;
 
import org.hibernate.Session;
 
import persistence.Site;
import persistence.Utilisateur;
 
import services.UsersManagerBeanRemote;
 
public class Test {
 
    public static String ad ="Admin";
 
    public static void main(String[] args) throws Exception 
    {        
        Context jndiContext = new InitialContext();
        Object ref = jndiContext.lookup("BaseEcuEAR/UsersManagerBean/remote");
        UsersManagerBeanRemote umb = (UsersManagerBeanRemote)ref;
 
 
 
        Utilisateur u1 = new Utilisateur();        
 
        u1.setNom("Bechir");
        u1.setPrenom("Hada");
        u1.setProfil("Admin");
        u1.setPseudo("hadakamatcho");
        Site site=umb.getSiteById(1);
        site.ajouterUser(u1);
        umb.maj(site);
        //u1.setSite(null);
        umb.ajout(u1);
 
        //System.out.println(umb.findUser("Bechir").);
 
 
    }    
}

J'ai pas compris cette erreur est du a quoi!!!

21/09/2010, 17h16
MaitreKaio

Ce qu'il nous faudrait surtout, c'est la méthode
Site.ajouterUser()

Ainsi que le paramétrage de la démarcation des transactions.

Citation:

Envoyé par MaitreKaio

Ce qu'il nous faudrait surtout, c'est la méthode
Site.ajouterUser()

Ainsi que le paramétrage de la démarcation des transactions.

;) Dacord voila les deux entité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
package persistence;
 
import java.io.Serializable;
import javax.persistence.*;
 
import java.util.List;
 
@Entity
 
@Table(name="`SITES`",schema="public")
public class Site implements Serializable {
    private static final long serialVersionUID = 1L;
 
    @Id
    @Column(name="`IdSite`")
    private Integer idSite;
 
    @Column(name="`NomSite`")
    private String nomSite;
 
    //bi-directional many-to-one association to Utilisateur
    @OneToMany(mappedBy="site", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Utilisateur> utilisateurs;
 
    public Site() {        
    }
 
    public Integer getIdSite() {
        return this.idSite;
    }
 
    public void set_IdSite_(Integer idSite) {
        this.idSite = idSite;
    }
 
    public String getNomSite() {
        return this.nomSite;
    }
 
    public void set_NomSite_(String nomSite) {
        this.nomSite = nomSite;
    }
 
    public List<Utilisateur> getUtilisateurs() {
        return this.utilisateurs;
    }
 
    public void setUtilisateurs(List<Utilisateur> utilisateurs) {
        this.utilisateurs = utilisateurs;
    }
    public void ajouterUser(Utilisateur u) {
        this.utilisateurs.add(u);
        u.setSite(this);
}
}

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
package persistence;
 
import java.io.Serializable;
import javax.persistence.*;
 
import javax.xml.bind.ValidationException;
 
@Entity
@Table(name="`UTILISATEUR`",schema="public")
public class Utilisateur implements Serializable {
    private static final long serialVersionUID = 1L;
 
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="`IdUtilisateur`")
    private Integer idUtilisateur;
 
    //@Column(name="`IdSite`")
    //private Integer idSite;
 
    @Column(name="`Nom`")
    private String nom;
 
    @Column(name="`Prenom`")
    private String prenom;
 
    @Column(name="`Profil`")
    private String profil;
 
    @Column(name="`Pseudo`")
    private String pseudo;
 
    //bi-directional many-to-one association to Site
 
    @ManyToOne
    @JoinColumn(name="`IdSite`", nullable=true)
    private Site site;
 
 
    @Transient
    private boolean admin ;
 
 
    public boolean isAdmin() {
        /*if((getProfil().equalsIgnoreCase("Admin")))
        {return true;}
        return false;*/
        return true;
    }
 
    public void setAdmin(boolean admin) {
        this.admin = admin;
    }
 
    public Utilisateur() 
    {
    }
 
    public Integer getIdUtilisateur() {
        return this.idUtilisateur;
    }
 
    public void setIdUtilisateur(Integer idUtilisateur) {
        this.idUtilisateur = idUtilisateur;
    }    
 
    public String getNom() {
        return this.nom;
    }
 
    public void setNom(String nom) {
        this.nom = nom;
    }
 
    public String getPrenom() {
        return this.prenom;
    }
 
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
 
    public String getProfil() {
        return this.profil;
    }
 
    public void setProfil(String profil) {
        this.profil = profil;
    }
 
    public String getPseudo() {
        return this.pseudo;
    }
 
    public void setPseudo(String pseudo) {
        this.pseudo = pseudo;
    }
 
    public Site getSite() {
        return this.site;
    }
 
    public void setSite(Site site) {
        this.site = site;
    }
 
}

23/09/2010, 18h04
MaitreKaio

d'accord, et pour la démarcation des transactions ? Tu sais comment c'est géré dans ton appli ?
23/09/2010, 18h17
hadakamatcho

comment peut on avoir la démarcation des transactions !?
ca parait stupid comme question :oops:

Tu as déclaré ta liste utilisateurs avec l'attribut fetch = FetchType.LAZY. Ainsi, ta liste n'est pas chargée quand tu la récupère en base.
LazyInitializationException indique que tu essaies d'utiliser cette liste sans l'avoir chargé.

Reprends ta méthode getSiteById() dans ton EJB session :
Code:

1 2 3 4 5 6 7 8 public Site getSiteById(int id){ Site s = em.find(Site.class, id); // chargement de ta liste if(s.getUtilisateurs() != null) { s.getUtilisateurs().size(); } return s; }

24/09/2010, 16h02
hadakamatcho

dacord merci pour la réponse je vais essayer ;)
26/09/2010, 16h16
scorplayer

OK, tiens nous au courant.

MaitreKaio, Les EJB3, grâce à la récupération du contexte de persistance (@PersistenceContext), s'occupent de la gestion des transactions. Dans ce cas, l'ouverture et la fermeture des transactions sont désormais transparentes.