继续整理记录这段时间来的收获，详细代码可在我的Gitee仓库SpringBoot克隆下载学习使用！

6.4 命令模式

6.4.1 定义

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分隔开，方便了将命令对象进行存储，传递，调用，增加与管理

6.4.2 结构

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

6.4.3 案例(点餐)

• 抽象命令类

public interface Command {  
    public void execute();  
}

• 具体命令类

public class OrderCommand implements Command{  
//    持有接收者对象  
    private SeniorChef receivers;  
    private Order order;  
    public OrderCommand(SeniorChef receivers, Order order) {  
        this.receivers = receivers;  
        this.order = order;  
    }  
    @Override  
    public void execute() {  
        System.out.println(order.getDingTable() +"桌的订单：");  
        Map<String, Integer> foodDir = order.getFoodDir();  
        Set<String> strings = foodDir.keySet();  
        for (String string : strings) {  
            receivers.makeFood(string, foodDir.get(string));  
        }  
        System.out.println(order.getDingTable() + "桌的饭准备完毕!");  
    }  
}

• 订单类

public class Order {  
//    餐桌号码  
    private int dingTable;  
    //所下的餐品及份数  
    private Map<String,Integer> foodDir = new HashMap<String,Integer>();  
  
    public int getDingTable() {  
        return dingTable;  
    }  
    public void setDingTable(int dingTable) {  
        this.dingTable = dingTable;  
    }  
    public Map<String, Integer> getFoodDir() {  
        return foodDir;  
    }  
    public void setFood(String name,int num) {  
        this.foodDir.put(name,num);  
    }  
}

• 厨师类

public class SeniorChef {  
    public void makeFood(String name,int num){  
        System.out.println(num  + "份" + name);  
    }  
}

• 服务员类–请求者角色

public class Waitor {  
//    持有多个命令对象  
    private List<Command> commandList = new ArrayList<>();  
    public void setCommand(Command command) {  
        this.commandList.add(command);  
    }  
//    发起命令功能 订单来了  
    public void orderComings(){  
        System.out.println("服务员：大厨，新活来咯！！");  
//        遍历集合  
        for (Command command : commandList) {  
            if (command != null)  
                command.execute();  
        }  
    }  
}

• 测试

public static void main(String[] args) {  
//        创建第一个订单对象  
        Order order = new Order();  
        order.setDingTable(1);  
        order.setFood("兰州拉面",1);  
        order.setFood("卤鸡蛋",2);  
//        创建第二个订单对象  
        Order order1 = new Order();  
        order1.setDingTable(2);  
        order1.setFood("肉丝炒面",1);  
        order1.setFood("可乐",2);  
//        创建厨师对象  
        SeniorChef seniorChef = new SeniorChef();  
//        创建命令对象  
        OrderCommand orderCommand = new OrderCommand(seniorChef,order);  
        OrderCommand orderCommand1 = new OrderCommand(seniorChef,order1);  
//        创建调用者对象  
        Waitor waitor = new Waitor();  
        waitor.setCommand(orderCommand);  
        waitor.setCommand(orderCommand1);  
//        服务员发起命令  
        waitor.orderComings();  
    }

• 结果
• 类图

6.4.4 优缺点

6.4.4.1 优点

• 降低系统的耦合度，命令模式能将调用操作的对象与实现该操作的对象解耦
• 增加或删除命令方便，采用命令模式增减与删除命令不会影响 其他类，满足“开闭原则”,对扩展比较灵活
• 可以实现宏命令，可与组合模式结合，将多个命令装配成一个组合命令，即宏命令
• 方便实现Undo和Redo操作，可与备忘录模式结合，实现命令的撤销与恢复

6.4.4.2 缺点

• 可能会导致某些系统有过多的具体命令类
• 系统结构更加复杂

6.4.5 使用场景

• 系统需要将请求者和调用者解耦，使得调用这和接收者不直接交互
• 系统需要在不同的时间指定请求，将请求排对和执行请求
• 系统需要支持命令的撤销操作和恢复命令

6.4.6 JDK源码

Runable属于命令模式,Runable担当命令的角色，Thread充当调用者，start()为执行方法

//命令接口(抽象命令角色)
public interface Runnable{
public abstract void run();
}
public class Thread implements Runnable {
private Runnable target;
public synchronized void start() {  
//           ………………
    if (threadStatus != 0)  
        throw new IllegalThreadStateException();  
    group.add(this);  
    boolean started = false;  
    try {  
        start0();  
        started = true;  
    } finally {  
        try {  
            if (!started) {  
                group.threadStartFailed(this);  
            }  
        } catch (Throwable ignore) {  
     }  
    }  
}  
private native void start0();
//         ………………
}

其中start0()方法，调用系统方法开启新线程，而接收者 是对程序员开放的，可自定义

public class TurnOffThread implements Runnable{  
    private Receiver receiver;  
    public TurnOffThread(Receiver receiver) {  
        this.receiver = receiver;  
    }  
    @Override  
    public void run() {  
        receiver.turnOff();  
    }  
}
public class Receiver {  
    public void turnOff(){  
        System.out.println("开启新线程");  
    }  
}