Skip to main content
 首页 » 编程设计

Java Lambda 异常处理

2022年07月19日189lhb25

Java 8 Lambda 异常处理

java8 lambda表达式利用函数式编程提供精简的方式表达行为。然而,JDK函数式接口没有很好地处理异常,使得处理异常代码非常臃肿和麻烦。本文探讨在lambda表达式中处理异常的一些方式。

处理非检查异常

首先我们通过示例来说明问题。有List和常量除,比如50和list中每个元素除并打印出结果:

List<Integer> integers = Arrays.asList(3, 9, 7, 6, 10, 20); 
integers.forEach(i -> System.out.println(50 / i));

上述代码正常工作,但有问题。如果list有元素值为0,那么会抛出异常ArithmeticException: / by zero。我们利用传统的try-catch块处理该异常,打印异常内容并继续执行一个元素:

List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(i -> { 
    try { 
        System.out.println(50 / i); 
    } catch (ArithmeticException e) { 
        System.err.println( 
          "Arithmetic Exception occured : " + e.getMessage()); 
    } 
});

利用try-catch块解决了问题,但没有了lambda表达式的精简性,不再是一个小函数了。为了解决这个问题,我们给lambda函数写一个lambda包装器。请看代码:

static Consumer<Integer> lambdaWrapper(Consumer<Integer> consumer) { 
    return i -> { 
        try { 
            consumer.accept(i); 
        } catch (ArithmeticException e) { 
            System.err.println( 
              "Arithmetic Exception occured : " + e.getMessage()); 
        } 
    }; 
}

然后进行调用:

List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(lambdaWrapper(i -> System.out.println(50 / i)));

上面代码我们首先定义包装方法负责处理异常,然后将其作为参数传给遍历方法。通过包装方法解决了问题,但你可能争辩这仅仅从一个地方删除try-catch,移动到另一个方法中,实际并没有减少代码。

这时事实,因为包装器仅给特定的类型使用,但我们可以使用泛型提升包装方法的使用范围:

static <T, E extends Exception> Consumer<T> 
  consumerWrapper(Consumer<T> consumer, Class<E> clazz) {
    
 
    return i -> { 
        try { 
            consumer.accept(i); 
        } catch (Exception ex) { 
            try { 
                E exCast = clazz.cast(ex); 
                System.err.println( 
                  "Exception occured : " + exCast.getMessage()); 
            } catch (ClassCastException ccEx) { 
                throw ex; 
            } 
        } 
    }; 
}

调用代码:

List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(consumerWrapper(i -> System.out.println(50 / i),  ArithmeticException.class));

你看到包装方法带两个参数,lamdba表达式和捕获异常类型。lamdba包装器能够处理任何类型,不仅是Integer,也可以捕获任何类型的异常,而不仅是超类Exception。

你可能注意到包装器的方法名从lambdaWrapper改成了consumerWrapper。那是因为这个方法仅处理Consumer类型的函数接口的lambda表达式。同样我们也可以定义其他函数接口的包装方法,如:Function, BiFunction, BiConsumer 等。

处理检查异常

考虑之前的示例,我们不再除元素并打印结果至控制台,我们想写至文件,该操作会抛出异常IOException:

static void writeToFile(Integer integer) throws IOException { 
    // logic to write to file which throws IOException 
}
List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(i -> writeToFile(i));

一旦编译,会出现下面错误:

java.lang.Error: Unresolved compilation problem: Unhandled exception type IOException

因为IOException异常是检查异常,代码必须处理。现在我们有两种方法,通过throw签名方法让调用者处理,或在lambda方法内部处理。下面分别进行讨论。

从Lambda表达式中throw检查异常

在包括lambda表达式的方法上通过throw抛出异常:

public static void main(String[] args) throws IOException { 
    List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
    integers.forEach(i -> writeToFile(i)); 
}

然而,编译仍然报相同的未处理异常IOException,因为lambda表达式类似于匿名内部类。在这种情况下,lambda表达式是带有accept(T t)方法的Consumer接口的实现。从main方法中throw异常没有意义,因为在父接口中的方法没有throw任何异常,其实现中也不能有throw异常:

Consumer<Integer> consumer = new Consumer<Integer>() { 
 
    @Override 
    public void accept(Integer integer) throws Exception { 
        writeToFile(integer); 
    } 
};

上面代码不能编译,因为accept实现方法不能throw任何异常。最直接方法使用try-catch块并包装检查异常至非检查异常并重新throw:

List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(i -> { 
    try { 
        writeToFile(i); 
    } catch (IOException e) { 
        throw new RuntimeException(e); 
    } 
});

通过这个方法获得编译器通过并正常工作,但出现了和前面提及的问题一样。既然我们仅项抛出异常,我们只需要定义自己的Consumer 函数接口可以抛出异常,然后在包装方法中使用,下面定义ThrowingConsumer:

@FunctionalInterface 
public interface ThrowingConsumer<T, E extends Exception> {
    
    void accept(T t) throws E; 
}
static <T> Consumer<T> throwingConsumerWrapper( 
  ThrowingConsumer<T, Exception> throwingConsumer) { 
 
    return i -> { 
        try { 
            throwingConsumer.accept(i); 
        } catch (Exception ex) { 
            throw new RuntimeException(ex); 
        } 
    }; 
}

现在我们可以写lambda表达式,既可以抛异常也不失简洁性。

List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(throwingConsumerWrapper(i -> writeToFile(i)));

处理Lambda表达式中检查异常

最后,我们仅需要修改包装器使其可以处理检查异常。既然ThrowingConsumer 使用泛型,我们能处理任何类型异常:

static <T, E extends Exception> Consumer<T> handlingConsumerWrapper( 
  ThrowingConsumer<T, E> throwingConsumer, Class<E> exceptionClass) {
    
 
    return i -> { 
        try { 
            throwingConsumer.accept(i); 
        } catch (Exception ex) { 
            try { 
                E exCast = exceptionClass.cast(ex); 
                System.err.println( 
                  "Exception occured : " + exCast.getMessage()); 
            } catch (ClassCastException ccEx) { 
                throw new RuntimeException(ex); 
            } 
        } 
    }; 
}

我们能使用该包装器处理IOException,包装器把任何其他检查异常至一个非检查异常:

List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20); 
integers.forEach(handlingConsumerWrapper( i -> writeToFile(i), IOException.class));

与处理非检查异常一样,其他类似的函数接口也可类似处理,如ThowingFunction, ThrowingBiFunction, ThrowingBiConsumer 。

总结

本文我们介绍了如何使用包装器在lambda表达式中处理特定异常并不失简洁性。学习了如何定义自己的函数式接口,通过包装可以把检查异常变为非检查异常并处理。


本文参考链接:https://blog.csdn.net/neweastsun/article/details/82557509
阅读延展