命令模式

1.定义

将一个请求封装成一个对象，从而可以使用不同的请求来参数化客户端。

命令模式通常有3种角色

Receiver：接收者角色。负责执行命令的角色

抽象接收者：具有所有特性的接收者的集合

public abstract class AbstractReceiver {

    public abstract void action();
}

具体接收者角色：执行不同的业务逻辑

public class ReceiverOne extends AbstractReceiver {

    @Override
    public void action() {
        System.out.println("执行ReceiverOne的业务逻辑");
    }
}

public class ReceiverTwo extends AbstractReceiver {

    @Override
    public void action() {
        System.out.println("执行ReceiverTwo的业务逻辑");
    }
}

Command：命令角色。需要执行的命令，指定接收者来执行命令

抽象命令：指定命令接收者，并执行命令

public abstract class AbstractCommand {

    /**
     * 定义一个子类的共享变量（命令接收者）
     */
    protected final AbstractReceiver receiver;

    /**
     * 指定命令接收者
     * @param receiver
     */
    public AbstractCommand(AbstractReceiver receiver) {
        this.receiver = receiver;
    }

    /**
     * 执行命令
     */
    public abstract void execute();
}

具体命令：每一个命令是对一个或多个接收者的封装，采用封闭Receiver方式，可以减小上层模块对下层模块的依赖

public class CommandOne extends AbstractCommand {

    /**
     * 指定命令接收者
     * @param receiver
     */
    public CommandOne(AbstractReceiver receiver) {
        super(receiver);
    }

    @Override
    public void execute() {
        super.receiver.action();
    }
}

public class CommandTwo extends AbstractCommand {

    /**
     * 指定命令接收者
     * @param receiver
     */
    public CommandTwo(AbstractReceiver receiver) {
        super(receiver);
    }

    @Override
    public void execute() {
        super.receiver.action();
    }
}

Invoker：调用者角色。接收命令并执行

public class Invoker {

    private AbstractCommand command;

    /**
     * 接收命令
     * @param command
     */
    public void setCommand(AbstractCommand command) {
        this.command = command;
    }

    /**
     * 执行命令
     */
    public void run() {
        this.command.execute();
    }
}

场景类

public class Client {

    public static void main(String[] args) {
        // 声明调用者
        Invoker invoker = new Invoker();

        // 定义一个发送给接收者的命令
        AbstractCommand commandOne = new CommandOne();
        // 调用者执行命令
        invoker.setCommand(commandOne);
        invoker.run();

        AbstractReceiver receiver = new ReceiverTwo();
        AbstractCommand commandTwo = new CommandTwo(receiver);
        invoker.setCommand(commandTwo);
        invoker.run();
    }
}

2.应用

2.1 优点

• 解耦：调用者角色与接收者角色没有任何关系。
• 可扩展性：抽象命令的子类容易扩展，调用者及高层模块不产生严重的代码耦合。

2.2 缺点

• 抽象命令的子类过多，会导致命令角色过于膨胀

2.3 应用场景

触发-反馈机制的处理

3.扩展

撤销命令

3.1 使用备忘录模式还原状态

备忘录模式见后续博文

3.2 新增撤销命令

修改接收者角色，新增rollBack方法，回滚任务

public abstract class AbstractReceiver {

    public abstract void action();

    public abstract void rollBack();
}

public class ReceiverOne extends AbstractReceiver {

    @Override
    public void action() {
        System.out.println("执行ReceiverOne的业务逻辑");
    }

    @Override
    public void rollBack() {
        System.out.println("撤销ReceiverOne的action操作");
    }
}

新增撤销命令

public class RollBackOneCommand extends AbstractCommand {

    /**
     * 指定一个默认命令接收者
     */
    public RollBackOneCommand() {
        super(new ReceiverOne());
    }

    /**
     * 指定命令接收者
     * @param receiver
     */
    public RollBackOneCommand(AbstractReceiver receiver) {
        super(receiver);
    }

    @Override
    public void execute() {
        super.receiver.rollBack();
    }
}