设计模式_命令模式

定义

    Encapsulate a request as an object ,thereby letting you parameterize clients with different requests,queue or log requests,and support undoable operations.(将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能)

不认识的单词

Encapsulate  封装

thereby  从而

parameterize 用参数表示，参数化

undoable   可撤销

类图  

接受者Recevier:定义每个接受者要完成的任务(类似于一个工具类)

Command抽象类，有一个execute方法        (类似于一个组装机器图)

ConcreteCommand子类，成员为一个抽象类，execute方法时就调用接受者的方法 (类似于一个组装机器)

Invoker 有一个Command成员，action方法就是执行execute方法(在我看来，这个有点多余了)

总之就是这样的，Command封装Receiver，Invoker封装Command

public abstract class Group {
 public abstract void find();
 public abstract void add();
 public abstract void delete();
 public abstract void change();
 public abstract void plan();
}

public abstract class Command {
 
 protected RequirementGroup rg=new RequirementGroup();
 protected PageGroup pg=new PageGroup();
 protected CodeGroup cg=new CodeGroup();
 
 public abstract void execute();
}

public class Invoker {
 private Command command;
 
 public void setCommand(Command command){
  this.command=command;
 }
 
 public void action(){
  this.command.execute();
 }
}

三个子类

public class CodeGroup extends Group {

 @Override
 public void add() {
  System.out.println("add code");
 }

 @Override
 public void change() {
  System.out.println("change code");
 }

 @Override
 public void delete() {
  System.out.println("delete code");
 }

 @Override
 public void find() {
  System.out.println("find code");
 }

 @Override
 public void plan() {
  System.out.println("plan code");
 }
}

public class PageGroup extends Group {

 @Override
 public void add() {
  System.out.println("add page");
 }

 @Override
 public void change() {
  System.out.println("change page");
 }

 @Override
 public void delete() {
  System.out.println("delete page");
 }

 @Override
 public void find() {
  System.out.println("find page");
 }

 @Override
 public void plan() {
  System.out.println("plan page");
 }
}

public class RequirementGroup extends Group {

 @Override
 public void add() {
  System.out.println("add requirement");
 }

 @Override
 public void change() {
  System.out.println("change requirement");
 }

 @Override
 public void delete() {
  System.out.println("delete requirement");
 }

 @Override
 public void find() {
  System.out.println("find requirement");
 }

 @Override
 public void plan() {
  System.out.println("plan requirement");
 }
}

现在根据需要来一个一个的写命令，非常好扩展

public class AddRequirementCommand extends Command {

 /**
  * 执行增加一项需求的命令
  */
 @Override
 public void execute() {
  super.rg.find();
  super.rg.add();
  super.rg.plan();
 }
}

public class DeletePageCommand extends Command {
 
 /**
  * 删除页面的命令
  */
 @Override
 public void execute() {
  super.pg.find();
  super.rg.delete();
  super.rg.plan();
 }
}

好了，命令已经写好了。

如何调用呢？  直接调用这个类的execute方法不就行了吗？ 为了更加体现依赖关系和系统设计特点(无论接受了什么命令，都要接受和执行)，调用者和接受者没有任何依赖关系。调用者只需要调用Command抽象类的execute方法即可，不需要了解谁执行了。

public class Client {

  
 public static void main(String[] args) {
  Invoker invoker=new Invoker();
  System.out.println("--------客户要求增加一项需求-------------");
  Command command = new AddRequirementCommand();  //使用早就写好的东西 
  command.execute();
  invoker.setCommand(command);
  invoker.action();
 }
}
/*高内聚
 *调用者Invoker和接受者Group没有依赖，Command容易扩展
 *缺点就是如果Command子类多的话，需要N多个的子类去一个一个实现 
 */

悟: 在我看来，这个扩展性是好的，但是写的没有技术含量，因为每多一项，就需要写一个组合命令来供客户调用，同样Invoker的存在也是为了好看而已，本质是组装，加工。

     和中介者不同的是这里的业务各个子类是相同的，而中介者是不同的。

优点 

    类间解耦

    可扩展性好

  

缺点

    类容易膨胀

我是菜鸟，我在路上。