设计模式之命令模式

一、定义

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志。以及支持可撤销的操作。简单说就是将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通。

二、主要解决

在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

三、包含角色

Command（抽象命令类）：抽象出命令对象，可以根据不同的命令类型。写出不同的实现类

ConcreteCommand（具体命令类）：实现了抽象命令对象的具体实现

Invoker（调用者/请求者）：请求的发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令来之间

存在关联。在程序运行时，将调用命令对象的execute() ，间接调用接收者的相关操作。

Receiver（接收者）：接收者执行与请求相关的操作，真正执行命令的对象。具体实现对请求的业务处理。未抽象前，实际执行操作内容的对象。

Client（客户端）：在客户类中需要创建调用者对象，具体命令类对象，在创建具体命令对象时指定对应的接收者。发送者和接收者之间没有之间关系。都通过命令对象来调用。

四、优缺点

优点： 1、降低了系统耦合度。 2、新的命令可以很容易添加到系统中去。

缺点：使用命令模式可能会导致某些系统有过多的具体命令类。

五、代码实现

//接收者：真正执行命令的对象
public class Receiver {
    public void action(){
        //do something 实现业务逻辑，执行命令
    }
}

//抽象命令类：抽象的命令，可以根据不同类型的命令写出不同的实现
public interface Command {
    //调用命令
    void execute();
}

//具体命令类
class ConcreteCommand implements Command{
    //持有真正执行命令对象的引用
    private Receiver receiver;
    
    public ConcreteCommand(Receiver receiver) {
        super();
        this.receiver = receiver;
    }
    
    @Override
    public void execute() {
        //调用接收者执行命令的方法
        receiver.action();
    }
}

//请求者/调用者：发起执行命令请求的对象
public class Invoker {
    //持有命令对象的引用
    private Command command;
    public Invoker(Command command) {
        super();
        this.command = command;
    }
    public void call(){
        //请求者调用命令对象执行命令的那个execute方法
        command.execute();
    }
}

客户端测试：客户端
public static void main(String[] args) {
    //通过请求者（invoker）调用命令对象（command），命令对象中调用了命令具体执行者（Receiver）
    Command command = new ConcreteCommand(new Receiver());
    Invoker invoker = new Invoker(command);
    invoker.call();
}

六、代码案例

假如一个人去餐馆吃饭，餐馆里有鲁菜，湘菜，粤菜套餐，然后这个人吃了一个湘菜套餐

我们先看下非命令模式如何实现代码

package command.v1;

/**
 * @Package: command.v1
 * @ClassName: Cooker
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/11/16 17:45
 */
public class Cooker {

    public void huNanFood(){
        System.out.println("厨师做了湘菜套餐");
    }

    public void anHuiFood(){
        System.out.println("厨师做了徽菜套餐");
    }

    public  void guangDongFood(){
        System.out.println("厨师做了粤菜套餐");
    }
}


package command.v1;

/**
 * @Package: command.v1
 * @ClassName: Diners
 * @Author: tanp
 * @Description: 食客
 * @Date: 2020/11/16 17:51
 */
public class Diners {

    private Cooker lunch;

    public Diners(Cooker lunch){
        this.lunch = lunch;
    }

    public void eatHuNanFood(){
        lunch.huNanFood();
        System.out.println("食客吃了湘菜");
    }

    public void eatAnHuiFood(){
        lunch.anHuiFood();
        System.out.println("食客吃了徽菜");
    }

    public  void eatGuangDongFood(){
        lunch.guangDongFood();
        System.out.println("食客吃了粤菜");
    }
}


package command.v1;

/**
 * @Package: command.v1
 * @ClassName: DemoClient
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/11/16 17:54
 */
public class DemoClient {

    public static void main(String[] args) {
        Diners diners = new Diners(new Cooker());
        diners.eatAnHuiFood();
        diners.eatGuangDongFood();
        diners.eatHuNanFood();
    }
}

结果

由上面的代码可以看到当使用非命令模式时，我们的请求和执行是耦合在一起的，直接在食客内部定义执行对象，然后执行相应方法就行，但是这样就有一个问题，现在的代码里只要三大菜系，假如食客要吃川菜，还要在食客类添加吃川菜的方法，执行类添加川菜套餐实现方法。

但是这明显违背了“对修改关闭，对扩展开放“的重要设计原则。而且假如食客先是点了湘菜套餐，但是突然又后悔了，这样的代码逻辑也是无法实现的

下面我们来用命令模式来写代码，我们先来划分先角色，午餐lunch为抽象命令类（Command）角色，湘菜，鲁菜等为具体命令类（Concrete Command）角色，厨师为实现者/接收者（Receiver）角色，而我们的食客为调用者/请求者（Invoker）角色，下面来编写代码

package command.v2;

/**
 * @Package: command.v2
 * @ClassName: Cooker
 * @Author: tanp
 * @Description: 接收者：真正执行命令的对象
 * @Date: 2020/11/17 10:12
 */
public class Cooker {

    public void cooked(String lunchType) {
        System.out.println("厨师做好了" + lunchType + "套餐");
    }
}


package command.v2;

/**
 * @Package: command.v2
 * @ClassName: Lunch
 * @Author: tanp
 * @Description: 抽象命令类
 * @Date: 2020/11/17 9:52
 */
public interface Lunch {

    public String getOrder();

    public void cookingLunch();
}

package command.v2;

/**
 * @Package: command.v2
 * @ClassName: AnhuiFood
 * @Author: tanp
 * @Description: 具体命令类
 * @Date: 2020/11/17 10:17
 */
public class AnhuiFood implements Lunch {

    private Cooker cooker;

    public AnhuiFood(Cooker cooker) {
        this.cooker = cooker;
    }

    @Override
    public String getOrder() {
        return "徽菜套餐";
    }

    @Override
    public void cookingLunch() {
        cooker.cooked("徽菜");
    }
}

package command.v2;

/**
 * @Package: command.v2
 * @ClassName: GuangdongFood
 * @Author: tanp
 * @Description: 具体命令类
 * @Date: 2020/11/17 10:16
 */
public class GuangdongFood implements Lunch {

    private Cooker cooker;

    public GuangdongFood(Cooker cooker){
        this.cooker = cooker;
    }

    @Override
    public String getOrder() {
        return "粤菜套餐";
    }

    @Override
    public void cookingLunch() {
        cooker.cooked("粤菜");
    }
}

package command.v2;

/**
 * @Package: command.v2
 * @ClassName: HuNanFood
 * @Author: tanp
 * @Description: 具体命令类
 * @Date: 2020/11/17 10:14
 */
public class HuNanFood implements Lunch{

    private Cooker cooker;

    public HuNanFood(Cooker cooker){
        this.cooker = cooker;
    }

    @Override
    public void cookingLunch() {
        cooker.cooked("湘菜");
    }

    @Override
    public String getOrder() {
        return "湘菜套餐";
    }
}


package command.v2;

import java.util.ArrayList;
import java.util.List;

/**
 * @Package: command.v2
 * @ClassName: Waiter
 * @Author: tanp
 * @Description: 食客，请求者/调用者：发起执行命令请求的对象
 * @Date: 2020/11/17 10:20
 */
public class Diners {

    List<Lunch> comands = new ArrayList<Lunch>();

    public void order(Lunch lunch){
        comands.add(lunch);
        System.out.print("食客下单");
        System.out.println(lunch.getOrder());
    }

    public void payMoney(Lunch lunch){
        System.out.println("食客买单");
        lunch.cookingLunch();
    }

    public void Cancer(){
        if(comands.size() <= 0){
            return;
        }
        int size = comands.size();
        int preIndex = size-1<=0?0:size-1;

        //获取食客前面点单的套餐
        Lunch lunch = comands.remove(preIndex);

        System.out.print("食客取消下单");
        System.out.println(lunch.getOrder());
    }

}

package command.v2;

/**
 * @Package: command.v2
 * @ClassName: DemoClient
 * @Author: tanp
 * @Description: ${客户端
 * @Date: 2020/11/17 10:23
 */
public class DemoClient {

    public static void main(String[] args) {
        //新建请求
        Diners diners = new Diners();
        //新建接受者
        Cooker cooker = new Cooker();
        //新建命令1
        Lunch lunch = new AnhuiFood(cooker);
        //下单
        diners.order(lunch);
        //付钱
        diners.payMoney(lunch);
        //新建命令2
        lunch = new GuangdongFood(cooker);
        //下单
        diners.order(lunch);
        //取消
        diners.Cancer();
    }
}

结果