命令模式

命令模式：将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也可支持可撤销的操作。
在客厅的进门处有一个开关面板，该面板上有两个开关，第一个开关是打开客厅的灯，第二个开关是打开客厅的电视。下面就来具体实现一下。

电视与灯类:

public class Light {
    String location = "";

    public Light(String location) {
        this.location = location;
    }

    public void on() {
        System.out.println("打开"+location+"的灯");
    }

    public void off() {
        System.out.println("关闭"+location+"的灯");
    }
}

    

public class Television {

    public void open() {
        System.out.println("打开电视");
    }

    public void close() {
        System.out.println("关闭电视");
    }
}

硬编码的方式实现开关面板功能

//开关控制器
public class SwitchControlOld {
    Light light = new Light("客厅");
    Television television = new Television();

    public void onButtonWasPressed(int solt) {
        //打开第一个开关
        if(solt==0){
            light.on();
        }else if(solt==1){
            television.open();
        }
    }

    public void offButtonWasPressed(int solt) {
        //关闭第一个开关
        if(solt==0){
            light.off();
        }else if(solt==1){
            television.close();
        }
    }
}

从上面可以看到，实现得十分的不友好，如果开关面板上再加个开关按钮就必须得再加一组判断。而且，开关控制面板跟具体的电器开关逻辑强耦合。
使用命令模式重新实现该逻辑

//可以理解为这里为转接口的定义
public interface Command {
    //运行
    public void execute();
    //回退
    public void undo();
}

//开灯命令
public class LightOnCommand implements Command {
    Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.on();
    }

    @Override
    public void undo() {
        // TODO Auto-generated method stub
        light.off();
    }
}

```java
//关灯命令
public class LightOffCommand implements Command {
    Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.off();
    }

    @Override
    public void undo() {
        // TODO Auto-generated method stub
        light.on();
    }
}

//打开电视
public class TelevisionOnCommand implements Command {
    Television television;

    public TelevisionOnCommand(Television television) {
        this.television = television;
    }
    @Override
    public void execute() {
        television.open();
    }
    @Override
    public void undo() {
        television.close();
    }
}

//关闭电视
public class TelevisionOffCommand implements Command {
    Television television;

    public TelevisionOffCommand(Television television) {
        this.television = television;
    }
    @Override
    public void execute() {
        television.close();
    }
    @Override
    public void undo() {
        television.open();
    }
}

使用命令模式实现的开关控制器

//开关控制器
public class SwitchControl {
    Command[] onCommands = new Command[2];
    Command[] offCommands = new Command[2];
    //把开关与具体要干的事情关联起来
    public void setCommand(int solt,Command onCommand,Command offCommand) {
        onCommands[solt] = onCommand;
        offCommands[solt] = offCommand;
    }
    //按下开关
    public void onButtonWasPressed(int solt) {
        onCommands[solt].execute();
    }
    //回退
    public void offButtonWasPressed(int solt) {
        onCommands[solt].undo();
    }
}

```java
测试代码

public class Test {
    public static void main(String[] args) {
        //有两个开关的开关控制器
        SwitchControl control = new SwitchControl();
        //把电灯逻辑绑定到第一个开关上
        Light light = new Light("客厅");
        control.setCommand(0,new LightOnCommand(light),new LightOffCommand(light));
        control.onButtonWasPressed(0);      //- 打印：打开客厅的灯

        //把电视逻辑绑定到第二个开关上
        Television television = new Television();
        control.setCommand(1,new TelevisionOnCommand(television),new TelevisionOffCommand(television));
        control.onButtonWasPressed(1);      //- 打印：打开电视
    }
}

从上面的代码中可以看到，对于开关控制面板来讲，它只需要按下开关并执行命令的execute方法，不需要知道每个电器的具体实现。

通过使用命令模式对代码的改造，让开关控制器跟具体电器的开/关彻底的解耦。如果想要在控制器上增加新的按钮，可以很方便的增加上去。使得代码更加清晰，易于扩展与维护。

从命令模式的特性中可以看出，如果此时的需求变为按下一个开关需要同时打开灯与电视，那么只需要一个command数组即可。把LightOnCommand和TelevisionOnCommand放入其中，遍历调用execute。

另外，在队列请求中大量的用到了命令模式。一个个的请求依次而来，接收端不需要知道每个请求的具体逻辑，只需要依次调用请求的execute方法即可完成请求的处理。