Detaillierte Erläuterung des Beispielcodes für den Java-Ausnahme-Stack-Trace

In diesem Artikel werden hauptsächlich detaillierte Erläuterungen zum Java-Ausnahme-Stack-Trace (Stack Trace) und zugehörige Informationen zum Beispielcode vorgestellt.

Java-Ausnahme-Stack-Trace (Stack Trace) im Detail Erklärung

Wenn eine Ausnahme abgefangen wird, ist häufig eine gewisse Verarbeitung erforderlich. Eine einfachere und direktere Möglichkeit besteht darin, den Ausnahme-Stack-Trace Stack Trace auszudrucken. Apropos Stapelspuren: Viele Leute mögen wie ich. Die erste Reaktion ist die printStackTrace()-Methode. Tatsächlich gibt es neben dieser Methode noch einige andere Inhalte im Zusammenhang mit Stack-Traces.

1.printStackTrace()

Zunächst muss klar sein, dass diese Methode nicht aus der Klasse Exception stammt. Mit Ausnahme der Exception-Klasse selbst, die mehrere Konstruktoren definiert, werden alle Methoden von ihrer übergeordneten Klasse geerbt. Die mit Ausnahmen verbundenen Methoden werden alle von der Klasse java.lang.Throwable geerbt. Und printStackTrace() ist einer davon.

Diese Methode gibt die Stack-Trace-Informationen des Throwable-Objekts im Standardfehlerausgabestream aus. Die Ausgabe sieht im Allgemeinen wie folgt aus:

java.lang.NullPointerException
     at MyClass.mash(MyClass.java:9)
     at MyClass.crunch(MyClass.java:6)
     at MyClass.main(MyClass.java:3)

Die erste Ausgabezeile ist die Ausgabe der toString()-Methode und der Inhalt der folgenden Zeilen ist der Inhalt, der zuvor über die fillInStackTrace()-Methode gespeichert wurde. Wir werden später über diese Methode sprechen.

Schauen wir uns ein Beispiel an:

public class TestPrintStackTrace {
  public static void f() throws Exception{
    throw new Exception("出问题啦！");
  }
  public static void g() throws Exception{
    f();
  }
  public static void main(String[] args) {
    try {
      g();
    }catch(Exception e) {
      e.printStackTrace();
    }
  }
}

Die Ausgabe dieses Beispiels ist wie folgt:

java.lang.Exception: 出问题啦！
  at TestPrintStackTrace.f(TestPrintStackTrace.java:3)
  at TestPrintStackTrace.g(TestPrintStackTrace.java:6)
  at TestPrintStackTrace.main(TestPrintStackTrace.java:10)

In diesem Beispiel wird in der Methode f() löst eine Ausnahme aus, die Methode f() wird in der Methode g() aufgerufen, die Ausnahme wird in der Hauptmethode abgefangen und Stack-Trace-Informationen werden gedruckt. Daher zeigt die Ausgabe den Prozess von f->g->main der Reihe nach.

2.getStackTrace()-Methode

Diese Methode bietet programmgesteuerten Zugriff auf die von der printStackTrace()-Methode gedruckten Informationen. Es gibt ein Array von Stack-Trace-Elementen zurück. Am Beispiel der obigen Ausgabe entspricht der Inhalt jeder Zeile der Ausgabezeilen 2 bis 4 einem Stack-Trace-Element. Speichern Sie diese Stack-Trace-Elemente in einem Array. Jedes Element entspricht einem Stapelrahmen des Stapels. Das erste Element des Arrays speichert das oberste Element des Stapels, das f darüber liegt. Das unterste Element des Stapels, das vom letzten Element gespeichert wird.

Das Folgende ist ein Beispiel für die Verwendung von getStackTrace(), um auf diese Trace-Stack-Elemente zuzugreifen und die Ausgabe zu drucken:

public class TestPrintStackTrace {
  public static void f() throws Exception{
    throw new Exception("出问题啦！");
  }
  public static void g() throws Exception{
    f();
  }
  public static void main(String[] args) {
    try {
      g();
    }catch(Exception e) {
      e.printStackTrace();
      System.out.println("------------------------------");
      for(StackTraceElement elem : e.getStackTrace()) {
        System.out.println(elem);
      }
    }
  }
}

Eine solche Ausgabe ist im Grunde die gleiche wie die Ausgabe von printStackTrace(), wie folgt:

java.lang.Exception: 出问题啦！
  at TestPrintStackTrace.f(TestPrintStackTrace.java:3)
  at TestPrintStackTrace.g(TestPrintStackTrace.java:6)
  at TestPrintStackTrace.main(TestPrintStackTrace.java:10)
TestPrintStackTrace.f(TestPrintStackTrace.java:3)
TestPrintStackTrace.g(TestPrintStackTrace.java:6)
TestPrintStackTrace.main(TestPrintStackTrace.java:10)

3.fillInStackTrace()

Wir haben diese Methode auch bereits erwähnt. Um diese Methode klar zu erklären, müssen wir zunächst über das Problem des erneuten Auslösens von Ausnahmen nach dem Abfangen sprechen. Fangen Sie die Ausnahme im Catch-Code-Block ab, drucken Sie den Stack-Trace aus und werfen Sie ihn erneut aus. Fangen Sie diese Ausnahme im Methodenaufruf der vorherigen Ebene ab und geben Sie die Stack-Trace-Informationen aus. Werden die beiden Stack-Trace-Informationen identisch sein? Werfen wir einen Blick auf den Code:

public class TestPrintStackTrace {
  public static void f() throws Exception{
    throw new Exception("出问题啦！");
  }
  public static void g() throws Exception{
    try {
      f();
    }catch(Exception e) {
      e.printStackTrace();
      throw e;
    }
     
  }
  public static void main(String[] args) {
    try {
      g();
    }catch(Exception e) {
      e.printStackTrace();
    }
  }
}

Die in der Hauptmethode abgefangene Ausnahme wird in der g()-Methode ausgelöst. Es liegt auf der Hand, dass die Informationen der beiden gedruckten Stapelspuren unterschiedlich sein sollten. Der zweite Druck Die Informationen von sollten keine Informationen über f enthalten. Tatsächlich sind die zweimal gedruckten Stack-Trace-Informationen jedoch dieselben. Das Ausgabeergebnis lautet wie folgt:

java.lang.Exception: 出问题啦！
  at TestPrintStackTrace.f(TestPrintStackTrace.java:3)
  at TestPrintStackTrace.g(TestPrintStackTrace.java:7)
  at TestPrintStackTrace.main(TestPrintStackTrace.java:16)
java.lang.Exception: 出问题啦！
  at TestPrintStackTrace.f(TestPrintStackTrace.java:3)
  at TestPrintStackTrace.g(TestPrintStackTrace.java:7)
  at TestPrintStackTrace.main(TestPrintStackTrace.java:16)

Mit anderen Worten: Wenn die Ausnahme sofort abgefangen und ausgelöst wird und die Ausnahme im übergeordneten Methodenaufruf erneut abgefangen wird, sind die gedruckten Stack-Trace-Informationen dieselben . Der Grund dafür ist, dass der Status des Trajektorienstapels im aktuellen Status des aktuellen Threads nicht in Throwabe gespeichert wird. Jetzt stellen wir die Methode fillInStackTrace() vor. Diese Methode erledigt genau diese Art der Konservierungsarbeit. Schauen wir uns den Prototyp dieser Methode an:

public Throwable fillInStackTrace()

Diese Methode hat einen Rückgabewert. Zurückgegeben wird ein Throwable-Objekt, das die aktuellen Stack-Trace-Informationen speichert. Werfen wir einen Blick auf den Unterschied in den Stack-Trace-Informationen, die nach Verwendung der fillInStackTrace()-Methode gedruckt werden. Der Code lautet wie folgt:

public class TestPrintStackTrace {
  public static void f() throws Exception{
    throw new Exception("出问题啦！");
  }
  public static void g() throws Exception{
    try {
      f();
    }catch(Exception e) {
      e.printStackTrace();
      //不要忘了强制类型转换
      throw (Exception)e.fillInStackTrace();
    }
     
  }
  public static void main(String[] args) {
    try {
      g();
    }catch(Exception e) {
      e.printStackTrace();
    }
  }
}

Die Ausgabe lautet wie folgt:

java.lang.Exception: 出问题啦！
  at TestPrintStackTrace.f(TestPrintStackTrace.java:3)
  at TestPrintStackTrace.g(TestPrintStackTrace.java:7)
  at TestPrintStackTrace.main(TestPrintStackTrace.java:17)
java.lang.Exception: 出问题啦！
  at TestPrintStackTrace.g(TestPrintStackTrace.java:11)
  at TestPrintStackTrace.main(TestPrintStackTrace.java:17)

Wir sehen das in main Der in der Methode gedruckte Stack-Trace enthält keine f-bezogenen Informationen mehr.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Beispielcodes für den Java-Ausnahme-Stack-Trace. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!