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);// 12
            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);// 18
            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方法体中的内容...