• 将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加和管理。

结构

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

实例

• 命令类即为将请求封装为一个对象后的产物，通过其可以实现接收者和发起者之间的沟通。
• 在这个例子中，显然厨师是最终命令的接收和执行者，而服务员则是命令的发起者。
• 因此，在具体的命令类中需要持有厨师对象；
• 在服务员类（调用者）中需要持有命令对象。

// 订单类
// Order.java
public class Order {
    // 餐桌号码
    private int diningTable;

    // 所下的餐品及份数
    private Map<String,Integer> foodDir = new HashMap<>();

    public int getDiningTable(){
        return diningTable;
    }

    public void setDiningTable(int diningTable) {
        this.diningTable = diningTable;
    }

    public Map<String, Integer> getFoodDir() {
        return foodDir;
    }

    public void setFood(String name,int num) {
        foodDir.put(name,num);
    }
}
// 接收者类
// SeniorChef.java
public class SeniorChef {
    public void makeFood(String name,int num){
        System.out.println(num + "份" + name);
    }
}

// 抽象命令类
// Command.java
public interface Command {
    void execute();
}

// 具体的命令类
// OrderCommand.java
public class OrderCommand implements Command{

    // 持有接收者对象
    private SeniorChef receiver;
    private Order order;

    public OrderCommand(SeniorChef receiver, Order order) {
        this.receiver = receiver;
        this.order = order;
    }

    @Override
    public void execute() {
        System.out.println(order.getDiningTable() + "桌的订单");
        Map<String, Integer> foodDir = order.getFoodDir();
        // 遍历Map集合
        Set<String> keys = foodDir.keySet();
        for(String foodName:keys){
            receiver.makeFood(foodName,foodDir.get(foodName));
        }
        System.out.println(order.getDiningTable() + "桌的餐品准备完毕");
    }
}

// 命令发起者
// Waitor.java
public class Waitor {
    // 持有多个命令对象
    private List<Command> commands = new ArrayList<>();

    public void setCommand(Command command) {
        // 将command对象存储到集合中
        commands.add(command);
    }
    // 发起命令的功能
    public void orderUp(){
        System.out.println("服务员：订单来了");
        for(Command command:commands){
            if(command!=null) {
                command.execute();
            }
        }
    }
}
public class Client {
    public static void main(String[] args) {
        // 创建一个订单对象
        Order order1 = new Order();
        order1.setDiningTable(1);
        order1.setFood("西红柿鸡蛋面",1);
        order1.setFood("可口可乐",2);


        Order order2 = new Order();
        order2.setDiningTable(2);
        order2.setFood("牛肉面",1);
        order2.setFood("百事可乐",2);

        // 创建厨师对象
        SeniorChef receiver = new SeniorChef();
        // 创建命令对象
        OrderCommand cmd1 = new OrderCommand(receiver,order1);
        OrderCommand cmd2 = new OrderCommand(receiver,order2);

        // 创建服务员对象
        Waitor waitor = new Waitor();
        waitor.setCommand(cmd1);
        waitor.setCommand(cmd2);
        waitor.orderUp();
    }
}

优缺点

• 优点：
  • 降低了调用者和接收者之间的耦合度；
  • 增加或删除命令方便，满足开闭原则；
  • 可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令；
  • 方便的实现命令的恢复和撤销操作。
• 缺点：
  • 可能导致过多的命令类；
  • 系统结构更加复杂；