设计模式——命令模式

假设某个项目组分为需求组（Requirement Group，简称RG）、美工组（Page Group，简称PG）、代码组（Code Group，简称CG），还有一个项目经理，刚开始的时候客户（甲方）很乐意和每个组探讨，比如和需求组讨论需求，和美工讨论页面，和代码组讨论实现，告诉他们修改这里，删除这里，增加这些等等，这是一种比较常见的甲乙方合作模式，甲方深入到乙方的项目开发中，我们把这个模式用类图表示一下：

这个类图很简单，客户和三个组都有交流，我们看看代码：

Group是命令模式中的命令接收者角色(Receiver)，客户命令它增加功能、减少功能、列出计划等

/**
 * @description: 项目组分成了三个组，每个组要接受增删改的命令
 */
public abstract class Group {
    
    public abstract void add();
    public abstract void delete();
    public abstract void change();
    public abstract void find(); // 客户要和某个小组沟通，必须先找到对应的小组
    public abstract void plan(); // 客户要求某小组列出执行计划

}

/**
 * @description: 需求组
 */
public class RequirementGroup extends Group {

    @Override
    public void add() {
        System.out.println("客户要求增加一项需求...");
    }

    @Override
    public void delete() {
        System.out.println("客户要求删除一项需求...");
    }

    @Override
    public void change() {
        System.out.println("客户要求修改一项需求...");
    }

    @Override
    public void find() {
        System.out.println("找到需求组...");
    }

    @Override
    public void plan() {
        System.out.println("客户要求列出需求变更计划...");
    }

}

/**
 * @description: 美工组
 */
public class PageGroup extends Group {

    @Override
    public void add() {
        System.out.println("客户要求增加一个页面...");
    }

    @Override
    public void delete() {
        System.out.println("客户要求删除一个页面...");
    }

    @Override
    public void change() {
        System.out.println("客户要求修改一个页面...");
    }

    @Override
    public void find() {
        System.out.println("找到美工组...");
    }

    @Override
    public void plan() {
        System.out.println("客户要求列出页面变更计划...");
    }

}

/**
 * @description: 代码组
 */
public class CodeGroup extends Group {

    @Override
    public void add() {
        System.out.println("客户要求增加一个功能...");
    }

    @Override
    public void delete() {
        System.out.println("客户要求删除一个功能...");
    }

    @Override
    public void change() {
        System.out.println("客户要求修改某个功能...");
    }

    @Override
    public void find() {
        System.out.println("找到代码组...");
    }

    @Override
    public void plan() {
        System.out.println("客户要求列出代码变更计划...");
    }

}

假设客户要求增加一项需求，看代码怎么写：

public class Client {
    
    public static void main(String[] args) {
        System.out.println("----------------客户要求增加一项需求----------------");
        Group rg = new RequirementGroup();
        rg.find(); // 找到需求组
        rg.add(); // 增加需求
        rg.plan(); // 列出需求变更计划
    }

}

# 运行结果：
----------------客户要求增加一项需求----------------
找到需求组...
客户要求增加一项需求...
客户要求列出需求变更计划...

过了一段时间，客户发现有个页面太多余，要求删除这个页面，代码如下：

public class Client {
    
    public static void main(String[] args) {
        System.out.println("----------------客户要求删除一个页面----------------");
        Group pg = new PageGroup();
        pg.find(); // 找到美工组
        pg.delete(); // 删除某个页面
        pg.plan(); // 列出页面变更计划
    }

}

问题来了，修改是可以的，但是每次都是叫一个组去，布置个任务，然后出计划，次次都这样，如果让你当甲方也就是客户，你烦不烦？而且这种方式很容易出错误，而且还真发生过，客户把美工叫过去了，要删除，可美工说需求是这么写的，然后客户又命令需求组过去，一次次的折腾，客户也烦躁了，于是和项目经理说：“我不管你们内部怎么安排，你就给我找个接头人，我告诉他怎么做，删除页面了，增加功能了，你们内部怎么处理我不管，我就告诉他我要干什么就成了...”，项目经理也很乐意这么做，于是我们改变一下类图：

Command抽象类：客户发给我们的命令，定义三个工作组的成员变量，供子类使用；定义一个抽象方法execute()，由子类来实现；
Invoker实现类：项目接头人，setComand接受客户发给我们的命令，action()方法是执行客户的命令（方法名写成action()是与command的execute()区分开，避免混淆）

修改后的代码如下：

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 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.pg.delete(); 
        // 给出计划
        super.pg.plan();
    }

}

Command抽象类还可以有很多的子类，比如增加一个功能命令（AddCodeCommand），删除一份需求命令（DeleteRequirementCommand）等等，这里就不描述了，都很简单。

我们再看看接头人，就是Invoker类的实现：

public class Invoker {
    
    private Command command;

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

}

现在客户提出各种需求就简单的多了：

public class Client {
    
    public static void main(String[] args) {
        
        // 定义张三为接头人
        Invoker zhangsan = new Invoker();
        
        System.out.println("----------------客户要求增加一项需求----------------");
        // 客户下命令
        Command command = new AddRequirementCommand();
        // 接头人接受命令
        zhangsan.setCommand(command);
        // 接头人执行命令
        zhangsan.action();
    }
}

# 执行结果
----------------客户要求增加一项需求----------------
找到需求组...
客户要求增加一项需求...
客户要求列出需求变更计划...

假如客户又提出了新的需求：删除页面，那么只要在Client中把Command command = new AddRequirementCommand();换为Command command = new DeletePageCommand();即可，这就是命令模式，命令模式的通用类图如下：

在这个类图中，我们看到三个角色：

• Receiver角色：这个就是干活的角色，命令传递到这里是应该被执行的，具体到上面我们的例子中就是Group的三个实现类；
• Command角色：就是命令，需要执行的所有命令都这里声明；
• Invoker角色：调用者，接收到命令，并执行命令，例子中项目经理就是这个角色；

命令模式比较简单，但是在项目中使用是非常频繁的，封装性非常好，因为它把请求方（Invoker）和执行方（Receiver）分开了，扩展性也有很好的保障。但是，命令模式也是有缺点的，如果需要扩展命令，就需要新增加Command类的子类，如果要新增的子类数量很多，那么是否使用命令模式就需要考虑了。

我们的例子还没有结束，通常来说，一个新增需求的命令，并不是通知给需求组就可以的，而是需要三个组通力合作的，那么我们在AddRequirementCommand命令中怎么调动其他组呢？很简单的，在AddRequirementCommand类的execute()方法中增加对PageGroup和CodePage的调用就成了，修改后的代码如下：

public class AddRequirementCommand extends Command {

    @Override
    public void execute() {
        // 找到需求组
        super.rg.find(); 
        // 增加一份需求
        super.rg.add(); 
        // 页面要增加
        super.pg.add();
        // 功能也要增加
        super.cg.add();
        //给出计划
        super.rg.plan();
    }

}

那么，客户提出需求后，又取消了，这个该怎么实现呢？其实取消也是一个命令，比如叫做undo()，那么在Group抽象类中增加undo()方法，3个Group继承类中重写undo()方法，然后在UndoRequirementCommand类中调用3个Group继承类中的undo()方法就可以加上这个撤销命令的功能，扩展起来还是很简单的。

原文：https://www.jianshu.com/p/2da80c468e0a