Lamdas绕过try / catch块以检查异常

如何解决Lamdas绕过try / catch块以检查异常

由于我尝试提取我在大多数项目中使用的一些常见的包装lambda例程，因此我得以创建CheckedFunction（由PermeableFunction子类化）的功能接口，从而绕过了需求尝试/捕获块。我已经在Windows（v1.8.0_251）/ linux（v1.8.0_261）和其他几个在线编译器的Oracle jdks上进行了测试（不确定在那里使用了哪种实现）。

不确定这是否确实违反了规范或标准是否允许...根据我对docs的解释，这应该是不可能的：

更确切地说，假设B是类或接口，而A是B的超类或超接口，并且B中的方法声明n覆盖或隐藏A中的方法声明m。然后：

• 如果n具有引发任何检查过的异常类型的throws子句，则m必须具有throws子句，否则会发生编译时错误。
  
• 对于n的throws子句中列出的每个检查的异常类型，必须在m的throws子句的擦除（第4.6节）中出现相同的异常类或其超类之一；否则，将发生编译时错误。
  
• 如果m的未擦除throws子句在n的throws子句中不包含每种异常类型的超类型，则会发生编译时未经检查的警告。

这是我使用的示例代码：

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.function.Function;

public class Main {

    public static void main(String[] args) {

        PermeableFunction<Path,Long> function = PermeableFunction.from(Files::size);

        Path doesNotExist = Paths.get("/does/not/exist");

        // function.apply(doesNotExist); -> throws WrappedException
        function.applyChecked(doesNotExist); // throws NoSuchFileException without the need of a try/catch block!
    }
}

interface PermeableFunction<T,R> extends CheckedFunction<T,R,RuntimeException> {

    static <T,R> PermeableFunction<T,R> from(WrappedFunction<T,R> wrappedFunction) {

        return CheckedFunction.<T,RuntimeException>from(wrappedFunction)::applyChecked;
    }
}

interface CheckedFunction<T,E extends Exception> extends WrappedFunction<T,R> {

    @Override
    R applyChecked(T t) throws E;

    static <T,E extends Exception> CheckedFunction<T,E> from(WrappedFunction<T,R> wrappedFunction) {

        return wrappedFunction::applyChecked;
    }
}

interface WrappedFunction<T,R> extends Function<T,R> {

    R applyChecked(T t) throws Exception;

    @Override
    default R apply(T t) {

        try {

            return applyChecked(t);

        } catch (Exception e) {

            throw new WrappedException(e);
        }
    }
}

class WrappedException extends RuntimeException {

    public WrappedException(Throwable cause) {
        super(cause);
    }
}

CheckedFunction还允许对可抛出对象进行阴影处理，如下所示：

这是我的问题：

这是应该报告给实施者的问题，还是该标准强加的普遍问题？

解决方法

您的方法

static <T,R,E extends Exception> CheckedFunction<T,E> from(WrappedFunction<T,R> wrappedFunction) {
    return wrappedFunction::applyChecked;
}

我的Eclipse版本以及9至14的所有JDK中的javac都拒绝了

。只有JDK 8接受了它，所以这是一个错误，但不值得报告，因为较新的版本没有它。

也就是说，可以通过泛型类型系统来颠覆异常检查。

将方法更改为

static <T,R> wrappedFunction) {
    return (CheckedFunction)(CheckedFunction<T,Exception>)wrappedFunction::applyChecked;
}

所有编译器都将接受它，但是会产生“未经检查”的警告。这是已知的事情。

您可以将示例简化为：

public class Main {
    public static void main(String[] args) {
        CheckedFunction<Path,Long,RuntimeException> function = (CheckedFunction)
            (CheckedFunction<Path,IOException>)Files::size;
        Path doesNotExist = Paths.get("/does/not/exist");

        function.applyChecked(doesNotExist); // throws NoSuchFileException without the need of a try/catch block!
    }

    interface CheckedFunction<T,E extends Exception> {
        R applyChecked(T t) throws E;
    }
}

即使没有lambda表达式，也可能有多种变体。它所需要的只是一个使用类型参数的throws声明和与此类型参数有关的未经检查的操作。

例如

public class Main {
    public static void main(String[] args) {
        try {
            Files.size(Paths.get("/does/not/exist"));
        }
        catch(IOException ex) {
            doThrow(ex); // throws undeclared IOException
        }
    }

    static <T extends Throwable> void doThrow(Throwable t) throws T {
        throw (T)t;
    }
}

如前所述，这是众所周知的，但总的来说，您永远不应忽略“未经检查”的警告。