命令模式——Command

案例展示——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 class RequirementGroup extends Group {
    //客户找到需求组进行讨论
    public void find() {
        System.out.println("找到需求组。。。");
    }
    //客户要求增加一项需求
    public void add() {
        System.out.println("客户要求增加一项需求。。。");
    }
    //客户要求删除一项需求
    public void delete() {
        System.out.println("客户要求删除一项需求。。。");
    }
    //客户要求修改一项需求
    public void change() {
        System.out.println("客户要求修改一项需求。。。");
    }
    //客户要求给出变更计划
    public void plan() {
        System.out.println("客户要求给出变更计划。。。");
    }
}

//美工组
public class PageGroup extends Group {
    //客户找到美工组进行讨论
    public void find() {
        System.out.println("找到美工组。。。");
    }
    //客户要求增加一个页面
    public void add() {
        System.out.println("客户要求增加一个页面。。。");
    }
    //客户要求删除一个页面
    public void delete() {
        System.out.println("客户要求删除一个页面。。。");
    }
    //客户要求修改一个页面
    public void change() {
        System.out.println("客户要求修改一个页面。。。");
    }
    //客户要求给出变更计划
    public void plan() {
        System.out.println("客户要求给出变更计划。。。");
    }
}


//代码组
public class CodeGroup extends Group {
    //客户找到代码组进行讨论
    public void find() {
        System.out.println("找到代码组。。。");
    }
    //客户要求增加一个功能
    public void add() {
        System.out.println("客户要求增加一个功能。。。");
    }
    //客户要求删除一个功能
    public void delete() {
        System.out.println("客户要求删除一个功能。。。");
    }
    //客户要求修改一个功能
    public void change() {
        System.out.println("客户要求修改一个功能。。。");
    }
    //客户要求给出变更计划
    public void plan() {
        System.out.println("客户要求给出变更计划。。。");
    }
}

//在一个场景中实现
public class Client {
    public static void main(String[] args) {
        System.out.println("=======找到需求组谈需求=======");
        Group group = new RequirementGroup();
        group.find();
        group.add();
        group.plan();

        System.out.println("=======找到美工组谈页面=======");
        Group group2 = new RequirementGroup();
        group2.find();
        group2.add();
        group2.plan();

        System.out.println("=======找到代码组谈功能=======");
        Group group3 = new RequirementGroup();
        group3.find();
        group3.add();
        group3.plan();
    }
}

//结果如下：
=======找到需求组谈需求=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。
=======找到美工组谈页面=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。
=======找到代码组谈功能=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。。

 结果很令人满意，但是其过程却是很曲折，过了不久，干员找到公司领导反映情况：什么事情都需要他去操心，需求需要去找需求组，美工要找美工组，功能要找代码组，这样跑来跑去他受不了了，希望公司高层拿出一个方案来，他只负责下命令，其他的由一个代理的负责人去找各个组协商去。没办法，谁让顾客是上帝呢？于是公司高层经过几个昼夜的深思熟虑，一种新的设计方案诞生了——使用命令模式，设计类图如下：

• Command抽象类：包装客户发送的命令，定义三个工作组的成员变量供子类使用，定义一个抽象方法 execute() 供子类实现使用

• DeletePageCommand类和AddRequirementCommand类：继承了Command类，对客户发出的命令进行了封装，每个命令就是一个对象，避免客户，负责人，组员之间出现交流误差

• Invoker类：项目负责人，接收客户发送的命令，将命令给Command类进行封装，使用 action() 方法执行客户的命令。

代码实现如下(给出和上面示例不同的代码)：

//抽象命令类
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 {
    //执行增加一个需求的命令
    public void execute() {
        //找到需求组
        super.rg.find();
        //增加需求
        super.rg.add();
        //给出计划
        super.rg.plan();
    }
}

//删除页面的命令
public class DeletePageCommand extends Command {
    //执行删除一个页面的命令
    public void execute() {
        //找到页面组
        super.pg.find();
        //删除一个页面
        super.pg.delete();
        //给出计划
        super.pg.plan();
    }
}

//负责人
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 tom = new Invoker();
        System.out.println("=======客户要求增加一项需求=======");
        //客户下命令
        Command command = new AddRequirementCommand();
        //负责人接收到命令
        tom.setCommand(command);
        //负责人执行命令
        tom.action();

        //定义一个负责人
        Invoker jerry = new Invoker();
        System.out.println("=======客户要求删除一个页面=======");
        //客户下命令
        Command command2 = new DeletePageCommand();
        //负责人接收到命令
        jerry.setCommand(command2);
        //负责人执行命令
        jerry.action();
    }
}

//结果如下：
=======客户要求增加一项需求=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。
=======客户要求删除一个页面=======
找到美工组。。。
客户要求删除一个页面。。。
客户要求给出变更计划。。。

 上面的示例使用的就是命令模式，我们发现使用了命令模式之后，职责更加清晰：客户就只管发命令，负责人负责执行命令，各个小组负责执行相应的业务逻辑；低耦合：客户端不必亲自和各小组成员直接交谈，只需要联络负责人就行；扩展性增强：如果客户端下达了新的命令，只需要新建一个类然后继承于Command类就行。

深入分析——Command是什么？

Command定义

定义： 将一个请求封装成一个对象，从而使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。其通用类图如下：

通用代码实现如下：

//通用的Receiver类：接收命令
public abstract class Receiver {
    //抽象接收者，定义每个接收者都必须完成的业务
    public abstract void doSomething();
}

//具体的Receiver类，可以有多个：执行业务逻辑
public class ConcreteReceiver extends Receiver {
    public void doSomething() {
        //业务逻辑
    }
}

//抽象的Command类：封装命令
public abstract class Command {
    //对具体的Receiver类进行命令处理
    protected ConcreteReceiver receiver = new ConcreteReceiver();

    //每个命令类都必须有一个执行命令的方法
    public abstract void execute();
}

//具体的Command类，可以有多个
public class ConcreteCommand extends Command {
    //执行命令
    public void execute() {
        //业务处理
        super.receiver.doSomething();
    }
}

//负责人
public class Invoker {
    private Command command;
    //接收命令
    public void setCommand(Command command) {
        this.command = command;
    }
    //执行命令
    public void action() {
        this.command.execute();
    }
}

//client类
public class Client {
    public static void main(String[] args) {
        //声明负责人
        Invoker invoker = new Invoker();
        //具体命令
        Command command = new ConcreteCommand();
        //负责人接收命令
        invoker.setCommand(command);
        //执行命令
        invoker.action();
    }
}

Command的优点

• 类间解耦： 调用角色与接收角色之间没有任何依赖关系，调用者实现功能时只需要调用Command抽象类的execute方法，不需要了解到底是哪个接收者执行

• 可扩展性： Command的子类可以非常容易的扩展，而调用者Invoker和高层次的模块Client不产生严重的代码耦合

Command的缺点

• 命令太多会导致类膨胀问题，增加了系统复杂度

参考

《设计模式之禅》