Java 8方法引用未处理的异常

Question

我正在使用Java 8进行项目,发现了一种我无法理解的情况.

我有这样的代码:

void deleteEntity(Node node) throws SomeException {
    for (ChildNode child: node.getChildren()) {
       deleteChild(child);
    }
}

void deleteChild(Object child) throws SomeException {
    //some code
}

这段代码工作正常,但我可以用方法引用重写它:

void deleteEntity(Node node) throws SomeException {
    node.getChildren().forEach(this::deleteChild);
}

并且此代码无法编译,从而产生错误Incompatible thrown types *SomeException* in method reference.

IDEA也给了我错误unhandled exception.

所以,我的问题是为什么？为什么代码为每个循环编译而不用lambda编译？

Answer 1

如果你看一下Consumer<T>接口的accept方法(这是你的方法引用将有效使用什么)没有声明抛出任何checked异常-所以你不能使用它的方法引用被声明为抛出checked异常.增强的for循环是可以的,因为你总是在一个SomeException可以抛出的上下文中.

您可能会创建一个包装器,将已检查的异常转换为未经检查的异常,然后抛出该异常.或者,您可以使用一个accept()方法声明您自己的函数接口,该方法会抛出一个已检查的异常(可能使用该异常参数化参数),然后编写您自己的forEach方法,将该功能接口作为输入.

Answer 2

你可以试试这个:

void deleteEntity(Node node) throws SomeException {     node.getChildren().forEach(UtilException.rethrowConsumer(this::deleteChild));
    }

下面的UtilException帮助程序类允许您在Java流中使用任何已检查的异常.注意上面的流也抛出了抛出的原始检查异常this::deleteChild,而不是一些包装未经检查的异常.

public final class UtilException {

@FunctionalInterface
public interface Consumer_WithExceptions<T, E extends Exception> {
    void accept(T t) throws E;
    }

@FunctionalInterface
public interface BiConsumer_WithExceptions<T, U, E extends Exception> {
    void accept(T t, U u) throws E;
    }

@FunctionalInterface
public interface Function_WithExceptions<T, R, E extends Exception> {
    R apply(T t) throws E;
    }

@FunctionalInterface
public interface Supplier_WithExceptions<T, E extends Exception> {
    T get() throws E;
    }

@FunctionalInterface
public interface Runnable_WithExceptions<E extends Exception> {
    void run() throws E;
    }

/** .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or .forEach(rethrowConsumer(ClassNameUtil::println)); */
public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) throws E {
    return t -> {
        try { consumer.accept(t); }
        catch (Exception exception) { throwAsUnchecked(exception); }
        };
    }

public static <T, U, E extends Exception> BiConsumer<T, U> rethrowBiConsumer(BiConsumer_WithExceptions<T, U, E> biConsumer) throws E {
    return (t, u) -> {
        try { biConsumer.accept(t, u); }
        catch (Exception exception) { throwAsUnchecked(exception); }
        };
    }

/** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName)) */
public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E {
    return t -> {
        try { return function.apply(t); }
        catch (Exception exception) { throwAsUnchecked(exception); return null; }
        };
    }

/** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))), */
public static <T, E extends Exception> Supplier<T> rethrowSupplier(Supplier_WithExceptions<T, E> function) throws E {
    return () -> {
        try { return function.get(); }
        catch (Exception exception) { throwAsUnchecked(exception); return null; }
        };
    }

/** uncheck(() -> Class.forName("xxx")); */
public static void uncheck(Runnable_WithExceptions t)
    {
    try { t.run(); }
    catch (Exception exception) { throwAsUnchecked(exception); }
    }

/** uncheck(() -> Class.forName("xxx")); */
public static <R, E extends Exception> R uncheck(Supplier_WithExceptions<R, E> supplier)
    {
    try { return supplier.get(); }
    catch (Exception exception) { throwAsUnchecked(exception); return null; }
    }

/** uncheck(Class::forName, "xxx"); */
public static <T, R, E extends Exception> R uncheck(Function_WithExceptions<T, R, E> function, T t) {
    try { return function.apply(t); }
    catch (Exception exception) { throwAsUnchecked(exception); return null; }
    }

@SuppressWarnings ("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E { throw (E)exception; }

}

关于如何使用它的许多其他示例(静态导入后UtilException):

@Test
public void test_Consumer_with_checked_exceptions() throws IllegalAccessException {
    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
          .forEach(rethrowConsumer(className -> System.out.println(Class.forName(className))));

    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
          .forEach(rethrowConsumer(System.out::println));
    }

@Test
public void test_Function_with_checked_exceptions() throws ClassNotFoundException {
    List<Class> classes1
          = Stream.of("Object", "Integer", "String")
                  .map(rethrowFunction(className -> Class.forName("java.lang." + className)))
                  .collect(Collectors.toList());

    List<Class> classes2
          = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
                  .map(rethrowFunction(Class::forName))
                  .collect(Collectors.toList());
    }

@Test
public void test_Supplier_with_checked_exceptions() throws ClassNotFoundException {
    Collector.of(
          rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))),
          StringJoiner::add, StringJoiner::merge, StringJoiner::toString);
    }

@Test    
public void test_uncheck_exception_thrown_by_method() {
    Class clazz1 = uncheck(() -> Class.forName("java.lang.String"));

    Class clazz2 = uncheck(Class::forName, "java.lang.String");
    }

@Test (expected = ClassNotFoundException.class)
public void test_if_correct_exception_is_still_thrown_by_method() {
    Class clazz3 = uncheck(Class::forName, "INVALID");
    }

但在了解以下优点,缺点和限制之前,请不要使用它:

•如果调用代码要处理已检查的异常,则必须将其添加到包含该流的方法的throws子句中.编译器不会强迫你再添加它,因此更容易忘记它.

•如果调用代码已经处理了已检查的异常,编译器将提醒您将throws子句添加到包含流的方法声明中(如果不这样做,则会说:异常永远不会在相应的try语句的主体中抛出).

•在任何情况下,您将无法包围流本身以捕获已检查的异常INSIDE包含流的方法(如果您尝试,编译器将说:异常永远不会在相应的try语句的主体中抛出).

•如果您正在调用一个字面上永远不会抛出它声明的异常的方法,那么您不应该包含throws子句.例如:new String(byteArr,"UTF-8")抛出UnsupportedEncodingException,但Java规范保证UTF-8始终存在.在这里,投掷声明是一个麻烦,任何解决方案,以最小的样板沉默它是受欢迎的.

•如果你讨厌检查异常,并认为它们永远不应该被添加到Java语言中(越来越多的人这样认为,而我不是其中之一),那么就不要将已检查的异常添加到throws包含流的方法的子句.然后,检查的异常将表现得像UNchecked异常.

•如果您正在实现一个严格的接口,其中您没有添加throws声明的选项,但抛出异常是完全合适的,那么为了获得抛出它的特权而包装异常会导致带有虚假异常的堆栈跟踪没有提供实际出错的信息.一个很好的例子是Runnable.run(),它不会抛出任何已检查的异常.在这种情况下,您可以决定不将已检查的异常添加到包含该流的方法的throws子句中.

•在任何情况下,如果您决定不将(但忘记添加)已检查的异常添加到包含流的方法的throws子句中,请注意抛出CHECKED异常的这两个后果:

1)调用代码将无法通过名称捕获它(如果您尝试,编译器将说:异常永远不会在相应的try语句的主体中抛出).它会冒泡并可能​​在主程序循环中被一些"捕获异常"或"捕获Throwable"捕获,这可能是你想要的.

2)它违反了最少惊喜的原则:捕获RuntimeException以便能够保证捕获所有可能的异常将不再足够.出于这个原因,我认为这不应该在框架代码中完成,而只能在您完全控制的业务代码中完成.

总结:我认为这里的局限并不严重,UtilException可以毫无畏惧地使用该课程.但是,这取决于你!

• 参考文献:
  • http://www.philandstuff.com/2012/04/28/sneakily-throwing-checked-exceptions.html
  • http://www.mail-archive.com/javaposse@googlegroups.com/msg05984.html
  • 龙目岛项目注释:@SneakyThrows
  • Brian Goetz的观点(反对):我如何从Java 8流中抛出CHECKED异常？
  • https://softwareengineering.stackexchange.com/questions/225931/workaround-for-java-checked-exceptions?newreg=ddf0dd15e8174af8ba52e091cf85688e*