Discussion :

[Gildas Huart]

Bonjour,

En écrivant les méthodes de manipulation de ma base de données via Hibernate, je me suis posé quelques questions qui m'ont un peu chamboulé.

J'écrivais initialement un delete de la maniète suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public void insertPalette(Palette palette) throws Exception {
 
	Session session = this.getSession();
	Transaction transaction = session.beginTransaction();
 
	session.save(palette);
 
	transaction.commit();
	session.close();
 
}

Cela implique que je récupère dans la classe appelant cette méthode avec un try et un catch.
C'est déjà un premier choix.
Mais au final, j'aurais pu gérer directement l'erreur dans la classe.
J'ai en fait choisi de le gérer aux deux niveaux :
- au niveau de ce qu'on appellera ma classe DAO, qui gère la manipulation des données de la base
- au niveau de ma classe métier qui fait appelle à ma classe DAO pour savoir que faire en fonction de son résultat.

Cependant, je me demande comment gérer une exception.
Je m'expliquer, voici ma classe DAO réécrite :

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
 
public void insertPalette(Palette palette) throws Exception{
 
	Session session = null;
	Transaction transaction = null;
 
	/* récupération de la session */
	try{
		session = this.getSession();
	}
	catch(HibernateException he){
		System.out.println ("   Impossible de récupérer la session hibernate");
		System.out.println ("   Erreur hibernate : " + he.toString());
		throw new Exception("   Impossible d'insérer une palette dans la base !");
	}
 
	/* début de la transaction */
	try{
		transaction = session.beginTransaction();
	}
	catch(HibernateException he){
		session.close(); 				// fermeture de la session
		System.out.println ("   Impossible de démarrer une transaction hibernate");
		System.out.println ("   Erreur hibernate : " + he.toString());
		throw new Exception("   Impossible d'insérer une palette dans la base !");
	}
 
	/* insertion de la palette dans la base */
	try{
		session.save(palette);
	}
	catch(HibernateException he){
		transaction.rollback(); // annulation de la transaction
		session.close();				// fermeture de la session
		System.out.println ("   Erreur hibernate : " + he.toString());
		throw new Exception("   Impossible d'insérer une palette dans la base !");
	}
 
		/* validation de la transaction */
		try{
			transaction.commit();
		}
		catch(HibernateException he){
			transaction.rollback(); // annulation de la transaction
			session.close();				// fermeture de la session
			System.out.println ("   Impossible de valider la transaction !");
			System.out.println ("   Erreur hibernate : " + he.toString());
			throw new Exception("   Impossible d'insérer une palette dans la base !");
		}
 
		/* fermeture de la session */
		try{
			session.close();
		}
		catch(HibernateException he){
			System.out.println ("   Impossible de fermer la session !");
			System.out.println ("Erreur hibernate : " + he.toString());
			throw new Exception("Impossible d'insérer une palette dans la base !");
		}
 
 
}

Si la méthode

Code :

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

this.getSession()

échoue, je récupère l'erreur et j'en renvois une au métier.
Pour celle là, aucun problème.

Par contre, pour la deuxième méthode, c'est déjà plus compliqué :

Code :

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

1
2
 
transaction = session.beginTransaction();

Si cette méthode échoue, je récupère l'exception, et je ferme la session ouverte.
Cependant, si je teste l'ouverture de la session, je dois donc tester la fermeture de la session également.

Dois-je donc faire un try/catch du genre :

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
 
/* début de la transaction */
	try{
		transaction = session.beginTransaction();
	}
	catch(HibernateException he){
		try{
			session.close(); 				// fermeture de la session
		}
		catch(HibernateException){
			//gestion de l'erreur
		}
		System.out.println ("   Impossible de démarrer une transaction hibernate");
		System.out.println ("   Erreur hibernate : " + he.toString());
		throw new Exception("   Impossible d'insérer une palette dans la base !");
	}

?

Si oui, cela complique énormément les choses, car j'aurais quasiment un code de longueur exponentielle !

L'option finally est elle faite pour gérer ce genre de problème ?


N'aurais-je pas interêt à placer toutes mes méthodes dans un unique try ?
Ce serait plus simple, mais cela m'empecherait de fermer une session éventuellement ouverte !


En réflchissant à tout ça, je m'emmêle les pinceaux, et j'ai besoin d'un avis confirmé pour me clarifier l'esprit.

Merci de me sortir de l'obsurité !

[ghorgor]

Dejà, il y a plusieurs levées d'exception au sein de ta methode, que tu fais en double...

Quand tu fais ton session.save(palette); et quand tu fais ton transaction.commit(); la levée d'exception que tu fais est identiquement la meme... Meme les messages sont les memes... Tu aurais interet a les regrouper au sein du meme Try/catch...

Ensuite tu leves tout le temps le meme type d'exception, tout au long de ton code... Pour clarifier l'ensemble, je mettrais a ta place des variables locales permettant de suivre l'evolution de ton appli, (En String, ou en tableaux de String, ou en Vector de String, ou autre tu as le choix), et je mettrai le tout dans un seul bloc try/catch. Si une exception est levee, je ferai le necessaire au niveau du catch, a partir des variables de suivi, pour faire le Rollback, la fermeture de session, ou autre, suivant les cas...
Ca t'economiserai quelques lignes, je pense...

Enfin, si tu veux effectivement etre sur de fermer ta session a la fin, Finally me semble etre le bon choix, vu que son but est de s'executer, quel que soit le deroulement du code precedent...

Enfin, si je ne me trompe pas !

[Gildas Huart]

Dejà, il y a plusieurs levées d'exception au sein de ta methode, que tu fais en double...

Quand tu fais ton session.save(palette); et quand tu fais ton transaction.commit(); la levée d'exception que tu fais est identiquement la meme... Meme les messages sont les memes... Tu aurais interet a les regrouper au sein du meme Try/catch...

=> ok, j'ai fusionné ces 2 try !

Ensuite tu leves tout le temps le meme type d'exception, tout au long de ton code... Pour clarifier l'ensemble, je mettrais a ta place des variables locales permettant de suivre l'evolution de ton appli, (En String, ou en tableaux de String, ou en Vector de String, ou autre tu as le choix), et je mettrai le tout dans un seul bloc try/catch. Si une exception est levee, je ferai le necessaire au niveau du catch, a partir des variables de suivi, pour faire le Rollback, la fermeture de session, ou autre, suivant les cas...
Ca t'economiserai quelques lignes, je pense...

=> je vois ce que tu veux dire, mais en fait, je voulais effectuer les actions (rollback, session.close) en fonction de l'endroit ou je me situais.
remarque, je peux le faire avec une variable de suivi !

Enfin, si tu veux effectivement etre sur de fermer ta session a la fin, Finally me semble etre le bon choix, vu que son but est de s'executer, quel que soit le deroulement du code precedent...

Enfin, si je ne me trompe pas !

Là par contre, je fais un try dans le finally ?
Car aprés tout, si la méthode getSession peut lancer une exception, la méthode session.close également non ?

[Gildas Huart]

J'obtiens maintenant ce genre de méthode, mais je ne devrais peut être avoir un entier qui me permette de faire des comparaison de niveau afin d'avoir un semblant de chronlogie, et savoir exactement quelle action déclencher en cas d'exception, en fonction de l'étape où elle a été levée :

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
	public void insertPalette(Palette palette) throws Exception{
 
		Session session = null;
		Transaction transaction = null;
		String etape = "";
 
		try{
			etape = "récupération de la session";
			session = this.getSession(); 							// récupération de la session
			etape = "démarrage la transaction";
			transaction = session.beginTransaction();	// début de la transaction
			etape = "insertion de l'objet dans la base";
			session.save(palette);										// insertion de l'objet
			etape = "validation la transaction";
			transaction.commit(); 										// validation de la transaction
		}
		catch(HibernateException he){
			transaction.rollback();
			System.out.println("   Erreur à l'étape : " + etape);
			System.out.println("   Erreur hibernate : " + he.toString());
			throw new Exception("   Impossible d'insérer une palette dans la base !");
		}
		finally{
			session.close();													// fermeture de la session
		}
}

[pimousse76]

juste une remarque (pas le temps de regarder ton code), tu devrais utiliser des System.err et non des System.out dans le cas de gestion d'erreurs et d'exception.
System.err garantit la "chronologie" des messages.

[Gildas Huart]

La chronologie des messages ?
Le System.out n'assure pas qu'un message soit afficher avant un message qui serait envoyé aprés ??

[thibaut]

Ceci dit pour info les System.out et System.err sont proscris car trop lent, parceke le System.out.println fonctionne de façon synchrone, il vo mieux lui préféré un system de log genre log4j commonLogging ou autre qui travaille de manière asynchrone...

A+

[Gildas Huart]

J'ai du mal à configurer log4j, j'ai le .jar, et j'ai un truc du genre :

Code :

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

1
2
3
4
5
    <env-entry> 
      <env-entry-name>LOG4J/PropFile</env-entry-name>
      <env-entry-value>C:\J2EE\IntranetV2\WEB-INF\src\log4j.xml</env-entry-value>
      <env-entry-type>java.lang.String</env-entry-type>
    </env-entry>

dans mon web.xml (je travaille en fait sur tomcat/mysql) mais je suppose que c'est pour un autre post vu la complexité de ce truc