命令模式

命令模式的本质是对命令进行封装，将发出命令的责任和执行命令的责任分割开。关键在于引入了抽象命令接口，且发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。

• UML:

  
  image.png
• 模型：家电自动遥控器
• 特点：我们想用一个遥控器来控制多个家电，例如，电灯，音响，空调，电视等。家电是请求的接收者，遥控器是请求的发送者，遥控器上有一些按钮，不同的按钮对应家电的不同操作。抽象命令角色由一个命令接口来扮演，有三个具体的命令类实现了抽象命令接口，这三个具体命令类分别代表三种操作：打开家电、关闭关闭和啥都不干。

public class Light {
        //灯的位置，卧室，厨房...
    String loc = "";
    public Light(String loc) {
        this.loc = loc;
    }
    public void On() {
        System.out.println(loc + " On");
    }
    public void Off() {
        System.out.println(loc + " Off");
    }
}
//音响设备
public class Stereo {
    static int volume = 0;
    public void On() {
        System.out.println("Stereo On");
    }
    public void Off() {
        System.out.println("Stereo Off");
    }
    public void SetCd() {
        System.out.println("Stereo SetCd");
    }
    public void SetVol(int vol) {
        volume = vol;
        System.out.println("Stereo volume=" + volume);
    }
    public int GetVol() {
        return volume;
    }
    public void Start() {
        System.out.println("Stereo Start");
    }
}
//模拟设备厂家提供的遥控器控制接口
public interface Control {
    public void onButton(int slot);
    public void offButton(int slot);
    public void undoButton();
}

使用传统的面向对象的设计，一般是创建一个遥控器实例，将灯、音响的实例传给遥控器，然后根据遥控器的按钮设置不同的家电操作，例如按下1号键是音响开，2号键是音响加音量等

public class TraditionControl implements Control {
    Light light;
    Stereo stereo;
    public TraditionControl(Light light, Stereo stereo) {
        this.light = light;
        this.stereo = stereo;
    }
    @Override
    public void onButton(int slot) {
        // TODO Auto-generated method stub
        switch (slot) {
        case 0:
            light.On();
            break;
        case 1:
            stereo.On();
            break;
        case 2:
            int vol = stereo.GetVol();
            if (vol < 11) {
                stereo.SetVol(++vol);
            }
            break;
        }
    }
    @Override
    public void offButton(int slot) {
        // TODO Auto-generated method stub
        switch (slot) {
        case 0:
            light.Off();
            break;
        case 1:
            stereo.Off();
            break;
        case 2:
            int vol = stereo.GetVol();
            if (vol > 0) {
                stereo.SetVol(--vol);
            }
            break;
        }
    }
    @Override
    public void undoButton() {  
    }
}

这样设计，如果要加一种设备，这种设计的控制器就不好添加了，首先要在控制器中注入设备，按键处理中要再加新设备的处理。所以，这样就高耦合了，不利于扩展。

• 使用命令模式：

//将命令抽象处理请求接口
public interface Command {
    public void execute();
    public void undo();
}
//卧室关灯命令
public class LightOffCommand implements Command {
    private Light light;
    public LightOffCommand(Light light){
        this.light=light;
    }
    @Override
    public void execute() {
        light.Off();
    }
    @Override
    public void undo() {
        light.On();
    }
}
//卧室开灯命令
public class LightOnCommand implements Command {
    private Light light;
    public LightOnCommand(Light light){
        this.light=light;
    }
    @Override
    public void execute() {
        light.On();
    }
    @Override
    public void undo() {
        light.Off();
    }
}
//操作无响应命令
public class NoCommand implements Command {
    @Override
    public void execute() {}
    @Override
    public void undo() {}
}
//音响开命令
public class StereoOnCommand implements Command {
    private Stereo setreo;
    public StereoOnCommand(Stereo setreo){
        this.setreo=setreo;
    }
    @Override
    public void execute() {
        setreo.On();
        setreo.SetCd();
    }
    @Override
    public void undo() {
        setreo.Off();
    }
}
//音响关命令
public class StereoOffCommand implements Command {
    private Stereo setreo;
    public StereoOffCommand(Stereo setreo){
        this.setreo=setreo;
    }
    @Override
    public void execute() {
        setreo.Off();
    }
    @Override
    public void undo() {
        setreo.On();
        setreo.SetCd();
    }
}
//音响加音量
public class StereoAddVolCommand implements Command{
    private Stereo setreo;
    public StereoAddVolCommand(Stereo setreo){
        this.setreo=setreo;
    }
    @Override
    public void execute() {
    int vol=    setreo.GetVol();
    if(vol<11){
        setreo.SetVol(++vol);
    }   
    }
    @Override
    public void undo() {
    int vol=    setreo.GetVol();
    if(vol>0){
        setreo.SetVol(--vol);
    }   
    }
}
//音响减音量命令
public class StereoSubVolCommand implements Command{
    private Stereo setreo;
    public StereoSubVolCommand(Stereo setreo){
        this.setreo=setreo;
    }
    @Override
    public void execute() {
    int vol=    setreo.GetVol();
    if(vol>0){
        setreo.SetVol(--vol);
    }   
    }
    @Override
    public void undo() {
    int vol=    setreo.GetVol();
    if(vol<11){
        setreo.SetVol(++vol);
    }   
    }
}

//当有了这样命令之后，我们只需要将命令设置给遥控器的不同的按键即可，用户在按键时会请求执行已经设定好的命令，由命令再调用具体家电执行。

public class CommandModeControl implements Control{
       //所有开命令
    private Command[] onCommands;
      //所有关命令
    private Command[] offCommands;
       //记录上一个执行的命令
    private Stack<Command> stack=new Stack<Command>();
    public CommandModeControl(){
        onCommands=new Command[5];
         offCommands=new Command[5];
         Command noCommand=new NoCommand();
                 // 初始化为无操作命令
         for(int i=0,len=onCommands.length;i<len;i++) {
             onCommands[i]=noCommand;
             offCommands[i]=noCommand;
         } 
    }
       //设置具体按键命令
    public void setCommand(int slot,Command onCommand,Command offCommand){
        onCommands[slot]=onCommand;
         offCommands[slot]=offCommand;
    }
    @Override
    public void onButton(int slot) {
                //执行命令
        onCommands[slot].execute();
        stack.push(onCommands[slot]);
    }
    @Override
    public void offButton(int slot) {
        offCommands[slot].execute();
        stack.push(offCommands[slot]);
    }
    @Override
    public void undoButton() {
        stack.pop().undo();
    }
}
//使用遥控器
public class ControlTest {
    public static void main(String[] args) {
                //创建遥控器，也就是UML中的Invoker实现类
        CommandModeControl control = new CommandModeControl();
        Light bedroomlight = new Light("BedRoom");
        Light kitchlight = new Light("Kitch");
        Stereo stereo = new Stereo();
        //设置各种命令
        LightOnCommand bedroomlighton = new LightOnCommand(bedroomlight);
        LightOffCommand bedroomlightoff = new LightOffCommand(bedroomlight);
        LightOnCommand kitchlighton = new LightOnCommand(kitchlight);
        LightOffCommand kitchlightoff = new LightOffCommand(kitchlight);

         Command[] oncommands={bedroomlighton,kitchlighton};
         Command[] offcommands={bedroomlightoff,kitchlightoff};

        
        StereoOnCommand stereoOn = new StereoOnCommand(stereo);
        StereoOffCommand stereoOff = new StereoOffCommand(stereo);
        StereoAddVolCommand stereoaddvol = new StereoAddVolCommand(stereo);
        StereoSubVolCommand stereosubvol = new StereoSubVolCommand(stereo);
                //将命令注入到遥控器中
        control.setCommand(0, bedroomlighton, bedroomlightoff);
        control.setCommand(1, kitchlighton, kitchlightoff);
        control.setCommand(2, stereoOn, stereoOff);
        control.setCommand(3, stereoaddvol, stereosubvol);
              //操作遥控器就能执行已经绑定好的命令控制家电了
        control.onButton(0);
        control.undoButton();
        //control.offButton(0);
        control.onButton(1);
        control.offButton(1);
        control.onButton(2);
        control.onButton(3);
                
        control.offButton(3);
        control.undoButton();
        control.offButton(2);
        control.undoButton();
    }
}

通过上面的设计，遥控器不需要注入家电设备，而是注入各种命令。如果新加一种家电，则只需要扩展新的命令，并注入到遥控器中即可。遥控器不关心家电的实现，它是调用命令接口，解耦了遥控器与家电。但是可能会导致某些系统有过多的具体命令类。因为针对每一个命令都需要设计一个具体命令类，因此某些系统可能需要大量具体命令类。