设计模式总结通过命令模式.docx

1、设计模式总结 通过命令模式注：文档内容基本上来自于网上，并加上自己的理解而成。有的觉得网友总结得非常好，就完全照搬下来，供学习之用。然而，有的摘抄并没有加上原链接和出处，请谅解。通过命令模式，通过在客户端和具体的命令之间添加一层Invoker，剪断了客户端和具体服务提供者之间的耦合，降低了两者之间的耦合度，同时也增加了灵活性，比如我们可以灵活的某一个请求的服务提供者，通过单独的服务提供者Command类，可以很方便的提供redo和undo的功能等等，这些都是命令模式的优势。在软件系统中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合，比如要对行为进行“记录、撤销/重做、事务

2、”等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为抽象为对象，实现二者之间的松耦合。这就是命令模式（Command Pattern）即命令模式的核心是要解决“行为请求者”和“行为实现”都之间的耦合，以达到灵活多变的效果。目标：客户只需要发命令，而不需要管命令是如何被执行的！Command patternFrom Wikipedia, the free encyclopediaThis article includes alist of references, related reading orexternal links, but

3、its sources remain unclear because it lacksinline citations.Pleaseimprovethis article by introducing more precise citations.(December 2012)Inobject-oriented programming, thecommand patternis abehaviouraldesign patternin whichan object is used to represent andencapsulateall the information needed to

4、call a method at a later time. This information includes the method name, the object that owns the method and values for the method parameters.Four terms always associated with the command pattern arecommand,receiver,invokerandclient.A concretecommandobject has areceiverobject and invokes a method o

5、f the receiver in a way that is specific to that receivers class(即在concrete command Object里面有 receiver 的成员变量，并且有触发 receiver 动作的方法，这个方法是所有receiver所共有的接口级别的方法). The receiver then does the work.A concrete command object is separately passed to aninvokerobject, which invokes the command, and optionally

6、does bookkeeping about the command execution. Any concrete command object can be passed to the same invoker object（即在Invoker有一个接受Concrete Command的方法，形如setCommand(XXX)）. Both an invoker object and several concrete command objects are held by aclientobject(Client创建具体的 Concrete Command). The client con

7、tains the decision making about which commands to execute at which points.To execute a command, it passes the command object to the invoker object.See example code below.Using command objects makes it easier to construct general components that need to delegate, sequence or execute method calls at a

8、 time of their choosing without the need to know the class of the method or the method parameters. Using an invoker object allows bookkeeping about command executions to be conveniently performed, as well as implementing different modes for commands, which are managed by the invoker object, without

9、the need for the client to be aware of the existence of bookkeeping or modes.Contentshide 1Uses 2Structure 3Terminology 4Example 4.1C# 4.2Java 4.3Python 4.4Scala 4.5Javascript 5See also 6References 7External linkseditUsesCommand objects are useful for implementing:GUI buttons and menu itemsInSwingan

10、dBorland Delphiprogramming, anActionis a command object. In addition to the ability to perform the desired command, anActionmay have an associated icon, keyboard shortcut, tooltip text, and so on. A toolbar button or menu item component may be completely initialized using only theActionobject.Macror

11、ecordingIf all user actions are represented by command objects, a program can record a sequence of actions simply by keeping a list of the command objects as they are executed. It can then play back the same actions by executing the same command objects again in sequence. If the program embeds a scr

12、ipting engine, each command object can implement atoScript()method, and user actions can then be easily recorded as scripts.Mobile CodeUsing languages such as Java where code can be streamed/slurped from one location to another via URLClassloaders and Codebases the commands can enable new behavior t

13、o be delivered to remote locations (EJB Command, Master Worker)Multi-levelundoIf all user actions in a program are implemented as command objects, the program can keep a stack of the most recently executed commands. When the user wants to undo a command, the program simply pops the most recent comma

14、nd object and executes itsundo()method.NetworkingIt is possible to send whole command objects across the network to be executed on the other machines, for example player actions in computer games.Parallel ProcessingWhere the commands are written as tasks to a shared resource and executed by many thr

15、eads in parallel (possibly on remote machines -this variant is often referred to as the Master/Worker pattern)Progress barsSuppose a program has a sequence of commands that it executes in order. If each command object has agetEstimatedDuration()method, the program can easily estimate the total durat

16、ion. It can show a progress bar that meaningfully reflects how close the program is to completing all the tasks.Thread poolsA typical, general-purpose thread pool class might have a publicaddTask()method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of t

17、hreads that execute commands from the queue. The items in the queue are command objects. Typically these objects implement a common interface such asjava.lang.Runnablethat allows the thread pool to execute the command even though the thread pool class itself was written without any knowledge of the

18、specific tasks for which it would be used.TransactionalbehaviorSimilar to undo, a database engine or software installer may keep a list of operations that have been or will be performed. Should one of them fail, all others can be reversed or discarded (usually calledrollback). For example, if two da

19、tabase tables that refer to each other must be updated, and the second update fails, the transaction can be rolled back, so that the first table does not now contain an invalid reference.WizardsOften a wizard presents several pages of configuration for a single action that happens only when the user

20、 clicks the Finish button on the last page. In these cases, a natural way to separate user interface code from application code is to implement the wizard using a command object. The command object is created when the wizard is first displayed. Each wizard page stores its GUI changes in the command

21、object, so the object is populated as the user progresses. Finish simply triggers a call toexecute(). This way, the command class contains no user interface code.editStructure UPDATE: The explanation for the Receiver block above should be The actual work to be done by the command (action)editTermino

22、logyThe terminology used to describe command pattern implementations is not consistent and can therefore be confusing. This is the result ofambiguity, the use ofsynonyms, and implementations that may obscure the original pattern by going well beyond it.1. Ambiguity.2. The termcommandis ambiguous. Fo

23、r example,move up, move upmay refer to a single (move up) command that should be executed twice, or it may refer to two commands, each of which happens to do the same thing (move up). If the former command is added twice to an undo stack, both items on the stack refer to the same command instance. T

24、his may be appropriate when a command can always be undone the same way (e.g. move down). Both theGang of Fourand theJava example belowuse this interpretation of the termcommand. On the other hand, if the latter commands are added to an undo stack, the stack refers to two separate objects. This may

25、be appropriate when each object on the stack must contain information that allows the command to be undone. For example, to undo adelete selectioncommand, the object may contain a copy of the deleted text so that it can be re-inserted, if thedelete selectioncommand must be undone. Note that using a

26、separate object for each invocation of a command is also an example of thechain of responsibility pattern.3. The termexecuteis also ambiguous. It may refer to running the code identified by the command objectsexecutemethod. However, in MicrosoftsWindows Presentation Foundationa command is considered

27、 to have been executed when the commandsexecutemethod has been invoked, but that does not necessarily mean that the application code has run. That occurs only after some further event processing.4. Synonyms andhomonyms.5. Client, Source, Invoker: the button, toolbar button, or menu item clicked, the

28、 shortcut key pressed by the user.6. Command Object, Routed Command Object, Action Object: a singleton object (e.g. there is only one CopyCommand object), which knows about shortcut keys, button images, command text, etc. related to the command. A source/invoker object calls the Command/Action objec

29、ts execute/performAction method. The Command/Action object notifies the appropriate source/invoker objects when the availability of a command/action has changed. This allows buttons and menu items to become inactive (grayed out) when a command/action cannot be executed/performed.7. Receiver, Target

30、Object: the object that is about to be copied, pasted, moved, etc. The receiver object owns the method that is called by the commandsexecutemethod. The receiver is typically also the target object. For example, if the receiver object is acursorand the method is calledmoveUp, then one would expect th

31、at the cursor is the target of the moveUp action. On the other hand, if the code is defined by the command object itself, the target object will be a different object entirely.8. Command Object, routed event args, event object: the object that is passed from the source to the Command/Action object,

32、to the Target object to the code that does the work. Each button click or shortcut key results in a new command/event object. Some implementations add more information to the command/event object as it is being passed from one object (e.g. CopyCommand) to another (e.g. document section). Other implementations put command/event objects in other event objects (like a box inside a bigger box) as they move along the