Discussion :

[Targan]

Bonjour,

je continue le tour des sujets qui me posent problème, et pour lesquels je n'ai pas forcément bien compris les bonnes pratiques.

Aujourd'hui, j'ai un problème avec les exceptions couplées à un logger.

J'ai lu cet article fort intéressant, mais cela ne répond pas forcément à mes interrogations :

http://anisfrikha.developpez.com/tut...xceptions/#LVI

Imaginons une classe, dans laquelle une méthode en appelle une autre d'une autre class, elle même appelant une 3ème méthode d'une 3ème class.

En gros F1->F2->F3.

Quelle est la bonne manière d'opérer pour logger ce qu'il faut, et bien remonter les exceptions ?

Je m'explique, actuellement je vois ce genre de pratique dans le projet :

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
 
public void F1();
{
    try {
        F2();
        .....
    } catch (Exception ex) {
        Log.error("message 1", ex);
    }
}
 
public void F2();
{
    try {
        F3();
        .....
    } catch (Exception ex) {
        Log.error("message 2", ex);
        Throw ex;
    }
}
 
public void F3();
{
    try {
        .....
    } catch (Exception ex) {
        Log.error("message 3", ex);
        Throw ex;
    }
}

Est ce normal finalement pour une exception générée dans F3 d'avoir finalement 3 écritures dans le log ?
Serait il plus judicieux de virer les appels aux Log dans F2 et F3 ? je présume que non car F2 peut parfaitement planter pour du code autre que l'appel à F3...
Devrait on remplacer les bloc try...catch par un throws global sur la méthode pour F2 et F3 ?

Bref me conseillez vous ?

Par avance merci.

[michon]

Ce que je te conseil est d'adapter les Exceptions aux différentes méthodes si tu le souhaite. Ensuite, ne faire que un seul "try catch" au niveau le plus haut.

En gros :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
public void F1() throw F1Exception{
    ...
}
 
public void F2() throw F2Exception{
    ...
}
 
public void F3() throw F3Exception{
    ...
}

Et plus loin dans ton main (ou là ou tu appelera la méthode F1()) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
try{
F1();
catch(F3Exception e){
    ....
}
catch(F2Exception e){
    ....
}
catch(F1Exception e){
    ....
}

Après à toi de définir les erreur FXException, et savoir quand chaque méthode doit la lancer, ainsi que le traitement associé.

[Targan]

Oui j'y pensais à cette solution, sauf que c'est toujours le même type d'exception qui est remonté.....et que je n'ai point le temps, ni vraiment la possibilité de définir un type spécifique d'exception.

Si je gère le log au niveau le plus haut et qu'une exception est issue d'un niveau inférieur, est ce que le logger conservera une trace d'où a été générée l'exception ?

[michon]

le logger je ne sais pas, par contre tu peux faire afficher la stack dans ton log via la méthode "printStackTrace()"

Code :

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

1
2
3
4
 
catch (Exception e) {
        e.printStackTrace();
    }

après tu peux faire écrire son contenu dans ton Log si tu le souhaite. Et la tu auras la pile d'appel complète, donc tu sauras d'où est partie l'exception.

[Targan]

Oui justement, je fais des appels du style

Log.error(String message, Throwable t)

Mais ce qui m'inquiète c'est de savoir comment la pile sera constituée si je le fais au plus haut niveau.
Je voudrais que si l'exception est générée au niveau le plus bas avoir une seule trace dans le log, et avoir une pile d'appel précise.

[wax78]

Normalement tu devrais remontrer jusqu'ou l'exception a été throw dés le depart.

Donc logguer a la base et pas dans les branches me semblerait mieux ... mais bon c'est mon avis.

Edit : T'as edité entretemps, mais sinon le mieux c'est d'essayer je pense pour etre sure et etre fixé.

[Pill_S]

Hello,

moi je loggerais partout, et n'activerais le log que dans les classes que l'on souhaite monitorer. Il est normal pour une classe X de produire du log en cas d'exception, même si cette exception est propagée plus loin. Il ne faut pas préjuger de qui utilisera une classe.

Dans ton cas, tu as F1->F2->F3, mais rien ne garantit que demain, tu n'auras pas F4->F5->F3. Si tu ne log qu'au niveau de F1, alors demain tu n'auras plus de log même que tu as eu une exception dans F3.....

Après, rien n'est rigide, rien n'est figé. Et certains cas d'utilisation se justifient à 100% de ne PAS avoir de log du tout. Mais il faut toujours penser à ce qu'il se passera lorsque l'on changera le comportement / enrichira l'application.