响应式java开发_java 响应式编程（1）

Java-9-Reactive-Programming-1-1024x488.jpg

java8 应该是三年前发布的版本，当时如果关注过 java8 Api，可能会发现从我们直接从 list 和 set 调用 map 和 filter 这些方法来处理集合。

list.filter()

list.map()

java8-1-638.jpg

但是现在 java8 的 api 做了调整将 filter 和 map 从 list 和 set 类中移除到 stream 上，为什么将这些方法调整到 stream 上，而不在 list 和 set 保留了呢？这是因为延迟处理(计算)的原因，当我们调用 foreach 这样遍历方法希望是立即计算(也叫迫切计算)而filter 和 map 作为延迟计算处理。

作为 Api 设计人员希望 Api 是无缝，直接 list 就可以调用 map 和 filter，这样做是更直接更方便，不过这样做同时也丢失一些语义上区别，就此考虑我们在考虑无缝也不能丢失一些语义上区分。

这样做反而让 developer 更加迷惑，对 map filter 这样方法与 forEach 本质的不同所在。所以最好做法来list转为 stream 再调用这些方法。

在 java8 出现之前命令式编程占据绝对统治地位，直到 java8 出现，不过我想大家用的最顺手还是命令式编程，因为他更贴近我们认识和处理问题的方式。我们应该改变自己学着机器是如何思考和处理问题。

可能大家说 java 不是面向对象方式来进行开发，我想说的确如此，不过仔细研究就会发现是命令式编程+面向对象。

List numbers = Arrays.asList(1,2,3,5,6,7,8,9,10);

List doubled = new ArrayList<>();

for (int i = 0; i < numbers.size(); i++) {

if(numbers.get(i) % 2 == 0){

doubled.add(numbers.get(i) * 2);

}

}

System.out.println(doubled);

这是命令式编程实现筛选出偶数

empty collection

看似简单是因为我们已经熟悉

Michael Feathrer

"In OOP we encapsulate the moving parts; in FP we eliminate the moving"

这里所指的 moving part 就是可变的，在函数式编程我们努力消除可变的，将那些可变的变量变为不可变的变量。

命令式编程 ： 告诉我们这是什么同时还告诉我们如何做

System.out.println(

numbers.stream()

.filter(e -> e % 2 == 0)

.map( e -> e *2)

.collect(toList())

);

声名式编程 ：仅告诉你这是什么而不是纠结怎么做

函数式编程等于 声名式编程 + 高阶函数

可读性显而易见，可以测试一下家人，或者没有编程经验人员看一下这两部分代码进行对比。

分享可变的变量是一种 bug 源泉。

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("ok");

}

}).start();

runnable 在 java 语言中也是算是大名鼎鼎的方法了，不过他确实从来给予别人总是一味索取。这就是大名鼎鼎的 run 方法所干的吗？有些人总是向你打听着打听那，却从来不把自己的事情告诉你一点。

th-4.jpeg

每天都在顺序执行的代码，无需考虑线程，程序安稳运行，每天我们都能享受可口的午餐，彼此谈笑风声。

但是一但引入并行多线程到程序中，随着而来的是难以控制线程问题，一个接一个等待我们处理，从而也没有了享受午餐的心情，都是在抱怨线程带来麻烦。

顺序执行的代码接口完全不同于并行的代码

3eb30699aea445a50f1c857e84667860.jpg

多线程高并发编程就像丛林生存一样，听起来那么美，一旦身处其中就苦不堪言了。

System.out.println(

numbers.parallelStream()

.filter(e -> e % 2 == 0)

.map( e -> e *2)

.collect(toList())

);

the structure of sequential code is the same as the structure of concurrent code.

函数容易同步

那么到底什么是函数式编程呢？

functional == declarative + higher-order

告诉 developer 只能使用 immutable 就好像告诉小孩你只能吃蔬菜一样。

函数式编程也就是函数的 == 函数的堆砌

Stream 并非数据结构而是对函数的抽象

lazy evaluation

许多支持函数式编程语言像ruby python 和 javascript 虽然支持函数式编程但是好像没有实现延迟处理

System.out.println(

numbers.parallelStream()

.filter(e -> isEven(e))

.map( e -> e *2)

.collect(toList())

);

public static boolean isEven(int n){

System.out.println("called for " + n);

return n % 2 == 0;

}

called for 9

called for 3

called for 2

called for 7

called for 10

called for 5

called for 1

called for 6

called for 8

// System.out.println(

numbers.parallelStream()

.filter(e -> isEven(e))

.map( e -> e *2);

// .collect(toList())

// );

这一次就没有任何输出了，

同时 Stream 受单一的限制

Stream stream = numbers.stream();

System.out.println(

stream

.filter(e -> isEven(e))

.map( e -> e *2)

.collect(toList())

);

System.out.println(

stream.filter(e -> isEven(e))

.map( e -> e * 6)

.collect(toList())

);

stream has already been operated upon or closed

Stream 是单通道

也就是以为我们无法对其分流处理，

难于异常处理

在函数式编程由于其确定性，而异常的不确定有着本质区别，所以异常处理是我们面临的难题。