命令模式

目录

https://blog.csdn.net/dongganen/article/details/79688794

定义命令模式

---

将请求封装成对象，这可以让你使用不同的请求、队列，或者日志请求来参数化其它对象。命令模式也可以支持撤销模式。

案例分析

---

有一家很好吃的饭店，饭店聘用了很多的厨师，每当6点之后会有很多的顾客来吃饭。

逻辑很简单就是：

顾客点餐，厨师做菜。

代码实现

---

public class Part1 {

    public static void main(String[] args) {
        Customer customerA = new Customer("小明");
        CookA cookA = new CookA("厨师师傅A");
        customerA.order("红烧鱼", cookA);

        Customer customerb = new Customer("小红");
        CookB cookB = new CookB("厨师师傅B");
        customerb.order("白斩鸡", cookB);
    }
}

class Customer{
    String name;
    public Customer(String name){
        this.name = name;
    }
    public void order(String orderName, Cook cook){
        System.out.println(name + "点了" + orderName + "," + cook.name + "来接单");
        cook.cooking(orderName);
    }
}

class Cook{
    String name;
    public void cooking(String orderName){
        System.out.println(name + "正在做:" + orderName);
    }
}

class CookA extends Cook{
    public CookA(String name){
        super.name = name;
    }
}

class CookB extends Cook{
    public CookB(String name){
        super.name = name;
    }
}

分析

我们聘用了很多的厨师

我们也有不同的客户

在上面例子中，客户和厨师紧耦合了

哪里紧耦合了？

顾客把想吃的菜告诉厨师，厨师按照顾客的需求完成

是不是这样做更合适？

顾客点好菜不需要知道哪个厨师给他做(私人定制除外)

厨师安心做菜，不需要知道谁点的菜(不需要接单)

怎么解耦和？

我们把客户点的菜抽取出来封装成一个对象(订单)

我们再招一个服务员处理这些订单

厨师根据服务员给的订单做菜

UML

代码实现

public class Part2 {

    public static void main(String[] args) {
        //顾客小明
        Customer customer = new Customer("小明");

        //小明想吃红烧鱼
        CookA cookA = new CookA();
        HongShaoYuOrder hongShaoYuOrder = new HongShaoYuOrder(cookA);

        //告诉服务员
        Waiter waiter = new Waiter();
        waiter.setOrder(hongShaoYuOrder);

        //服务员提交订单
        waiter.commit();

        //顾客小红
        Customer customerB = new Customer("小红");

        //小明想吃红烧鱼
        waiter.setOrder(hongShaoYuOrder);

        //服务员提交订单
        waiter.commit();


    }
}

//客户
class Customer{

    String name;

    public Customer(String name){
        this.name = name;
    }
}

//订单
interface Order{
    //提交订单
    void orderUp();
}

//红烧鱼订单
class HongShaoYuOrder implements Order{

    CookA cookA;

    HongShaoYuOrder(CookA cookA){
        this.cookA = cookA;
    }

    @Override
    public void orderUp() {
        cookA.cooking("红烧鱼");
    }
}

//白斩鸡订单
class BaiZhanJi implements Order{

    CookB cookB;

    BaiZhanJi(CookB cookB){
        this.cookB = cookB;
    }

    @Override
    public void orderUp() {
        cookB.cooking("白斩鸡");
    }
}

//服务员
class Waiter{

    Order order;

    public Waiter(){

    }

    public void setOrder(Order order){
        this.order = order;
    }

    public void commit(){
        order.orderUp();
    }
}

//厨师
class Cook{
    String name;
    public void cooking(String orderName){
        System.out.println(name + "正在做:" + orderName);
    }
}

class CookA extends Cook{
    public CookA(){
        super.name = "CookA";
    }
}

class CookB extends Cook{
    public CookB(){
        super.name = "CookB";
    }
}

分析

客户(顾客)创建命令

将命令交给执行者(服务员)

执行者(服务员)处理命令

接收者(厨师)处理

分析

我们增加撤销功能

服务员不是每次订单都提交

当订单满3个时才提交

点了未提交的可以撤销

有时候我们饭吃饱了，菜还没上，我们就退了

简单逻辑实现

在我们使命令的发出者和命令执行者解耦

我们可以做很多的操作，如记录日志啊等

代码

public class Part3 {

    public static void main(String[] args) {
        Customer customerA = new Customer("小明");
        Customer customerB = new Customer("小红");

        Waiter waiter = new Waiter();

        CookA cookA = new CookA();
        CookB cookB = new CookB();
        //先点一个红烧肉
        HongShaoYuOrder hongShaoYuOrder = new HongShaoYuOrder(cookA);
        waiter.setOrder(hongShaoYuOrder);
        waiter.commit();

        //再点一个白斩鸡
        BaiZhanJi baiZhanJi = new BaiZhanJi(cookB);
        waiter.setOrder(baiZhanJi);
        waiter.commit();

        //再点一个鱼香肉丝
        YuXiangRouSi yuXiangRouSi = new YuXiangRouSi(cookB);
        waiter.setOrder(yuXiangRouSi);
        waiter.commit();

        //满三个提交

        //再点一个蛋花汤
        DanHuaTang danHuaTang = new DanHuaTang(cookB);
        waiter.setOrder(danHuaTang);
        waiter.commit();

        //撤销红烧肉
        boolean undo = waiter.undo(hongShaoYuOrder);
        System.out.println(undo);
        //撤销蛋花汤
        boolean undo1 = waiter.undo(danHuaTang);
        System.out.println(undo1);
    }
}

//客户
class Customer{

    String name;

    public Customer(String name){
        this.name = name;
    }
}

//订单
interface Order{
    //提交订单
    void orderUp();
}

//红烧鱼订单
class HongShaoYuOrder implements Order{

    CookA cookA;

    HongShaoYuOrder(CookA cookA){
        this.cookA = cookA;
    }

    @Override
    public void orderUp() {
        cookA.cooking("红烧鱼");
    }
}

//白斩鸡订单
class BaiZhanJi implements Order{

    CookB cookB;

    BaiZhanJi(CookB cookB){
        this.cookB = cookB;
    }

    @Override
    public void orderUp() {
        cookB.cooking("白斩鸡");
    }
}

//鱼香肉丝订单
class YuXiangRouSi implements Order{

    CookB cookB;

    YuXiangRouSi(CookB cookB){
        this.cookB = cookB;
    }

    @Override
    public void orderUp() {
        cookB.cooking("鱼香肉丝");
    }
}

//蛋花汤订单
class DanHuaTang implements Order{

    CookB cookB;

    DanHuaTang(CookB cookB){
        this.cookB = cookB;
    }

    @Override
    public void orderUp() {
        cookB.cooking("蛋花汤");
    }
}

//服务员
class Waiter{

    List<Order> orders;

    public Waiter(){
        orders = new ArrayList<>();
    }

    public void setOrder(Order order){
        orders.add(order);
    }

    public void commit(){
        if(orders.size() >= 3){
            orders.stream().forEach(e -> e.orderUp());
            orders.clear();
        }
    }

    public boolean undo(Order order){
        boolean b = false;
        int index = orders.indexOf(order);
        if(index >= 0){
            orders.remove(index);
            b = true;
        }
        return b;
    }
}

//厨师
class Cook{
    String name;
    public void cooking(String orderName){
        System.out.println(name + "正在做:" + orderName);
    }
}

class CookA extends Cook{
    public CookA(){
        super.name = "CookA";
    }
}

class CookB extends Cook{
    public CookB(){
        super.name = "CookB";
    }
}

参考《Head First设计模式》