Discussion :

[zuzuu]

Bonjour à vous !


Dans le cadre de l'utilisation d'hibernate, nous avons du mettre en place le design pattern Facade et utiliser le mécanisme des services et des DAO.
Cependant, il apparait nécessaire, lors d'une opération de sauvegarde par exemple, d'initialiser une session, une transaction, etc...?
J'admets que ces contextes ne me sont pas vraiment familier, mais je n'ai que peu de temps pour les mettre en application. Aussi, je souhaiterais savoir si quelqu'un pouvait m'expliquer comment mettre en place rapidement un certain système utilisant les intercepteurs (spring) m'a t'on dit...
Dois-je télécharger des librairies spring, il y a t'il des classes pré-existentes, auriez vous un exemple concret montrant leur utilisation ?

Je vous remercie pour le temps que vous m'avez accordé, et je vous souhaite une excellente journée.

[foucha]

Bonjour z,

Si tu veux utiliser des intercepteurs spring, j'imagine que c'est pour automatiquement créer une session + transaction avant les méthodes de dao et ferme tout cela apres chacune de ces méthodes.

Tu devrais trouver des réponses en faisant une recherche google / developpez sur "spring transaction" ou "spring aop". Les docs spring sont tres bien faites.

++
Foucha.

[zuzuu]

En effet, c'est exactement ce que je cherche à faire.
Merci pour ta direction, en effet, j'étais du coup en train de lire toute la documentation Hibernate à ce sujet !
Bonne journée à toi !

[zuzuu]

Bonjour Foucha,

J'ai essayé de mettre en place le système aop, pour initialiser les transactions, mais en vain.

En fait, je suis partie sur le principe d'un intercepteur que je lie à la configuration hibernate.

Mais je pense avoir un problème de compréhension.

En fait, dans mon mes classes DAO, j'essaie à l'aide d'hibernate, de récupérer la session, de sauver ou récupérer des données...

D'après ce que j'ai cru comprendre, lorsque je vaux sauver des données, il faut ouvrir une transaction, sauver mes données, puis faire un commit.
Cependant, ensuite la session est close, et pour la prochaine fois que je veux sauver, il faut recommencer ces opérations...

à l'heure actuelle, mon problème vient du fait que je voudrais automatiquement entourer mes appels avec l'initialisation d'une session, transaction, fermeture de la session.

Par exemple, voilà ce qui se produit dans mon code :

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
public class HibernateUtil {
	private static final SessionFactory sessionFactory;
 
	static {
		try {
			Configuration annotationConfiguration = new AnnotationConfiguration()
 
           .addAnnotatedClass(Dossier.class)
            	annotationConfiguration.setInterceptor(new BDInterceptor());
 
 
 
             sessionFactory = annotationConfiguration.configure().buildSessionFactory();	             
 
 
		} catch (Throwable ex) {
			throw new ExceptionInInitializerError(ex);
		}
	}
 
	public static Session getSession() throws HibernateException {
		return sessionFactory.openSession();
	}

D'après ce code, j'en déduis, qu'à chaque appel de la méthode getSession(), c'est une nouvelle session qui est crée.
Donc, dans mes classes DAO, à chaque fois, j'ai bien une session par opération :

Code :

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

1
2
3
4
5
6
7
8
 
public class DAODossierImpl {
...
      public List<Object> getAll() {
		Session session = HibernateUtil.getSession();
		List<Object> results = session.createQuery("from Dossier").list();
		return results;
	}

Cependant, je fais appel à une facade :

Code :

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

1
2
3
4
5
6
7
8
 
public class FacadeDossier {
 
 
	public List<Dossier> getAllDossier() {
		List<Dossier> dossiers = serviceDossier.getAll();
               return dossiers;
	}

qui ne fait qu'appeller un service, qui lui même appel mon DAO :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 
class ServiceDossier {
 
	public List<Dossier> getAll() {
 
		List<Object> dossiers = getIDAO().getAll();
...
		return dossiers;
	}

MA question est donc la suivante, si dans ma facade, j'entoure mon code avec l'initialisation d'une transaction et son commit et que je fermer la session... la prochaine fois que j'appelle HibernateUtil.getSesssion() celle ci pose problème...

J'avoue être un peu perdue...
On m'a conseiller d'utiliser un intercepteur (il est attaché à la configuration de HibernateUtil), celui ci implémente l'interface Intercepteur. Mais celui ci, ne réagissant que lorsque qu'un requete hibernate vas être appelé, je ne sais pas vraiment comment l'entourer de transaction... puisque meme si j'en ouvre une dans l'intercepteur, à aucun moment je ne sais où la fermer, de plus, je voulais savoir, pourquoi ou pourquoi pas, il ne faudrait pas fermer la session de HibernateUtil???

MErci de m'éclairer par votre expérience dans ces nouvelles techno que je découvre...

[foucha]

Je ne connais pas particulierement bien hibernate en fait, ni les transactions.

Mais j'aurais tendance à vouloir éviter de créer une session à chaque fois, car c'est probablement couteux. Et ca voudrait dire qu'avant la fin de la méthode il faudrait avoir committé les requetes dans la base (avec un flush).

Du coup j'utiliserais plutot getCurrentSession dans HibernateUtils, quitte à la créer si elle n'existe pas. Coté intercepteur, tu implémentes des comportements et spécifie quand il se produit. Par exemple, avant et apres l'appel de la méthode. La méthode appelée avant ouvrira une transaction, celle appelé après fermera la transaction.

++
Foucha.

[zuzuu]

Du coup, j'ai utilisé un interceptor...
Cependant, la configuration de celui ci me pose problème, il ne se déclenche pas comme il devrait... Typiquement dès qu'un bean finissant par Business appelle une méthode, il devrait se déclencher...
J'ai vu qu'il fallait enregistrer les beans dans la configuration sinon il était pas pris en compte, mais cela ne fonctionne toujours pas... Tu t'y connais la dedans... ?

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
 
 
<bean id="spring-business-interceptor"
		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="beanNames">
			<list>
				<value>*Business</value>
			</list>
		</property>
		<property name="interceptorNames">
			<list>
				<value>businessInterceptor</value>
			</list>
		</property>
	</bean>
 
<bean id="businessInterceptor"
		class="control.hibernate.BusinessInterceptor"
		abstract="false" singleton="true" lazy-init="default" autowire="default"
		dependency-check="default">
	</bean>
 
<bean id="dossierBusiness" class="control.business.facade.impl.FacadeDossierBusiness" />

C'est tout pour ma config... Sachant que mon intercepteur se charge de récupérer d'ouvrir une session et de l'assigner au composant en ayant besoin... ?
Pourquoi mon intercepteur ne se déclenche pas ?

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
 
public class BusinessInterceptor implements MethodBeforeAdvice,
                                                    AfterReturningAdvice,
                                                    ThrowsAdvice {
 
    public void before(Method m, Object[] args, Object targetObject)
                throws Throwable {
    	System.out.println("BeforeInterceptor");
        Session session = openSession();
        Transaction t = session.beginTransaction();
        Class[] paramsType = { Session.class };
        Object[] params = { session };
        targetObject.getClass().getMethod("setSession", paramsType)
                    .invoke(targetObject, params);
    }
 
    public void afterThrowing(Method m, Object[] args, Object targetObject,
                              Exception ex) throws Throwable {
    	System.out.println("After");
        closeSession(getSession(targetObject));
        throw new Exception(ex);
    }
 
    private Session getSession(Object targetClass) throws Throwable {
    	System.out.println("getSession");
        return (Session) targetClass.getClass().getMethod("getSession", null)
                                    .invoke(targetClass, null);
    }
 
    private Session openSession() {
    	System.out.println("openSession");
    	return HibernateUtil.getSession();
    }
 
    private void closeSession(Session session) {
    	System.out.println("closeSession");
        if (session != null) {
            session.close();
        }
    }
 
    public void afterReturning(Object returnValue, Method m, Object[] args,
                               Object targetObject) throws Throwable {
    	System.out.println("afterReturing");
        Session session = getSession(targetObject);
        if (session != null) {
            Transaction t = session.getTransaction();
            if (t != null) {
                t.commit();
            }
        }
        closeSession(session);
    }

Snif ?