简化异常处理的Throwables类

转载：https://www.cnblogs.com/peida/p/Guava_Throwables.html

也许你会想：为什么要帮我们处理异常呢？我们自己不会抛出异常吗？

假定下面的方法是我们要调用的方法。

public void doSomething() throws Throwable {
    //ignore method body
}

public void doSomethingElse() throws Exception {
    //ignore method body
}

这两个方法的签名一个throws出了Throwable另外一个throws出了Exception，他们没有定义具体会抛出什么异常，也就是说他们什么异常都有可能抛出来，如果我们要调用这样的方法，就需要对他们的异常做一些处理了，我们需要判断什么样的异常需要抛出去，什么样的异常需要封装成RuntimeException。而这些事情就是Throwables类要帮我们做的事情。

假定我们要实现一个doIt的方法，该方法要调用doSomething方法，而doIt的定义中只允许抛出SQLException，我们可以这样做：

public void doIt() throws SQLException {
    try {
        doSomething();
    } catch (Throwable throwable) {
        Throwables.propagateIfInstanceOf(throwable, SQLException.class);
        Throwables.propagateIfPossible(throwable);
    }
}

请注意doIt的catch块，下面这行代码的意思是如果异常的类型是SQLException，那么抛出这个异常

Throwables.propagateIfInstanceOf(throwable, SQLException.class);

第二行表示如果异常是Error类型，那么抛出这个类型，否则将抛出RuntimeException，我们知道RuntimeException是不需要在throws中声明的。

Throwables.propagateIfPossible(throwable);

有时候, 当我们我们捕获异常, 并且像把这个异常传递到下一个try/catch块中。Guava提供了一个异常处理工具类, 可以简单地捕获和重新抛出多个异常。例如：

import java.io.IOException;
import org.junit.Test;
import com.google.common.base.Throwables;

public class ThrowablesTest {
    
    @Test
    public void testThrowables(){
        try {
            throw new Exception();
        } catch (Throwable t) {
            String ss = Throwables.getStackTraceAsString(t);
            System.out.println("ss:"+ss);
            Throwables.propagate(t);
        }
    }
    
    @Test
    public void call() throws IOException {
        try {
            throw new IOException();
        } catch (Throwable t) {
            Throwables.propagateIfInstanceOf(t, IOException.class);
            throw Throwables.propagate(t);
        }
    }    
}

将检查异常转换成未检查异常,例如：

import java.io.InputStream;
import java.net.URL;
import org.junit.Test;
import com.google.common.base.Throwables;

public class ThrowablesTest {
    
    @Test
    public void testCheckException(){
        try {  
            URL url = new URL("http://ociweb.com");  
            final InputStream in = url.openStream();  
            // read from the input stream  
            in.close();  
        } catch (Throwable t) {  
            throw Throwables.propagate(t);  
        }  
    }
}

传递异常的常用方法：

1.RuntimeException propagate(Throwable)：把throwable包装成RuntimeException，用该方法保证异常传递，抛出一个RuntimeException异常
　　2.void propagateIfInstanceOf(Throwable, Class) throws X：当且仅当它是一个X的实例时，传递throwable
　　3.void propagateIfPossible(Throwable)：当且仅当它是一个RuntimeException和Error时，传递throwable
　　4.void propagateIfPossible(Throwable, Class) throws X：当且仅当它是一个RuntimeException和Error时，或者是一个X的实例时，传递throwable。

使用实例：

import java.io.IOException;
import org.junit.Test;
import com.google.common.base.Throwables;

public class ThrowablesTest {
@Test
public void testThrowables(){
try {
throw new Exception();
} catch (Throwable t) {
String ss = Throwables.getStackTraceAsString(t);
System.out.println(“ss:”+ss);
Throwables.propagate(t);
}
}

@Test
public void call() throws IOException {
    try {
        throw new IOException();
    } catch (Throwable t) {
        Throwables.propagateIfInstanceOf(t, IOException.class);
        throw Throwables.propagate(t);
    }
}

public Void testPropagateIfPossible() throws Exception {
      try {
          throw new Exception();
      } catch (Throwable t) {
        Throwables.propagateIfPossible(t, Exception.class);
        Throwables.propagate(t);
      }

      return null;
}

}

Guava的异常链处理方法：

1.Throwable getRootCause(Throwable)
　　2.List getCausalChain(Throwable)
　　3.String getStackTraceAsString(Throwable)