[SPRING 2.5][Hibernate]Problème de session: LazyInitializationException:no session

**hkefi** · 26/12/2008, 15h52

Bonjour,
Pour situer mon contexte, je développe actuellement dans le cadre d'une application java SE, un programme qui permet de sauvegarder dans une base de données toutes les requêtes posées par des utilisateurs pour générer des stats. Les données sont lues depuis des fichiers XML et stockées dans une base de données Mysql.
J'utilise JPA, les annotations Spring et Hibernate.

Grace à mes anciens posts et vos réponses, j'ai pu utiliser les annotations Spring pour me faire injecter les beans services dans mon main afin d'invoquer les différentes méthodes sur une Personne.

Voici mon problème :

J'ai une relation many to many entre une personne et une requête :

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
@Table(name = "PERSONNE")
public class Personne implements Serializable {
 
	// champs
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long			id;
 
	@SuppressWarnings("unused")
	@Version
	@Column(name = "VERSION", nullable = false)
	private int				version;
 
	@Column(name = "ID_Personne", nullable = false, unique = true)
	private int				id_personne;
 
	@ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.LAZY)
	@JoinTable(name = "PERSON_REQUEST", joinColumns = @JoinColumn(name = "PERSON_ID"), inverseJoinColumns = @JoinColumn(name = "REQUEST_ID"))
	private Set<Request>	requests	= new HashSet<Request>();

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
@Table(name = "REQUEST")
public class Request implements Serializable {
 
	// ID
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long		id;
 
	@Column(name = "DATE", nullable = false)
	@Temporal(TemporalType.TIMESTAMP)
	private Date		date;
 
       // relation inverse Request -> PErsonne
	@ManyToMany(mappedBy = "requests", cascade = {   CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.LAZY)
	private Set<Personne>	Personnes = new HashSet<Personne>();

Dans mon Main, lorsque j'essaye de rajouter une requête à la liste des requêtes posées par une personne :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");
		// couche service
		IService service = (IService) ctx.getBean("service");
 
Personne person = new Personne(id_personne);
Request requete = new Request(id_request);
person.getRequests().add(requete);
request.getPersonnes().add(person);
service.savePersonne(person);

J'ai une exception qui me dit que la session a été fermée !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
15:26:04,673 ERROR LazyInitializationException:19 - failed to lazily initialize a collection of role: fr.pack.entites.Personne.requests, no session or session was closed
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: fr.pack.entites.Personne.requests, no session or session was closed
	at org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:358)
	at org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationExceptionIfNotConnected(AbstractPersistentCollection.java:350)
	at org.hibernate.collection.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:343)
	at org.hibernate.collection.PersistentSet.add(PersistentSet.java:189)
	at fr.stime.test.TrackLoader.PersistFile(TrackLoader.java:180)
	at fr.stime.test.TrackLoader.run(TrackLoader.java:75)
	at fr.stime.test.InitDB.callTrackLoader(InitDB.java:92)
	at fr.stime.test.InitDB.main(InitDB.java:52)

J'ai cherché sur les forum et dans la doc Spring mais je n'ai pas trouvé une réponse claire à ma question!

Avez-vous une idée comment résoudre ce problème ?

Voic mon fichier de configuration Spring :

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
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
       http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
 
 
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
          <property name="location" value="jdbc.properties" />
   </bean>  
 
	<context:annotation-config />
	<context:component-scan base-package="fr.pack.dao" />
	<context:component-scan base-package="fr.pack.service" />
	<context:component-scan base-package="fr.pack.manager" />
 
 
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">			 
				<!-- <property name="showSql" value="true" />-->
				<property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
				<property name="generateDdl" value="true" />
			</bean>
		</property>
		<property name="jpaProperties">
                 <props>
                     <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                     <prop key="hibernate.hbm2ddl.auto">update</prop><!--  validate | update | create | create-drop-->
                 </props>
        </property>
		<property name="loadTimeWeaver">
			<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver" />
		</property>
	</bean>
 
	<!-- la source de donnéees DBCP -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
 
	<!-- le gestionnaire de transactions -->
	<tx:annotation-driven transaction-manager="txManager" />
	<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
 
	<!-- traduction des exceptions -->
	<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
 
	<!-- persistence -->
	<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
 
</beans>

Merci beaucoup par avance de votre réponse.

**djo.mos** · 26/12/2008, 16h59

Salut,
Il aurait fallu nous montrer ton service

Mais je dirais que ça vient du fait que tu n'as pas déclaré ton services (ou ses méthodes) commes transactionnelles.
Spring va ouvrir la session hibernate lorsque tu exécutes une méthode marquée par @Transactional.

**hkefi** · 26/12/2008, 17h08

Salut djo.mos,

Merci de m'avoir encore répondu.

Non, j'ai mis les bonnes annotations que tu m'as indiqué la dernière fois.

Voici mon service et mon DAO

/************** DAO ***************/

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
 
@Repository
@Transactional
public class DaoImpl implements Dao {
	private static final Logger	LOG	= Logger.getLogger(DaoImpl.class);
 
	@PersistenceContext
	private EntityManager		em;
 
 
 
	// get Personne by Id
	public PDV getPersonne(Long Id) {
		return em.find(Personne.class, Id);
	}
 
	// get Personne by Id_Personne
	@SuppressWarnings("unchecked")
	public PDV getPersonneById(int id_Personne) {
		PDV result = null;
		Session hibSession = (Session) em.getDelegate();
		Criteria criteria = hibSession.createCriteria(Personne.class).add(Restrictions.eq("id_Personne", id_personne));
		List<Personne> _results = criteria.list();
		if (_results != null && _results.size() == 0) {
			System.err.println("getPersonneById: No entity found for query");
		}
		else
			result = _results.get(0);
		return result;
	}
 
	// save Personne
	public Personne savePersonne(Personne personne) {
		em.persist(personne);
		return personne;
	}
 
	// update Personne
	public Personne updatePersonne(Personne personne) {
		return em.merge(personne);
	}
 
	// delete Personne
	public void deletePersonne(Long Id) {
		Personne pdv = em.find(Personne.class, Id);
		if (pdv == null) {
			throw new DaoException(-1);
		}
		em.remove(pdv);
	}
 
	// get all Personne
	@SuppressWarnings("unchecked")
	public List<Personne> getAllPersonne() {
		return em.createNamedQuery("get All Personne").getResultList();
	}
 
	// get all Request of Personne
	@SuppressWarnings("unchecked")
	public List<Request> getAllRequestsOfPersonne(Long pdvId) {
		return em.createNamedQuery("get all Request of PDV").setParameter("Id_personne", pdvId).getResultList();
	}

/****************SERVICE *******************/

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
 
@Service("service")
public class ServiceImpl implements IService {
 
	// couche [dao]
	private Dao	dao;
 
	public Dao getDao() {
		return dao;
	}
 
	@Autowired
	public void setDao(Dao dao) {
		this.dao = dao;
	}
 
 
 
	// get Personne by Id
	public Personne getPersonne (Long id) {
		return dao.getPersonne (id);
	}
 
	// get Personne by IdPDV
	public Personne getPersonne ById(int pdv) {
		return dao.getPersonne ById(pdv);
	}
 
	// save Personne 
	public Personne savePersonne (Personne pdv) {
		return dao.savePersonne (pdv);
	}
 
	// update Personne 
	public Personne updatePersonne (Personne pdv) {
		return dao.updatePersonne (pdv);
	}
 
	// delete Personne 
	public void deletePersonne (Long id) {
		dao.deletePersonne (id);
	}
 
	// get all Personne 
	@SuppressWarnings("unchecked")
	public List<Personne > getAllPersonne () {
		return dao.getAllPersonne ();
	}
 
 
	// get all Request of Personne 
	@SuppressWarnings("unchecked")
	public List<Request> getAllRequestsOfPersonne (Long pdvId) {
		return dao.getAllRequestsOfPersonne (pdvId);
	}

Merci pour votre aide

**djo.mos** · 26/12/2008, 17h21

Oups, c'est de ma faute

J'ai lu ton premier post un peu trop vite.

J'avais cru qu'il y avait pas de session, mais non, en fait, il s'agit d'autre chose, la fameuse (maudite) LazyInitializationException

et là, c'est plus Hibernate que Spring.

Essaies ceci :
- Crées la personne
- Enregistre là, en écrasant la variable avec ce que te retourne Hibernate
- Idem pour request
et essaies ensuite de faire l'association, mais c'est pas sûr que ça marcherait

Autre chose, la gestion de transactions serait mieux placé dans le service, et non pas dans le DAO.

**hkefi** · 26/12/2008, 17h35

1- J'ai déplacé l'annotation @Transactional sur le service :

Code :

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

1
2
3
4
 
@Service("service")
@Transactional
public class ServiceImpl implements IService {

2- Pour le fameux problème d'hibernate, j'essaye de contourner le problème mais ce n'est pas évident par que je rencontre le même problème pour mes autres entités request <==> pages, etc. en plus dans la même fonction j'ouvre et je ferme beaucoup de fichier XML,

J'ai vu que dans d'autres forum ils proposent de placer un filtre dans le web.xml. mais comme j'utilise une classe main je ne peux pas passer par cette solution à moins que de transformer tous mes fetch = FetchType.EAGER ce qui n'est pas possible par ce que je vais exploser ma mémoire. (très couteux en ressources).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
<filter>
		<filter-name>hibernateFilter</filter-name>
		<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
		<init-param>
			<param-name>sessionFactoryBeanName</param-name>
			<param-value>mySessionFactory</param-value>
		</init-param>
		<init-param>
			<param-name>singleSession</param-name>
			<param-value>false</param-value>
		</init-param>
	</filter>

Il n'existe vraiment pas un autre moyen pour résoudre ce problème ?

**djo.mos** · 26/12/2008, 17h43

Il y aurait une solution peut être (que j'aime pas du tout) :

Mettre ça sur ton EntityManager :

Code :

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

@PersistenceContext(type = PersistenceContextType.EXTENDED)

**hkefi** · 26/12/2008, 18h14

Ca fait quoi cette instruction ? Elle transforme la classe DAO en un EJB statefull ?

**djo.mos** · 26/12/2008, 18h40

Envoyé par hkefi

Ca fait quoi cette instruction ? Elle transforme la classe DAO en un EJB statefull ?

Nope, elle fait en sorte que Spring garde l'EM ouvert entre les différentes transactions, or avant sa durée de vie était la même que celle de la transaction.

Puisque l'EM reste ouvert, les entités restent actives entre les transactions.

**hkefi** · 26/12/2008, 18h46

Ah ca m'arrange très bien ça par ce que je vais des insertion en masse dans la base de données.
Mais je suppose qu'il ne faudra pas pas faire ceci lorsqu'on est en mode normal par ce qu'on retient la ressource ouverte tout au lent de la session de l'utilisateur.
Quand je passerai par une application web pour aller consulter les données, je vais enlever cette ligne mais j'espère que je n'aurais pas la même surprise du LazyInitializationException !
D'ailleurs, as-tu une idée comment configurer ceci dans Spring pour une application web ? passer par le fameux filtre ?

Merci bcp de m'avoir encore une fois aider à résoudre mon problème.

**djo.mos** · 26/12/2008, 18h56

Envoyé par hkefi

Ah ca m'arrange très bien ça par ce que je vais des insertion en masse dans la base de données.
Mais je suppose qu'il ne faudra pas pas faire ceci lorsqu'on est en mode normal par ce qu'on retient la ressource ouverte tout au lent de la session de l'utilisateur.
Quand je passerai par une application web pour aller consulter les données, je vais enlever cette ligne mais j'espère que je n'aurais pas la même surprise du LazyInitializationException !
D'ailleurs, as-tu une idée comment configurer ceci dans Spring pour une application web ? passer par le fameux filtre ?

Merci bcp de m'avoir encore une fois aider à résoudre mon problème.

Dans une application web, si tu veux avoir ce comportement, il faut pas utiliser le filtre OSIV (OpenSessionInView). suffit de faire comem tu fais là, et d'ajouter la configuration nécessaire dans web.xml (listener(s) de Spring).

Cette solution (extended entity manager) est déconseillé car elle n'est pas multithread. je te conseille donc de mettre lle localContainerEMFactory en scope session, donc par conséquent mettre ton service et tes daos dans le même scope.
Mais là, la consommation mémoire risque de faire mal

**hkefi** · 26/12/2008, 19h05

Je pense qu'on s'est pas compris.
la solution avec @PersistenceContext(type = PersistenceContextType.EXTENDED) ne me gene pas maintenant par ce que je suis en mode console batch.

Mais mon application web n'auras pas à faire ce genre de traitement. Elle accédera à la base de données juste en mode lecture pour chercher par exemple pour un utilisateur toutes ses requêtes.

Donc, je vais enlever l'annotation @PersistenceContext devant mon entity manager pour revenir en mode transactionnel normal. Je voulais savoir s'il fallait mettre autre chose dans mon web.xlm ou dans ma conf Spring pour que le mode fetch.Lazy fonctionne normalement ?

Je n'ai pas envie de maintenir mon entity manager ouvert tout au lent de la session de l'utilisateur.

Aurais-tu STP un lien d'une petite application web exemple en Spring et hibernate qui pourrait me servir de point de départ pour développer la mienne ?

**djo.mos** · 26/12/2008, 19h09

Envoyé par hkefi

Mais mon application web n'auras pas à faire ce genre de traitement. Elle accédera à la base de données juste en mode lecture pour chercher par exemple pour un utilisateur toutes ses requêtes.

Donc, je vais enlever l'annotation @PersistenceContext devant mon entity manager pour revenir en mode transactionnel normal. Je voulais savoir s'il fallait mettre autre chose dans mon web.xlm ou dans ma conf Spring pour que le mode fetch.Lazy fonctionne normalement ?

Je n'ai pas envie de maintenir mon entity manager ouvert tout au lent de la session de l'utilisateur.

Non,

je vais enlever l'annotation @PersistenceContext devant mon entity manager pour revenir en mode transactionnel normal

Il te faut toujours cette annotation pour que Spring crée en injecte l'EM dans le DAO.
C'est la partie (type=Extended) qu'il faut virer.

Et pour le cas que tu décris, l'OSIV me semble parfait

**hkefi** · 26/12/2008, 19h12

Merci bcp pour toutes tes réponses et tes explications
Je ferme le post.

**hkefi** · 27/12/2008, 23h49

Excuse moi je n'ai pas fait attention à ta remarque, c'est quoi OSIV ?

**djo.mos** · 28/12/2008, 02h17

Envoyé par hkefi

Excuse moi je n'ai pas fait attention à ta remarque, c'est quoi OSIV ?

Ma faute

Open Session In View

**hkefi** · 28/12/2008, 03h58

Peux-tu me donner un petit exemple ?
Par ailleurs, je t'ai posté un commentaire qui est en relation avec cette discussion sur ton blog

http://blog.developpez.com/djo-mos?t...r_sprin#c37883

Merci

**djo.mos** · 28/12/2008, 04h06

Il s'agit d'ouvrir l'EM à l'arrivé d'une requête, et de le faire partager à tous les DAOs impliqués (qui seront donc de scope request normalement, l'EM peut être stocké dans un thread local), et le fermer à la fin de la reqûete.

De cette façon, quand tu accèdes à un champ lazy dans un service ou lors du rendu de la page résultat, ça passera sans problème.

Spring fournit justement un filtre pareil, que tu as utilisé si on regarde ce post là :p

**hkefi** · 29/12/2008, 10h29

Pour que les autres membres du forum puisses bénéficier de nos échanges, je ne vais pas étendre ce post puisqu'il a été marqué comme étant fermé.
Je vais ouvrir un nouveau pour discuter ce point avec toi en essayant de présenter un exemple si tu le veux bien.

Merci beaucoup pour ta disponibilité et tes promptes réponses.

[SPRING 2.5][Hibernate]Problème de session: LazyInitializationException:no session [Data]

Spring Java

Discussions similaires

Partager

Partager