命令模式

 
命令模式
  • 何时使用：在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，应将"行为请求者"与"行为实现者"解耦。
  • 如何解决：调用者依赖命令，命令依赖接收者（即：接收者依赖注入到命令，特定的接收处理者与相对应的命令绑定；命令依赖注入到接收者）。通过调用者发布命令，命令中的接收者执行这个命令，顺序：调用者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. }
 
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）：
 
 
 
 





【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Doing-what-I-love/p/5621165.html