[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();
    }

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