exceptions - Rethrowing an Exception

最新推荐文章于 2022-01-13 19:24:51 发布

wangbingfeng0

最新推荐文章于 2022-01-13 19:24:51 发布

阅读量401

点赞数

CC 4.0 BY-SA版权

分类专栏： Thinking in Java

本文链接：https://blog.youkuaiyun.com/wangbingfengf98/article/details/88044694

Thinking in Java 专栏收录该内容

155 篇文章

订阅专栏

本文探讨了Java中异常处理的高级技巧，包括如何使用fillInStackTrace()方法更新异常的堆栈跟踪信息，以及如何抛出不同于捕获的异常对象。通过实例演示了这些操作的实际效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

To install new stack trace information, we can call fillInStackTrace(), which returns a Throwable object it creates by stuffing the current stack information into the old exception object.

case 1:

use fillInStackTrace() method

// exceptions/Rethrowing.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.
// Demonstrating fillInStackTrace()

public class Rethrowing {
  public static void f() throws Exception {
    System.out.println("originating the exception in f()");
    throw new Exception("thrown from f()");
  }

  public static void g() throws Exception {
    try {
      f();
    } catch (Exception e) {
      System.out.println("Inside g(), e.printStackTrace()");
      e.printStackTrace(System.out);
      throw e;
    }
  }

  public static void h() throws Exception {
    try {
      f();
    } catch (Exception e) {
      System.out.println("Inside h(), e.printStackTrace()");
      e.printStackTrace(System.out);
      throw (Exception) e.fillInStackTrace();
    }
  }

  public static void main(String[] args) {
    try {
      g();
    } catch (Exception e) {
      System.out.println("main: printStackTrace()");
      e.printStackTrace(System.out);
    }
    try {
      h();
    } catch (Exception e) {
      System.out.println("main: printStackTrace()");
      e.printStackTrace(System.out);
    }
  }
}
/* My Output:
originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.f(Rethrowing.java:10)
        at Rethrowing.g(Rethrowing.java:15)
        at Rethrowing.main(Rethrowing.java:35)
main: printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.f(Rethrowing.java:10)
        at Rethrowing.g(Rethrowing.java:15)

        at Rethrowing.main(Rethrowing.java:35)
originating the exception in f()
Inside h(), e.printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.f(Rethrowing.java:10)
        at Rethrowing.h(Rethrowing.java:25)
        at Rethrowing.main(Rethrowing.java:41)
main: printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.h(Rethrowing.java:29)
        at Rethrowing.main(Rethrowing.java:41)
*/

fillInStackTrace

public Throwable fillInStackTrace()

Fills in the execution stack trace. This method records within this Throwable object information about the current state of the stack frames for the current thread.

If the stack trace of this Throwable is not writable, calling this method has no effect.

Returns:

a reference to this Throwable instance.

See Also:

printStackTrace()

case 2:

rethrow a different object from the one we caught.

// exceptions/RethrowNew.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.
// Rethrow a different object from the one you caught

class OneException extends Exception {
  OneException(String s) {
    super(s);
  }
}

class TwoException extends Exception {
  TwoException(String s) {
    super(s);
  }
}

public class RethrowNew {
  public static void f() throws OneException {
    System.out.println("originating the exception in f()");
    throw new OneException("thrown from f()");
  }

  public static void main(String[] args) {
    try {
      try {
        f();
      } catch (OneException e) {
        System.out.println("Caught in inner try, e.printStackTrace()");
        e.printStackTrace(System.out);
        throw new TwoException("from inner try");
      }
    } catch (TwoException e) {
      System.out.println("Caught in outer try, e.printStackTrace()");
      e.printStackTrace(System.out);
    }
  }
}
/* My Output:
originating the exception in f()
Caught in inner try, e.printStackTrace()
OneException: thrown from f()
        at RethrowNew.f(RethrowNew.java:22)
        at RethrowNew.main(RethrowNew.java:28)
Caught in outer try, e.printStackTrace()
TwoException: from inner try
        at RethrowNew.main(RethrowNew.java:32)
*/

Don’t worry about cleaning up the previous exception, or any exceptions. They’re all heap-based objects created with new, so the garbage collector automatically cleans them all up.

references:

1. On Java 8 - Bruce Eckel

2. https://github.com/wangbingfeng/OnJava8-Examples/blob/master/exceptions/Rethrowing.java

3. https://docs.oracle.com/javase/8/docs/api/java/lang/Throwable.html#fillInStackTrace--

4. https://github.com/wangbingfeng/OnJava8-Examples/blob/master/exceptions/RethrowNew.java