命令模式

命名、命令就是我下一个命令你就要来执行，我不关心谁来实现的，我只关心我的命令执没执行。命令模式就是将命令和执行封装在一起，并且高层组件是接触不到底层组件的，实现了调用者和执行者解耦合

看一下类图

命令模式类图

Command：定义了命令的抽象
ConcreteCommand：是具体的命令实现类，他实现了具体的execute()
Invoker：是接口人他用来接收命令和执行命令
Receiver：真正执行命令的

这里假设一个场景，是一个软件项目建立，有用户，产品经理，程序员，设计，还有一个项目经理。如果说没有项目经理，那用户要改功能，需求和页面都需要去找相应的人员，有的时候你找的还不一定是对的人。如果你是用户你会不会觉得很麻烦，我直接找项目经理告诉你我要做什么你给我找人去做就完了。
用户就是高层调用发送具体命令ConcreteCommand
产品经理，程序员，设计就是Receiver
项目经理是Invoker
1，定义执行角色的抽象类

public abstract class Group {
    //甲乙双方办公，如果你要和某个组讨论，首先要找到这个组
    public abstract void find();
    //被要求增加功能
    public abstract void add();
    //被要求删除功能
    public abstract void delete();
    //被要求修改功能
    public abstract void change();
    //被要求给出所有变更计划
    public abstract void plan();
}

2，定义各个角色的具体实现

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

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

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

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

    @Override
    public void plan() {
        System.out.println("客户要求变更一条页面。。。");
    }
}

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

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

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

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

    @Override
    public void plan() {
        System.out.println("客户要求变更一条需求。。。");
    }
}


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

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

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

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

    @Override
    public void plan() {
        System.out.println("客户要求变更一条功能。。。");
    }
}

3，定义抽象的命令

public abstract class Command {
    //把三组都定义好子类可以直接使用
    protected RequirementGroup rg = new RequirementGroup();
    protected PageGroup pg = new PageGroup();
    protected CodeGroup cg = new CodeGroup();
    //只有一个方法你要我做什么事
    public abstract void execute();
}

4，定义具体的命令，增加一个需求，减少一个页面

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() {
        pg.find();
        pg.delete();
        pg.plan();
    }
}

5，定义一接口人

//接口人
public class Invoker {
    private Command command;

    //客户发出命令
    public void setCommand(Command command){
        this.command = command;
    }

    //执行客户命令
    public void action(){
        this.command.execute();
    }
}

6，调用

public class Main {

    public static void main(String[] args){
        //定义接头人
        Invoker invoker = new Invoker();
        System.out.println("--------------客户要求增加一项需求---------------");
        Command command = new AddRequirementCommand();
        invoker.setCommand(command);
        invoker.action();
    }

}

总结：我们看到在高层组件调用时只需要让接头人去执行一个命令就行了，调用者根本就不知道是谁实现的，也就是调用和实现分离，实现了高内聚，如果我们要修改对应命令的实现直接修改命令中的调用execute即可

使用时要注意因为每一个命令都要建立一个命令类，所以可能会导致类爆炸

命令模式也可以实现请求排队和命令撤销恢复的功能