行为型模式-03命令模式

三、命令模式

1. 定义

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

2. 结构

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

3. 案例

• 客户订果汁，服务员传话给Crj做果汁

• UML

4. 代码

• Action

/**
 * 抽象命令类
 */
public interface Action {
    void execute();
}

• OrderAction

/**
 * 具体命令类
 */
public class OrderAction implements Action{

    //接收者的对象
    private Order order;
    private DrinksSpecialist crj;

    public OrderAction(Order order,DrinksSpecialist crj){
        this.crj = crj;
        this.order = order;
    }

    @Override
    public void execute() {
        System.out.println(order.getOrderNum()+"号的订单");
        Map<String,Integer> juice = order.getJuice();
        for (Map.Entry entry: juice.entrySet()
             ) {
            crj.makeJuice((String)entry.getKey(),(Integer)entry.getValue());
        }
        System.out.println(order.getOrderNum()+"号的果汁已经做好了");
    }
}

• Order

/**
 * 订单类
 */
public class Order {
    //订单号
    private int orderNum;

    //订单内容，果汁名字，分数
    private Map<String,Integer> juice = new HashMap<>();

    public int getOrderNum() {
        return orderNum;
    }

    public void setOrderNum(int orderNum) {
        this.orderNum = orderNum;
    }

    public Map<String, Integer> getJuice() {
        return juice;
    }

    //改一下默认的set方法
    public void setJuice(String name,int num) {
        juice.put(name,num);
    }
}

• DrinksSpecialist

/**
 * 饮品师类
 */
public class DrinksSpecialist {
    public void makeJuice(String name, int num){
        System.out.println("果汁名称："+name+"|份数："+num);
    }
}

• Waitor

/**
 * 服务员类（属于请求者角色）
 */
public class Waitor {
    //持有多个命令对象
    private List<Action> commands = new ArrayList<>();

    public void setList(Action action){
        //将命令对象存储到list中
        commands.add(action);
    }

    public void say(){
        System.out.println("Jerry：Crj，新的订单来了");
        for (Action action :
                commands) {
            action.execute();
        }
    }
}

• 测试类

public class Client {
    public static void main(String[] args) {

        Order order1 = new Order();
        order1.setOrderNum(1);
        order1.setJuice("蓝莓果汁", 1);
        order1.setJuice("爱心蛋糕", 2);

        Order order2 = new Order();
        order2.setOrderNum(2);
        order2.setJuice("珍珠奶茶", 1);
        order2.setJuice("糖葫芦", 2);

        DrinksSpecialist crj = new DrinksSpecialist();
        OrderAction cmd1 = new OrderAction(order1, crj);
        OrderAction cmd2 = new OrderAction(order2, crj);

        Waitor jerry = new Waitor();
        jerry.setList(cmd1);
        jerry.setList(cmd2);
        jerry.say();
    }
}

• 测试结果

Jerry：Crj，新的订单来了
1号的订单
果汁名称：蓝莓果汁|份数：1
果汁名称：爱心蛋糕|份数：2
1号的果汁已经做好了
2号的订单
果汁名称：珍珠奶茶|份数：1
果汁名称：糖葫芦|份数：2
2号的果汁已经做好了

5. 优缺点

• 优点
  • 降低系统的耦合度
  • 增加或删除非常方便
  • 可以实现命令模式与组合模式结合，形成宏命令
• 缺点
  • 系统结果复杂

6. 使用场景

• 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。
• 系统需要在不同的时间指定请求、将请求排队和执行请求。

7. JDK源码实例

• Runable是一个典型命令模式，Runnable担当命令的角色，Thread充当的是调用者，start方法就 是其执行方法