1 取出Throwable的堆栈信息

使用Throwable一个很大的好处在于，他能保存他被实例化的方法的堆栈信息，通过方法：

  1. Throwable#printStackTrace()

可以将他和他的cause Throwable和他的cause的cause…( 递归 ) 的堆栈信息都打印出来。

而例如我们要将一个Throwable对象的堆栈信息不仅仅是输出到控制台，还要保存到本地日志或者发送到服务器呢？那么就要将Throwable的堆栈信息提取出来。

令人开心的是，android.util.Log类提供了这么一个工具方法：

  1. /**
  2.  * Handy function to get a loggable stack trace from a Throwable
  3.  * @param tr An exception to log
  4.  */
  5. public static String getStackTraceString(Throwable tr) {
  6.     if (tr == null) {
  7.         return "";
  8.     }
  9.     // This is to reduce the amount of log spew that apps do in the non-error
  10.     // condition of the network being unavailable.
  11.     Throwable t = tr;
  12.     while (t != null) {
  13.         if (t instanceof UnknownHostException) {
  14.             return "";
  15.         }
  16.         t = t.getCause();
  17.     }
  18.     StringWriter sw = new StringWriter();
  19.     PrintWriter pw = new PrintWriter(sw);
  20.     tr.printStackTrace(pw);
  21.     pw.flush();
  22.     return sw.toString();
  23. }

通过该方法，可以直接把Throwable对象的堆栈信息都拿出来了。

2 该如何构造一个Throwable

  1. public Throwable() {
  2.     fillInStackTrace();
  3. }
  4. public Throwable(String message) {
  5.     fillInStackTrace();
  6.     detailMessage = message;
  7. }
  8. public Throwable(String message, Throwable cause) {
  9.     fillInStackTrace();
  10.     detailMessage = message;
  11.     this.cause = cause;
  12. }
  13. public Throwable(Throwable cause) {
  14.     fillInStackTrace();
  15.     detailMessage = (cause==null ? null : cause.toString());
  16.     this.cause = cause;
  17. }

他有4个构造方法。每个构造方法都会调用fillInStackTrace()来记录当前的堆栈信息。

只有两个参数可选：String类型的message，和他的cause Throwable。

那么现在来看一下这两个变量对Throwable有什么用，以及对我们来说有什么意义。

先说结论：detailMessage和cause变量在调用printStackTrace()的时候都会被打印出来。

看下printStackTrace()

  1. private void printStackTrace(PrintStreamOrWriter s) {
  2.     // Guard against malicious overrides of Throwable.equals by
  3.     // using a Set with identity equality semantics.
  4.     Set<Throwable> dejaVu =
  5.         Collections.newSetFromMap(new IdentityHashMap<Throwable, Boolean>());
  6.     dejaVu.add(this);
  7.     synchronized (s.lock()) {
  8.         // Print our stack trace
  9.         //打印toString()
  10.         s.println(this);
  11.         //打印详细的堆栈信息
  12.         StackTraceElement[] trace = getOurStackTrace();
  13.         for (StackTraceElement traceElement : trace)
  14.             s.println("\tat " + traceElement);
  15.         // Print suppressed exceptions, if any
  16.         for (Throwable se : getSuppressed())
  17.             se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu);
  18.         // Print cause, if any
  19.         //打印cause
  20.         Throwable ourCause = getCause();
  21.         if (ourCause != null)
  22.             ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu);
  23.     }
  24. }

看下toString是如何包含message进来的：

  1. public String toString() {
  2.     String s = getClass().getName();
  3.     String message = getLocalizedMessage();
  4.     return (message != null) ? (s + ": " + message) : s;
  5. }
  6. public String getLocalizedMessage() {
  7.     return getMessage();
  8. }
  9. public String getMessage() {
  10.     return detailMessage;
  11. }

看下打印cause:

  1. public synchronized Throwable getCause() {
  2.     return (cause==this ? null : cause);
  3. }
  5. private void printEnclosedStackTrace(PrintStreamOrWriter s,
  6.                                      StackTraceElement[] enclosingTrace,
  7.                                      String caption,
  8.                                      String prefix,
  9.                                      Set<Throwable> dejaVu) {
  10.     if (dejaVu.contains(this)) {
  11.         s.println("\t[CIRCULAR REFERENCE:" + this + "]");
  12.     } else {
  13.         dejaVu.add(this);
  14.         // Compute number of frames in common between this and enclosing trace
  15.         StackTraceElement[] trace = getOurStackTrace();
  16.         int m = trace.length - 1;
  17.         int n = enclosingTrace.length - 1;
  18.         while (m >= 0 && n >=0 && trace[m].equals(enclosingTrace[n])) {
  19.             m--; n--;
  20.         }
  21.         int framesInCommon = trace.length - 1 - m;
  22.         // Print our stack trace
  23.         s.println(prefix + caption + this);
  24.         for (int i = 0; i <= m; i++)
  25.             s.println(prefix + "\tat " + trace[i]);
  26.         if (framesInCommon != 0)
  27.             s.println(prefix + "\t... " + framesInCommon + " more");
  28.         // Print suppressed exceptions, if any
  29.         for (Throwable se : getSuppressed())
  30.             se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION,
  31.                                        prefix +"\t", dejaVu);
  32.         // Print cause, if any
  33.         //又调用了getCause()，在这里实际上是一个递归。直到找到最根源的那个cause才会停止。
  34.         Throwable ourCause = getCause();
  35.         if (ourCause != null)
  36.             ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, prefix, dejaVu);
  37.     }
  38. }

可以发现，printEnclosedStackTrace()方法中又调用了getCause()和printEnclosedStackTrace()，那么其实就是一个递归，直到递归到最根源的那个cause。

那么当我们要构造一个Throwable对象的时候，如果上下文中有一个关联的Throwable，那么把他作为cause参数来构造新的Throwable对象，这样能更好地记录问题真正的原因。