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)。而且λ演算的函数可以接受函数当作输入(引数)和输出(传出值)。
它属于”结构化编程”的一种,主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说,现在有这样一个数学表达式:
传统的过程式编程,可能这样写:
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相关的内容
函数接口:
- 为什么需要使用函数接口?
我们看如下代码:
// 定义一个用于格式化字符串的接口
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的顶层接口,而现在函数接口直接能实现这种简单接口的定义,我们在使用时只需要关注入参是什么,返回值是什么。只要明确这两点后,往往我们就能找到合适的函数接口
- 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);
- 如何使用上面的这些函数式接口?
- 明确返回值,如果没有返回值,一定是消费型的函数接口。再确认入参个数,单个的话,为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);
这两个特性使用的不多,所以能看懂其含义就行,这里就不多介绍了。这篇文章就到这里,下篇文章我们开始进入流式编程的学习,希望在国庆期间能把这一系列的文章写文。
希望能交到一些兴趣相同的朋友哦
码字不易,喜欢的话,点个赞吧!!!