命令模式

Posted 2020-07-31 _Doing

 

命令模式

• 何时使用：在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，应将"行为请求者"与"行为实现者"解耦。
• 如何解决：调用者依赖命令，命令依赖接收者（即：接收者依赖注入到命令，特定的接收处理者与相对应的命令绑定；命令依赖注入到接收者）。通过调用者发布命令，命令中的接收者执行这个命令，顺序：调用者Invoker→命令Command→接收者Receiver。
• 优点： 1、降低了系统耦合度：命令模式使得发起命令的对象——客户端，和具体实现命令的对象——接收者对象完全解耦，也就是说发起命令的对象完全不知道具体实现对象是谁，也不知道如何实现。  2、更好的扩展性：新的命令可以很容易添加到系统中去。由于发起命令的对象和具体的实现完全解耦，因此扩展新的命令就很容易，只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象中，然后就可以使用这个命令对象，已有的实现完全不用变化。    3、更动态的控制：命令模式把请求封装起来，可以动态地对它进行参数化、队列化和日志化等操作，从而使得系统更灵活。    4、很自然的复合命令：命令模式中的命令对象能够很容易地组合成复合命令，也就是宏命令，从而使系统操作更简单，功能更强大。
• 缺点：使用命令模式可能会导致某些系统有过多的具体命令类。
• 使用场景：认为是命令的地方都可以使用命令模式，比如： 1、GUI 中每一个按钮都是一条命令。 2、模拟 CMD。3、struts 1 中的 action 核心控制器 ActionServlet 只有一个，相当于 Invoker，而模型层的类会随着不同的应用有不同的模型类，相当于具体的 Command。4、系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作，也可以考虑使用命令模式，见命令模式的扩展。

 

典型框架

• 请求者(Invoker)角色：负责调用命令对象Command执行请求。
• 命令(Command)角色：声明了一个给所有具体命令类的抽象接口。
• 具体命令(ConcreteCommand)角色：定义一个接收者和行为之间的弱耦合，实现execute()方法：负责调用接收者的相应操作。
• 接收者(Receiver)角色：负责具体实施和执行一个请求。
• 客户端(Client)角色：创建一个具体命令(ConcreteCommand)对象并确定其接收者（Receiver）。

 

接收者角色类

1. publicclassReceiver{
2.    // 真正执行命令相应的操作
3.     publicvoid action(){
4.         System.out.println("执行操作");
5.     }
6. }

抽象命令角色类

1. public interface Command{
2.     // 执行方法
3.     void execute();
4. }

具体命令角色类

1. publicclassConcreteCommand implements Command{
2.     //持有相应的接收者对象
3.     privateReceiver receiver = null;
5.     publicConcreteCommand(Receiver receiver){
6.         this.receiver = receiver;
7.     }
9.     @Override
10.     publicvoid execute(){
11.         //通常会转调接收者对象的相应方法，让接收者来真正执行功能
12.         receiver.action();
13.     }
14.  
15. }

请求者角色类

1. publicclassInvoker{
2.     //持有命令对象
3.     privateCommand command = null;
5.     publicInvoker(Command command){
6.         this.command = command;
7.     }
8.     // 行动方法
9.     publicvoid action(){
10.         command.execute();
11.     }
12. }

客户端角色类

1. publicclassClient{
2.  
3.     publicstaticvoid main(String[] args){
4.         //创建接收者
5.         Receiver receiver =newReceiver();
6.         //创建命令对象，设定它的接收者
7.         Command command =newConcreteCommand(receiver);
8.         //创建请求者，把命令对象设置进去
9.         Invoker invoker =newInvoker(command);
10.         //执行方法
11.         invoker.action();
12.     }
13.  
14. }

（参考来源：http://www.cnblogs.com/java-my-life/archive/2012/06/01/2526972.html）

 

android中的Thread与Runnable

        命令模式中，Command接口提供了Execute方法，客户端通过Invoker调用命令Command来调用Recriver，绕了一大圈，就是把具体对Receiver的操作请求封装在具体的Command中，使得客户端对recriver的操作清晰简明。

        但是在实际项目中，我们常常忽略Receiver，而把命令对象的目标对象直接设置为子类自己的成员变量或者作为execute()方法的临时变量。以Android中的Runnable(在java.lang包下)为例，画出UML结构图如下：

命令接口Runnable：

1. public interface Runnable{
2.     public abstract void run();
3. }

具体命令Runnable实现与执行：

调用者Thread简化版代码：

1. //命令模式在调用者这里不需要继承Runnable接口，但是这里考虑到实际情况，比如方便性等，继承了Runnable接口，实现了run方法，这个是Thread自身的运行run的方法
2. classThread implements Runnable{
3.     privateRunnable target;
4.  
5.     publicThread(Runnable target){
6.         this.target = target;
7.     }
8.  
9.      public synchronized void start(){
10.         if(threadStatus !=0||this!= me)
11.             thrownewIllegalThreadStateException();
12.         group.add(this);
13.         start0();//这个是本地方法，调用run方法
14.         if(stopBeforeStart){
15.         stop0(throwableFromStop);
16.     }
17.     }
18.  
19.     //可选
20.     publicvoid run(){
21.     if(target != null){
22.         target.run();
23.     }
24.     }
25. }

客户端只需要new Thread(new Runnable(){}).start()就开始执行相关的一系列的请求，这些请求大部分都是实现Runnable接口的匿名类（如下ThreadRunnable）：

 

（参考来源：http://www.cnblogs.com/qianxudetianxia/archive/2011/08/13/2135478.html）

 

 

 

来自为知笔记(Wiz)