命令模式(Command Pattern)

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

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

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

    JavaScript

    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.       theLight.turnOff();
    58.    }
    59. }
    61. /* The test class or client */
    62. public class PressSwitch {
    63.    public static void main(String[] args){
    64.       Light lamp = new Light();
    66.       Command switchDown = new FlipDownCommand(lamp);
    68.       Switch mySwitch = new Switch();
    70.       try {
    71.          if ("ON".equalsIgnoreCase(args[0])) {
    72.             mySwitch.storeAndExecute(switchUp);
    73.          }
    74.          else if ("OFF".equalsIgnoreCase(args[0])) {
    75.             mySwitch.storeAndExecute(switchDown);
    76.          }
    77.          else {
    78.             System.out.println("Argument \"ON\" or \"OFF\" is required.");
    79.          }
    80.       } catch (Exception e) {
    81.          System.out.println("Arguments required.");
    82.       }
    83.    }
    84. }

    实例

    紧耦合设计

    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. //抽象命令
    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. {
    18.     {
    19.         :base(receiver)
    20.     }
    22.     public override void EccuteCommand()
    23.     {
    24.         receiver.BakeChickenWing();
    25.     }
    26. }
    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. 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. }

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

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