行为型设计模式-命令模式

1 命令模式概念

1.1 介绍

　　将一个请求封装成对象，从而使你可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。命令模式可以将调用操作的对象和知道如何实现该操作的对象解耦。同时命令模式是面向过程变成中回调机制的一个替代。

1.2 定义

　　命令模式是一个高内聚的模式，其定义为将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

1.3 使用场景

　　对于大多数请求——响应模式的功能，比较适合使用命令模式。

• 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。例如：RxJava。
• 需要在不同的时间指定请求、将请求排队（如：线程池+工作队列）和执行请求。
• 需要支持命令的撤销(Undo)操作和恢复(Redo)操作（如：系统挂掉之后重启做一些恢复操作，还有数据库的事务等）。
• 需要将一组操作组合在一起，即支持宏命令。

2 命令模式UML类图通用

图片来源于：命令模式在Android实际场景中运用
　　
　　在该类图中，我们看到三个角色：

• Receive（接收者）：实现关机的操作。
• Command（命令）：命令的抽象接口。
• ConcreteCommand（具体命令）：调用关机的操作。
• Invoker（请求者）：关机键，负责调用命令对象执行请求，相关的方法叫做行动方法。
• Client（客户端）：我们创建一个具体命令，去按关机键。

3 通用模式代码

（1）接收者Receiver类

/**
 * 抽象接收者，定义每个接收者都必须完成的业务
 */
public interface Receiver { 
    void action();
}

/**
 * 具体接收者
 */
public class ConcreteReciver implements Receiver {
    // 真正执行关机的操作
    public void action() {
        System.out.println("执行具体方法");
    }
}

（2）抽象命令Command类

/**
 * 抽象命令接口，每个命令类都必须有一个执行命令的方法
 */
public interface Command {
    // 执行具体逻辑的命令
    void execute();
}

（3）具体命令ConcreteCommand类

/**
 * 具体命令类
 */
public class ConcreteCommand implements Command { 
    // 持有一个对接收者对象的引用
    private Receiver receiver; 

    public ConcreteCommand(Receiver receiver) {
        receiver = receiver;
    }

    public void execute() {
        // 调用接受者方法来执行具体逻辑
        receiver.action();
    }
}

（4）请求者Invoker类

public class Invoker {
    // 持有一个对相应命令对象的引用
    private Command command; 

    public Invoker(Command command) {
        this.command = command;
    }

    public void action() {
        // 调用具体命令对象的相关方法，执行具体命令
        this.command.execute();
    }
}

（5）客户端类

public class Client {

    public static void main(String[] args) { 
        // 创建接收者
        Receiver receiver = new ConcreteReciver(); 
        // 创建命令对象，设定它的接收者
        Command command = new ConcreteCommand(receiver); 
        // 创建请求者，把命令对象设置进去
        Invoker invoker = new Invoker(command);
        // 执行方法
        invoker.action();
    }
}

（6）结果

4 命令模式简单实现

　　对客户发出的命令进行封装，每个命令是一个对象，避免客户、负责人、组员之间的交流误差，封装后的结果就是客户只要说一个命令，我的项目组就立刻开始启动，不用思考、解析命令字符串。

（1）Receiver类-工作组Group

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 void rollBack() {
        // 根据日志进行回滚
    }
}

/**
 * 需求组
 */
public class RequirementGroup extends Group { 
    // 客户要求需求组过去和他们谈
    public void find() {
        System.out.println("找到需求组...");
    }
    // 客户要求增加一项需求
    public void add() {
        System.out.println("客户要求增加一项需求...");
    }
    // 客户要求修改一项需求
    public void change() {
        System.out.println("客户要求修改一项需求...");
    }
    // 客户要求删除一项需求
    public void delete() {
        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 change() {
        System.out.println("客户要求修改一个页面...");
    }
    // 甲方是老大，要求删除一些页面
    public void delete() {
        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 change() {
        System.out.println("客户要求修改一项功能...");
    }
    // 客户要求删除一项功能
    public void delete() {
        System.out.println("客户要求删除一项功能...");
    }
    // 客户要求给出变更计划
    public void plan() {
        System.out.println("客户要求代码变更计划...");
    }
}

（2）命令类

/**
 * 抽象命令类
 */
public abstract class Command { 
    // 只有一个方法，你要我做什么事情
    public abstract void execute();
}

/**
 * 增加需求的命令
 */
public class AddRequirementCommand extends Command {

    protected RequirementGroup requirementGroup; // 需求组 
    protected PageGroup pageGroup;// 美工组                                                     
    protected CodeGroup codeGroup; // 代码组

    public ConcreteCommand(RequirementGroup requirementGroup,PageGroup pageGroup,CodeGroup codeGroup) {
        this.receiver = receiver;
        this.requirementGroup = requirementGroup; 
        this.pageGroup = pageGroup;
        this.codeGroup = codeGroup;                              
    }

    /**
     * 修改后，执行增加一项需求的命令
     * 要增加一项需求，内部调动三个组通力合作，然后把结果反馈给客户 
     */
    public void execute() {
        // 找到需求组
        requirementGroup.find();
        // 增加一份需求
        requirementGroup.add();
        // 页面也要增加
        pageGroup.add();
        // 功能也要增加
        codeGroup.add();
        // 给出计划
        requirementGroup.plan();
    }
}

/**
 * 撤销删除一个页面的命令
 */
public class CancelDeletePageCommand extends Command {

    // ......
    public void execute() {
        super.pageGroup.rollBack();
    }
}

（3）请求者类-项目经理

/**
 * 项目经理
 */
public class Invoker {

    private Command command; // 客户发出命令

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

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

（4）客户端类

public class Client {
    public static void main(String[] args) {
        // 客户要求增加一项需求
        System.out.println("------客户要求增加一项需求-------"); 
        // 1、定义接收人，具体干活的部门
        protected RequirementGroup requirementGroup = new RequirementGroup(); // 需求组 
        protected PageGroup pageGroup = new PageGroup();// 美工组                                                   
        protected CodeGroup codeGroup = new CodeGroup(); // 代码组
        // 2、客户给我们下命令来，干活的部门都参与进来
        Command command = new AddRequirementCommand(requirementGroup,pageGroup,codeGroup); 
        // 3、定义我们的接头人:项目经理,接收到命令
        Invoker invoker = new Invoker(command);
        // 4、项目经理执行命令
        invoker.action();
    }
}

（5）结果

5 命令模式实战

　　只要你认为是命令的地方就可以采用命令模式，例如，在GUI开发中，一个按钮的点击是一个命令，可以采用命令模式；模拟DOS命令的时候，当然也要采用命令模式；触发－反馈机制的处理等。

6 Android源码中的命令模式

（1）Android事件机制中底层逻辑对事件的转发处理。
（2）Android事件输入系统介绍。
（3）RxJava：

Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(i);
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {

            }
            @Override
            public void onError(Throwable t) {

            }
            @Override
            public void onNext(Integer var1) {
                System.out.println(var1);
            }
        });

// subscriber = new Subscriber<Integer>()   --> 创建接收者，执行方法:onNext(i)
// onSubscribe = Observable.OnSubscribe     --> 命令者,执行方法:call(subscriber)
// observable = Observable.create()         --> 返回请求者:subscribe(subscriber)
// 执行方法:observable.subscribe(subscriber) --> onSubscribe.call(subscriber) --> subscriber.onNext(i);

7 总结

7.1 优点

• 类间解耦：调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需调用Command抽象类的execute方法就可以，不需要了解到底是哪个接收者执行。
• 可扩展性：Command的子类可以非常容易地扩展，而调用者Invoker和高层次的模块Client不产生严重的代码耦合。
• 命令模式结合其他模式会更优秀：命令模式可以结合责任链模式，实现命令族解析任务；结合模板方法模式，则可以减少Command子类的膨胀问题。

7.2 缺点

　　命令模式也是有缺点的，请看Command的子类：如果有N个命令，问题就出来了，Command的子类就可不是几个，而是N个，这个类膨胀得非常大，这个就需要在项目中慎重考虑使用。

8 参考文章与链接

《Android源码设计模式解析与实战》

《设计模式之禅》

Android源码中的命令模式