[Guava源码日报](7)Throwables分析

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/SunnyYoona/article/details/71079798

有时候,你会想把捕获到的异常再次抛出。这种情况通常发生在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();
    }

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

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页