设计模式_命令模式

定义

    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没有依赖，Commandeasy扩展
 *缺点就是假设Command子类多的话。须要N多个的子类去一个一个实现 
 */

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

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

长处 

    类间解耦

    可扩展性好

  

缺点

    类easy膨胀

我是菜鸟。我在路上。