如何优雅的处理Lambda中异常?

最新推荐文章于 2024-04-25 14:54:05 发布
最新推荐文章于 2024-04-25 14:54:05 发布
阅读量3.7k 收藏 7
点赞数 4
分类专栏： Java8 文章标签： Java8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37607679/article/details/102789878
版权

在这里插入图片描述

1.如何优雅的处理Lambda中异常?

java8新增的特性Lambda表达式为我们使用匿名内部类提供了非常简洁的方式。然而，平时在使用lambda的过程发，却发现lambda表达式中如果存在异常，使用try-catch去处理异常，那么这个lambda表达式就会看起来非常臃肿。

在lambda中使用try-catch处理异常：

     List<String> list = Arrays.asList("海", "上", "月", "是", "天", "上", "月");

     list.forEach(e -> {
         try{
             Integer integer = Integer.valueOf(e);
         }catch (Exception ex){
             System.err.println("发生异常  :"+ex.toString());
         }
            
     });

这么做其实也没有什么问题。只不过在视觉上看着非常臃肿，破坏了lambda简洁的效果。除了使用try-catch的方式去处理异常，我们还可以选择throw的方式将异常抛出去。

但是实际上lambda对受检异常和非受检异常的上抛处理方式支持是不同的。

		List<String> list = Arrays.asList("海", "上", "月", "是", "天", "上", "月");
		// 非受检异常  编译通过
        list.forEach(e-> {
            throw  new RuntimeException();
        });
		// 受检异常 编译不通过
        list.forEach(e -> {
            throw  new IOException();
        });

可以看到，受检异常是不能抛出去的，编译无法通过。我们就只能使用try-catch或者将异常抛出去从而处理这个异常。

如果我们将异常从方法上再次抛出去呢?

@Test
public void test02() throws  IOException{

    List<String> list = Arrays.asList("海", "上", "月", "是", "天", "上", "月");
    //编译不通过
    list.forEach(e -> {
        throw  new IOException();
    });


}

很难过的是，对于受检异常，这样的做法也是不被允许的。

那么该如何简洁又优雅的处理lambda中的异常呢？

对于非受检异常，使用包装方法来进行处理：

List<String> list = Arrays.asList("海", "上", "月", "是", "天", "上", "月");

list.forEach(
        HandlingConsumerWrapper.handlingConsumerWrapper(e->{
    System.out.println(Integer.valueOf(e));
}));


/**
 * @ClassName handlingConsumerWrapper
 * @Description 对lambda异常进行处理的包装类
 * @Date 2019-10-25 下午 6:04
 * @Version V1.0
 */
public class HandlingConsumerWrapper {

    private static final Logger logger = LoggerFactory.getLogger(HandlingConsumerWrapper.class);

    public static <T> Consumer<T> handlingConsumerWrapper(Consumer<T> throwingConsumer){

        return  i -> {

            try{

                throwingConsumer.accept(i);
            }
            catch (Exception e){

                logger.error(" 处理lambda中的异常发生异常 "+e.toString());

            }

        };
    }

}

简单来说，就是将本来要传入的Consumer接口的实现，传入handlingConsumerWrapper方法中，并对其中的异常进行处理，然后再返回一个Consumer接口的实现。

这样来处理，在lambda中既可以处理异常又可以保证代码的简洁。不会让lambda显得很臃肿。

对于受检异常，需要自己定义一个函数接口：

/**
 * @ClassName ThrowingConsumer
 * @Description 封装consumer接口异常的接口
 * @Author
 * @Date 2019-10-25 下午 6:02
 * @Version V1.0
 */
@FunctionalInterface
public interface ThrowingConsumer<T, E extends Exception> {
	//对异常选择上抛	原consumer接口没有上抛 才使得不好处理
    void accept (T t)throws Exception;
}

 List<String> list = Arrays.asList("海", "上", "月", "是", "天", "上", "月");

        list.forEach(
                HandlingConsumerWrapper.handlingConsumerWrapper(e->{
                    File file = new File("");
                    file.createNewFile();
                }));
}


public static <T,E extends Exception>  Consumer<T> handlingConsumerWrapper(ThrowingConsumer<T, E> throwingConsumer){

    return  i -> {

        try{
			//处理函数接口抛上来的异常
            throwingConsumer.accept(i);
          
        }catch (Exception e){

            logger.error(" 处理lambda中的异常发生异常 "+e.toString());

        }

    };
}

这里实际上是定义了一个函数接口ThrowingConsumer，ThrowingConsumer的方法和Consumer接口一致，只不过抛出了异常，这样我们才可以在包装方法中处理受检异常。

上述两种方法实际上都是将异常在包装方法中进行了处理。下面说一下一定要将异常抛出方法的情况：

对于一定想要将异常抛出方法的情况：

//可以将异常抛出来了
@Test
public void test_Consumer_with_checked_exceptions() throws IllegalAccessException, ClassNotFoundException {
    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));
}

//定义可以抛出异常的函数接口
@FunctionalInterface
public interface Consumer_WithExceptions<T, E extends Exception> {
    void accept(T t) throws E;
}


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

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

可以看到，其实大体上和try-catch的处理是基本一致的。只不过在将异常catch之后，将异常全部作为非受检异常抛了出去。但是这种情况就可以将异常都上抛给调用的方法进行处理了。

处理lambda的工具类：

package com.uplus.gateway.util.lambda;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @ClassName LambdaExceptionUtil
 * @Description
 * @Author
 * @Date 2019-10-27 下午 3:16
 * @Version V1.0
 */
public class LambdaExceptionUtil {

    @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;
    }
}

在这里插入图片描述

咋看都像坏蛋
关注
专栏目录
lambda处理异常四种方式
gb4215287的博客
09-13 934
lambda处理异常四种方式
这样也行,在lambda表达式中优雅的处理checked exception
BASK2311的博客
04-13 183
以上就是如何在lambda表达式中优雅的进行异常转换的例子了。大家使用的过程中一定要注意最后对异常的捕获。好了，本文的代码：本文的例子作者：程序那些事链接：https://juejin.cn/post/7221126755329933371。
golang java8_如何优雅地在 Java 8 中处理异常
weixin_39636608的博客
02-15 210
#### 前言Java 8 引入的流 (Stream) API 和 lambda 表达式为我们打开了新世界的大门，自此之后我们也可以在 Java 中进行函数式编程了。然而，在实际工作中，许多小伙伴并不知道如何正确的在 lambda 中处理异常，今天就来给大家讲解一下。![](https://upload-images.jianshu.io/upload_images/11633898-cf1651...
java的lambda如何优雅处理异常
qrycsa的博客
10-26 52
1. 丑陋的写法 引入lambda的原因是代码更简洁，如果lambda中有异常处理代码，就会变成下面的样子。 在lambda表达式中，如果需要处理异常，加入try-catch，那么使用lambda简化代码的效果就会消失。那我为啥还要使用lambda呢？ //遍历文件夹中的文件，输出文件的大小，File.size方法会抛出IOException，需要try-catch public stat...
优雅的处理Lambda异常
水木小窝
09-08 578
Lambda中的异常处理 在Lambda中使用try-catch处理是比较丑陋的，那么如何优雅的处理异常昵？ 我们可以采取将异常包装的方式进行处理，下面将以Function函数为例 新建一个函数接口，该接口抛出异常 @FunctionalInterface public interface CheckExceptionFunction<T, R> { R apply(T t) throws Exception; } 新建一个函数工具类，方便调用 public class L
lambda表达式异常应该如何处理
u010896467的博客
07-22 1857
lambda表达式异常应该如何处理 java 8中引入了lambda表达式，lambda表达式可以让我们的代码更加简介，业务逻辑更加清晰，但是在lambda表达式中使用的Functional Interface并没有很好的处理异常，因为JDK提供的这些Functional Interface通常都是没有抛出异常的，这意味着需要我们自己手动来处理异常。 因为异常分为Unchecked Exception和checked Exception,我们分别来讨论。 处理Unchecked Exception Unch
Kotlin中如何优雅地处理空指针异常？有哪些避免空指针的方法？
最新发布
FredaSophy的博客
04-25 969
而Kotlin通过其独特的设计，提供了更加优雅和安全的方式来处理空值，从而避免了空指针异常的发生。）在某些情况下可能看起来方便，因为它会在运行时检查变量是否为null，并抛出空指针异常（如果为null的话），但通常建议避免使用它，因为它破坏了Kotlin的空安全特性。然而，在某些你确信变量不会为null，但编译器无法确定的情况下，可以使用非空断言操作符来告诉编译器“相信我，这个不会是null”。当然，除了Kotlin提供的这些工具外，良好的编程习惯和代码规范也是避免空指针异常的重要一环。
优雅地在Java 8中处理异常的方法详解
08-26
在Java 8中，异常处理有了新的方式，特别是在使用流(Stream) API和lambda表达式时。传统的try-catch块在lambda表达式中显得不够优雅，因为它们会破坏代码的简洁性。本文将介绍如何在Java 8中更优雅地处理异常。 ...
StreamUnthrower,lambda表达式中的异常.zip
09-26
总的来说，`StreamUnthrower`提供了一种优雅的方式来处理Lambda表达式中可能遇到的检查异常，使得在使用Java 8的流API时，能够更好地遵循异常处理的最佳实践。通过阅读和研究这个开源项目，开发者可以增强对Java异常...
Lambda表达式中的异常处理
在Java等编程语言中，Lambda表达式可以让我们写出更具有可读性和简洁性的代码。 ## 1.2 Lambda表达式的语法 Lambda表达式通常由参数列表、箭头符号（->）和方法体组成。下面是Lambda表达式的基本语法： ```java ...
教妹学 Java：异常处理机制
沉默王二
07-13 2167
“二哥，今天就要学习异常了吗？”三妹问。 “是的。只有正确地处理好异常，才能保证程序的可靠性，所以异常的学习还是很有必要的。”我说。 “那到底什么是异常呢？”三妹问。 “异常是指中断程序正常执行的一个不确定的事件。当异常发生时，程序的正常执行流程就会被打断。一般情况下，程序都会有很多条语句，如果没有异常处理机制，前面的语句一旦出现了异常，后面的语句就没办法继续执行了。” “有了异常处理机制后，程序在发生异常的时候就不会中断，我们可以对异常进行捕获，然后改变程序执行的流程。” “除此之外，异常处理机制可以保证
lambda stream流处理异常的方法/Either不终止stream流处理异常
日常记录
11-12 1702
当你在使用一个抛出checkedException的函数式，如果你想要在lambda里使用它，你需要做一些额外的工作，比如将异常包装成RuntimeException是一种可行的方案。这种方法非常适合创建一个简单的工具包装函数，然后每次你只需要调用这个检查函数而不必再写try/catch。 如果你想进一步控制异常并在不终止stream的需求下，可以使用Either来再对函数包装，把异常和正确执行结果分开处理。
java 8 lambda表达式中的异常处理
V539413949的博客
04-30 4338
简介 java 8中引入了lambda表达式，lambda表达式可以让我们的代码更加简介，业务逻辑更加清晰，但是在lambda表达式中使用的Functional Interface并没有很好的处理异常，因为JDK提供的这些Functional Interface通常都是没有抛出异常的，这意味着需要我们自己手动来处理异常。 因为异常分为Unchecked Exception和checked Exception,我们分别来讨论。 处理Unchecked Exception Unchecked exception
Lambda表达式中的异常
qq_31192711的博客
01-17 587
Java引入了已检异常的概念。与早期的方法相比，强制开发人员管理异常的想法是革命性的。现在，Java仍然是唯一广泛使用的提供已检异常的语言。例如，Kotlin中的每个异常都是未检查的。即使在Java中，新特性也和已检异常不一致:Java内置函数式接口的签名不使用异常。在lambda中集成遗留代码时，代码会变得很麻烦。这在溪流中很明显。在这篇文章中，我想深入探讨如何管理这样的问题。
详解lambda表达式（一）：表达式定义与异常处理
m0_64694079的博客
08-11 1155
详解lambda表达式，第一篇，表达式定义与异常处理
Java高级-Lambda 表达式、异常处理、集合、泛型、List集合、Map集合、Collections类
m0_65696574的博客
10-28 1213
学习笔记
lambda表达式异常处理工具
文若书生的专栏
02-17 442
lambda表达式可以让我们的代码更加简介，业务逻辑更加清晰，但是在lambda表达式中使用的Functional Interface并没有很好的处理异常，因为JDK提供的这些Functional Interface通常都是没有抛出异常的，这意味着需要我们自己手动来处理异常。 Lambda表达式能够自动抛出非检查异常，检查异常，必须catch，如果每个表达式都去处理，代码会非常臃肿，可以看一下如下代码： private List<String> list = Arrays.asList("1.
lambda表达式无法抛出异常
xiao_dondon的博客
01-21 8150
背景：在一个方法中使用了lambda表达式，表达式中需要捕获异常，使用throws关键字发现并不起作用，必须使用trycatch才行 public class BeanUtil { public static &lt;T,R&gt; List&lt;R&gt; copyList(List&lt;T&gt; source , Class&lt;R&gt; clazz) throws E...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值