Discussion :

[sragons]

Bonjour a tous,
Je traite les exceptions de la facon suivante

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
 
public class A{
 public void methodeA()
  throws OscarException 
  {
    try 
    {
	...
	if(erreur)
		throw new OscarException("A", "methodeA", "message");
    } 
    catch (Exception e) 
    {
      e.printStackTrace();
      logger.error("Erreur inconnue: " + e.getMessage());
		throw new OscarException("A", "methodeA", "cause A");());
    }
  }
}
 
public class B{
 public void methodeB()
  throws OscarException 
  {
    try 
    {
	....
	instanceDeA.methodeA();
    } 
    catch (Exception e) 
    {
      e.printStackTrace();
      logger.error("Erreur inconnue: " + e.getMessage());
		throw new OscarException("B", "methodeB", "cause B");());
    }
  }
}

De cette facon je traite toutes les exceptions possibles dans chaque methode.
Le probleme c'est que si une OscarException se produit dans methodeA, la methodeB
la catch (catch (Exception e) ) et la renvoie en tant que nouvelle OscarException.
Du coup ca masque l'origine du probleme.

Comme l'OscarException provient forcement de la methodeA je me propose d'ajouter
ceci dans methodeB:
catch(OscarException e)
{
throw e;
}

Ainsi, toutes les exceptions sont traitées (j'ai tj mon catch (Exception e) )
Et je regle mon probleme.

Qu'en pensez vous, est ce une bonne maniere de traiter les Exceptions ?

Merci
Sebastien

Sébastien RAGONS
DSIV OX PQ
ext.osiatis.ragons@sncf.fr
22.52.07 / 03.28.55.62.07

[adiGuba]

Salut,


En effet si tu veux regrouper toutes tes exceptions dans un seul type c'est une solution assez pratique...

Une remarque toutefois concernant ton OscarException : tu devrais lui passer en paramètre l'exception 'e' d'origine de l'erreur afin de la conserver comme source, et ainsi conserver l'information dans le stacktrace via le 'caused by' :

Code :

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

1
2
3
4
Exception in thread "x" xxx.xxx.OscarException: le message de ton OscarException
	at ....
Caused by: ExceptionOriginal: message de l'exception original
	at ...

a++

[CyberChouan]

Qu'en pensez vous, est ce une bonne maniere de traiter les Exceptions ?

N'avoir qu'un seul type d'exception, pourquoi pas... Mais je ne trouve pas que ta manière de la traiter soit la bonne...

Normalement, soit on l'intercepte, soit on la rejette à la méthode appelante: ce qui permet de traiter l'exception au niveau du programme que l'on souhaite. En les attrapant dans chaque méthode, tu perds complètement cette gestion.

De plus, supposons que tu as une pile d'appels de profondeur 7. La méthode jette une exception:
- elle est immédiatement logguée, mais rejettée au niveau supérieur!
- au niveau 6, elle est donc re-logguée, puis rejettée!
- etc.

Bilan: 7 messages dans la log alors qu'il n'y a finalement qu'une seule erreur... ce n'est pas propre et ça alourdit la log inutilement.

Alors que si à chaque fois que tu remontes l'exception, tu passes en paramètre l'exception d'origine, tu auras au final toute l'information sur la trace de l'exception, et une seule entrée dans la log, au niveau que tu désires.

[EDIT] Grilled

[sragons]

En resumé:

• Mettre l'exception d'origine en parametre de mon oscarException
• Faire un catch + creation d'une oscarExcetion ok.
• Mais faire des catch de toutes les exceptions n'est pas une 'bonne pratique'

Merci de vos conseils.
Sebastien

[OButterlin]

Je crois que tu te compliques inutilement la vie...
Pourquoi ne pas faire ceci

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
try 
{
...
if (erreur) throw new OscarException("A", "methodeA", "message");
...
} 
catch (Exception e) 
{
  e.printStackTrace();
  logger.error("Erreur inconnue: " + e.getMessage());
  throw e;
}

Là, tu propages l'exception source...

a+

[sragons]

OButterlin, il semble inapproprié de catcher toutes les Exceptions surtout si c'est pour les renvoyer sans rien faire. Je te renvoie aux propos de CyberChouan:

Normalement, soit on l'intercepte, soit on la rejette à la méthode appelante: ce qui permet de traiter l'exception au niveau du programme que l'on souhaite. En les attrapant dans chaque méthode, tu perds complètement cette gestion.

De plus, supposons que tu as une pile d'appels de profondeur 7. La méthode jette une exception:
- elle est immédiatement logguée, mais rejettée au niveau supérieur!
- au niveau 6, elle est donc re-logguée, puis rejettée!
- etc.

Bilan: 7 messages dans la log alors qu'il n'y a finalement qu'une seule erreur... ce n'est pas propre et ça alourdit la log inutilement.

Sébastien