Groovy - Gestion des exceptions

La gestion des exceptions est requise dans tout langage de programmation pour gérer les erreurs d'exécution afin que le flux normal de l'application puisse être maintenu.

L'exception perturbe normalement le flux normal de l'application, ce qui explique pourquoi nous devons utiliser la gestion des exceptions dans notre application.

Les exceptions sont généralement classées dans les catégories suivantes -

  • Checked Exception - Les classes qui étendent la classe Throwable à l'exception de RuntimeException et Error sont appelées exceptions vérifiées, egIOException, SQLException, etc. Les exceptions vérifiées sont vérifiées au moment de la compilation.

Un cas classique est le FileNotFoundException. Supposons que vous ayez le code suivant dans votre application qui lit un fichier dans le lecteur E.

class Example {
   static void main(String[] args) {
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file);
   } 
}

si le fichier (file.txt) n'est pas présent dans le lecteur E, l'exception suivante sera déclenchée.

Attrapé: java.io.FileNotFoundException: E: \ file.txt (le système ne trouve pas le fichier spécifié).

java.io.FileNotFoundException: E: \ file.txt (Le système ne trouve pas le fichier spécifié).

  • Unchecked Exception - Les classes qui étendent RuntimeException sont appelées exceptions non vérifiées, par exemple, ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, etc. Les exceptions non vérifiées ne sont pas vérifiées au moment de la compilation mais sont vérifiées au moment de l'exécution.

Un cas classique est l'exception ArrayIndexOutOfBoundsException qui se produit lorsque vous essayez d'accéder à un index d'un tableau qui est supérieur à la longueur du tableau. Voici un exemple typique de ce type d'erreur.

class Example {
   static void main(String[] args) {
      def arr = new int[3];
      arr[5] = 5;
   } 
}

Lorsque le code ci-dessus est exécuté, l'exception suivante sera déclenchée.

Attrapé: java.lang.ArrayIndexOutOfBoundsException: 5

java.lang.ArrayIndexOutOfBoundsException: 5

  • Error - L'erreur est irrécupérable, par exemple OutOfMemoryError, VirtualMachineError, AssertionError, etc.

Ce sont des erreurs dont le programme ne peut jamais récupérer et qui provoqueront un plantage du programme.

Le diagramme suivant montre comment la hiérarchie des exceptions dans Groovy est organisée. Tout est basé sur la hiérarchie définie en Java.

Attraper les exceptions

Une méthode intercepte une exception en utilisant une combinaison des try et catchmots clés. Un bloc try / catch est placé autour du code qui peut générer une exception.

try { 
   //Protected code 
} catch(ExceptionName e1) {
   //Catch block 
}

Tout votre code qui pourrait déclencher une exception est placé dans le bloc de code protégé.

Dans le bloc catch, vous pouvez écrire du code personnalisé pour gérer votre exception afin que l'application puisse récupérer de l'exception.

Examinons un exemple du code similaire que nous avons vu ci-dessus pour accéder à un tableau avec une valeur d'index supérieure à la taille du tableau. Mais cette fois, enveloppons notre code dans un bloc try / catch.

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(Exception ex) {
         println("Catching the exception");
      }
		
      println("Let's move on after the exception");
   }
}

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons le résultat suivant -

Catching the exception 
Let's move on after the exception

À partir du code ci-dessus, nous enveloppons le code défectueux dans le bloc try. Dans le bloc catch, nous interceptons simplement notre exception et émettons un message indiquant qu'une exception s'est produite.

Blocs de capture multiples

On peut avoir plusieurs blocs catch pour gérer plusieurs types d'exceptions. Pour chaque bloc catch, selon le type d'exception déclenchée, vous écririez du code pour le gérer en conséquence.

Modifions notre code ci-dessus pour intercepter spécifiquement l'exception ArrayIndexOutOfBoundsException. Voici l'extrait de code.

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      }
		
      println("Let's move on after the exception");
   } 
}

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons le résultat suivant -

Catching the Aray out of Bounds exception 
Let's move on after the exception

À partir du code ci-dessus, vous pouvez voir que le bloc catch ArrayIndexOutOfBoundsException est intercepté en premier car il signifie les critères de l'exception.

Enfin bloquer

le finallyblock suit un bloc try ou un bloc catch. Un bloc de code finally s'exécute toujours, indépendamment de l'occurrence d'une exception.

L'utilisation d'un bloc finally vous permet d'exécuter toutes les instructions de type nettoyage que vous souhaitez exécuter, peu importe ce qui se passe dans le code protégé. La syntaxe de ce bloc est donnée ci-dessous.

try { 
   //Protected code 
} catch(ExceptionType1 e1) { 
   //Catch block 
} catch(ExceptionType2 e2) { 
   //Catch block 
} catch(ExceptionType3 e3) { 
   //Catch block 
} finally {
   //The finally block always executes. 
}

Modifions notre code ci-dessus et ajoutons le dernier bloc de code. Voici l'extrait de code.

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      } finally {
         println("The final block");
      }
		
      println("Let's move on after the exception");
   } 
}

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons le résultat suivant -

Catching the Array out of Bounds exception 
The final block 
Let's move on after the exception

Voici les méthodes d'exception disponibles dans Groovy -

public String getMessage ()

Renvoie un message détaillé sur l'exception qui s'est produite. Ce message est initialisé dans le constructeur Throwable.

public Throwable getCause ()

Renvoie la cause de l'exception représentée par un objet Throwable.

chaîne publique toString ()

Renvoie le nom de la classe concaténée avec le résultat de getMessage ()

public void printStackTrace ()

Imprime le résultat de toString () avec la trace de la pile dans System.err, le flux de sortie d'erreur.

public StackTraceElement [] getStackTrace ()

Renvoie un tableau contenant chaque élément de la trace de pile. L'élément à l'index 0 représente le haut de la pile d'appels et le dernier élément du tableau représente la méthode au bas de la pile d'appels.

public Throwable fillInStackTrace ()

Remplit la trace de pile de cet objet Throwable avec la trace de pile actuelle, en ajoutant à toutes les informations précédentes dans la trace de pile.

Exemple

Voici l'exemple de code utilisant certaines des méthodes données ci-dessus -

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println(ex.toString());
         println(ex.getMessage());
         println(ex.getStackTrace());  
      } catch(Exception ex) {
         println("Catching the exception");
      }finally {
         println("The final block");
      }
		
      println("Let's move on after the exception");
   } 
}

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons le résultat suivant -

java.lang.ArrayIndexOutOfBoundsException: 5 
5 
[org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayPutAtMetaMethod$MyPojoMetaMet 
hodSite.call(IntegerArrayPutAtMetaMethod.java:75), 
org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:48) ,
org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:113) ,
org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:133) ,
Example.main(Sample:8), sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
org.codehaus.groovy.reflection.CachedMethod.invoke(CachedMethod.java:93),
groovy.lang.MetaMethod.doMethodInvoke(MetaMethod.java:325),
groovy.lang.MetaClassImpl.invokeStaticMethod(MetaClassImpl.java:1443),
org.codehaus.groovy.runtime.InvokerHelper.invokeMethod(InvokerHelper.java:893),
groovy.lang.GroovyShell.runScriptOrMainOrTestOrRunnable(GroovyShell.java:287),
groovy.lang.GroovyShell.run(GroovyShell.java:524),
groovy.lang.GroovyShell.run(GroovyShell.java:513),
groovy.ui.GroovyMain.processOnce(GroovyMain.java:652),
groovy.ui.GroovyMain.run(GroovyMain.java:384),
groovy.ui.GroovyMain.process(GroovyMain.java:370),
groovy.ui.GroovyMain.processArgs(GroovyMain.java:129),
groovy.ui.GroovyMain.main(GroovyMain.java:109),
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:109),
org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:131),
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)]
 
The final block 
Let's move on after the exception