[Guava源码日报]（7）Throwables分析

有时候，你会想把捕获到的异常再次抛出。这种情况通常发生在Error或RuntimeException被捕获的时候，你没想捕获它们，但是声明捕获Throwable和Exception的时候，也包括了了Error或RuntimeException。Guava提供了若干方法，来判断异常类型并且重新传播异常。

例如：

try {    someMethodThatCouldThrowAnything();} catch (IKnowWhatToDoWithThisException e) {    // 处理异常     handle(e);} catch (Throwable t) {    // 继续抛出异常    Throwables.propagateIfInstanceOf(t, IOException.class);    Throwables.propagateIfInstanceOf(t, SQLException.class);    throw Throwables.propagate(t);}

所有这些方法都会自己决定是否要抛出异常，但也能直接抛出方法返回的结果——例如，throw Throwables.propagate(t);—— 这样可以向编译器声明这里一定会抛出异常。

1.void propagateIfInstanceOf(Throwable throwable,Class<X> declaredType) throws X

Throwable类型为X才抛出

public static <X extends Throwable> void propagateIfInstanceOf(      @Nullable Throwable throwable, Class<X> declaredType) throws X {    // Check for null is needed to avoid frequent JNI calls to isInstance().    if (throwable != null && declaredType.isInstance(throwable)) {      throw declaredType.cast(throwable);    }  }

如果Throwable类型与给定的异常类型一致，会直接抛出该异常，否则不做任何操作。

例子：

@Test    public void test1() throws IOException {        try {            throw new RuntimeException("RuntimeException");        }        catch (Throwable t) {            Throwables.propagateIfInstanceOf(t, IOException.class);            System.out.println(t.getMessage()); // RuntimeException        }    }    @Test    public void test2() throws IOException {        try {            throw new IOException("IOException");        }        catch (Throwable t) {            Throwables.propagateIfInstanceOf(t, IOException.class);  // java.io.IOException: IOException        }    }

2. void propagateIfPossible(Throwable throwable)

Throwable类型为Error或RuntimeException才抛出。

public static void propagateIfPossible(@Nullable Throwable throwable) {    propagateIfInstanceOf(throwable, Error.class);    propagateIfInstanceOf(throwable, RuntimeException.class);  }

举例：

@Test    public void test3() throws IOException {        try {            throw new IOException("IOException");        }        catch (Throwable t) {            Throwables.propagateIfPossible(t);            System.out.println(t.getMessage()); // IOException        }    }    @Test    public void test4() throws IOException {        try {            throw new RuntimeException("RuntimeException");        }        catch (Throwable t) {            Throwables.propagateIfPossible(t); // java.lang.RuntimeException: RuntimeException            System.out.println(t.getMessage()); // 得不到执行        }    }

3.void propagateIfPossible(Throwable throwable,Class<X> declaredType)

Throwable类型为Error，RuntimeException或者X才抛出。

public static <X extends Throwable> void propagateIfPossible(      @Nullable Throwable throwable, Class<X> declaredType) throws X {    propagateIfInstanceOf(throwable, declaredType);    propagateIfPossible(throwable);  }

方法中调用propagateIfPossible(throwable)方法，因此Throwable类型为Error或RuntimeException才抛出。

4. RuntimeException propagate(Throwable throwable)

如果Throwable是Error或RuntimeException，直接抛出；否则把Throwable包装成RuntimeException抛出。返回类型是RuntimeException，所以你可以写成throw Throwables.propagate(t)，Java编译器会意识到这行代码保证抛出异常。

public static RuntimeException propagate(Throwable throwable) {    propagateIfPossible(checkNotNull(throwable));    throw new RuntimeException(throwable);  }

propagate方法调用propagateIfPossible方法，因此Throwable是Error或RuntimeException，直接抛出。如果不是，throw new RuntimeException，把Throwable包装成RuntimeException抛出。

T doSomething() {    try {        return someMethodThatCouldThrowAnything();    }     catch (IKnowWhatToDoWithThisException e) {        return handle(e);    }     catch (Throwable t) {        throw Throwables.propagate(t);    }}

备注：

模仿Java7的多重异常捕获和再抛出

通常来说，如果调用者想让异常传播到栈顶，他不需要写任何catch代码块。因为他不打算从异常中恢复，他可能就不应该记录异常，或者有其他的动作。他可能是想做一些清理工作，但通常来说，无论操作是否成功，清理工作都要进行，所以清理工作可能会放在finallly代码块中。但有时候，捕获异常然后再抛出也是有用的：也许调用者想要在异常传播之前统计失败的次数，或者有条件地传播异常。

当只对一种异常进行捕获和再抛出时，代码可能还是简单明了的。但当多种异常需要处理时，却可能变得一团糟：

@Override public void run() {    try {        delegate.run();    } catch (RuntimeException e) {        failures.increment();        throw e;    }catch (Error e) {        failures.increment();        throw e;    }}

Java7用多重捕获解决了这个问题：

} catch (Throwable t) {    failures.increment();    throw t;}

解决办法是用throw Throwables.propagate(t)替换throw t。在限定情况下（捕获Error和RuntimeException），Throwables.propagate和原始代码有相同行为。然而，用Throwables.propagate也很容易写出有其他隐藏行为的代码。尤其要注意的是，这个方案只适用于处理RuntimeException 或Error。如果catch块捕获了受检异常，你需要调用propagateIfInstanceOf来保留原始代码的行为，因为Throwables.propagate不能直接传播受检异常。

5. List<Throwable> getCausalChain(Throwable throwable)

方法返回一个Throwable对象集合，从堆栈的最顶层依次到最底层。

public static List<Throwable> getCausalChain(Throwable throwable) {    checkNotNull(throwable);    List<Throwable> causes = new ArrayList<Throwable>(4);    while (throwable != null) {      causes.add(throwable);      throwable = throwable.getCause();    }    return Collections.unmodifiableList(causes);  }

通过throwable.getCause()方法得到引起该异常的上一级异常。

例子：

@Test    public void test5() {        ExecutorService executor = Executors.newSingleThreadExecutor();        Callable<FileInputStream> callable = new Callable<FileInputStream>() {            @Override            public FileInputStream call() throws Exception {                return new FileInputStream("a.txt");            }        };        Future<FileInputStream> fisFuture = executor.submit(callable);        try {            fisFuture.get();        }        catch (Exception e) {            // 得到异常链            List<Throwable> throwAbles = Throwables.getCausalChain(e);            for(Throwable throwable : throwAbles){                System.out.println(throwable.getClass().toString());            }//for            // class java.util.concurrent.ExecutionException            // class java.io.FileNotFoundException        }        executor.shutdownNow();    }

在这个例子中，我们创建了一个Callable实例期望返回一个FileInputStream对象，我们故意制造了一个 FileNotFoundException。之后，我们将Callable实例提交给ExecutorService，并返回了Future引用。当我 们调用Future.get方法，抛出了一个异常，我们调用Throwables.getCausalChain方法获取到具体的异常链。

6. Throwable getRootCause(Throwable throwable)

Throwables.getRootCause方法接收一个Throwable实例，并返回根异常信息。

public static Throwable getRootCause(Throwable throwable) {    Throwable cause;    while ((cause = throwable.getCause()) != null) {      throwable = cause;    }    return throwable;  }

例子：

public void test5() {        ExecutorService executor = Executors.newSingleThreadExecutor();        Callable<FileInputStream> callable = new Callable<FileInputStream>() {            @Override            public FileInputStream call() throws Exception {                return new FileInputStream("a.txt");            }        };        Future<FileInputStream> fisFuture = executor.submit(callable);        try {            fisFuture.get();        }        catch (Exception e) {            // 得到异常链            Throwable throwable = Throwables.getRootCause(e);            System.out.println(throwable.getClass().toString());            // class java.io.FileNotFoundException        }        executor.shutdownNow();    }

这个例子和上一个例子是一样的，只不过这个例子只是返回的根异常信息。