JPA + Postgresql: LazyInitializationException

**hadakamatcho** · 21/09/2010, 16h45

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 :

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

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 :

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
<?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 :

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
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 :

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
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!!!

**MaitreKaio** · 21/09/2010, 17h16

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

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

**hadakamatcho** · 21/09/2010, 17h25

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 :

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
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 :

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
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;
    }
 
}

**MaitreKaio** · 23/09/2010, 18h04

d'accord, et pour la démarcation des transactions ? Tu sais comment c'est géré dans ton appli ?

**hadakamatcho** · 23/09/2010, 18h17

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

**scorplayer** · 24/09/2010, 14h45

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 :

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

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;
    }

**hadakamatcho** · 24/09/2010, 16h02

dacord merci pour la réponse je vais essayer

**scorplayer** · 26/09/2010, 16h16

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.

JPA + Postgresql: LazyInitializationException

JPA Java

Vue hybride

Discussions similaires

Partager

Partager