Spring8中lambda表达式的学习(Function接口、BiFunction接口、Consumer接口)

代码重构，为了确保功能的等效性，梳理代码时，发现如下代码：

 public  SingleRespTTO fundI(SingleReqTTO request) throws Exception {

     return handlerSingleReq((req, logInfo) -> {

         // 业务操作

         ....略....

     }, request);

 }

 public SingleRespTTO handlerSingleReq(BiConsumer<SingleReqTTO, SingleRespTTO> consumer,

                                           SingleReqTTO request) throws Exception {

     // 业务操作

     consumer.accept(request, respTTO);

         ....略....

     return respTTO;

 }

问题：

fundI(SingleReqTTO request)方法实现很简单：

直接调用handlerSingleReq(BiConsumer<SingleReqTTO, SingleRespTTO> consumer,SingleReqTTO request)方法并返回，而handlerSingleReq的参数1 consumer是个lambda表达式：

(req, logInfo) -> {
// 业务操作
....略....
}

1、lambda表达式的方法参数是啥

这个lambda表达式有2个参数：req, logInfo，这是哪来的？

2、方法执行顺序是啥

lambda作为参数，包含有方法体（很明显还是个内部实现），先执行该lambda的内部逻辑呢还是先执行的handlerSingleReq方法体呢？

解析：

lambda的三个概念：Function接口、BiFunction接口、Consumer接口分析

问题答案：

Java8 内置的四大核心函数式接口：

内置的四大核心函数式接口
函数式接口	参数类型	返回类型	用途
Consumer<T> 消费型接口	T	void	对类型为T的对象应用操作，包含方法 : void accept(T t)
Supplier<T> 供给型接口	无	T	返回类型为T的对象，包含方法 : T get()
Function<T, R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象，包含方法 : R apply(T t)
Predicate<T> 断定型接口	T	Boolean	确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法 : boolean test(T t)

函数式接口，具体请参考：

https://blog.csdn.net/chenshun123/article/details/78122467

https://www.cnblogs.com/knowledgesea/p/3163725.html

https://blog.csdn.net/qq_28410283/article/details/80618456

https://blog.csdn.net/qq_29848473/article/details/79554472

简单一句话：只要是@FunctionalInterface 修饰的接口都是函数式接口，就可以通过lambda表达式简化代码（lambda最大的优势就是简洁的代码）

查看代码，这里调用的是，查看源码如下：

 @FunctionalInterface

 public interface BiConsumer<T, U> {

     /**

      * Performs this operation on the given arguments.

      *

      * @param t the first input argument

      * @param u the second input argument

      */

     void accept(T t, U u);

     /**

      * Returns a composed {@code BiConsumer} that performs, in sequence, this

      * operation followed by the {@code after} operation. If performing either

      * operation throws an exception, it is relayed to the caller of the

      * composed operation.  If performing this operation throws an exception,

      * the {@code after} operation will not be performed.

      *

      * @param after the operation to perform after this operation

      * @return a composed {@code BiConsumer} that performs in sequence this

      * operation followed by the {@code after} operation

      * @throws NullPointerException if {@code after} is null

      */

     default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {

         Objects.requireNonNull(after);

         return (l, r) -> {

             accept(l, r);

             after.accept(l, r);

         };

     }

 }

解释：

接口有一个 accept方法，必须自己实现，它接收两个泛型参数，而另一个方法是默认实现好的方法；

简单测试下：

     public static void main(String[] args) {

         BiConsumer<Integer,String> biconsumer = (x,y) -> {

             int a = x + 2;

             System.out.println(a);//

             System.out.println("----"+y);// ----我爱你

         };

         biconsumer.accept(10,"我爱你");

         System.out.println("-----执行andThen()方法--------");

         BiConsumer<Integer,String> afterBiconsumer = (x,y) -> {

             int a = x + 8;

             System.out.println(a);//

             System.out.println("----"+y);// ----哇呀呀

         };

         biconsumer.andThen(afterBiconsumer).accept(10,"哇呀呀");

     }

 }

结论：

BiFunction接口暴露的accept方法必须实现，并且是执行的入口（默认实现的andThen()方法，如果调用会执行两次accept方法，首先执行accept方法，然后执行传入的BiConsumer引用对象的accept方法方法）

lambda表达式中，BiFunction接口实现体自己不会去执行，它只是实现了accept方法，只有手工去调用它的时候才会执行accept方法体的内容。。。

而且，它接受的2个参数，是调用的时候传递过去的，方法体中只是声明为泛型。。。

一切都明了：

1、lambda方法参数是啥

handlerSingleReq方法中，consumer.accept(request, respTTO)调用了lambda的的accept方法，参数就在这传递

2、方法执行顺序是啥

只有调用的时候才执行，handlerSingleReq方法顺序执行，consumer.accept(request, respTTO)时执行lambda方法体中的内容...

巴特西

Spring8中lambda表达式的学习(Function接口、BiFunction接口、Consumer接口)

最新文章

热门文章