Discussion :

[thefutureisnow]

Salut,

Je bosse sur une appli sous eclipse qui utilise tomcat et hibernate, j'ai nécessité de la modifier pour configurer dynamiquement la classe : HibernateSessionFactory.java avec une variable de session (qui dépend du login de l'utilisateur)

Celle ci est récupérable dans le code d'une jsp via cette variable :
#{sessionScope.utilisateur.datasource}

J'aimerais savoir comment récupérer cette variable dans cette classe.

Si un maitre java pouvait éclairer ma petite lanterne, ca serait génial!

Par avance merci !

[aragon]

Hello,

Pourrais-tu fournir plus de détails sur ton application: les technos utilisées, l'architecture, les différentes couches...

Sans ça... je ne peux pas t'aider.

A plus

[thefutureisnow]

Salut,

Merci de ta réponse, en faite c'est un projet utilisant donc hibernate et richfaces.
L'application fonctionne avec un logging d'une personne sr une base principale, quand l'utilisateur se logue l'appli extrait plusieurs champs dont un champs "datasource", ces informations sont ensuite stockés en session.

Mon objectif est de reconfigurer hibernate à chaque fois qu'un utilisateur se logue. J'ai eu l'idée de faire une classe listener de session qui à la création de la variable session "utilisateur" modifis la configuration hibernate et à la destruction de la session la sessionfactory de hibernate.

Sauf que c'est assez instable...
Je me pose donc la question de savoir si en utilisant plusieurs sessionfactory (1 par datasource) ca ne serait pas mieux ?

Je sais pas si j'ai été clair sur le topo ! Je dois avouer que je nage un peu dans le flou... :/

[tchize_]

si ce sont des bases différentes, effectivement, il vaux mieux une sessionfactory par utilisateur. Pour récupérer ton information, les infos disponibles dépendront d'à quel endroit dans ton code tu te trouve. Par exemple, si t'es dans une bean JSF, le mieux est de passer par une managed-property dans ton faces-config.xml. Si t'est dans un filtre servlet, ou dans une servlet, le mieux est de passer par l'objet HttpSession qui y est disponible.

[thefutureisnow]

Merci de tes éclaircissements,

En faite, par exemple, j'ai une classe bean de cette structure :

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package lims.jsf.service;
 
import java.util.Collection;
import java.util.List;
import lims.jsf.filtre.FiltreProduit;
import lims.jsf.hibernate.HibernateSessionFactory;
import lims.jsf.model.Fournisseur;
import lims.jsf.model.Produit;
import org.hibernate.Criteria;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Expression;
import org.hibernate.criterion.Restrictions;
 
 
public class SrvProduit {
 
	public List<Produit> list(FiltreProduit filtre) {
 
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
 
		Criteria cr = session.createCriteria(Produit.class);
		if (filtre.getLib() != null && !"".equals(filtre.getLib())) {
			cr.add(Restrictions.like("libelle", filtre.getLib() + '%'));
		}
		if (filtre.getSecteur() != null && !"".equals(filtre.getSecteur())) {
			cr.createCriteria("secteur").add(Restrictions.like("libelle", filtre.getSecteur() + '%'));
		}
		if (filtre.getSsecteur() != null && !"".equals(filtre.getSsecteur())) {
			cr.createCriteria("soussecteur").add(Restrictions.like("libelle", filtre.getSsecteur() + '%'));
		}
		if (filtre.getFournisseur() != null && !"".equals(filtre.getFournisseur())) {
			cr.createCriteria("fournisseur").add(Restrictions.like("libelle", filtre.getFournisseur() + '%'));
		}
 
		List<Produit> res = cr.list();
 
		tr.commit();
 
		return res;
 
	}
 
 
	public Collection<Produit> list() {
		Session session = HibernateSessionFactory.getSession();
		//session.clear();
		Transaction tr = session.beginTransaction();
		Criteria cr = session.createCriteria(Produit.class);
		List<Produit> res = cr.list();
		tr.commit();
		session.close();
		return res;
 
	}
 
 
	public Collection<Produit> listPF(Fournisseur fournisseur) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
		Criteria cr = session.createCriteria(Produit.class);
		cr.add(Expression.eq("fournisseur", fournisseur));
 
		Collection<Produit> res = cr.list();
		tr.commit();
		return res;
	}
 
 
	public void supprimer(Produit produit) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
		session.delete(produit);
		tr.commit();
 
	}
 
 
	public Produit retourner(Long id) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
		Produit produit = (Produit) session.get(Produit.class, id);
 
		tr.commit();
 
		return produit;
	}
 
 
	public List<Fournisseur> list(String produit) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
		SQLQuery query = session.createSQLQuery("selected * from produit where libelle=" + produit).addEntity(Produit.class);
 
		List res = ((Criteria) query).list();
		tr.commit();
		return res;
	}
 
 
	public void add(Produit prod) {
 
		Session session = HibernateSessionFactory.getSession();
		session.clear();
		Transaction tr = session.beginTransaction();
 
		session.save(prod);
		tr.commit();
	}
 
 
	public void update(Produit produit) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
		session.update(produit);
		tr.commit();
	}
 
 
	public List<Produit> ListProduitFournisseur(Fournisseur fournisseur) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tr = session.beginTransaction();
		Criteria cr = session.createCriteria(Produit.class);
		cr.add(Expression.eq("fournisseur", fournisseur));
		List<Produit> res = cr.list();
		tr.commit();
		return res;
	}
}

Ce bean appel la classe HibernateSessionFactory.java pour récupérer les données, c'est pour l'instant dans cette classe que j'ai modifié comme ceci :

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
package lims.jsf.hibernate;
 
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
 
 
public class HibernateSessionFactory {
 
	private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
	private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
	private static Configuration configuration = new Configuration();
	private static org.hibernate.SessionFactory sessionFactory;
	private static String configFile = CONFIG_FILE_LOCATION;
	private static String dsource = "";
 
 
	private HibernateSessionFactory() {
 
	}
 
 
	public static Session getSession() throws HibernateException {
 
		Session session = (Session) threadLocal.get();
		if (session == null || !session.isOpen()) {
			if (sessionFactory == null) {
				//MODIF A VERIFIER
				System.out.println("########## REBUILD : " + dsource);
				rebuildSessionFactory(dsource);
			}
			session = (sessionFactory != null) ? sessionFactory.openSession() : null;
			threadLocal.set(session);
		}
 
		return session;
 
	}
 
 
	public static void rebuildSessionFactory(String datasource) {
 
		dsource = datasource;
 
		System.out.println("### CONFIG HIBERNATE AVEC DATASOURCE : " + dsource);
 
		try {
			configuration = new Configuration();
			configuration.configure(configFile);
 
			//reconfiguration du datasource en fonction de l'utilisateur
			configuration.setProperty("hibernate.connection.datasource", "java:comp/env/" + dsource);
 
			sessionFactory = configuration.buildSessionFactory();
 
		} catch (Exception e) {
			System.err.println("%%%% Error Creating SessionFactory %%%%");
			e.printStackTrace();
		}
	}
 
 
	public static void closeSession() throws HibernateException {
 
		Session session = (Session) threadLocal.get();
		threadLocal.set(null);
 
		if (session != null) {
			session.close();
			System.out.println("FERMETURE SESSION HIBERNATE");
		}
	}
 
 
	public static org.hibernate.SessionFactory getSessionFactory() {
 
		return sessionFactory;
	}
 
 
	public static void setConfigFile(String configFile) {
 
		HibernateSessionFactory.configFile = configFile;
		sessionFactory = null;
	}
 
 
	public static Configuration getConfiguration() {
 
		return configuration;
	}
 
}

Et enfin ma classe SessionListener :

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
package lims.jsf.hibernate;
 
import java.util.HashMap;
import java.util.Iterator;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
 
 
public class SessionListener implements ServletContextListener, HttpSessionAttributeListener, HttpSessionListener {
 
	private ServletContext context = null;
	private HashMap<String, HttpSession> sessions = new HashMap<String, HttpSession>();
	private static SessionListener me;
 
 
	public void attributeAdded(HttpSessionBindingEvent event) {
 
		System.out.println(("attributeAdded('" + event.getSession().getId() + "', '" + event.getName() + "', '"
				+ event.getValue() + "')"));
 
		//on récupère le datasource quand la session utilisateur est renseigné
		if ("utilisateur".equalsIgnoreCase(event.getName())) {
			HibernateSessionFactory.rebuildSessionFactory(event.getValue().toString());
 
		}
 
	}
 
 
	public void attributeRemoved(HttpSessionBindingEvent event) {
 
		//System.out.println("attributeRemoved('" + event.getSession().getId() + "', '" + event.getName() + "', '"
		//		+ event.getValue() + "')");
 
	}
 
 
	public void attributeReplaced(HttpSessionBindingEvent event) {
		System.out.println(("attributeReplaced('" + event.getSession().getId() + "', '" + event.getName() + "', '"
				+ event.getValue() + "')"));
 
	}
 
 
	public void contextDestroyed(ServletContextEvent event) {
		System.out.println("contextDestroyed()");
		this.context = null;
 
	}
 
 
	public void contextInitialized(ServletContextEvent event) {
 
		this.context = event.getServletContext();
		System.out.println("contextInitialized()");
 
	}
 
 
	public void sessionCreated(HttpSessionEvent event) {
		sessions.put(event.getSession().getId(), event.getSession());
 
		System.out.println("sessionCreated('" + event.getSession().getId() + "')");
	}
 
 
	public static SessionListener getInstance() {
		return me;
	}
 
 
	public Iterator<HttpSession> getSessions() {
		return sessions.values().iterator();
	}
 
 
	public void sessionDestroyed(HttpSessionEvent event) {
		sessions.remove(event.getSession().getId());
		System.out.println("sessionDestroyed('" + event.getSession().getId() + "')");
		//on ferme la sessionfactory dès la destruction de la session
		HibernateSessionFactory.closeSession();
	}
 
}

Je vois pas trop comment modifier le bean pour qu'il puisse bien prendre en compte la bonne factory et pas rester avec une ancienne sessionfactory en memoire ...

[tchize_]

puisque tu travaille avec une threadlocal et un session listener, le plus porpre serait peut etre

1) dans le session listener tu créer un session factory associée à l'utilisateur, tu l'associe aussi au thread courant via ton threadlocal.set(....)
2) dans le requestfilter (à créer) tu récupère la session factory depuis la session http, et tu la stock dans le threadlocal avant de faire le forward vers la requete en elle meme. A coté de ca, après l'exécution de la requete, tu nettoie la treadlocal (set(null))

J'espère que tu a peu d'utilisateurs et un bonne raison de devoir travailler avec des connections différenciées par utilisateur, parce qu'une session factory hibernate, c'est long à initialiser et c'est emcombrant en mémoire.

[thefutureisnow]

Merci de ta réponse, je vois à peut près ce que tu veux faire, mais là manière de le mettre en place me semble un peu obscure mais je vais essayer de me documenter là dessus ^^

EDIT: j'ai lu quelque part que l'utilisation de Spring serait possible, ca pourrait être plus simple et fiable ou non ?

[tchize_]

je ne connais pas spring a fond, mais autant que je sache, il est pas prévu pour gérer des Factories multiple coté hibernate.

[thefutureisnow]

Salut,

Je ne sais pas si c'est trop demandé, mais je vois pas trop comment mettre ca en place dans mon cas :/ Tu pourrais me donner quelques pistes de code à mettre en place ?

Merci encore !

[tchize_]

ta factory, actuellement, tu la stocke ou? Ta gestion de la factory tu compte la mettre ou? Dans un bean jsf? Dans un threadlocal? Y a plein de codes possible suivant la manière dont tu veux gérer çà et suivant l'architecture de ton application.

[thefutureisnow]

tchize_ en faite c'est mon session listener qui doit s'occuper de créer la session factory en fonction du login de l'utilisateur pour qu'il attaque une base de donné précise (même structure entre elles). Donc passage de variable "currentSession(String ds)".
Le session factory en cours de l'utilisateur est ensuite appelée par une classe DAO via currentSession() car cette classe n'a pas accès à la variable de session.

Je reviens donc à la charge avec mon fameux session factory, j'essaye de créer un hashmap de sessionfactory avec une variable datasource, voici ma classe :

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
 
public class HibernateUtil {
 
	private static HashMap<String, SessionFactory> sessionFactoryMap = new HashMap<String, SessionFactory>();
	private static Configuration configuration = new Configuration();
	private static String datasource = null;
	public static final ThreadLocal session = new ThreadLocal();
 
 
	public static Session currentSession() throws HibernateException {
 
		System.out.println("currentSession 1 : " + datasource);
		return currentSession(datasource);
	}
 
 
	public static Session currentSession(String ds) throws HibernateException {
 
		datasource = ds;
 
		System.out.println("currentSession 2 : " + ds);
 
		SessionFactory s = sessionFactoryMap.get(ds);
		if (s == null) {
 
			try {
				configuration = new Configuration();
				configuration.configure("/hibernate.cfg.xml");
 
				//reconfiguration du datasource en fonction de l'utilisateur
				configuration.setProperty("hibernate.connection.datasource", "java:comp/env/" + ds);
 
				s = (SessionFactory) sessionFactoryMap.get(ds).openSession();
				s = configuration.buildSessionFactory();
				sessionFactoryMap.put(ds, s);
				session.set(sessionFactoryMap.get(ds));
			} catch (Exception ex) {
				System.out.println("ERREUR DE FACTORY : " + ex.getMessage());
			}
 
		}
 
		return (Session) s;
	}
 
 
	public static void closeSession() throws HibernateException {
 
		System.out.println("closeSession 1 : " + datasource);
		closeSession(datasource);
	}
 
 
	public static void closeSession(String ds) throws HibernateException {
 
		System.out.println("closeSession 2 : " + ds);
 
		datasource = ds;
 
		SessionFactory s = (SessionFactory) sessionFactoryMap.get(ds);
		session.set(null);
		if (s != null)
			s.close();
		sessionFactoryMap.remove(ds);
	}
}

Visiblement quelque chose coince mais je ne situe pas l'erreur :/

[tchize_]

Si tu stocke ta sessionfactory dans ta session utilisateur, tu n'a aucun besoin de la stocker dans ton Hibernate util. Ton schema devrais être le suivant:

HTTP Session create -> créer un session factory hibernate la stocker dans http session
HTTP Session destroy-> récupérer la session factory depuis la session http et la détruire.


Ensuite, en parallère, pour chaque requete

début de requete -> récupérer la session factory hibernate dans la session http, la stocker dans un ThreadLocal quelque part
plein d'appels à ton DAO -> récuperer la session factory depuis le Thread local, créer la session hibernate , faire les opération, détruire la session
fin de la requete -> détruire les éventuelles sessions restantes

Voilà pour la version pesudo propre (perso je trouve moche de faire plusieurs session factory, une par user, hibernate n'est pas concu dans cette optique)

Pour ce qui est de ton code, je ne vois pas ce qui "coince". Par contre, il est très curieux de détruire les session factory dès que tu cloture un session. N'oublie pas qu'une session factory hibernante, ca peut mettre plusieurs secondes à démarrer, ca bouffe pas mal de ressources (création des proxy nottement) et ca risque de finir par encombrer ton classloader. Ne cloture une sessions factory que quand le user n'en aura définitivement plus besoin. De plus ta hashmap n'est pas protégées contre les accès concurrents, ce qui est dangereux!

[thefutureisnow]

En faite ce n'est pas une datasource par utilisateur, disons qu'il y a 20 datasources différentes et 50 utilisateurs par exemple, plusieurs utilisateurs donc sur la même datasource.

J'ai effectué quelques modifications dans mon HibernateUtil,

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
 
 
public class HibernateUtil {
 
	private static HashMap<String, SessionFactory> sessionFactoryMap = new HashMap<String, SessionFactory>();
	private static Configuration configuration = new Configuration();
	private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
	private static org.hibernate.SessionFactory sessionFactory;
 
 
public static void currentSession(String datasource) throws HibernateException {
 
		System.out.println("### CONFIG HIBERNATE AVEC DATASOURCE : " + datasource);
 
		try {
 
			if (!sessionFactoryMap.containsKey(datasource)) {
				System.out.println("SESSION FACTORY ABSENTE DE LA MAP, CREATION DE LA SESSION FACTORY");
 
				configuration = new Configuration();
				configuration.configure("/hibernate.cfg.xml");
 
				//reconfiguration du datasource en fonction de l'utilisateur
				configuration.setProperty("hibernate.connection.datasource", "java:comp/env/" + datasource);
 
				sessionFactory = configuration.buildSessionFactory();
				//on stock la session factory dans la map
				sessionFactoryMap.put(datasource, sessionFactory);
				System.out.println("NB SESSION FACTORY : " + sessionFactoryMap.size());
 
			} else {
				System.out.println("SESSION FACTORY PRESENTE DANS LA MAP");
 
				sessionFactory = sessionFactoryMap.get(datasource);
			}
 
		} catch (Exception e) {
			System.err.println("%%%% Error Creating SessionFactory %%%%");
			e.printStackTrace();
		}
	}
}

Il me créer bien mes sessionfactory dans mon hashmap, mais étrangement si je me logue avec un utilisateur utilisant la datasource X puis un utilisateur avec datasource Y et que je me relogue en datasource X, il va bien chercher la bonne session factory mais j'aurais parfois les données de la datasource Y dans mon appli

[tchize_]

hibernate est pas vraiment prévu pour des factory multiples sur les mêmes classes. T'a vérifié que ton cache de second niveau est bien désactivé? De plus, tu dois protéger les accès concurrent à ta hashmap

[thefutureisnow]

Le cache de second niveau ? J'ai fais une recherche sur cette expression :
"<cache usage="
Mais dans les fichiers du projet, aucune correspondance... Je pense qu'il est donc désactivé par défaut...

Je me rend compte que hibernate n'est visiblement pas fais pour gérer de multiple session factory, vu comment j'en bave :/ ... Mais j'ai pas trop le choix vis à vis de l'existant du projet

[tchize_]

après vérifications, de toutes facons le cache est associé à la factory, donc ca ne devrais pas jouer. Je pencherais plus pour un problème liée à ton code (cache de données, appels non synchronizés à des données centrales, etc)