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

标签: Guava 源码
445人阅读 评论(0) 收藏 举报
分类:

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

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

查看评论

Google Guava学习(5)-Guava Throwables类

1.功能:简化的异常处理 2.代码: package com.example.google.guava.demo.clazz; import com.example.google.guava.dem...
  • baidu_30809315
  • baidu_30809315
  • 2017-10-19 11:31:49
  • 95

Guava学习笔记【5】:简化异常处理的Throwables类

有时候, 当我们我们捕获异常, 并且像把这个异常传递到下一个try/catch块中。Guava提供了一个异常处理工具类, 可以简单地捕获和重新抛出多个异常。例如: import java.i...
  • azhegps
  • azhegps
  • 2017-05-08 23:56:08
  • 257

[Guava]Throwables:简化异常和错误的传播与检查

1. 异常传播有时候,你会想把捕获到的异常再次抛出。这种情况通常发生在 Error 或 RuntimeException 被捕获的时候,你没想捕获它们,但是声明捕获 Throwable 和 Excep...
  • SunnyYoona
  • SunnyYoona
  • 2017-08-14 20:28:30
  • 574

Java-类库-Guava-Throwables类

有时候, 当我们我们捕获异常, 并且像把这个异常传递到下一个try/catch块中。Guava提供了一个异常处理工具类, 可以简单地捕获和重新抛出多个异常。import java.io.IOExcep...
  • youdianjinjin
  • youdianjinjin
  • 2016-07-02 17:33:32
  • 476

[Google Guava]--Throwables类

简介:Throwable类提供了相关的Throwable接口的实用方法。类声明以下是com.google.common.base.Throwables类的声明:public final class T...
  • w372426096
  • w372426096
  • 2018-03-13 18:41:17
  • 11

Guava cacha 机制及源码分析

Guava 是Google开源出来的Java常用工具集库,包括集合,缓存,并发,字符串,I/O操作等在Java开发过程中经常需要去实现的工具类。 在平常开发过程中,很多情况需要使用缓存来避免频繁...
  • u013851082
  • u013851082
  • 2017-04-21 13:49:16
  • 1369

知乎日报 API 分析(如何规范api设计)

知乎日报 API 分析 Xiao Liang edited this page on 30 Sep · 41 revisions  Pages 2 H...
  • h330531987
  • h330531987
  • 2017-12-06 05:39:09
  • 268

【项目源码】- 【模仿知乎日报二】吐血高仿知乎日报

对之前的模仿做品进行了改善改善。。。再改善。。。(仅供学习) 多说无益。。。。上图才是王道: 这个东西越模仿发现他的东西就越多,离上次的模仿时间已经过去好久了,这一版本的界面看似好很多,...
  • wduj123
  • wduj123
  • 2016-06-03 18:39:48
  • 1384

[Guava源码日报](2)Strings分析

我们先看大体看一下Strings的源码: //// Source code recreated from a .class file by IntelliJ IDEA// (powered by...
  • SunnyYoona
  • SunnyYoona
  • 2016-03-04 21:30:28
  • 1263

[Guava源码日报](3)Joiner分析

把任意的字符串,通过一些分隔符将它们连接起来是大多数程序员经常处理东西。以前的方式就是迭代,append等操作,使用Joiner可以更方便。我们先看一下以前的处理方式:// 通过分隔符将字符串链接在一...
  • SunnyYoona
  • SunnyYoona
  • 2017-05-02 11:01:43
  • 426
    个人资料
    专栏达人 持之以恒
    等级:
    访问量: 159万+
    积分: 2万+
    排名: 371
    博客专栏
    最新评论