Discussion :

[hugo123]

Salut,
J'utilise Spring et Hibernate pour le portage d'une appli.
On m'avait conseillé d'utiliser Spring et d'étendre de HibernateDAOSupport pour pouvoir utiliser le HibernateTemplate.

Cependant, dans la doc de Spring :

http://www.springframework.org/docs/...aoSupport.html

En gras, ils semblent décourager son utilisation pour hibernate 3

Un utilisateur de spring et hibernate 3 pour un commentaire ? ^^

[fr1man]

J'utilise Hibernate 3 et Spring mais pas HibernateDAOSupport.
Je crée de simples DAO avec injection de la sessionFactory via Spring.
On est un peu moins dépendant de spring dans ce cas là.

[Ioan]

Bonjour,

Cependant, dans la doc de Spring :

http://www.springframework.org/docs/...aoSupport.html

En gras, ils semblent décourager son utilisation pour hibernate 3

Ou as tu vu dans l'API que s'est déconseillé ?

Ceci dit, il y a une package spécifique pour hibernate 3.

@+

[hugo123]

Désolé, le lien est effectivement mauvais, voici le bon :

http://www.springframework.org/docs/...eTemplate.html

[Ioan]

Salut,
Si tu parles de la remarque "As of Hibernate 3.0.1, transactional ...", tu peux trouver un exemple d'implémentation dans la doc Spring : Implementing DAOs based on plain Hibernate3 API.
Ils y expliquent les avantages, notamment ce qu'a dit fr1man .
L'implémentation "classique", à base de HibernateDaoSupport, est juste au dessus.
@+

[hugo123]

Je continue a regarder et j'avoue être perdu. Je rencontre x façons différentes de faire et pas vraiment de prise de position sur le fait que ce soit une bonne ou une mauvaise pratique par les auteurs.

Dans l'article qui vient de paraitre :

http://zekey.developpez.com/articles/spring/

Concernant hibernate, l'article utilise le hibernate template, on obtient donc une méthode delete comme suit :

Code :

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

1
2
3
4
5
6
7
8
public void deleteEmployee(String pEmployeeId) {
		List l=getHibernateTemplate().find(
		"from EmployeeDto e where e.employeeId='"+pEmployeeId+"'");
		if(l.size()>0){
			EmployeeDto ret=(EmployeeDto)l.get(0);
			getHibernateTemplate().delete(ret);
		}
	}

Et la même sans 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
 
public void deleteEmployee(String pEmployeeId) {
		tx=session.beginTransaction();
		try{		
 
			List l=session.find("from EmployeeDto e where e.employeeId='"
			+pEmployeeId+"'");
			if(l.size()>0){
				EmployeeDto ret=(EmployeeDto)l.get(0);
				session.delete(ret);
			}
 
			tx.commit();
		}catch(Exceptiom e){
 
		}
	}

Spring indique qu'en hibernate 3, il faut passer par la session (la raison m'est encore un peu floue). Ils indiquent donc de passer par SessionFactory.getCurrentSession().
Donc par exemple pour une méthode delete :

Code :

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

1
2
3
4
5
6
    /**
     * Delete an object.
     */
    public void delete(Object obj) {
        getSessionFactory().getCurrentSession().delete(obj);
    }

Mais pour être honnête, celle ci j'ai pas réussi la faire fonctionner, j'obtiens une exception.
Donc a la place j'ai écris celle ci qui fonctionne :

Code :

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

1
2
3
4
5
6
7
8
    /**
     * Delete an object.
     */
    public void delete(Object obj) {
        Session session = getSession();
        session.delete(obj);
        releaseSession(session);
    }

On note donc maintenant l'obligation de faire le getSession et le releaseSession à chaque fois.

Quels sont vos facons d'écrire les DAO ? Certains sont-ils déconseillés ?

[fr1man]

J'utilise cette méthode :

Code :

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

1
2
3
4
5
6
 
    private SessionFactory sessionFactory;
 
    public void delete(Object obj) {
        sessionFactory.getCurrentSession().delete(obj);
    }

La sessionFactory étant injectée via Spring.

[zekey]

(Spring's LocalSessionFactoryBean automatically supports Spring transaction management for the Hibernate3 getCurrentSession() method.)

Je suis d'accord, la nouvelle méthode est plus propre puisque il n'y a pas de nécessité d'étendre une classe de Spring (concept qui est de toutes facons contracdictoire avec la philosophie de Spring).

[hugo123]

Je teste mais autant ceci fonctionne

Code :

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

1
2
3
 Session session = getSession();
        session.delete(obj);
        releaseSession(session);

Si j'hérite de la classe de HibernateDAOSupport

Autant

Code :

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

1
2
3
    public void delete(Object obj) {
        getSessionFactory().getCurrentSession().delete(obj);
    }

Ne fonctionne pas, que je dérive de HibernateDAOSupport ou non (en ajoutant un sessionFactory en private si je dérive pas)

Par exemple sur le find

Code :

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

        Accounts account = (Accounts) getSessionFactory().getCurrentSession().get(Accounts.class, id);

J'ai l'exception suivante :

Code :

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

1
2
3
4
5
org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here
	at org.springframework.orm.hibernate3.LocalSessionFactoryBean$TransactionAwareInvocationHandler.invoke(LocalSessionFactoryBean.java:1175)
	at $Proxy0.getCurrentSession(Unknown Source)
	at net.sf.l2j.loginserver.dao.impl.AccountsDAOHib.findById(AccountsDAOHib.java:49)
	at net.sf.l2j.loginserver.dao.AccountsDAOTest.testFindAccount(AccountsDAOTest.java:73)

Ma configuration est :

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
<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="hibernateProperties">
			<props>
			   <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
			   <prop key="hibernate.show_sql">true</prop>
			   <prop key="hibernate.c3p0.min_size">1</prop>
			   <prop key="hibernate.c3p0.max_size">20</prop>
			   <prop key="hibernate.c3p0.timeout">0</prop>
			   <prop key="hibernate.c3p0.max_statement">100</prop>
			   <prop key="hibernate.c3p0.idle_test_period">60</prop>
		       <prop key="hibernate.c3p0.acquire_increment">5</prop>
		       <prop key="hibernate.c3p0.autocommit">false</prop>			   			   			   
			   <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
			</props>
		</property>
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath:/net/sf/l2j/loginserver/beans/</value>
			</list>
		</property>
	</bean>
 
   	<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
		<property name="driverClass">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="jdbcUrl">
			<value>jdbc:mysql://localhost/l2jdbtest</value>
		</property>
		<property name="user">
			<value>root</value>
		</property>
		<property name="password">
			<value></value>
		</property>
	</bean> 
 
    <bean id="AccountDataDAO" class="net.sf.l2j.loginserver.dao.impl.AccountDataDAOHib">		
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
	</bean>

Une idée ?

[gronono]

Salut, je réponds peut-être un peu tard mais je n'avais pas lu ton post avant.

Il faut demander à spring d'ouvrir la transaction avant de faire :

Code :

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

getSessionFactory().getCurrentSession()

et de la fermer à la fin de la méthode (commit ou rollback)

Pour cela tu dois ajouter dans ton fichier de 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
 
<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
 
	<bean id="transactionInterceptor"
		class="org.springframework.transaction.interceptor.TransactionInterceptor">
		<property name="transactionManager" ref="transactionManager" />
		<property name="transactionAttributes">
			<props>
				<!-- prop key="insert*">PROPAGATION_REQUIRED</prop>
					<prop key="update*">PROPAGATION_REQUIRED</prop -->
				<prop key="*">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>
 
	<bean id="autoProxyCreator"
		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="interceptorNames">
			<list>
				<idref local="transactionInterceptor" />
			</list>
		</property>
		<property name="beanNames">
			<list>
				<idref local="AccountDataDAO" />
			</list>
		</property>
	</bean>

En espérant de t'avoir quand même aider.
A+