java.lang.*中Throwable 源代码详解

迈不过友情╰ 2022-12-24 06:00 159阅读 0赞

### java.lang.\*中Throwable 源代码详解 ###

*   *  Throwable详解
     *  Throwable的使用场景
     *   *  调用方(client)破坏协议
         *  method方法本身无法处理的异常
         *  预料不到的异常
         *  不要轻易捕获Throwable异常
     *  核心方法
     *  public Throwable()
     *  String getMessage()
     *  synchronized Throwable getCause()
     *  synchronized Throwable initCause(Throwable cause)
     *  String toString()
     *  void printStackTrace()
     *  StackTraceElement\[\] getStackTrace()
     *  final synchronized void addSuppressed(Throwable exception)
     *  final synchronized Throwable\[\] getSuppressed()

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！

## Throwable详解 ##

Throwable类是Java语言中所有错误或异常的父类，只有当对象时此类(或者其子类之一)的实例时，才能通过Java虚拟机或者Java throw语句抛出。类似地，只有此类或者其子类之一，才可以是catch子句中的参数类型。  
Throwable的子类有，Exception类、Error类、RuntimeException等等。  
图解如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNDQ2Njg_size_16_color_FFFFFF_t_70_pic_center]

## Throwable的使用场景 ##

对于Throwable类的场景，实际项目当中比较少，更多的是其子类以及派生的子类，主要分为Error、Exception两大派，用于区分项目当中发生的详细异常信息。  
异常体系，主要解决以下两类问题：

*  何时抛异常和抛什么异常
 *  何时抓异常和抓什么异常

### 调用方(client)破坏协议 ###

常见的就是，调用方法时，没有按照约定好的规范来传参数，典型的比如参数是一个非空集合，却传入了空值。这种破坏协议可以细分成两类:  
一类是，调用方从接口形式上不易察觉的规则，但需要在异常发生时，给调用方一些提示信息，这时异常就是很好的方式；  
另一类，是调用方可以明确看到的规则，正常情况下会正确处理协议，不会产生破坏，但可能因为内部的bug导致破坏协议的。比如Integer.parseInt(String args)，虽然args是合法字符串，但不一定是合法数字类型，此处会抛出NumberFormatException异常。

### method方法本身无法处理的异常 ###

对于使用FileInputStream读取文件来说，从调用方的角度来说属于正常逻辑，但从被调用方来说(文件参数本身)，method内部读取的指定文件，根本不存在，此时会抛出FileNotFoundException异常，此时需要结束任务，将异常信息返回给调用者。

### 预料不到的异常 ###

空指针异常、数据越界这些典型的场景，一般是由于代码分支缺少健壮性判断造成的，此类异常是编译时检测不出来的异常，属于运行时异常。

### 不要轻易捕获Throwable异常 ###

应该尽量只去抓关注的异常，明确catch的都是具体的异常类。对于方法本身处理不了的异常，不要去捕获，比如DB连接断开，这种异常在Dao层是无法解决的，需要返回给上层调用者。  
遵循的一个总原则就是：异常捕获宜晚不宜早，抛出异常宜早不宜迟。如果将异常状态流和业务状态流混合在一起了，这样是不符合java异常的处理机制的。

## 核心方法 ##

public class Throwable implements Serializable
    
    public Throwable() 构造方法
    String getMessage() 返回此throwable的详细消息字符串
    synchronized Throwable getCause() 返回导致此抛出动作的源头Throwable对象
    synchronized Throwable initCause(Throwable cause) 设置导致此抛出动作的源头Throwable对象
    String toString() 返回throwable对象的字符串形式
    void printStackTrace() 将此throwable和其追溯打印到标准错误流
    StackTraceElement[] getStackTrace() 
    void setStackTrace(StackTraceElement[] stackTrace) 提供对printStackTrace()打印的堆栈跟踪信息的编程访问
    final synchronized void addSuppressed(Throwable exception) 将指定的异常附加到为了传递此异常而被抑制的异常
    final synchronized Throwable[] getSuppressed() 返回一个包含所有被抑制的异常的数组

## public Throwable() ##

源码如下：

public Throwable() { 
        fillInStackTrace();
    }
    
    public Throwable(String message) { 
        fillInStackTrace();
        detailMessage = message;
    }
    
    public Throwable(String message, Throwable cause) { 
        fillInStackTrace();
        detailMessage = message;
        this.cause = cause;
    }
    
    public Throwable(Throwable cause) { 
        fillInStackTrace();
        detailMessage = (cause==null ? null : cause.toString());
        this.cause = cause;
    }
    
    //fillInStackTrace每次执行的时候，会清空原来的栈内的trace信息
    //告知StackTrace堆栈,回去的时候记录详细异常信息
    public synchronized Throwable fillInStackTrace() { 
        if (stackTrace != null ||
            backtrace != null /* Out of protocol state */ ) { 
            fillInStackTrace(0);
            stackTrace = UNASSIGNED_STACK;
        }
        return this;
    }
    
    //调用JNI接口,其实就是java本地用户调用C代码的API接口
    private native Throwable fillInStackTrace(int dummy);

测试程序：

public class ThrowableSource extends Throwable { 
    
        public static void main(String[] args) { 
            try { 
                testThrowable();
            } catch (Throwable throwable) { 
                System.out.println("抛出的信息：" + throwable.getMessage());
                System.out.println("捕获的对象：" + throwable);
                throwable.printStackTrace();//打印信息的堆栈信息
            }
        }
    
        private static void testThrowable() throws Throwable { 
            Throwable t = new Throwable("错误信息");
    
            Throwable t2 = new Throwable("错误信息2",t);
            throw t2;
        }
    }

测试结果：

抛出的信息：错误信息2
    捕获的对象：java.lang.Throwable: 错误信息2
    java.lang.Throwable: 错误信息2
    	at com.jdk.source.ThrowableSource.testThrowable(ThrowableSource.java:23)
    	at com.jdk.source.ThrowableSource.main(ThrowableSource.java:12)
    Caused by: java.lang.Throwable: 错误信息
    	at com.jdk.source.ThrowableSource.testThrowable(ThrowableSource.java:21)
    	... 1 more
    
    Process finished with exit code 0

## String getMessage() ##

/** * 返回此throwable的详细消息字符串 */
    public String getMessage() { 
        return detailMessage;
    }

## synchronized Throwable getCause() ##

/** * 返回导致此的源头Throwable对象 */
    public synchronized Throwable getCause() { 
        return (cause==this ? null : cause);
    }

## synchronized Throwable initCause(Throwable cause) ##

/** * 设置导致此抛出动作的源头Throwable对象 */
    public synchronized Throwable initCause(Throwable cause) { 
        //如果当前的cause不等于this,那么抛出不能重写异常
        if (this.cause != this)
            throw new IllegalStateException("Can't overwrite cause with " +
                                            Objects.toString(cause, "a null"), this);
        if (cause == this)
            throw new IllegalArgumentException("Self-causation not permitted", this);
        this.cause = cause;
        return this;
    }

## String toString() ##

/** * 返回throwable对象的字符串形式 */
    public String toString() { 
    	//获取当前对象的类名s
        String s = getClass().getName();
        //获取当前对象的message信息
        String message = getLocalizedMessage();
        //如果message不为空,则让s拼接message,否则直接返回s
        return (message != null) ? (s + ": " + message) : s;
    }

## void printStackTrace() ##

/** * 将此throwable和其追溯打印到标准错误流 * 打印throwable对象的详细堆栈信息 */
    public void printStackTrace() { 
        printStackTrace(System.err);
    }
    
    public void printStackTrace(PrintStream s) { 
        printStackTrace(new WrappedPrintStream(s));
    }
    
    //私有内部类WrappedPrintStream
    WrappedPrintStream(PrintStream printStream) { 
        this.printStream = printStream;
    }
    
    private void printStackTrace(PrintStreamOrWriter s) { 
        // Guard against malicious overrides of Throwable.equals by
        // using a Set with identity equality semantics.
        Set<Throwable> dejaVu =
            Collections.newSetFromMap(new IdentityHashMap<Throwable, Boolean>());
        dejaVu.add(this);
    
        synchronized (s.lock()) { 
            // Print our stack trace
            s.println(this);
            StackTraceElement[] trace = getOurStackTrace();
            for (StackTraceElement traceElement : trace)
                s.println("\tat " + traceElement);
    
            // Print suppressed exceptions, if any
            for (Throwable se : getSuppressed())
                se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu);
    
            // Print cause, if any
            Throwable ourCause = getCause();
            if (ourCause != null)
                ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu);
        }
    }

## StackTraceElement\[\] getStackTrace() ##

/** * 提供对printStackTrace()打印的堆栈跟踪信息的编程访问 */
    public StackTraceElement[] getStackTrace() { 
        return getOurStackTrace().clone();
    }
    
    private synchronized StackTraceElement[] getOurStackTrace() { 
        // Initialize stack trace field with information from
        // backtrace if this is the first call to this method
        if (stackTrace == UNASSIGNED_STACK ||
            (stackTrace == null && backtrace != null) /* Out of protocol state */) { 
            int depth = getStackTraceDepth();
            stackTrace = new StackTraceElement[depth];
            for (int i=0; i < depth; i++)
                stackTrace[i] = getStackTraceElement(i);
        } else if (stackTrace == null) { 
            return UNASSIGNED_STACK;
        }
        return stackTrace;
    }

## final synchronized void addSuppressed(Throwable exception) ##

/** * 将指定的异常附加到为了传递此异常而被抑制的异常 */
    public final synchronized void addSuppressed(Throwable exception) { 
        if (exception == this)
            throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE, exception);
    
        if (exception == null)
            throw new NullPointerException(NULL_CAUSE_MESSAGE);
    
        if (suppressedExceptions == null) // Suppressed exceptions not recorded
            return;
    
        if (suppressedExceptions == SUPPRESSED_SENTINEL)
            suppressedExceptions = new ArrayList<>(1);
    
        suppressedExceptions.add(exception);
    }

## final synchronized Throwable\[\] getSuppressed() ##

/** * 返回一个包含所有被抑制的异常的数组 */
    public final synchronized Throwable[] getSuppressed() { 
        if (suppressedExceptions == SUPPRESSED_SENTINEL ||
            suppressedExceptions == null)
            return EMPTY_THROWABLE_ARRAY;
        else
            return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNDQ2Njg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/abceaee2e3ae47b08c2245445d8b13f1.png