设计模式-命令模式

命令模式

命令模式：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化。可以对请求进行排队或者记录请求日志，以及支持可撤销的操作。命令模式通过这种封装的方式实现将请求动作者和动作执行者解耦。

控制小车移动

接下来创建一个需求来用命令模式实现。
我们有一个Car对象，它有向前移动的方法forward()和向后移动的方法backward()的方法。现在我们要控制小车的移动，要怎么做呢？

紧耦合设计

我们先来看看不使用命令模式的紧耦合设计
Car类:

public class Car {
    /**
     * 向前移动
     */
    public void forward(){
        System.out.println("向前移动");
    }

    /**
     * 向后移动
     */
    public void backward(){
        System.out.println("向后移动");
    }
}

Client类：

/**
 * 紧耦合客户端类
 */
public class Client {
    public static void main(String[] args) {
        //创建小车对象
        Car car = new Car();
        //小车向前移动
        car.forward();
        //小车向前移动
        car.forward();
        //小车向后移动
        car.backward();
    }
}

向前移动
向前移动
向后移动

我们可以看到客户端（Client）与动作执行者（Car）是紧密耦合的。

松耦合命令模式设计

既然想要将请求动作者和动作执行者进行解耦，那么我们就设计一个遥控器（RemoteControl）来帮我们传达命令，控制小车移动。
Car类不变

public class Car {
    /**
     * 向前移动
     */
    public void forward(){
        System.out.println("向前移动");
    }

    /**
     * 向后移动
     */
    public void backward(){
        System.out.println("向后移动");
    }
}

Command类

/**
 * 命令接口 所以命令类都要实现此接口
 */
public interface Command {
    void execute();
}

ForwardCommand类

/**
 * 向前移动的命令类
 */
public class ForwardCommand implements Command {

    private Car car;

    /**
     * 接受操作执行者
     * @param car
     */
    public ForwardCommand(Car car){
        this.car = car;
    }

    public void execute() {
        car.forward();
    }
}

BackwardCommand类

/**
 * 向后移动的命令类
 */
public class BackwardCommand implements Command {

    private Car car;

    /**
     * 接受操作执行者
     * @param car
     */
    public BackwardCommand(Car car){
        this.car = car;
    }

    public void execute() {
        car.backward();
    }
}

RemoteControl类

/**
 * 遥控器类
 */
public class RemoteControl {

    private Command command;

    /**
     * 设置控制命令
     * @param command
     */
    public void setCommand(Command command){
        this.command = command;
    }

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

Client类

public class Client {
    public static void main(String[] args) {
        Car car = new Car();
        ForwardCommand forwardCommand = new ForwardCommand(car);
        BackwardCommand backwardCommand = new BackwardCommand(car);

        RemoteControl control = new RemoteControl();
        //设置向前的命令
        control.setCommand(forwardCommand);
        //执行命令
        control.executeCommand();
        control.setCommand(backwardCommand);
        control.executeCommand();
    }
}

向前移动
向后移动

现在如果我们想让小车移动，那么我们就只需要给遥控器传达移动的命令就行了。小车接收到命令就会去执行对应的动作。

添加命令队列

我们可以把小车需要执行的命令一次性的添加进去，形成一个队列统一执行。
我们需要对代码稍微调整一下
RemoteControl类

/**
 * 遥控器类
 */
public class RemoteControl {

    private List<Command> commands = new ArrayList<Command>();

    /**
     * 设置控制命令
     * @param command
     */
    public void setCommand(Command command){
        commands.add(command);
    }

    /**
     * 执行命令
     */
    public void executeCommand(){
        for (Command command : commands) {
            command.execute();
        }
    }
}

遥控器的命令属性我们采用集合来接受，执行时候循环调用command的execute方法。
Client类

public class Client {
    public static void main(String[] args) {
        Car car = new Car();
        ForwardCommand forwardCommand = new ForwardCommand(car);
        BackwardCommand backwardCommand = new BackwardCommand(car);

        RemoteControl control = new RemoteControl();
        //设置向前和向后的命令
        control.setCommand(forwardCommand);
        control.setCommand(backwardCommand);
        //执行命令
        control.executeCommand();
    }
}

Client这边只要添加多次命令统一执行就好了。

添加命令执行控制

命令模式可以选择命令是否执行
举个例子，虽然我向遥控器传递了向后移动的命令，但是我们有具体的校验逻辑决定是否执行后退命令。

/**
 * 遥控器类
 */
public class RemoteControl {

    private List<Command> commands = new ArrayList<Command>();

    /**
     * 设置控制命令
     * @param command
     */
    public void setCommand(Command command){
        if(check(command)){
            commands.add(command);
        }
    }

    /**
     * 执行命令
     */
    public void executeCommand(){
        for (Command command : commands) {
            command.execute();
        }
    }

    /**
     * 校验方法
     * @return
     */
    private boolean check(Command command){
        //如果是后退命令则忽略
        return !(command instanceof BackwardCommand);
    }
}

UML

总结

我们可以看到命令模式达到了将请求动作者和动作执行者进行解耦的效果。这样我们可以比较方便的设计一个命令队列，也可以对请求是否执行进行控制，比如还可以对请求进行撤销、重做操作、记录执行日志等。