命令模式(Command Pattern)

简介

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

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

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

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

命令模式 - 图1

JavaScript

  1. /* The Invoker function */
  2. var Switch = function(){
  3.     var _commands = [];
  4.     this.storeAndExecute = function(command){
  5.         _commands.push(command);
  6.         command.execute();
  7.     }
  8. }
  10. /* The Receiver function */
  11. var Light = function(){
  12.     this.turnOn = function(){ console.log ('turn on')};
  13.     this.turnOff = function(){ console.log ('turn off') };
  14. }
  16. /* The Command for turning on the light - ConcreteCommand #1 */
  17. var FlipUpCommand = function(light){
  18.     this.execute = light.turnOn;
  19. }
  21. /* The Command for turning off the light - ConcreteCommand #2 */
  22. var FlipDownCommand = function(light){
  23.     this.execute = light.turnOff;
  24. }
  26. var light = new Light();
  27. var switchUp = new FlipUpCommand(light);
  28. var switchDown = new FlipDownCommand(light);
  29. var s = new Switch();
  31. s.storeAndExecute(switchUp);
  32. s.storeAndExecute(switchDown);

Java

  1. import java.util.List;
  2. import java.util.ArrayList;
  4. /* The Command interface */
  5. public interface Command {
  6.    void execute();
  7. }
  9. /* The Invoker class */
  10. public class Switch {
  11.    private List<Command> history = new ArrayList<Command>();
  13.    public Switch() {
  14.    }
  16.    public void storeAndExecute(Command cmd) {
  17.       this.history.add(cmd); // optional 
  18.       cmd.execute();        
  19.    }
  20. }
  22. /* The Receiver class */
  23. public class Light {
  24.    public Light() {
  25.    }
  27.    public void turnOn() {
  28.       System.out.println("The light is on");
  29.    }
  31.    public void turnOff() {
  32.       System.out.println("The light is off");
  33.    }
  34. }
  36. /* The Command for turning on the light - ConcreteCommand #1 */
  37. public class FlipUpCommand implements Command {
  38.    private Light theLight;
  40.    public FlipUpCommand(Light light) {
  41.       this.theLight = light;
  42.    }
  44.    public void execute(){
  45.       theLight.turnOn();
  46.    }
  47. }
  49. /* The Command for turning off the light - ConcreteCommand #2 */
  50. public class FlipDownCommand implements Command {
  51.    private Light theLight;
  53.    public FlipDownCommand(Light light) {
  54.       this.theLight = light;
  55.    }
  57.    public void execute() {
  58.       theLight.turnOff();
  59.    }
  60. }
  62. /* The test class or client */
  63. public class PressSwitch {
  64.    public static void main(String[] args){
  65.       Light lamp = new Light();
  66.       Command switchUp = new FlipUpCommand(lamp);
  67.       Command switchDown = new FlipDownCommand(lamp);
  69.       Switch mySwitch = new Switch();
  71.       try {
  72.          if ("ON".equalsIgnoreCase(args[0])) {
  73.             mySwitch.storeAndExecute(switchUp);
  74.          }
  75.          else if ("OFF".equalsIgnoreCase(args[0])) {
  76.             mySwitch.storeAndExecute(switchDown);
  77.          }
  78.          else {
  79.             System.out.println("Argument \"ON\" or \"OFF\" is required.");
  80.          }
  81.       } catch (Exception e) {
  82.          System.out.println("Arguments required.");
  83.       }
  84.    }
  85. }

实例

模拟烧烤

紧耦合设计

  1. //烤肉串者
  2. public class Barbecuer
  3. {
  4.     //烤羊肉
  5.     public void BakeMutton()
  6.     {
  7.         Console.WriteMutton("烤羊肉串");
  8.     }
  9.     //烤鸡翅
  10.     public void BakeChikenWing()
  11.     {
  12.         Console.WriteMutton("烤鸡翅");
  13.     }
  15. }

客户端调用

  1. static void Main(string[] args)
  2. {
  3.     Barbecuer boy = new Barbecuew();
  4.     boy.BakeMutton();
  5.     boy.BakeMutton();
  6.     boy.BakeMutton();
  7.     boy.BakeChickenWing();
  8. }

松耦合设计

抽象命令类

  1. //抽象命令
  2. public abstract class Command
  3. {
  4.     protected Barbecuer receiver;
  6.     public Command(Barbecuer receiver)
  7.     {
  8.         this.receiver = receiver;
  9.     }
  11.     //执行命令
  12.     abstract public ExcuteCommand();
  13. }

具体命令类

  1. //烤羊肉命令
  2. class BakeMuttonCommand: Command
  3. {
  4.     public BakeMuttonCommand(Barbecuer receiver)
  5.     {
  6.         :base(receiver)
  7.     }
  9.     public override void EccuteCommand()
  10.     {
  11.         receiver.BakeMutton();
  12.     }
  13. }
  15. //烤鸡翅命令
  16. class BakeMuttonCommand: Command
  17. {
  18.     public BakeMuttonCommand(Barbecuer receiver)
  19.     {
  20.         :base(receiver)
  21.     }
  23.     public override void EccuteCommand()
  24.     {
  25.         receiver.BakeChickenWing();
  26.     }
  27. }

服务员类

  1. //服务员
  2. public class Waiter
  3. {
  4.     private Command command;
  6.     //设置订单
  7.     public void setOrder(Command command)
  8.     {
  9.         this.command
  10.     }
  12.     //通知执行
  13.     public void Notify()
  14.     {
  15.         command.ExcuteCommand();
  16.     }
  17. }
  1. //烤肉串者
  2. public class Barbecuer
  3. {
  4.     //烤羊肉
  5.     public void BakeMutton()
  6.     {
  7.         Console.WriteMutton("烤羊肉串");
  8.     }
  9.     //烤鸡翅
  10.     public void BakeChikenWing()
  11.     {
  12.         Console.WriteMutton("烤鸡翅");
  13.     }
  15. }

客户端实现

  1. static void Main(string[] args)
  2. {
  3.     //开店前的准备
  4.     Barbecuer boy = new Barbecuer();
  5.     Command BakeMuttonCommand1 = new BakeMuttonCommand(boy);
  6.     Command BakeMuttonCommand2 = new BakeMuttonCommand(boy);
  7.     Command BakeChickenWingCommand1 = new BakeMuttonCommand(boy);
  9.     Waiter girl = new Waiter();
  11.     //开门营业
  12.     girl.SetOrder(BakeMuttonCommand1);
  13.     girl.Notify();
  15.     girl.SetOrder(BakeMuttonCommand2);
  16.     girl.Notify();    
  18.     girl.SetOrder(BakeChickenWingCommand1);
  19.     girl.Notify();    
  21.     COnsole.Read();
  22. }

松耦合后

  1. //服务员
  2. public class Waiter
  3. {
  4.     private IList<Command> orders = new List<Command>();
  6.     //设置订单
  7.     public void SetOrder(Command command)
  8.     {
  9.         if (command.ToString() == "命令模式.BakeChikenWingCommand")
  10.         {
  11.             Console.WriteLine("服务员：鸡翅没有了，请点别的烧烤。");
  12.         } 
  13.         else
  14.         {
  15.             orders.Add(command);
  16.             Console.WriteLine("增加订单："+ command.ToString() + "时间" + DateTime.Now.ToString());
  17.         }
  18.     }
  20.     //取消订单
  21.     public void CancelOrder(Command command)
  22.     {
  23.         orders.Remove(command);
  24.         Console.WriteLine("取消订单" + command.ToString() + "时间" + DateTime.Now.ToString());
  25.     }
  27.     //通知全部执行
  28.     public void Notify()
  29.     {
  30.         foreach(Command cmd in orders)
  31.         {
  32.             cmd.ExcuteCommand();
  33.         }
  34.     }
  35. }

客户端代码实现

  1. static void Main(string[] args)
  2. {
  4.     Barbecuer boy = new Barbecuer();
  5.     Command BakeMuttonCommand1 = new BakeMuttonCommand(boy);
  6.     Command BakeMuttonCommand2 = new BakeMuttonCommand(boy);
  7.     Command BakeChickenWingCommand1 = new BakeMuttonCommand(boy);
  9.     Waiter girl = new Waiter();
  11.     girl.setOrder(bakeMuttonCommand1);
  12.     girl.setOrder(bakeMuttonCommand1);
  13.     girl.setOrder(BakeChickenWingCommand1);
  15.     girl.Notify();
  17.     Console.Read();
  18. }

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

命令模式的优点:

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