一天学习一个设计模式之命令模式

命令模式（Command），将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

 

代码如下：

/**
 * 抽象命令角色类
 */
public interface Command {
    /**
     * 执行方法
     */
    void execute();
}

/**
 * 接收者角色类
 */
public class Receiver {
    /**
     * 真正执行命令相应的操作
     */
    public void action(){
        System.out.println("执行操作");
    }
}

/**
 * 具体命令角色类
 */
public class ConcreteCommand implements Command {

    //持有相应的接收者对象
    private Receiver receiver = null;

    /**
     * 构造方法
     *
     * @param receiver
     */
    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }


    @Override
    public void execute() {
        //通常会转调用接收者对象的相应方法，让接收者来真正执行功能
        receiver.action();
    }
}

/**
 * 请求者角色类
 */
public class Invoker {
    /**
     * 持有命令对象
     */
    private Command command=null;

    /**
     * 构造方法
     * @param command
     */
    public Invoker(Command command) {
        this.command = command;
    }

    /**
     * 行动方法
      */
    public void action(){
        command.execute();
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        //创建接收者
        Receiver receiver=new Receiver();
        //创建命令对象，设定它的接收者
        Command command=new ConcreteCommand(receiver);
        //创建请求者，把命令对象设置进去
        Invoker invoker=new Invoker(command);
        //执行方法
        invoker.action();
    }
}

以下例子是《大话设计模式》中的例子：

/**
 * 烤串者（命令执行者）
 */
public class Barbecuer {
    public void bakeMutton(){
        System.out.println("烤羊肉串");
    }
    public void bakeChickenWing(){
        System.out.println("烤鸡翅");
    }
}

/**
 * 抽象命令类
 */
public abstract class Command {
    //抽象命令类，只需要确定‘烤肉串者'是谁
    protected Barbecuer receiver;

    /**
     *
     * @param receiver 参数为命名执行人
     */
    public Command(Barbecuer receiver) {
        this.receiver = receiver;
    }

    //执行命令
    abstract public void excuteCommand();
}

/**
 * 烤鸡翅命令
 */
public class BakeChickenWingCommand extends Command {
    public BakeChickenWingCommand(Barbecuer receiver) {
        super(receiver);
    }

    @Override
    public void excuteCommand() {
        receiver.bakeChickenWing();
    }
}

/**
 * 烤羊肉串命令
 */
public class BakeMuttonCommand extends Command {

    public BakeMuttonCommand(Barbecuer receiver) {
        super(receiver);
    }

    @Override
    public void excuteCommand() {
        receiver.bakeMutton();
    }
}

/**
 * 服务员类
 */
public class Waiter {
    private List<Command> orders=new ArrayList<>();
    /**
     * 不管用户想要什么烤肉，反正都是命令，只管记录订单，然后通知烤肉者执行
     * @param command
     */
    public void setOrder(Command command){
        orders.add(command);
        System.out.println("增加订单："+command.toString()+" 时间："+new Date());
    }
    public void cancelOrder(Command command){
        orders.remove(command);
        System.out.println("取消订单："+command.toString()+" 时间："+new Date());
    }
    //通知执行
    public void notifyExcuteCommand(){
        for (Command command:orders
             ) {
            command.excuteCommand();
        }

    }
}

public class Client {
    public static void main(String[] args) {
        //命令执行人
        Barbecuer boy=new Barbecuer();
        Command bakeMuttonCommand1=new BakeMuttonCommand(boy);
        Command bakeMuttonCommand2=new BakeMuttonCommand(boy);
        Command bakeChickenWingCommand1=new BakeChickenWingCommand(boy);
        //命令布人
        Waiter girl=new Waiter();

        //开门营业
        //记录订单命令
        girl.setOrder(bakeMuttonCommand1);
        girl.setOrder(bakeMuttonCommand2);
        girl.setOrder(bakeChickenWingCommand1);

        //点菜完毕，通知厨房(下达命令)
        girl.notifyExcuteCommand();
        girl.cancelOrder(bakeChickenWingCommand1);
    }
}

 命令模式作用

第一，它能较容易地设计一个命令队列；

第二，在需要的情况下，可以较容易地将命令记入日志；

第三，允许接收请求的一方决定是否要否决请求。

第四，可以容易地实现对请求的撤销和重做。

第五，由于加新的具体命令类不影响其他类，因此增加新的具体命令类很容易。

命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。