Exception - use printStackTrace() method for Chained exception & stack unwinding

[henry leu]

Hi,

When I use printStackTrace() to print from chained exception and stack unwinding, the result come out to be different. The exception order from chained and stack unwinding have reversed order. Why is that?
Stack unwinding print result: at UsingExceptions.method3(UsingExceptions.java:49) at UsingExceptions.method2(UsingExceptions.java:43) at UsingExceptions.method1(UsingExceptions.java:37) at UsingExceptions.main(UsingExceptions.java:10)
chained print result:
java.lang.Exception: Exception thrown in method1 at UsingChainedExceptions.method1(UsingChainedExceptions.java:27) at UsingChainedExceptions.main(UsingChainedExceptions.java:10) Caused by: java.lang.Exception: Exception thrown in method2 at UsingChainedExceptions.method2(UsingChainedExceptions.java:40) at UsingChainedExceptions.method1(UsingChainedExceptions.java:23) ... 1 more Caused by: java.lang.Exception: Exception thrown in method3 at UsingChainedExceptions.method3(UsingChainedExceptions.java:47) at UsingChainedExceptions.method2(UsingChainedExceptions.java:36) ... 2 more

[Stephan van Hulst]

Can you post example code demonstrating both?

[henry leu]

This is the code for chained exeption. The order is different. As you can see, method 3, method 2, method 1 comparing to method 1, method 2, and method 3.

public class UsingChainedExceptions
{
   public static void main(String[] args)
   {
      try 
      { 
         method1(); 
      } 
      catch (Exception exception) // exceptions thrown from method1
      { 
         exception.printStackTrace();
      } 
   } 

   // call method2; throw exceptions back to main
   public static void method1() throws Exception
   {
      try 
      { 
         method2(); 
      }
      catch (Exception exception) // exception thrown from method2
      {
         throw new Exception("Exception thrown in method1", exception);
      }
   } // end method method1

   // call method3; throw exceptions back to method1
   public static void method2() throws Exception
   {
      try 
      { 
         method3(); 
      } 
      catch (Exception exception) // exception thrown from method3
      {
         throw new Exception("Exception thrown in method2", exception);
      } 
   } // end method method2

   // throw Exception back to method2
   public static void method3() throws Exception
   {
      throw new Exception("Exception thrown in method3");
   } 
} // end class UsingChainedExceptions

RESULT OF CHAINED EXCEPTION:

java.lang.Exception: Exception thrown in method1
at UsingChainedExceptions.method1(UsingChainedExceptions.java:27)
at UsingChainedExceptions.main(UsingChainedExceptions.java:10)
Caused by: java.lang.Exception: Exception thrown in method2
at UsingChainedExceptions.method2(UsingChainedExceptions.java:40)
at UsingChainedExceptions.method1(UsingChainedExceptions.java:23)
... 1 more
Caused by: java.lang.Exception: Exception thrown in method3
at UsingChainedExceptions.method3(UsingChainedExceptions.java:47)
at UsingChainedExceptions.method2(UsingChainedExceptions.java:36)
... 2 more


FOLLOWING IS THE CODE FOR STACK UNWINDING.

public class UsingExceptions 
{
   public static void main(String[] args)
   {
      try 
      { 
         method1(); 
      }
      catch (Exception exception) // catch exception thrown in method1
      { 
         System.err.printf("%s%n%n", exception.getMessage());
         exception.printStackTrace(); 

      } 
   } // end main

   // call method2; throw exceptions back to main
   public static void method1() throws Exception
   {
      method2();
   } 

   // call method3; throw exceptions back to method1
   public static void method2() throws Exception
   {
      method3();
   }

   // throw Exception back to method2
   public static void method3() throws Exception
   {
      throw new Exception("Exception thrown in method3");
   } 
}

java.lang.Exception: Exception thrown in method3
at UsingExceptions.method3(UsingExceptions.java:49)
at UsingExceptions.method2(UsingExceptions.java:43)
at UsingExceptions.method1(UsingExceptions.java:37)
at UsingExceptions.main(UsingExceptions.java:10)

[Stephan van Hulst]

The reason is that the most relevant information should be presented first.

In a stack trace, you present the deepest stack frame first, because that's where the exception originated, and that's where you usually have to start looking for bugs.

However, sometimes an exception is too specific to be relevant to the caller of a method. Chaining exceptions means wrapping the cause of an exception in an exception that's more relevant.

When you're debugging, you're usually not really interested in the gory details of some library that you build upon. Chained exceptions are presented in order from outside to inside, because outer exceptions are usually more relevant to the issue.