如何从外部块重新抛出一个lambda块中的异常？

Question

使用以下代码，

void key(Key) throws SomeCheckedException {
}

void supplier(Supplier<Key> s) throws SomeCheckedException {
    ofNullable(s).ifPresent(s -> {                   //    |
        try {                                        //    |
            key(s.get());                            //    |
        } catch (final SomeCheckedException sce) {   //    |
            // sce is coming from key() method       //    |
            // How can I throw sce for outer method? //  --/
        }
    });
}

我sce该如何抛出方法（supplier）方法一样的方法？

请注意，以上代码仅是示例。我需要在key(s.get())lambda表达式内。

void supplier(Supplier<Key> s) throws SomeCheckException {
    key(s.get());
}

Answer 1

如果您想以安全的方式处理已检查的异常，则需要一个辅助方法，该方法提供了将异常包装为的子类型的便利RuntimeException。这是一个使用Generic的类型安全性的帮助程序函数，以确保仅声明的异常将被重新抛出（除非您使用不安全的操作）：

public static <E extends Throwable> void attempt(
    Consumer<Function<E,RuntimeException>> action) throws E {

    final class CarryException extends RuntimeException {
        final E carried;
        CarryException(E cause) {
            super(cause);
            carried=cause;
        }
    }

    try { action.accept( CarryException::new ); }
    catch(CarryException ex) { throw ex.carried; }
}

它支持任意方法action，该方法将接收将检查的异常类型临时包装到的函数RuntimeException。这种包装将是透明的，该方法attempt将正常完成或抛出原始的已检查异常E（如果发生，则抛出不相关的未检查异常）。

因此，您可以像这样使用它：

public static void processIterm(Supplier<Key> s)
    throws SomeCheckedException  {

    attempt( (Function<SomeCheckedException, RuntimeException> thrower) ->
        Optional.ofNullable(s).ifPresent(nonNull -> {
            try { key(nonNull.get()); } // assuming key may throw SomeCheckedException
            catch(SomeCheckedException  e) { throw thrower.apply(e); }
        }));
}

由于嵌套操作，编译器无法自动推断异常类型。上面的代码使用thrower参数类型的显式声明。或者，您可以使用辅助方法的类型调用，例如

ContainingClass.<SomeCheckedException>attempt( thrower ->
    Optional.ofNullable(s).ifPresent(nonNull -> {
        try { key(nonNull.get()); }
        catch(SomeCheckedException  e) { throw thrower.apply(e); }
    }));