一.Command模式

一、Command模式定义:

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

　　二、模式解说

　　Commad模式是一种对象行为模式，它可以对发送者(sender)和接收者(receiver)完全解耦(decoupling)。（"发 送者" 是请求操作的对象，"接收者" 是接收请求并执行某操作的对象。有了 "解耦"，发送者对接收者的接口一无所知。）这里，"请求"(request)这个术语指的是要被执行的命令。Command模式还让我们可以对 "何时" 以及 "如何" 完成请求进行改变。因此，Command模式为我们提供了灵活性和可扩展性。

　　三、结构图

　　Command模式结构图如下:

 

四、怎么使用？

　　1）定义一个Command接口，接口中有一个统一的方法，这就是将请求/命令封装为对象。

　　2）定义具体不同命令类ConcreteCommand实现Command接口。

　　3）定义一个命令的调用角色Invoker。

　　4）定义一个命令执行状态的接收者Receiver（非必须）。

五、一个例子

view plain copy to clipboard print ?

1. class  Document{     
2.     public   void  display(){     
3.         System.out.println("显示文档 内容" );     
4.     }     
5.     public   void  undo(){     
6.         System.out.println("撤销文档内容" );     
7.     }     
8.     public   void  redo(){     
9.         System.out.println("重做文档 内容" );     
10.     }     
11. }     
12. interface  DocumentCommand{     
13.     public   void  execute();     
14. }     
15. class  DisplayCommand  implements  DocumentCommand{     
16.     private  Document document;     
17.     public  DisplayCommand(Document doc){     
18.         document=doc;     
19.     }     
20.     public   void  execute() {     
21.   
22.         document.display();     
23.     }     
24. }     
25. class  UndoCommand  implements  DocumentCommand{     
26.     private  Document document;     
27.     public  UndoCommand(Document doc){     
28.         document=doc;     
29.     }     
30.     public   void  execute() {     
31.         document.undo();     
32.   
33.     }     
34. }     
35. class  RedoCommand  implements  DocumentCommand{     
36.     private  Document document;     
37.     public  RedoCommand(Document doc){     
38.         document=doc;     
39.     }     
40.     public   void  execute(){     
41.         document.redo();     
42.     }     
43. }     
44. class  DocumentInvoker{     
45.     private  DisplayCommand _dcmd;     
46.     private  UndoCommand _ucmd;     
47.     private  RedoCommand _rcmd;     
48.     public  DocumentInvoker(DisplayCommand dcmd,UndoCommand ucmd,RedoCommand rcmd){     
49.         this ._dcmd=dcmd;     
50.         this ._ucmd=ucmd;     
51.         this ._rcmd=rcmd;     
52.     }     
53.     public   void  display(){     
54.         _dcmd.execute();     
55.     }     
56.     public   void  undo(){     
57.         _ucmd.execute();     
58.     }     
59.     public   void  redo(){     
60.         _rcmd.execute();     
61.     }     
62. }     
63. public   class  CommandTest {     
64.   
65.     public   static   void  main(String[] args) {     
66.         Document doc=new  Document();     
67.         DisplayCommand display=new  DisplayCommand(doc);     
68.         UndoCommand undo=new  UndoCommand(doc);     
69.         RedoCommand redo=new  RedoCommand(doc);     
70.         DocumentInvoker invoker=new  DocumentInvoker(display,undo,redo);     
71.         invoker.display();     
72.         invoker.undo();     
73.         invoker.redo();     
74.   
75.     }     
76.   
77. }    

class Document{ public void display(){ System.out.println("显示文档内容"); } public void undo(){ System.out.println("撤销文档内容"); } public void redo(){ System.out.println("重做文档内容"); } } interface DocumentCommand{ public void execute(); } class DisplayCommand implements DocumentCommand{ private Document document; public DisplayCommand(Document doc){ document=doc; } public void execute() { document.display(); } } class UndoCommand implements DocumentCommand{ private Document document; public UndoCommand(Document doc){ document=doc; } public void execute() { document.undo(); } } class RedoCommand implements DocumentCommand{ private Document document; public RedoCommand(Document doc){ document=doc; } public void execute(){ document.redo(); } } class DocumentInvoker{ private DisplayCommand _dcmd; private UndoCommand _ucmd; private RedoCommand _rcmd; public DocumentInvoker(DisplayCommand dcmd,UndoCommand ucmd,RedoCommand rcmd){ this._dcmd=dcmd; this._ucmd=ucmd; this._rcmd=rcmd; } public void display(){ _dcmd.execute(); } public void undo(){ _ucmd.execute(); } public void redo(){ _rcmd.execute(); } } public class CommandTest { public static void main(String[] args) { Document doc=new Document(); DisplayCommand display=new DisplayCommand(doc); UndoCommand undo=new UndoCommand(doc); RedoCommand redo=new RedoCommand(doc); DocumentInvoker invoker=new DocumentInvoker(display,undo,redo); invoker.display(); invoker.undo(); invoker.redo(); } }

六、适用性

1）使用命令模式作为"CallBack"在面向对象系统中的替代。"CallBack"讲的便是先将一个函数登记上，然后在以后调用此函数。

　　2）需要在不同的时间指定请求、将请求排队。一个命令对象和原先的请求发出者可以有不同的生命期。换言之，原先的请求发出者可能已经不在了，而 命令对象本身仍然是活动的。这时命令的接收者可以是在本地，也可以在网络的另外一个地址。命令对象可以在串形化之后传送到另外一台机器上去。

　　3）系统需要支持命令的撤消(undo)。命令对象可以把状态存储起来，等到客户端需要撤销命令所产生的效果时，可以调用undo()方法，把 命令所产生的效果撤销掉。命令对象还可以提供redo()方法，以供客户端在需要时，再重新实施命令效果。

　　4）如果一个系统要将系统中所有的数据更新到日志里，以便在系统崩溃时，可以根据日志里读回所有的数据更新命令，重新调用Execute()方 法一条一条执行这些命令，从而恢复系统在崩溃前所做的数据更新。

　　七、优缺点

　　1)优点: Command模式将 "调用操作的对象"（DocumentInvoker）和 "知道如何执行操作的对象" (Document)完全分离开来。这带来了很大的灵活性：发送请求的对象只需要知道如何发送；它不必知道如何完成请求。

　　2)会导致某些系统有过多的具体命令类。