java 8 lambda表达式中的异常处理

Posted 2023-04-02 Lydia Bess

简介

java 8中引入了lambda表达式，lambda表达式可以让我们的代码更加简介，业务逻辑更加清晰，但是在lambda表达式中使用的Functional Interface并没有很好的处理异常，因为JDK提供的这些Functional Interface通常都是没有抛出异常的，这意味着需要我们自己手动来处理异常。

因为异常分为Unchecked Exception和checked Exception,我们分别来讨论。

处理Unchecked Exception

Unchecked exception也叫做RuntimeException，出现RuntimeException通常是因为我们的代码有问题。RuntimeException是不需要被捕获的。也就是说如果有RuntimeException，没有捕获也可以通过编译。

我们看一个例子：

List<Integer> integers = Arrays.asList(1,2,3,4,5);
        integers.forEach(i -> System.out.println(1 / i));

这个例子是可以编译成功的，但是上面有一个问题，如果list中有一个0的话，就会抛出ArithmeticException。

虽然这个是一个Unchecked Exception，但是我们还是想处理一下：

        integers.forEach(i -> 
            try 
                System.out.println(1 / i);
             catch (ArithmeticException e) 
                System.err.println(
                        "Arithmetic Exception occured : " + e.getMessage());
            
        );

上面的例子我们使用了try，catch来处理异常，简单但是破坏了lambda表达式的最佳实践。代码变得臃肿。

我们将try，catch移到一个wrapper方法中：

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

则原来的调用变成这样：

integers.forEach(lambdaWrapper(i -> System.out.println(1 / i)));

但是上面的wrapper固定了捕获ArithmeticException，我们再将其改编成一个更通用的类：

    static <T, E extends Exception> Consumer<T>
    consumerWrapperWithExceptionClass(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;
                
            
        ;
    

上面的类传入一个class，并将其cast到异常，如果能cast，则处理，否则抛出异常。

这样处理之后，我们这样调用：

integers.forEach(
                consumerWrapperWithExceptionClass(
                        i -> System.out.println(1 / i),
                        ArithmeticException.class));

处理checked Exception

checked Exception是必须要处理的异常，我们还是看个例子：

    static void throwIOException(Integer integer) throws IOException 
    

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
        integers.forEach(i -> throwIOException(i));

上面我们定义了一个方法抛出IOException，这是一个checked Exception，需要被处理，所以在下面的forEach中，程序会编译失败，因为没有处理相应的异常。

最简单的办法就是try，catch住，如下所示：

        integers.forEach(i -> 
            try 
                throwIOException(i);
             catch (IOException e) 
                throw new RuntimeException(e);
            
        );

当然，这样的做法的坏处我们在上面已经讲过了，同样的，我们可以定义一个新的wrapper方法：

    static <T> Consumer<T> consumerWrapper(
            ThrowingConsumer<T, Exception> throwingConsumer) 

        return i -> 
            try 
                throwingConsumer.accept(i);
             catch (Exception ex) 
                throw new RuntimeException(ex);
            
        ;
    

我们这样调用：

integers.forEach(consumerWrapper(i -> throwIOException(i)));

我们也可以封装一下异常：

static <T, E extends Exception> Consumer<T> consumerWrapperWithExceptionClass(
            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);
                
            
        ;
    

然后这样调用：

integers.forEach(consumerWrapperWithExceptionClass(
                i -> throwIOException(i), IOException.class));

总结

本文介绍了如何在lambda表达式中处理checked和unchecked异常，希望能给大家一些帮助。

愿与诸君共进步，大量的面试题及答案还有资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系，可以微信搜索539413949获取，最后祝大家都能拿到自己心仪的offer

Java 8 lambda表达式中的异常处理

1 概述

在Java 8 中，当写lambda表达式并处理异常时代码变得冗余不堪，本文主要介绍lambda表达式中一些异常处理方式。

2 处理 Unchecked 异常

下面的代码，当i为0时会引发ArithmeticException异常。

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

通常的做法是通过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后代码不再像以前一样简洁。我们可以通过写一个包装方法来进行处理。

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)));

通过编写包装方法lambdaWrapper并接收一个lambda表达式，在该方法内会进行异常处理。因此对于同类问题就可以避免反复写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));

类似的可以根据实际需求写出各种类型的函数式接口包装类，如Function, BiFunction, BiConsumer等。

3 处理 Checked 异常

这个例子中writeToFile会抛出IOException。IOException是一个Checked异常，所以必须处理。因此要么抛出要么捕获。

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));

3.1 从Lambda表达式中抛出Checked异常

throws抛出异常仍然会提示错误unhandled IOException。

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

尝试实现Consumer，并指定accept抛出Exception，仍然错误。因为accept定义中并未
抛出任何异常。

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

最直接的处理方法是通过try…catch捕获。

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

其次我们可以通过自定义函数式接口并声明方法抛出异常。

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

编写包装类，接着使用，这样在foreach中方法不但可以抛出异常同时又能保持简洁性。

static <T> Consumer<T> throwingConsumerWrapper(
  ThrowingConsumer<T, Exception> throwingConsumer) 
  
    return i -> 
        try 
            throwingConsumer.accept(i);
         catch (Exception ex) 
            throw new RuntimeException(ex);
        
    ;

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

3.2 在Lambda表达式中处理Checked异常

接着对throwingConsumerWrapper进行改造，使其能接收一个异常类型参数。

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);
            
        
    ;

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

类似的，可以根据实际需求编写ThowingFunction, ThrowingBiFunction, ThrowingBiConsumer。

4 结束语

本文主要介绍了java 8Lamda表达式的异常处理方式，如果希望使用现成的工具可以考虑Vavr或ThrowingFunction，这两个工具值得一看。vavr的功能简介可参考https://blog.csdn.net/revivedsun/article/details/80088080。

5 原文地址

http://www.baeldung.com/java-lambda-exceptions