行为型设计模式—

行为型设计模式——命令模式

news2025/2/27 10:29:16

命令模式

日常生活中，我们出去吃饭都会遇到下面的场景。

定义： 将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加与管理。命令模式包含以下主要角色：

抽象命令类（Command）角色：定义命令的接口，声明执行的方法。
具体命令（Concrete Command）角色：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
实现者/接收者（Receiver）角色：接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
调用者/请求者（Invoker）角色：要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。

案例实现

我们以一个美团外卖接单的例子来实现命令模式，假设你开了一家外卖饭店，角色有老板、厨师和接到的订单（命令类），
将上面的案例用代码实现，那我们就需要分析命令模式的角色在该案例中由谁来充当。

老板：就是调用者角色，由她来向后厨厨师发起做菜的命令。
大厨：就是接收者角色，真正命令执行的对象。
订单：命令，命令中就包含了订单。

类图如下：
在这里插入图片描述

代码如下：

首先定义订单类、接受者类（厨师）：

// 订单类
public class Order {
    // 订单
    private long ID;
    // 用来存储餐名并记录份数
    private Map<String, Integer> foodDic = new HashMap<String, Integer>();

    public long getID() {
        return ID;
    }
    public void setID(long ID) {
        this.ID = ID;
    }
    public Map<String, Integer> getFoodDic() {
        return foodDic;
    }
    public void setFoodDic(String name, int num) {
        foodDic.put(name,num);
    }
}

// 厨师类
public class Chef {
    public void makeFood(int num,String foodName){
        System.out.println("已经做好"+num + "份" + foodName);
    }
}

然后定义命令接口并和它的具体实现：

// 命令接口
public interface Command {
    void execute(); // 命令执行方法
}

// 具体订单命令
public class OrderCommand implements Command{
    // 命令接受者对象
    private Chef receiver;
    private Order order;
    public OrderCommand(Chef receiver, Order order){
        this.receiver = receiver;
        this.order = order;
    }

    // 命令执行方法：命令接受者处理命令 
    @Override
    public void execute() {
        System.out.println("订单号："+order.getID());
        Set<String> keys = order.getFoodDic().keySet();
        for (String key : keys) {
            receiver.makeFood(order.getFoodDic().get(key),key);
        }

        try {
            Thread.sleep(100);//停顿一下 模拟做饭的过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(order.getID() + "订单的饭弄好了");
    }
}

最后定义命令发出者（老板）类：

public class Boss {
    private ArrayList<Command> commands;//老板美团可以接很多单，可以持有很多的命令对象

    public Boss() {
        commands = new ArrayList();
    }

    // 不断接单
    public void setCommand(Command cmd){
        commands.add(cmd);
    }

    // 向后厨发出命令您有新的订单，厨师开始执行
    public void orderUp() {
        System.out.println("张师傅，该工作了，新订单来了.......");
        for (int i = 0; i < commands.size(); i++) {
            Command cmd = commands.get(i);
            if (cmd != null) {
                cmd.execute();
            }
        }
    }
}

客户类测试：

public class Main {
    public static void main(String[] args) {
        //创建2个order
        Order order1 = new Order();
        order1.setID(1);
        order1.getFoodDic().put("西红柿鸡蛋面",1);
        order1.getFoodDic().put("小杯可乐",2);

        Order order2 = new Order();
        order2.setID(3);
        order2.getFoodDic().put("尖椒肉丝盖饭",1);
        order2.getFoodDic().put("小杯雪碧",1);

        //创建接收者
        Chef receiver=new Chef();
        //将订单和接收者封装成命令对象
        OrderCommand cmd1 = new OrderCommand(receiver, order1);
        OrderCommand cmd2 = new OrderCommand(receiver, order2);
        //创建调用者 Boss 向后厨师傅发出做饭命令
        Boss invoker = new Boss();
        invoker.setCommand(cmd1); // 接单
        invoker.setCommand(cmd2); // 接单
        //将订单带到柜台 并向厨师喊 订单来了
        invoker.orderUp();
    }
}