我们一起学习WebFlux前置知识

最近太忙了，发文频率有点不稳定，理解万岁。前面和大家说了要更 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 注解去标记该接口：

 
 
 
 
    
  
  
  
  
  1. @FunctionalInterface
    2. 
  
  
  
  
  2. interface ICalculator{
    3. 
  
  
  
  
  3.     int square(int i);
    4. 
  
  
  
  
  4. }
    5.

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

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

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

1.1 单个参数的

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

 
 
 
 
    
  
  
  
  
  1. interface ICalculator{
    2. 
  
  
  
  
  2.     int square(int i);
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. public class LambdaDemo01 {
    5. 
  
  
  
  
  5.     public static void main(String[] args) {
    6. 
  
  
  
  
  6.         ICalculator ic = i -> i * i;
    7. 
  
  
  
  
  7.         int square = ic.square(5);
    8. 
  
  
  
  
  8.         System.out.println("square = " + square);
    9. 
  
  
  
  
  9.     }
    10. 
  
  
  
  
  10. }
    11.

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

1.2 多个参数

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

 
 
 
 
    
  
  
  
  
  1. .defaultLogoutSuccessHandlerFor((req,resp,auth)->{
    2. 
  
  
  
  
  2.     resp.setContentType("application/json;charset=utf-8");
    3. 
  
  
  
  
  3.     Map result = new HashMap<>();
    4. 
  
  
  
  
  4.     result.put("status", 200);
    5. 
  
  
  
  
  5.     result.put("msg", "使用 logout1 注销成功!");
    6. 
  
  
  
  
  6.     ObjectMapper om = new ObjectMapper();
    7. 
  
  
  
  
  7.     String s = om.writeValueAsString(result);
    8. 
  
  
  
  
  8.     resp.getWriter().write(s);
    9. 
  
  
  
  
  9. },new AntPathRequestMatcher("/logout1","GET"))
    10. 
  
  
  
  
  10. .defaultLogoutSuccessHandlerFor((req,resp,auth)->{
    11. 
  
  
  
  
  11.     resp.setContentType("application/json;charset=utf-8");
    12. 
  
  
  
  
  12.     Map result = new HashMap<>();
    13. 
  
  
  
  
  13.     result.put("status", 200);
    14. 
  
  
  
  
  14.     result.put("msg", "使用 logout2 注销成功!");
    15. 
  
  
  
  
  15.     ObjectMapper om = new ObjectMapper();
    16. 
  
  
  
  
  16.     String s = om.writeValueAsString(result);
    17. 
  
  
  
  
  17.     resp.getWriter().write(s);
    18. 
  
  
  
  
  18. },new AntPathRequestMatcher("/logout2","POST"))
    19. 
  
  
  
  
  19. .and()
    20. 
  
  
  
  
  20. .csrf().disable();
    21.

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

1.3 要写参数类型的

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

 
 
 
 
    
  
  
  
  
  1. interface ICalculator{
    2. 
  
  
  
  
  2.     int square(int i);
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. public class LambdaDemo01 {
    5. 
  
  
  
  
  5.     public static void main(String[] args) {
    6. 
  
  
  
  
  6.         ICalculator ic = (int i) -> i * i;
    7. 
  
  
  
  
  7.         int square = ic.square(5);
    8. 
  
  
  
  
  8.         System.out.println("square = " + square);
    9. 
  
  
  
  
  9.     }
    10. 
  
  
  
  
  10. }
    11.

1.4 方法体不止一行的

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

2.函数接口

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

2.1基本应用

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

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

 
 
 
 
    
  
  
  
  
  1. @FunctionalInterface
    2. 
  
  
  
  
  2. interface SayHello {
    3. 
  
  
  
  
  3.     String sayHello(String name);
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. class User {
    7. 
  
  
  
  
  7.     private String username;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     public String getUsername() {
    10. 
  
  
  
  
  10.         return username;
    11. 
  
  
  
  
  11.     }
    12. 
  
  
  
  
  12. 
  
  
  
  
  13.     public void setUsername(String username) {
    14. 
  
  
  
  
  14.         this.username = username;
    15. 
  
  
  
  
  15.     }
    16. 
  
  
  
  
  16. 
  
  
  
  
  17.     public String say(SayHello sayHello) {
    18. 
  
  
  
  
  18.         return sayHello.sayHello(this.username);
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20. }
    21. 
  
  
  
  
  21. 
  
  
  
  
  22. public class LambdaDemo02 {
    23. 
  
  
  
  
  23.     public static void main(String[] args) {
    24. 
  
  
  
  
  24.         User user = new User();
    25. 
  
  
  
  
  25.         user.setUsername("javaboy");
    26. 
  
  
  
  
  26.         String say = user.say((username) -> "hello " + username);
    27. 
  
  
  
  
  27.         System.out.println("say = " + say);
    28. 
  
  
  
  
  28.     }
    29. 
  
  
  
  
  29. }
    30.

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

 
 
 
 
    
  
  
  
  
  1. (username) -> "hello " + username
    2.

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

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

 
 
 
 
    
  
  
  
  
  1. class User2 {
    2. 
  
  
  
  
  2.     private String username;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     public String getUsername() {
    5. 
  
  
  
  
  5.         return username;
    6. 
  
  
  
  
  6.     }
    7. 
  
  
  
  
  7. 
  
  
  
  
  8.     public void setUsername(String username) {
    9. 
  
  
  
  
  9.         this.username = username;
    10. 
  
  
  
  
  10.     }
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     public String say(Function sayHello) {
    13. 
  
  
  
  
  13.         return sayHello.apply(this.username);
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15. }
    16. 
  
  
  
  
  16. public class LambdaDemo03 {
    17. 
  
  
  
  
  17.     public static void main(String[] args) {
    18. 
  
  
  
  
  18.         User2 user2 = new User2();
    19. 
  
  
  
  
  19.         user2.setUsername("javaboy");
    20. 
  
  
  
  
  20.         String say = user2.say((username) -> "hello " + username);
    21. 
  
  
  
  
  21.         System.out.println("say = " + say);
    22. 
  
  
  
  
  22.     }
    23. 
  
  
  
  
  23. }
    24.

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

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

 
 
 
 
    
  
  
  
  
  1. public class LambdaDemo03 {
    2. 
  
  
  
  
  2.     public static void main(String[] args) {
    3. 
  
  
  
  
  3.         User2 user2 = new User2();
    4. 
  
  
  
  
  4.         user2.setUsername("javaboy");
    5. 
  
  
  
  
  5.         Function func = (username) -> "hello " + username;
    6. 
  
  
  
  
  6.         String say = user2.say(func.andThen(s -> "你好 " + s));
    7. 
  
  
  
  
  7.         System.out.println("say = " + say);
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9. }
    10.

2.2 其他函数接口

 
 
 
 
    
  
  
  
  
  1. 接口  输入参数    返回类型    说明
    2. 
  
  
  
  
  2. UnaryOperator   T   T   一元函数，输入输出类型相同
    3. 
  
  
  
  
  3. Predicate   T   boolean 断言
    4. 
  
  
  
  
  4. Consumer    T   /   消费一个数据，只有输入没有输出
    5. 
  
  
  
  
  5. Function   T   R   输入 T 返回 R，有输入也有输出
    6. 
  
  
  
  
  6. Supplier    /   T   提供一个数据，没有输入只有输出
    7. 
  
  
  
  
  7. BiFunction   (T,U)   R   两个输入参数
    8. 
  
  
  
  
  8. BiPredicate   (L,R)   boolean 两个输入参数
    9. 
  
  
  
  
  9. BiConsumer    (T,U)   void    两个输入参数
    10. 
  
  
  
  
  10. BinaryOperator  (T,T)   T   二元函数，输入输出类型相同
    11.

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

2.2.1 UnaryOperator

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

 
 
 
 
    
  
  
  
  
  1. class User2 {
    2. 
  
  
  
  
  2.     private String username;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     public String getUsername() {
    5. 
  
  
  
  
  5.         return username;
    6. 
  
  
  
  
  6.     }
    7. 
  
  
  
  
  7. 
  
  
  
  
  8.     public void setUsername(String username) {
    9. 
  
  
  
  
  9.         this.username = username;
    10. 
  
  
  
  
  10.     }
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     public String say(UnaryOperator sayHello) {
    13. 
  
  
  
  
  13.         return sayHello.apply(this.username);
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15. }
    16. 
  
  
  
  
  16. public class LambdaDemo03 {
    17. 
  
  
  
  
  17.     public static void main(String[] args) {
    18. 
  
  
  
  
  18.         User2 user2 = new User2();
    19. 
  
  
  
  
  19.         user2.setUsername("javaboy");
    20. 
  
  
  
  
  20.         UnaryOperator func = (username) -> "helloo " + username;
    21. 
  
  
  
  
  21.         String say = user2.say(func);
    22. 
  
  
  
  
  22.         System.out.println("say = " + say);
    23. 
  
  
  
  
  23.     }
    24. 
  
  
  
  
  24. }
    25.

2.2.2 Predicate

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

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

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

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

注意

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

2.2.3 Consumer

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

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

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

2.2.4 Supplier

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

 
 
 
 
    
  
  
  
  
  1. Supplier supplier = ()->{
    2. 
  
  
  
  
  2.     Connection con = null;
    3. 
  
  
  
  
  3.     try {
    4. 
  
  
  
  
  4.         con = DriverManager.getConnection("", "", "");
    5. 
  
  
  
  
  5.     } catch (SQLException e) {
    6. 
  
  
  
  
  6.         e.printStackTrace();
    7. 
  
  
  
  
  7.     }
    8. 
  
  
  
  
  8.     return con;
    9. 
  
  
  
  
  9. };
    10. 
  
  
  
  
  10. Connection connection = supplier.get();
    11.

3.小结

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

本文转载自微信公众号「江南一点雨」，可以通过以下二维码关注。转载本文请联系江南一点雨公众号。

本文标题：我们一起学习WebFlux前置知识
本文网址：http://www.shufengxianlan.com/qtweb/news40/231440.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网页设计公司知识

同城分类信息

成都网站推广　　 　企业网站建设公司　　 　成都酒店服定制　　 　APP定制　　 　正泰动物　　 　响应式网站　　 　双流做网站　　 　移动网站建设　　 　网站制作　　 　胜锦安防科技　　 　响应式网站　　 　香港四川國際商會　　 　成都主机租用　　 　乐山做网站　　 　软文推广公司　　 　企业画册设计制作　　 　成都门窗定制　　 　成都网站建设　　 　仿古建筑设计　　 　外贸网站建设