[TOC]

最近太忙了，发文频率有点不稳定，理解万岁。前面和大家说了要更 WebFlux，学习 WebFlux 之前，我们先来学习一些前置知识。

Rome was not built in a day。

WebFlux 也不是一帮人拍脑门突然发明的，它是一个漫长的过程，WebFlux 本身在逐步完善，各种配套工具/理论也在逐步发展。

因此当松哥想写 WebFlux 的时候，发现没法直接从 WebFlux 本身开始写起，对于很多没有接触过函数式编程的人来说，上来就整 WebFlux 还是有一些挑战的，想来想去，我觉得还是先来和大家捋一捋 JDK8 中的一些旧玩意。

虽然 JDK8 发布距今已经七八年了，但是相信还是有相当多小伙伴用着 JDK8，写着 JDK6 的代码。所以我们有必要回顾一下 JDK8，也算是我们学习 WebFlux 的一些前置知识。

好啦，开整吧。

1.Lambda 表达式的四种写法

JDK8 中引入了 Lambda，这个大家都知道，虽然现在 JDK 都出到 16 了，但是老实说，项目中的 Lambda 表达式似乎还是很少有人用。有的团队技术风格激进，可能会见到很多 Lambda，但是大部分技术团队还是比较保守的。今天为了学习 WebFlux，我们还是先来回顾一下 Lambda 表达式的几种写法。

先来说说，如果要用 Lambda，必须是只有一个需要强制实现方法的接口，我们可以使用 @FunctionalInterface 注解去标记该接口：

@FunctionalInterface
interface ICalculator{
    int square(int i);
}

此时如果该接口中有多个空方法，编译期间就会报错。

现在我们建议尽量将一个接口设计的小一些，这样也满足单一职责原则。

不过 JDK8 中引入了 default 方法，就是自带默认实现的那种，自带默认实现的方法可以有多个，这个并不影响 Lambda，并且 @FunctionalInterface 注解也不会去检查默认方法的数量。

1.1 单个参数的

如果只是一个参数，那么直接写参数即可，例如如下代码：

interface ICalculator{
    int square(int i);
}
public class LambdaDemo01 {
    public static void main(String[] args) {
        ICalculator ic = i -> i * i;
        int square = ic.square(5);
        System.out.println("square = " + square);
    }
}

当函数只有一个参数的时候，直接写即可，不需要添加 ()。

1.2 多个参数

多个参数的话，就需要写上 () 了，以 Spring Security 中登录成功的回调为例（不了解 Spring Security 的小伙伴可在公号后台回复 ss）：

.defaultLogoutSuccessHandlerFor((req,resp,auth)->{
    resp.setContentType("application/json;charset=utf-8");
    Map<String, Object> result = new HashMap<>();
    result.put("status", 200);
    result.put("msg", "使用 logout1 注销成功!");
    ObjectMapper om = new ObjectMapper();
    String s = om.writeValueAsString(result);
    resp.getWriter().write(s);
},new AntPathRequestMatcher("/logout1","GET"))
.defaultLogoutSuccessHandlerFor((req,resp,auth)->{
    resp.setContentType("application/json;charset=utf-8");
    Map<String, Object> result = new HashMap<>();
    result.put("status", 200);
    result.put("msg", "使用 logout2 注销成功!");
    ObjectMapper om = new ObjectMapper();
    String s = om.writeValueAsString(result);
    resp.getWriter().write(s);
},new AntPathRequestMatcher("/logout2","POST"))
.and()
.csrf().disable();

这种情况，方法有多个参数，此时使用 Lambda 表达式就需要加上 ()。

1.3 要写参数类型的

正常来说用 Lambda 时候不需要写上参数类型，但是如果你需要写，就要加上 ()，还是上面那个例子，如下：

interface ICalculator{
    int square(int i);
}
public class LambdaDemo01 {
    public static void main(String[] args) {
        ICalculator ic = (int i) -> i * i;
        int square = ic.square(5);
        System.out.println("square = " + square);
    }
}

1.4 方法体不止一行的

如果方法体不止一行，需要用上 {}，如果方法体只有一行，则不需要 {}，参考上面 2、3。

2.函数接口

JDK8 中自带了函数式接口，使用起来也非常方便。

2.1基本应用

我们先来看一个简单的例子。

假设我有一个打招呼的接口 SayHello，SayHello 接口中只有一个 sayHello 方法，然后在 User 类中调用该接口对应的方法，最终用法如下：

@FunctionalInterface
interface SayHello {
    String sayHello(String name);
}

class User {
    private String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String say(SayHello sayHello) {
        return sayHello.sayHello(this.username);
    }
}

public class LambdaDemo02 {
    public static void main(String[] args) {
        User user = new User();
        user.setUsername("javaboy");
        String say = user.say((username) -> "hello " + username);
        System.out.println("say = " + say);
    }
}

分析 main 方法中的调用过程之后，我们发现，在调用时最核心的是如下一行代码：

(username) -> "hello " + username

在这段代码中，我们只关心方法的输入和输出，其他的都不是我所考虑的，为了一个简单的输入输出，我还要额外定义一个接口，这显然不太划算。

JDK8 中提供了函数接口，可以帮助我们简化上面的接口定义。如下：

class User2 {
    private String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String say(Function<String,String> sayHello) {
        return sayHello.apply(this.username);
    }
}
public class LambdaDemo03 {
    public static void main(String[] args) {
        User2 user2 = new User2();
        user2.setUsername("javaboy");
        String say = user2.say((username) -> "hello " + username);
        System.out.println("say = " + say);
    }
}

可以用 Function<String,String> 代替我们前面的接口定义，这里有两个泛型，第一个泛型表示接口输入的参数类型，第二个泛型表示接口输出的参数类型，而且大家注意，我们最终 main 方法中的调用方式是不变的。有了 Function 函数之后，以后我们就不需要定义一些简单的接口了。

而且 Function 函数还支持链式操作，如下：

public class LambdaDemo03 {
    public static void main(String[] args) {
        User2 user2 = new User2();
        user2.setUsername("javaboy");
        Function<String, String> func = (username) -> "hello " + username;
        String say = user2.say(func.andThen(s -> "你好 " + s));
        System.out.println("say = " + say);
    }
}

2.2 其他函数接口

接口	输入参数	返回类型	说明
UnaryOperator	T	T	一元函数，输入输出类型相同
Predicate	T	boolean	断言
Consumer	T	/	消费一个数据，只有输入没有输出
Function<T,R>	T	R	输入 T 返回 R，有输入也有输出
Supplier	/	T	提供一个数据，没有输入只有输出
BiFunction<T,U,R>	(T,U)	R	两个输入参数
BiPredicate<L, R>	(L,R)	boolean	两个输入参数
BiConsumer<T, U>	(T,U)	void	两个输入参数
BinaryOperator	(T,T)	T	二元函数，输入输出类型相同

接下来我们来看看这些函数接口。

2.2.1 UnaryOperator

当输入输出类型相同时，可以使用 UnaryOperator 函数接口，例如我们上面的代码，修改之后如下：

class User2 {
    private String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String say(UnaryOperator<String> sayHello) {
        return sayHello.apply(this.username);
    }
}
public class LambdaDemo03 {
    public static void main(String[] args) {
        User2 user2 = new User2();
        user2.setUsername("javaboy");
        UnaryOperator<String> func = (username) -> "helloo " + username;
        String say = user2.say(func);
        System.out.println("say = " + say);
    }
}

2.2.2 Predicate

Predicate 输入一个 T 类型的参数，输出一个 boolean 类型的值。

举一个简单的例子，例如如下代码，我们定义一个 List 集合中存放着用户姓名，现在要过滤出所有姓张的用户，代码如下：

public class LambdaDemo04 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("张三", "里斯", "张五");
        List<String> list = names.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());
        for (String s : list) {
            System.out.println("s = " + s);
        }
    }
}

filter 中传入的就是一个 Predicate 函数接口，这个接口接收 String 类型的数据，返回一个 boolean。

注意

一些常用类型的函数接口，JDK 中直接提供了相关的类供我们使用，例如 Predicate<Integer> 可以用 IntPredicate 代替；Consumer<Integer> 可以用 IntConsumer 代替。

2.2.3 Consumer

看名字就知道，这个是消费数据，只有输入没有输出。

例如集合的遍历就可以使用 Consumer 函数接口。

public class LambdaDemo04 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("张三", "里斯", "张五");
        names.stream().forEach(s -> System.out.println(s));
    }
}

2.2.4 Supplier

Supplier 刚好和 Consumer 相反，它只有输出没有输入。有的时候我们的工厂方法没有输入只有输出，这个时候就可以考虑使用 Supplier（如果有输入参数，则可以考虑使用 Function 函数接口）。

Supplier<Connection> supplier = ()->{
    Connection con = null;
    try {
        con = DriverManager.getConnection("", "", "");
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return con;
};
Connection connection = supplier.get();

3.小结

其实 WebFlux 前置知识还是蛮多的，今天先聊这些吧，我们后面继续。