SpringCloudGateWay学习 之 从函数式编程到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$
传统的过程式编程，可能这样写：

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的顶层接口，而现在函数接口直接能实现这种简单接口的定义，我们在使用时只需要关注入参是什么，返回值是什么。只要明确这两点后，往往我们就能找到合适的函数接口

2. 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);

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

• 明确返回值，如果没有返回值，一定是消费型的函数接口。再确认入参个数，单个的话，为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的值是不允许的：

可以看到，编译报错，我们使用在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);

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

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

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