前言

如果我们想要将公共的部分抽取出来，发现都比较零散，还不如不抽取，但是不抽取代码又存在大量重复的代码不符合我的风格。于是我便将手伸向了 Consumer 接口。

背景

没错，我还在做 XXXX 项目，还在与第三方对接接口，不同的是这次是对自己业务逻辑的处理。

在开发过程中我遇到这么一个问题：

表结构：一张主表A ，一张关联表B ，表 A 中存储着表 B 记录的状态。

场景：第一步创建主表数据，插入A表;第二步调用第三方接口插入B表同时更新A表的状态。此时大家应该都会想到在进行第二步的时候需要做好数据的幂等性。这样的话就会存在以下几种情况：

一、B表中不存在与A表关联的数据，此时需要调用第三方接口，插入B表同时更新A表的状态;

二、B表中存在与A表关联的数据;

A表中的状态为处理中：直接返回处理中字样;

A表中的状态为处理成功：直接返回成功的字样;

A表中的状态为处理失败：此时需要调用第三方接口，更新B表同时更新A表的状态;

代码实现

首先我是这样编写的伪代码

1. B b = this.baseMapper.selectOne(queryWrapper); 
2. if (b != null) { 
3.  String status = b.getStatus(); 
4.  if (Objects.equals(Constants.STATUS_ING, status)){ 
5.   return "处理中"; 
6.  } else if (Objects.equals(Constants.STATUS_SUCCESS, status)){ 
7.   return "处理成功"; 
8.  } 
9.  //失败的操作 
10.  //请求第三方接口并解析响应结果 
11.  ...... 
12.  if (ReturnInfoEnum.SUCCESS.getCode().equals(parse.getCode())) { 
13.         ...... 
14.         //更新B表操作 
15.   bb.setStatus(Constants.STATUS_ING); 
16.   mapper.updateById(bb); 
17.   //更新A表的状态 
18.   a.setStatus(Constants.STATUS_ING); 
19.   aMapper.updateById(a); 
20.  } 
21.   
22. } else { 
23.  //请求第三方接口并解析响应结果 
24.  ...... 
25.  if (ReturnInfoEnum.SUCCESS.getCode().equals(parse.getCode())) { 
26.         ...... 
27.         //插入B表操作 
28.   bb.setStatus(Constants.STATUS_ING); 
29.   mapper.insert(bb); 
30.   //更新A表的状态 
31.   a.setStatus(Constants.STATUS_ING); 
32.   aMapper.updateById(a); 
33.  } 
34. } 

不知道细心的小伙伴是否发现，存在B表记录并且状态为“失败”的情况和不存在B表的情况除了插入B表或者更新B表的操作之外，其余的操作都是相同的。

如果我们想要将公共的部分抽取出来，发现都比较零散，还不如不抽取，但是不抽取代码又存在大量重复的代码不符合我的风格。于是我便将手伸向了 Consumer 接口。

更改之后的伪代码

1. B b = this.baseMapper.selectOne(queryWrapper); 
2. if (b != null) { 
3.  String status = b.getStatus(); 
4.  if (Objects.equals(Constants.STATUS_ING, status)){ 
5.   return "处理中"; 
6.  } else if (Objects.equals(Constants.STATUS_SUCCESS, status)){ 
7.   return "处理成功"; 
8.  } 
9.  //失败的操作 
10.  getResponse(dto, response, s -> mapper.updateById(s)); 
11. } else { 
12.  getResponse(dto, response, s -> mapper.updateById(s)); 
13. } 
14. public void getResponse(DTO dto, Response response, Consumer<B> consumer){ 
15.  //请求第三方接口并解析响应结果 
16.  ...... 
17.  if (ReturnInfoEnum.SUCCESS.getCode().equals(parse.getCode())) { 
18.         ...... 
19.   bb.setStatus(Constants.STATUS_ING); 
20.   
21.   consumer.accept(bb); 
22.   //更新A表的状态 
23.   a.setStatus(Constants.STATUS_ING); 
24.   aMapper.updateById(a); 
25.  } 
26. } 

看到这，如果大家都已经看懂了，那么恭喜你，说明你对 Consumer 的使用已经全部掌握了。如果你还存在一丝丝的疑虑，那么就接着往下看，我们将介绍一下四种常见的函数式接口。

正在上传…重新上传取消​

函数式接口

那什么是函数式接口呢?函数式接口是只有一个抽象方法(Object的方法除外)，但是可以有多个非抽象方法的接口，它表达的是一种逻辑上的单一功能。

@FunctionalInterface

@FunctionalInterface 注解用来表示该接口是函数式接口。它有助于及早发现函数式接口中出现的或接口继承的不适当的方法声明。

如果接口用该注解来注释，但实际上不是函数式接口，则会在编译时报错。

Consumer

我们一般称之为“消费者”，它表示接受单个输入参数但不返回结果的操作。不同于其它函数式接口，Consumer 预期通过副作用进行操作。

那什么又是副作用呢?说一下我所理解的副作用，副作用其实就是一个函数是否会修改它范围之外的资源，如果有就叫有副作用，反之为没有副作用。比如修改全局变量，修改输入参数所引用的对象等。

1. @FunctionalInterface 
2. public interface Consumer<T> { 
3.     /** 
4.      *  对给定的参数执行此操作。 
5.      */ 
6.     void accept(T t); 
7.     /** 
8.      *  
9.      *  返回一个组合的 Consumer ，依次执行此操作，然后执行after操作。 
10.      *  如果执行任一操作会抛出异常，它将被转发到组合操作的调用者。 
11.      *  如果执行此操作会引发异常，则不会执行after操作。 
12.      */ 
13.     default Consumer<T> andThen(Consumer<? super T> after) { 
14.         Objects.requireNonNull(after); 
15.         return (T t) -> { accept(t); after.accept(t); }; 
16.     } 
17. } 

正如我们案例中遇到的场景，我们只需要将要执行的逻辑方法当作参数传入 getResponse() 中，然后在该方法中执行 accept() 方法进行消费即可。如果还不理解，我们可以把它转换为匿名内部类的调用方式。

1. getResponse(dto, response, new Consumer<B>() { 
2.    @Override 
3.    public void accept(B bb) { 
4.      mapper.insert(bb); 
5.    } 
6. ); 

当调用accept() 方法的时候就会去调用匿名内部类的方法了，也就是我们传入 getResponse() 的逻辑方法。

Supplier

我们一般称之为“生产者”，没有参数输入，但是能返回结果，为结果的提供者。

1. @FunctionalInterface 
2. public interface Supplier<T> { 
3.     /** 
4.      *  获取一个结果 
5.      */ 
6.     T get(); 
7. } 

可以举个简单的例子感受下：

1. Optional<Double> optional = Optional.empty(); 
2. optional.orElseGet(()->Math.random() ); 
3. //orElseGet 方法的源码，里边用到了 get 方法 
4. public T orElseGet(Supplier<? extends T> other) {    
5.     return value != null ? value : other.get(); 
6. } 

Function

我把它称为“转换者”，表示接收一个参数通过处理之后返回一个结果的函数。

1. @FunctionalInterface 
2. public interface Function<T, R> { 
3.     /** 
4.      *  将 T 类型的参数传入，经过函数表达式的计算，返回 R 类型的结果 
5.      */ 
6.     R apply(T t); 
7.     /** 
8.      * 返回一个组合函数，先将参数应用于 before 函数，然后将结果应用于当前函数，返回最终结果。 
9.      * 如果对任一函数的求值引发异常，则会将其转发给组合函数的调用方。 
10.      */ 
11.     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { 
12.         Objects.requireNonNull(before); 
13.         return (V v) -> apply(before.apply(v)); 
14.     } 
15.     /** 
16.      * 返回一个组合函数，先将参数应用与当前函数，然后将结果应用于 after 函数，返回最终的结果。 
17.      * 如果对任一函数的求值引发异常，则会将其转发给组合函数的调用方。  
18.      */ 
19.     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { 
20.         Objects.requireNonNull(after); 
21.         return (T t) -> after.apply(apply(t)); 
22.     } 
23.     /** 
24.      *  返回始终返回其输入参数的函数。 
25.      */ 
26.     static <T> Function<T, T> identity() { 
27.         return t -> t; 
28.     } 
29. } 

我们在 lambda 表达式中应用比较多，所以我们来简单演示下：

1. @Data 
2. @AllArgsConstructor 
3. public class Teacher { 
4.     private String name; 
5.     private int age; 
6. } 
7. public class TeacherTest { 
8.     public static void main(String[] args) { 
9.        List<Teacher> list = Arrays.asList( 
10.             new Teacher("张三",25), 
11.             new Teacher("李四",28), 
12.             new Teacher("王五",18)); 
13.       List<String> collect = list.stream().map(item -> item.getName()).collect(Collectors.toList()); 
14.       System.out.println(collect); 
15.     } 
16. } 

其中 map 接收的参数就是 Function 类型， item 为传入参数，item.getName() 为返回处理的结果，最后输出结果为

1. [张三, 李四, 王五] 

Predicate

我们称之为“判断者”，通过接收参数 T 来返回 boolean 的结果。

1. @FunctionalInterface 
2. public interface Predicate<T> { 
3.     /** 
4.      *  接收一个参数, 判断这个参数是否匹配某种规则, 匹配成功返回true, 匹配失败则返回false 
5.      */ 
6.     boolean test(T t); 
7.     /** 
8.      *  接收一个 Predicate 类型的参数，用当前函数和 other 函数逻辑与判断参数 t 是否匹配规则，成功返回true，失败返回 false  
9.      *  如果当前函数返回 false，则 other 函数不进行计算 
10.      * 在评估 Predicate 期间引发的任何异常都会转发给调用方 
11.      */ 
12.     default Predicate<T> and(Predicate<? super T> other) { 
13.         Objects.requireNonNull(other); 
14.         return (t) -> test(t) && other.test(t); 
15.     } 
16.     /** 
17.      *  返回当前Predicate取反操作之后的Predicate 
18.      */ 
19.     default Predicate<T> negate() { 
20.         return (t) -> !test(t); 
21.     } 
22.     /** 
23.      *  接收一个 Predicate 类型的参数，用当前函数和 other 函数 逻辑或 判断参数 t 是否匹配规则，成功返回true，失败返回 false  
24.      *  如果当前函数返回 true，则 other 函数不进行计算 
25.      * 在评估 Predicate 期间引发的任何异常都会转发给调用方 
26.      */ 
27.     default Predicate<T> or(Predicate<? super T> other) { 
28.         Objects.requireNonNull(other); 
29.         return (t) -> test(t) || other.test(t); 
30.     } 
31.     /** 
32.      *  静态方法：传入一个参数，用来生成一个 Predicate，调用test() 方法时调的 object -> targetRef.equals(object) 函数式 
33.      * 
34.      */ 
35.     static <T> Predicate<T> isEqual(Object targetRef) { 
36.         return (null == targetRef) 
37.                 ? Objects::isNull 
38.                 : object -> targetRef.equals(object); 
39.     } 
40. } 

相信大家在编码过程中经常会遇到该函数式接口，我们举个例子来说一下：

1. public static void main(String[] args) { 
2.     List<Teacher> list = Arrays.asList( 
3.         new Teacher("张三",25), 
4.         new Teacher("李四",28), 
5.         new Teacher("王五",18)); 
6.     list = list.stream().filter(item -> item.getAge()>25).collect(Collectors.toList()); 
7.     list.stream().forEach(item->System.out.println(item.getName())); 
8. } 

其中 filter() 的参数为 Predicate 类型的，返回结果为：李四

看到这儿，我们常见的四种函数式接口就已经介绍完了。说实话，函数式接口我已经看过好几遍了，尤其是 Consumer 和 Supplier。当时只是脑子里学会了，没有应用到具体的项目中，下次再遇到的时候还是一脸懵逼，不知道大家有没有这种感受。

所以我们需要总结经验教训，一定要将代码的原理搞懂，然后多敲几遍，争取应用到自己的项目中，提升自己的编码能力。