使用函数抽象行为进行优化
将这些做饭的命令抽象成函数接口,然后指定一个执行者,这样的接口在Java8 4大函数接口中属于Consumer接口,也就是消费者接口,下面就用Consumer接口进行行为抽象
厨房类依旧不变
public class Kitchen {
public void beefRice(){
System.out.println("一份牛肉饭做好了!");
}
public void scrambledEggsWithTomatoes(){
System.out.println("一份西红柿炒鸡蛋做好了!");
}
public void beerDuck(){
System.out.println("一份啤酒鸭做完啦!");
}
}
服务员类也很容易,原先装的是一个个命令对象,现在直接一点,直接将行为放进去
public class Waiter {
/**
* 此时队列装载的不再是命令对象了,而是更直接的厨房类的行为
*/
private final Queue<Consumer<Kitchen>> orders;
public Waiter() {
orders = new ArrayDeque<>();
}
/**
* 添加订单
* @param kitchenAction 厨房的具体行为
*/
public final void setOrders(Consumer<Kitchen> kitchenAction) {
System.out.printf("添加订单成功! 订单时间: %s \n", LocalDateTime.now());
orders.add(kitchenAction);
}
/**
* 这里增加一个执行者参数,来对队列中的行为进行操作
* @param kitchen 执行者,用于执行队列中的行为
*/
public final void notifyKitchen(Kitchen kitchen) {
while (orders.peek() != null) {
orders.peek().accept(kitchen);
orders.remove();
}
}
}
客户端代码,简单、清晰的惊人,代码自带注释效果,无论是简短性还是可阅读性,都比之前的要好上很多,中间的营业代码很直观,直接阅读代码就很清楚的看到添加了哪些行为到订单队里中
public class Client {
public static void main(String[] args) {
//准备厨房,服务员,菜单命令工作
Kitchen kitchen = new Kitchen();
Waiter waiter = new Waiter();
//开始营业
System.out.println("=======================添加订单环节=======================");
// 顾客：服务员 一份牛肉饭!
waiter.setOrders(Kitchen::beefRice);
// 顾客：服务员 一份啤酒鸭!
waiter.setOrders(Kitchen::beerDuck);
// 顾客：服务员 一份西红柿炒鸡蛋!
waiter.setOrders(Kitchen::scrambledEggsWithTomatoes);
// 顾客：服务员 两份啤酒鸭!
waiter.setOrders(Kitchen::beerDuck);
waiter.setOrders(Kitchen::beerDuck);
System.out.println("==========服务员将订单送至厨房,厨房按照订单顺序开始做饭=========");
//服务员通知厨房按照订单顺序开始做
waiter.notifyKitchen(kitchen);
}
}
输出结果
=======================添加订单环节=======================
添加订单成功! 订单时间: 2017-10-16T03:19:40.003
添加订单成功! 订单时间: 2017-10-16T03:19:40.019
添加订单成功! 订单时间: 2017-10-16T03:19:40.020
添加订单成功! 订单时间: 2017-10-16T03:19:40.020
添加订单成功! 订单时间: 2017-10-16T03:19:40.021
==========服务员将订单送至厨房,厨房按照订单顺序开始做饭=========
一份牛肉饭做好了!
一份啤酒鸭做完啦!
一份西红柿炒鸡蛋做好了!
一份啤酒鸭做完啦!
一份啤酒鸭做完啦!
Process finished with exit code 0
到这里,已经没有其他类的代码了!类的数量由原先的7个变成了3个,并且由于服务员类(Invoke角色)依然存在,原先的解耦复合控制扩展等优点,一个都没少，与此同时客户端的代码也清爽了不少。试想一下,假如现在厨房有100道做菜的方法,按照原先的方法实现的类的数量应该是3(客户端+厨房+服务员) + 1(抽象命令接口) + 100(具体命令接口) = 104个类,而采用lambda之后,依旧只需要三个类！并且原先的优点完全保留了下来。
函数补充优化(update 17.10.24)
在整理关于方法引用转换函数接口资料的时候忽然觉得命令模式优化这里似乎可以再稍微变动一下使得代码呈现链式(之前也有过类似的想法，但是没想到门路，今天想到了，就补充一下)
上文的代码其实已经成型了，这里做的优化是将多次调用设置成链式调用法。
链式调用一
只需要将waiter类的setOrders方法的返回值设置为this本身即可。
public final Waiter setOrders(Consumer<Kitchen> kitchenAction) {
System.out.printf("添加订单成功! 订单时间: %s \n", LocalDateTime.now());
orders.add(kitchenAction);
return this;
}
客户端链式调用
public class Client {
public static void main(String[] args) {
//准备厨房,服务员,菜单命令工作
Kitchen kitchen = new Kitchen();
Waiter waiter = new Waiter();
//开始营业
System.out.println("=======================添加订单环节=======================");
// 顾客：服务员 一份牛肉饭!
// 顾客：服务员 一份啤酒鸭!
// 顾客：服务员 一份西红柿炒鸡蛋!
// 顾客：服务员 两份啤酒鸭!
// 顾客：服务员 两份啤酒鸭!
//这里通过setOrders完成链式调用，和之前的效果完全一样，但是提高了可读性与间接性
waiter.setOrders(asConsumer(Kitchen::beefRice))
.setOrders(Kitchen::beerDuck)
.setOrders(Kitchen::scrambledEggsWithTomatoes)
.setOrders(Kitchen::beerDuck)
.setOrders(Kitchen::beerDuck);
System.out.println("==========服务员将订单送至厨房,厨房按照订单顺序开始做饭=========");
//服务员通知厨房按照订单顺序开始做
waiter.notifyKitchen(kitchen);
}
}
输出结果和上面一样，这里不再显示
链式调用二
这里是通过一个方法引用的包装器,然后通过function接口的andThen方法链式的讲订单存入订单队列中。
- 这里与上文的链式优化一的是有区别的，区别在于，上文中无论是普通的setOrders还是return this 链式的setOrders的 日志信息是会输出5条的(进行了5次的setOrders动作)，而这里只会输出一条，原因是这里的一条动作里andThen了4个动作，这一条动作链作为一个整体传入了Setorders，因此只会有一条日志信息输出。
- 至于什么时候使用，根据实际情况，例如通知厨房做一道便当快餐，而便当快餐假设是由一份牛肉饭+一份啤酒鸭构成的，那么在这里这一个订单就可以使用这样的andThen来进行构造，这样的链式组合其实是有序的，其实这就是建造者模式的lambda表示形式。
- 使用这样的方法，你的设计里就是包含了命令模式+建造者模式，以lambda形式表现出来，当然如果不按照顺序的话，这样的模式你还可以理解成组合的形式。
lambda的方法引用固然使得代码清晰可见，但是坏处是一旦使用了方法引用，就无法进行lambda的链式调用，也就是无法使用andThen这样的链式方法，但是我们通过一个中转站，先将方法引用转换成函数接口，再链式调用，因为方法引用本质上是lambda的语法糖，下面是转换方法，十分简易。
public class FunctionCastUtil {
public static <T> Consumer<T> asConsumer(Consumer<T> consumer) {
return consumer;
}
}
客户端代码
import static com.lambda.functionutils.FunctionCastUtil.*;
public class Client {
public static void main(String[] args) {
//准备厨房,服务员,菜单命令工作
Kitchen kitchen = new Kitchen();
Waiter waiter = new Waiter();
//开始营业
System.out.println("=======================添加订单环节=======================");
// 顾客：服务员 一份牛肉饭!
// 顾客：服务员 一份啤酒鸭!
// 顾客：服务员 一份西红柿炒鸡蛋!
// 顾客：服务员 两份啤酒鸭!
// 顾客：服务员 两份啤酒鸭!
//这里使用anThen完成链式调用,注意这里是只有一条订单，所以要注意使用的场合
waiter.setOrders(asConsumer(Kitchen::beefRice)
.andThen(Kitchen::beerDuck)
.andThen(Kitchen::scrambledEggsWithTomatoes)
.andThen(Kitchen::beerDuck)
.andThen(Kitchen::beerDuck));
System.out.println("==========服务员将订单送至厨房,厨房按照订单顺序开始做饭=========");
//服务员通知厨房按照订单顺序开始做
waiter.notifyKitchen(kitchen);
}
}
因为输出结果不同，所以这里贴一下输出结果，根据输出结果就明白这里的订单只记录了一条，这一条里面包含了要做多种菜，在厨房那里实际完成的结果是一样的，大家可以根据不同的需要使用不同的链式优化
=======================添加订单环节=======================
添加订单成功! 订单时间: 2017-10-24T07:01:59.444
==========服务员将订单送至厨房,厨房按照订单顺序开始做饭=========
一份牛肉饭做好了!
一份啤酒鸭做完啦!
一份西红柿炒鸡蛋做好了!
一份啤酒鸭做完啦!
一份啤酒鸭做完啦!
Process finished with exit code 0
结尾
使用lambda优化之后的命令模式在保证优点的同时极大的减少了代码量,简直完美。这就是语言特性所带来的力量,简单的几处修改就能获得如此多的受益,这也是我为什么这么喜欢lambda的原因。
欢迎加入学习交流群569772982，大家一起学习交流。
