SpringCloudGateWay学习之从函数式编程到lambda

水深无声 2023-08-17 17:15 196阅读 0赞

### 文章目录 ###

*   *   *   *   *  前言：
                 *  函数式编程：
                 *   *  什么是函数式编程：
                     *  函数式编程的特点
                 *  lambda表达式：
                 *   *  核心：
                     *  函数接口：
                     *  方法引用：
                     *  类型推断：
                     *  变量引用：
                     *  级联表达式跟柯里化：

##### 前言： #####

> 这一系列的文章主要是为了学习SpringCloudGateWay，如官网所说，SpringCloudGateWay是基于 [Spring Boot 2.x][], [Spring WebFlux][], and [Project Reactor][]的。并且Spring WebFlux中也用到了很多Project Reactor的知识，Reactor与Spring是兄弟项目，侧重于Server端的响应式编程，主要 artifact 是 reactor-core，这是一个基于 Java 8 的实现了响应式流规范 （Reactive Streams specification）的响应式库。所以在学习之前，我们首先需要对java8的lambda表达式以及流式编程有一定了解，这篇文章我们主要对lambda做一个总结学习

在学习lambda之前，我们先了解一个概念---------**函数式编程**

##### 函数式编程： #####

参考链接：https://blog.csdn.net/u012611878/article/details/78495165

###### 什么是函数式编程： ######

函数式编程（英语：functional programming）或称函数程序设计，又称泛函编程，是一种编程典范，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算（lambda calculus）。而且λ演算的函数可以**接受函数当作输入（引数）和输出（传出值）**。

它属于”结构化编程”的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：  
 ( 1 + 2 ) ∗ 3 − 4 (1 + 2) \* 3 - 4 (1\+2)∗3−4  
传统的过程式编程，可能这样写：

var a = 1 + 2;
    
    var b = a * 3;
    
    var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

var result = subtract(multiply(add(1,2), 3), 4);

这就是函数式编程。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

比起命令式编程，**函数式编程更加强调程序执行的结果而非执行的过程，倡导利用若干简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程**。

###### 函数式编程的特点 ######

函数式编程近些年异军突起，又重新回到了人们的视线，并得到蓬勃发展。总结起来，无外乎如下好处：

1.减少了可变量(Immutable Variable)的声明，程序更为安全。  
2.相比命令式编程，少了非常多的状态变量的声明与维护，天然适合高并发多现成并行计算等任务，这也是函数是编程近年又大热的重要原因。  
3.代码更为简洁，可读性更强，对强迫症的同学来说是个重大福音。

##### lambda表达式： #####

###### 核心： ######

对于lambda表达式我们首先明确一个概念，**lambda其实就一个特定接口的实现实例**。

我们通过一段代码来理解下这句话：

public class Demo01 { 
        public static void main(String[] args) { 
            // 可以看到在这一行，我们直接将一个lambda表达式赋值给了一个变量，这个lambda表达式其实就是一个实 // 现了Runnable接口的对象实例
            Runnable lambdaRunnable = () -> System.out.println("lambda表达式执行了");
            Runnable interfaceRunnable = new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("接口实现方法执行了");
                }
            };
            lambdaRunnable.run();
            interfaceRunnable.run();
        }
    }

现在我们再来看看jdk8中的一些跟lambda相关的内容

###### 函数接口： ######

1.  ***为什么需要使用函数接口？***

我们看如下代码：

// 定义一个用于格式化字符串的接口
    interface MyFormat { 
        String format(String str);
    }
    public class Demo02 { 
        public static void main(String[] args) { 
            MyFormat format = new MyFormat() { 
                @Override
                public String format(String str) { 
                    System.out.println("对字符串进行格式化，统一加后缀 ',hello'");
                    return str + ",hello";
                }
            };
    
            MyFormat lambdaFormat = str -> { 
                System.out.println("采用lambda对字符串进行格式化，统一加后缀 ',hello，my name is lambda'");
                return str + ",hello，my name is lambda";
            };
            String zhangsan = format.format("zhangsan");
            System.out.println(zhangsan);
        }
    }

我们再采用jdk8中提供的函数接口来改造上面的代码：

public static void main(String[] args) { 
        Function<String, String> function = str -> { 
            System.out.println("采用lambda对字符串进行格式化，统一加后缀 ',hello，my name is function inteface'");
            return str + ",hello，my name is function inteface";
        };
        function.apply("zhangsan");
    }

对比以上几种写法，我们发现函数接口简化了的接口定义，原本我们需要专门定义一个format的顶层接口，而现在函数接口直接能实现这种简单接口的定义，我们在使用时只需要关注入参是什么，返回值是什么。只要明确这两点后，往往我们就能找到合适的函数接口

1.  ***jdk8中提供了哪些函数接口？***

消费型接口：

Conusmer<T>  void accept(T t);
    BiConusmer<T,U> void accept(T t,U u); //增加一种入参类型

供给型接口：

Supplier<T>  void get();

函数型接口：

Function<T ,R> R apply(T t);
    UnaryOperator<T> T apply(T t);			//入参与返回值类型一致
    BiFunction <T ,U,R> R apply(T t,U u);	//增加一个参数类型
    BinaryOperator<T> T apply(T t1,T t2);	//两个相同类型入参与同类型返回值
    ToIntFunction<T>     					//限定返回int
    ToLongFunction<T>						//限定返回long
    ToDoubleFunction<T>						//限定返回double
    IntFunction<R>							//限定入参int,返回泛型R
    LongFunction<R>							//限定入参long,返回泛型R
    DoubleFunction<R>						//限定入参double,返回泛型R

断言型接口：

Predicate<T> boolean test(T t);

1.  ***如何使用上面的这些函数式接口？***

*  明确返回值，如果没有返回值，一定是消费型的函数接口。再确认入参个数，单个的话，为Conusmer，两个为BiConusmer
 *  如果有返回值，看入参，不需要入参，为供给型接口Supplier
 *  如果既有返回值又有入参，看入参个数，如果1个的话，为Function接口，两个的话为BiFunction
 *  其余的一些接口，都是从上面几个接口衍生出来的
 *  如果需要进行判断，需要使用Predicate接口进行断言

我们可以发现，上面的函数接口，参数个数最多为两个，但是当我们需要超过两个参数的情况该怎么办呢？这个时候我们需要自定义一些函数接口，如果定义一个函数接口呢？

假设我们现在需要定义一个三个参数的函数型接口，代码如下：

// 这个例子单纯为了说明这种情况，代码本身没有任何意义，大家不要纠结这个问题
    @FunctionalInterface
    interface MyFunctionInterface { 
        PersonAndDog apply(Dog dog, String str, Person person);
    }
    public class Demo03 { 
        public static void main(String[] args) { 
            MyFunctionInterface functionInterface = (dog, str, person) -> new PersonAndDog();
        }
    }
    class Person { 
        String name;
    }
    class Dog { 
        String dogName;
    }
    class PersonAndDog { 
        String someThing;
    }

我们可以看到，我们主要是添加了一个@FunctionalInterface的注解。其实不加这个注解，上面的代码也是完全可以的编译以及运行的。那么为什么我们需要添加这个注解呢？主要是为了在编译期对代码进行检查。因为申明为函数接口的接口只能有一个待实现的方法。我们想想看，当你申明了一个函数式接口，并且在项目的很多地方使用了它，结果有一天你的同事突然在这个接口中加了一个抽象方法。那么你之前所有的代码都原地爆炸了。这个注解的主要作用就是告诉别人，这是一个函数式接口，不能在其中添加其它抽象方法。当然，我们可以通过default关键字添加默认实现的方法，大家可以自行百度default关键字吗，这里不多赘述

###### 方法引用： ######

主要分为以下两种情况：

*  静态方法引用
 *  非静态方法引用
    
     *  使用对象实例进行引用
     *  不使用对象实例进行引用

示例代码：

class Cat {   
        int total = 10;
        static void miao(int num) { 
            System.out.println("让猫叫" + num + "次");
            for (int i = 0; i < num; i++) { 
                System.out.println("喵");
            }
        }
        int eat(int num) { 
            System.out.println("猫吃了" + num + "斤猫粮");
            total = total - num;
            System.out.println("还剩" + total + "斤猫粮");
            return total;
        }
    }
    public class Demo04 { 
        public static void main(String[] args) { 
            // 静态方法引用
            Consumer<Integer> consumer = Cat::miao;
            consumer.accept(2);
            // 非静态方法引用
            // 1.通过对象实例引用
            Cat cat = new Cat();
            Function<Integer, Integer> eat = cat::eat;
            eat.apply(2);
            // 2.通过类名的方式调用
            BiFunction<Cat, Integer, Integer> biFunction = Cat::eat;
            biFunction.apply(cat, 2);
        }
    }

\*\*可以看到，对于非静态方法引用，必须要指明这个方法要作用于哪个对象。\*\*当我们通过类名的方式的时候要在函数调用的时候传入这个对象，而当我们通过某一个对象调用的时候，只需要执行这个动作就可以了

###### 类型推断： ######

这点我就不多说了，看如下代码：

interface Imath { 
        int add(int x, int y);
    }
    
    public class Demo05 { 
        public static void test(Imath imath) { 
            System.out.println("test");
        }
        public static void main(String[] args) { 
            // 1.通过变量类型定义
            Imath imath = (x, y) -> x + y;
    
            // 2.通过数组,集合
            Imath[] imaths = { (x, y) -> x + y};
            List<Imath> imaths1 = Collections.singletonList((x, y) -> x + y);
           
            // 3.强转
            Object o = (Imath) (x, y) -> x + y;
    
            // 4.通过方法返回值限定
            test((x, y) -> x + y);
        }
    }

总结下来，没有什么特别特俗的地方。只要lambda符合接口定义的规范，你可以把它用到任何接口能用到的地方，并且能自动推导出类型

###### 变量引用： ######

我们直接通过代码说明问题

public class Demo06 { 
        public static void main(String[] args) { 
            String s = "haha";
            int a = 10;
            Consumer<String> consumer = s1 -> { 
                System.out.println(s1);
            };
        }
    }

如果我们想在上述的代码中更改a的值是不允许的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTA3OTkx_size_16_color_FFFFFF_t_70]

可以看到，编译报错，我们使用在lambda中的变量必须是final的或者是等同于final。什么叫等同于final呢？

我们更改上述代码：

public class Demo06 { 
        public static void main(String[] args) { 
            String s = "haha";
            int a = 10;
            Consumer<String> consumer = s1 -> { 
                System.out.println(s1);
            };
            // 将赋值语句放到lambad之后，可以发现编译是通过的
            a =20;
        }
    }

到这里我们可以总结了：

在lambda表达式中如果我们引用了外部的变量，不能改变这个变量。必须将其当作一个final类型的变量进行处理

###### 级联表达式跟柯里化： ######

*  级联表达式

Function<Integer, Function<Integer, Integer>> function = x -> y -> x + y;

上面就是一个级联表达式。

*  柯里化

柯里化就是把多个参数的函数转换为只有一个参数的函数，其目的就是为了将函数标准化

我们对上面的函数进行调用：

Integer apply = function.apply(2).apply(3);
    System.out.println(apply);

这两个特性使用的不多，所以能看懂其含义就行，这里就不多介绍了。这篇文章就到这里，下篇文章我们开始进入流式编程的学习，希望在国庆期间能把这一系列的文章写文。

希望能交到一些兴趣相同的朋友哦

码字不易，喜欢的话，点个赞吧！！！

[Spring Boot 2.x]: https://spring.io/projects/spring-boot#learn
[Spring WebFlux]: https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html
[Project Reactor]: https://projectreactor.io/docs
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTA3OTkx_size_16_color_FFFFFF_t_70]: /images/20230808/22373f971c1b45b9b66c25e3c73bdd98.png