Groovy - Ausnahmebehandlung
In jeder Programmiersprache ist eine Ausnahmebehandlung erforderlich, um die Laufzeitfehler zu behandeln, damit der normale Ablauf der Anwendung aufrechterhalten werden kann.
Eine Ausnahme stört normalerweise den normalen Ablauf der Anwendung. Aus diesem Grund müssen wir in unserer Anwendung die Ausnahmebehandlung verwenden.
Ausnahmen werden grob in die folgenden Kategorien eingeteilt:
Checked Exception - Die Klassen, die die Throwable-Klasse mit Ausnahme von RuntimeException und Error erweitern, werden als geprüfte Ausnahmen bezeichnet, z. B.IOException, SQLException usw. Geprüfte Ausnahmen werden zur Kompilierungszeit geprüft.
Ein klassischer Fall ist die FileNotFoundException. Angenommen, Sie hatten den folgenden Code in Ihrer Anwendung, der aus einer Datei im Laufwerk E liest.
class Example {
static void main(String[] args) {
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
}
}Wenn sich die Datei (file.txt) nicht im E-Laufwerk befindet, wird die folgende Ausnahme ausgelöst.
Gefangen: java.io.FileNotFoundException: E: \ file.txt (Das System kann die angegebene Datei nicht finden).
java.io.FileNotFoundException: E: \ file.txt (Das System kann die angegebene Datei nicht finden).
Unchecked Exception - Die Klassen, die RuntimeException erweitern, werden als nicht aktivierte Ausnahmen bezeichnet, z. B. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException usw. Nicht aktivierte Ausnahmen werden zur Kompilierungszeit nicht überprüft, sondern zur Laufzeit.
Ein klassischer Fall ist die ArrayIndexOutOfBoundsException, die auftritt, wenn Sie versuchen, auf einen Index eines Arrays zuzugreifen, der größer als die Länge des Arrays ist. Das Folgende ist ein typisches Beispiel für diese Art von Fehler.
class Example {
static void main(String[] args) {
def arr = new int[3];
arr[5] = 5;
}
}Wenn der obige Code ausgeführt wird, wird die folgende Ausnahme ausgelöst.
Gefangen: java.lang.ArrayIndexOutOfBoundsException: 5
java.lang.ArrayIndexOutOfBoundsException: 5
Error - Der Fehler kann nicht behoben werden, z. B. OutOfMemoryError, VirtualMachineError, AssertionError usw.
Dies sind Fehler, die das Programm niemals beheben kann und die zum Absturz des Programms führen.
Das folgende Diagramm zeigt, wie die Hierarchie der Ausnahmen in Groovy organisiert ist. Es basiert alles auf der in Java definierten Hierarchie.
Ausnahmen fangen
Eine Methode fängt eine Ausnahme mit einer Kombination aus try und catchSchlüsselwörter. Um den Code wird ein Try / Catch-Block platziert, der möglicherweise eine Ausnahme generiert.
try {
//Protected code
} catch(ExceptionName e1) {
//Catch block
}Ihr gesamter Code, der eine Ausnahme auslösen könnte, wird im geschützten Codeblock abgelegt.
Im catch-Block können Sie benutzerdefinierten Code schreiben, um Ihre Ausnahme zu behandeln, damit die Anwendung die Ausnahme wiederherstellen kann.
Schauen wir uns ein Beispiel für den ähnlichen Code an, den wir oben für den Zugriff auf ein Array mit einem Indexwert gesehen haben, der größer als die Größe des Arrays ist. Aber dieses Mal verpacken wir unseren Code in einen Try / Catch-Block.
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");
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
Catching the exception
Let's move on after the exceptionAus dem obigen Code schließen wir fehlerhaften Code im try-Block aus. Im catch-Block fangen wir nur unsere Ausnahme ab und geben eine Nachricht aus, dass eine Ausnahme aufgetreten ist.
Mehrere Fangblöcke
Man kann mehrere Catch-Blöcke haben, um mehrere Arten von Ausnahmen zu behandeln. Abhängig von der Art der ausgelösten Ausnahme würden Sie für jeden catch-Block Code schreiben, um ihn entsprechend zu behandeln.
Lassen Sie uns unseren obigen Code ändern, um die ArrayIndexOutOfBoundsException speziell abzufangen. Es folgt das Code-Snippet.
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");
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
Catching the Aray out of Bounds exception
Let's move on after the exceptionAus dem obigen Code können Sie ersehen, dass der ArrayIndexOutOfBoundsException-Fangblock zuerst abgefangen wird, da er die Kriterien der Ausnahme bedeutet.
Schließlich blockieren
Das finallyBlock folgt einem Try-Block oder einem Catch-Block. Ein endgültiger Codeblock wird immer ausgeführt, unabhängig vom Auftreten einer Ausnahme.
Mit einem finally-Block können Sie alle Anweisungen vom Bereinigungstyp ausführen, die Sie ausführen möchten, unabhängig davon, was im geschützten Code geschieht. Die Syntax für diesen Block ist unten angegeben.
try {
//Protected code
} catch(ExceptionType1 e1) {
//Catch block
} catch(ExceptionType2 e2) {
//Catch block
} catch(ExceptionType3 e3) {
//Catch block
} finally {
//The finally block always executes.
}Lassen Sie uns unseren obigen Code ändern und den endgültigen Codeblock hinzufügen. Es folgt das Code-Snippet.
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");
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
Catching the Array out of Bounds exception
The final block
Let's move on after the exceptionIm Folgenden sind die in Groovy verfügbaren Ausnahmemethoden aufgeführt:
public String getMessage ()
Gibt eine detaillierte Nachricht über die aufgetretene Ausnahme zurück. Diese Nachricht wird im Throwable-Konstruktor initialisiert.
public Throwable getCause ()
Gibt die Ursache der Ausnahme zurück, die durch ein Throwable-Objekt dargestellt wird.
public String toString ()
Gibt den Namen der Klasse zurück, die mit dem Ergebnis von getMessage () verknüpft ist.
public void printStackTrace ()
Druckt das Ergebnis von toString () zusammen mit der Stapelverfolgung an System.err, den Fehlerausgabestream.
public StackTraceElement [] getStackTrace ()
Gibt ein Array zurück, das jedes Element in der Stapelverfolgung enthält. Das Element am Index 0 repräsentiert den oberen Rand des Aufrufstapels, und das letzte Element im Array repräsentiert die Methode am unteren Rand des Aufrufstapels.
public Throwable fillInStackTrace ()
Füllt die Stapelverfolgung dieses Throwable-Objekts mit der aktuellen Stapelverfolgung und fügt alle vorherigen Informationen in der Stapelverfolgung hinzu.
Beispiel
Es folgt das Codebeispiel mit einigen der oben angegebenen Methoden:
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");
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
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