Discussion :

[psykoprof]

Bonjour, je suis en train de faire quelques tests sur la gestion des exceptions et j'aimerais être sûr de faire les choses convenablement.

Le principe du programme est de lire des trames GPS contenues dans un fichier texte, de splitter ces trames pour en récupérer que quelques infos qui seront ensuite enregistrer dans un autre fichier texte.

J'aimerais savoir si je dois gérer absolument toutes les exceptions possibles (NullPointeurException, IOException, etc....) ?
Comment exploiter proprement la fermeture des flux d'entrée/sorties en cas de levée d'exception ? utilisation d'un finally ?

Les exceptions semblent être extrêmement utiles en plus d'être obligatoires par moment mais j'aimerais être sûr de bien les utiliser ??

Voici quelques exemples que j'ai fait sur lesquels vos avis me seraient utiles :

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
public class AnalyseTrameGpsFile {
 
    public static void main(String[] args) {
 
            File ftrames = new File("trame1.txt");
            File fsortie = new File("latlong.txt");
            long taille = ftrames.length();
            long datemodif = ftrames.lastModified();
            Date d = new Date(datemodif);
            String date = d.toString();
            SimpleDateFormat formdate = new SimpleDateFormat("yyyy/MM/dd - HH:mm:ss");
            System.out.println(taille+"octets - "+formdate.format(d)+" - "+date);
 
            BufferedReader entree=null;
            FileWriter sortie = null;
            try
            {
                entree = new BufferedReader(new FileReader(ftrames));
                sortie = new FileWriter(fsortie, true);
                String ligne;
                try
                {
                    do
                    {
                        ligne = entree.readLine();
                            System.out.println(ligne);
                            String[] tabitemstrame = ligne.split(",");
                            sortie.append(date+" - LAT:"+tabitemstrame[1]+" - LONG:"+tabitemstrame[2]+"\r\n");
                     }while(ligne!=null);
                }
                catch(NullPointerException e)
                {
                    System.out.println("Erreur Pointeur Null !");
                }
                finally
                {
                    entree.close();
                    sortie.close();
                }
            }
            catch (FileNotFoundException ex) {
                String namefile = ftrames.getName();
                System.out.println("Le fichier : \""+namefile+"\" est introuvable. Arret du programme !");
            }
            catch (IOException ex) {
                String namefile = fsortie.getName();
                System.out.println("Le fichier : \""+namefile+"\" a subi une erreur. Arret du programme !");
 
            }
}

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
public class AnalyseTrameGpsFile {
 
    public static void main(String[] args) throws NullPointerException{
 
            File ftrames = new File("trame1.txt");
            File fsortie = new File("latlong.txt");
            long taille = ftrames.length();
            long datemodif = ftrames.lastModified();
            Date d = new Date(datemodif);
            String date = d.toString();
            SimpleDateFormat formdate = new SimpleDateFormat("yyyy/MM/dd - HH:mm:ss");
            System.out.println(taille+"octets - "+formdate.format(d)+" - "+date);
 
            BufferedReader entree=null;
            FileWriter sortie = null;
            try
            {
                entree = new BufferedReader(new FileReader(ftrames));
                sortie = new FileWriter(fsortie, true);
                String ligne;
                    do
                    {
                        ligne = entree.readLine();
                        if(ligne != null)
                        {
                            System.out.println(ligne);
                            String[] tabitemstrame = ligne.split(",");
                            sortie.append(date+" - LAT:"+tabitemstrame[1]+" - LONG:"+tabitemstrame[2]+"\r\n");
                        }
                     }while(ligne!=null);
                    entree.close();
                    sortie.close();
            }
            catch (FileNotFoundException ex) {
                String namefile = ftrames.getName();
                System.out.println("Le fichier : \""+namefile+"\" est introuvable. Arret du programme !");
            }
            catch (IOException ex) {
                //Comment savoir ici si l'exception est levée par FileWriter ou .close() ???????
                String namefile = fsortie.getName();
                System.out.println("Le fichier : \""+namefile+"\" a subi une erreur. Arret du programme !"); 
            }
    }

Merci d'avance pour votre aide.

[Heimdal]

Salut,

il n'y a pas vraiment de consensus sur la gestion des exceptions. L'idée de base est de traiter seulement les exceptions que ton programme peut tolérer, c'est à dire qui n'altère pas le fonctionnement attendu de ton programme.
Dans ton cas je dirai que tu ne devrais rien catcher et traiter les fermetures des flux dans un bloc finally.

[sleroux]

Bonjour ,

La run-time Java te garantit que le code dans un bloc finally sera exécuté. Exception ou pas.

A chaque fois que tu alloues une ressource, il est préférable de la libérer dans un bloc finally. Ainsi, tu es certain que les ressources allouées seront libérées dans tous les cas.

Concernant ton code, dans le bloc try "interne", je me limiterais au code suivant:

Code java :

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
 
                entree = new BufferedReader(new FileReader(ftrames));
                sortie = new FileWriter(fsortie, true);
                String ligne;
                try
                {
                    while((ligne = entree.readLine()) != null)
                    {
                            System.out.println(ligne);
                            String[] tabitemstrame = ligne.split(",");
                            sortie.append(date+" - LAT:"+tabitemstrame[1]+" - LONG:"+tabitemstrame[2]+"\r\n");
                     }
                }
                finally
                {
                    if (entree != null)
                         entree.close();
                    if (sortie != null)
                         sortie.close();
                }

Je ne vois pas l'intérêt pour toi d'intercepter NullPointerException. Il me semble plus simple (et plus efficace - et plus lisible) de remplacer ta boucle do { ... } while() par un while() { ... } Comme ci-dessus. A moins qu'il n'y ait un effet de bord qui m'échappe dans to code?

Remarque aussi les "if" dans le bloc finally. C'est pour prendre en compte le fait qu'une exception peut se produire dans les circonstances suivantes:
* lors de l'ouverture du fichier d'entrée (alors entree == null et sortie == null)
* lors de l'ouverture du fichier de sortie (alors entree != null et sortie == null)
* lors du traitement (alors entree != null et sortie != null)

Sans les "if"s les deux premiers cas vont générer une NullPointerException au moment d'appeler la méthode close() sur une variable non initialisée.

Espérant t'avoir aidé,
- Sylvain

[psykoprof]

Merci beaucoup pour vos réponses. Je comprends mieux l'utilisation des exceptions.

Donc l'imbrication de 2 blocs try n'est pas mauvaise et semblerait même convenir !? ne pourrait-on pas faire cela avec un seul ?

[adiGuba]

Salut,

Je ne vois pas l'intérêt pour toi d'intercepter NullPointerException. Il me semble plus simple (et plus efficace - et plus lisible) de remplacer ta boucle do { ... } while() par un while() { ... } Comme ci-dessus.

+1

Remarque aussi les "if" dans le bloc finally.

Là je serais plus nuancé...
Les bloc finally devrait comporter le moins de code possible, afin d'éviter tout risque de problème.
Ici c'est les exceptions sur les méthodes close() qui pourrait poser soucis, et empêcher la fermeture du second flux.

Perso je conseillerai d'utiliser un try/finally par ressource :

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
 
	BufferedReader entree = new BufferedReader(new FileReader(ftrames));
	try {
		FileWriter sortie = new FileWriter(fsortie, true);
		try {
			String ligne;
			while((ligne = entree.readLine()) != null) {
				System.out.println(ligne);
				String[] tabitemstrame = ligne.split(",");
				sortie.append(date+" - LAT:"+tabitemstrame[1]+" - LONG:"+tabitemstrame[2]+"\r\n");
			}
		}
		finally {
                         sortie.close();
                }
	} finally {
		entree.close();
	}

a++

[sleroux]

Tu as parfaitement raison adiGuba: il n'y a qu'avec des try{} finally{} imbriqués qu'on peut prendre en compte les exceptions potentielles générées par close()!


Par contre, je me pose une question sur l'expression suivante:

Code java :

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

1
2
 
	BufferedReader entree = new BufferedReader(new FileReader(ftrames));

N'y aurait-il pas un risque de voir la construction du nouveau FileReader réussir, mais la construction du BufferedReader échouer en générant une exception? Dans ce cas, le fichier ne serait pas fermé...

A+
- Sylvain

[tchize_]

N'y aurait-il pas un risque de voir la construction du nouveau FileReader réussir, mais la construction du BufferedReader échouer en générant une exception? Dans ce cas, le fichier ne serait pas fermé...

A+
- Sylvain

Sur le principe, oui, en pratique non. Il n'y a pas de code dans le constructeur BufferedReader suceptible de foirer:

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
    public BufferedReader(Reader in, int sz) {
	super(in);
	if (sz <= 0)
	    throw new IllegalArgumentException("Buffer size <= 0");
	this.in = in;
	cb = new char[sz];
	nextChar = nChars = 0;
    }
 
    /**
     * Creates a buffering character-input stream that uses a default-sized
     * input buffer.
     *
     * @param  in   A Reader
     */
    public BufferedReader(Reader in) {
	this(in, defaultCharBufferSize);
    }
    protected Reader(Object lock) {
	if (lock == null) {
	    throw new NullPointerException();
	}
	this.lock = lock;
    }

[unknow0]

Par contre, je me pose une question sur l'expression suivante:

Code java :

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

1
2
 
	BufferedReader entree = new BufferedReader(new FileReader(ftrames));

N'y aurait-il pas un risque de voir la construction du nouveau FileReader réussir, mais la construction du BufferedReader échouer en générant une exception? Dans ce cas, le fichier ne serait pas fermé...

a ceci pres que le constructeur de BufferedReader ne remonte pas d'exception.
donc c'est un cas qui ne peu arriver