命令模式(Command Pattern)

简介

在面向对象程式设计的范畴中，命令模式是一种设计模式，它尝试以物件来代表实际行动。命令物件可以把行动(action) 及其参数封装起来，于是这些行动可以被：

• 重复多次
• 取消（如果该物件有实作的话）
• 取消后又再重做

这些都是现代大型应用程序所必须的功能，即“复原”及“重复”。除此之外，可以用命令模式来实作的功能例子还有：

• 交易行为
• 进度列
• 精灵
• 使用者界面按钮及功能表项目
• 执行绪 pool
• 宏收录

JavaScript

/* The Invoker function */
var Switch = function(){
    var _commands = [];
    this.storeAndExecute = function(command){
        _commands.push(command);
        command.execute();
    }
}

/* The Receiver function */
var Light = function(){
    this.turnOn = function(){ console.log ('turn on')};
    this.turnOff = function(){ console.log ('turn off') };
}

/* The Command for turning on the light - ConcreteCommand #1 */
var FlipUpCommand = function(light){
    this.execute = light.turnOn;
}

/* The Command for turning off the light - ConcreteCommand #2 */
var FlipDownCommand = function(light){
    this.execute = light.turnOff;
}

var light = new Light();
var switchUp = new FlipUpCommand(light);
var switchDown = new FlipDownCommand(light);
var s = new Switch();

s.storeAndExecute(switchUp);
s.storeAndExecute(switchDown);

Java

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

/* The Command interface */
public interface Command {
   void execute();
}

/* The Invoker class */
public class Switch {
   private List<Command> history = new ArrayList<Command>();

   public Switch() {
   }

   public void storeAndExecute(Command cmd) {
      this.history.add(cmd); // optional 
      cmd.execute();        
   }
}

/* The Receiver class */
public class Light {
   public Light() {
   }

   public void turnOn() {
      System.out.println("The light is on");
   }

   public void turnOff() {
      System.out.println("The light is off");
   }
}

/* The Command for turning on the light - ConcreteCommand #1 */
public class FlipUpCommand implements Command {
   private Light theLight;

   public FlipUpCommand(Light light) {
      this.theLight = light;
   }

   public void execute(){
      theLight.turnOn();
   }
}

/* The Command for turning off the light - ConcreteCommand #2 */
public class FlipDownCommand implements Command {
   private Light theLight;

   public FlipDownCommand(Light light) {
      this.theLight = light;
   }

   public void execute() {
      theLight.turnOff();
   }
}

/* The test class or client */
public class PressSwitch {
   public static void main(String[] args){
      Light lamp = new Light();
      Command switchUp = new FlipUpCommand(lamp);
      Command switchDown = new FlipDownCommand(lamp);

      Switch mySwitch = new Switch();

      try {
         if ("ON".equalsIgnoreCase(args[0])) {
            mySwitch.storeAndExecute(switchUp);
         }
         else if ("OFF".equalsIgnoreCase(args[0])) {
            mySwitch.storeAndExecute(switchDown);
         }
         else {
            System.out.println("Argument \"ON\" or \"OFF\" is required.");
         }
      } catch (Exception e) {
         System.out.println("Arguments required.");
      }
   }
}

实例

模拟烧烤

紧耦合设计

//烤肉串者
public class Barbecuer
{
    //烤羊肉
    public void BakeMutton()
    {
        Console.WriteMutton("烤羊肉串");
    }
    //烤鸡翅
    public void BakeChikenWing()
    {
        Console.WriteMutton("烤鸡翅");
    }

}

客户端调用

static void Main(string[] args)
{
    Barbecuer boy = new Barbecuew();
    boy.BakeMutton();
    boy.BakeMutton();
    boy.BakeMutton();
    boy.BakeChickenWing();
}

松耦合设计

抽象命令类

//抽象命令
public abstract class Command
{
    protected Barbecuer receiver;

    public Command(Barbecuer receiver)
    {
        this.receiver = receiver;
    }

    //执行命令
    abstract public ExcuteCommand();
}

具体命令类

//烤羊肉命令
class BakeMuttonCommand: Command
{
    public BakeMuttonCommand(Barbecuer receiver)
    {
        :base(receiver)
    }

    public override void EccuteCommand()
    {
        receiver.BakeMutton();
    }
}

//烤鸡翅命令
class BakeMuttonCommand: Command
{
    public BakeMuttonCommand(Barbecuer receiver)
    {
        :base(receiver)
    }

    public override void EccuteCommand()
    {
        receiver.BakeChickenWing();
    }
}

服务员类

//服务员
public class Waiter
{
    private Command command;

    //设置订单
    public void setOrder(Command command)
    {
        this.command
    }

    //通知执行
    public void Notify()
    {
        command.ExcuteCommand();
    }
}

//烤肉串者
public class Barbecuer
{
    //烤羊肉
    public void BakeMutton()
    {
        Console.WriteMutton("烤羊肉串");
    }
    //烤鸡翅
    public void BakeChikenWing()
    {
        Console.WriteMutton("烤鸡翅");
    }

}

客户端实现

static void Main(string[] args)
{
    //开店前的准备
    Barbecuer boy = new Barbecuer();
    Command BakeMuttonCommand1 = new BakeMuttonCommand(boy);
    Command BakeMuttonCommand2 = new BakeMuttonCommand(boy);
    Command BakeChickenWingCommand1 = new BakeMuttonCommand(boy);

    Waiter girl = new Waiter();

    //开门营业
    girl.SetOrder(BakeMuttonCommand1);
    girl.Notify();

    girl.SetOrder(BakeMuttonCommand2);
    girl.Notify();    

    girl.SetOrder(BakeChickenWingCommand1);
    girl.Notify();    

    COnsole.Read();
}

松耦合后

//服务员
public class Waiter
{
    private IList<Command> orders = new List<Command>();

    //设置订单
    public void SetOrder(Command command)
    {
        if (command.ToString() == "命令模式.BakeChikenWingCommand")
        {
            Console.WriteLine("服务员：鸡翅没有了，请点别的烧烤。");
        } 
        else
        {
            orders.Add(command);
            Console.WriteLine("增加订单："+ command.ToString() + "时间" + DateTime.Now.ToString());
        }
    }

    //取消订单
    public void CancelOrder(Command command)
    {
        orders.Remove(command);
        Console.WriteLine("取消订单" + command.ToString() + "时间" + DateTime.Now.ToString());
    }

    //通知全部执行
    public void Notify()
    {
        foreach(Command cmd in orders)
        {
            cmd.ExcuteCommand();
        }
    }
}

客户端代码实现

static void Main(string[] args)
{

    Barbecuer boy = new Barbecuer();
    Command BakeMuttonCommand1 = new BakeMuttonCommand(boy);
    Command BakeMuttonCommand2 = new BakeMuttonCommand(boy);
    Command BakeChickenWingCommand1 = new BakeMuttonCommand(boy);

    Waiter girl = new Waiter();

    girl.setOrder(bakeMuttonCommand1);
    girl.setOrder(bakeMuttonCommand1);
    girl.setOrder(BakeChickenWingCommand1);

    girl.Notify();

    Console.Read();
}

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

命令模式的优点:

• 容易地设计一个命令队列。
• 在需求的情况下，比较容易地将命令记入日志。
• 允许接受请求的一方决定是否要回绝请求。
• 很容易对请求撤销或者重做。
• 加入新的命令类不影响其它的类。
• 把请求一个操作的对象与知道怎么执行一个操作的对象分割开。