2. 程式人生 > 實用技巧 >《Head First 設計模式》：命令模式

《Head First 設計模式》：命令模式

阿新 • • 發佈：2020-08-10

正文

一、定義

命令模式將“請求”封裝成物件（命令物件），以便使用不同的“請求”來引數化其他物件。

要點：

  • 命令模式可將“動作的請求者”從“動作的執行者”物件中解耦。
  • 被解耦的兩者之間通過命令物件進行溝通。命令物件封裝了接收者和一個或多個動作。
  • 命令物件提供一個 execute() 方法，該方法封裝了接收者的動作。當此方法被呼叫時，接收者就會執行這些動作。
  • 呼叫者持有一個或多個命令物件，通過呼叫命令物件的 execute() 方法發出請求，這會使得接收者的動作被呼叫。

二、實現步驟

1、建立接收者類

接收者類中包含要執行的動作。

（1）接收者A

/**
 * 接收者A
 */
public class ReceiverA {
    
    /**
     * 動作1
     */
    public void action1() {
        System.out.println("ReceiverA do action1");
    }
    
    /**
     * 動作2
     */
    public void action2() {
        System.out.println("ReceiverA do action2");
    }
}

（2）接收者B

/**
 * 接收者B
 */
public class ReceiverB {

    /**
     * 動作1
     */
    public void action1() {
        System.out.println("ReceiverB do action1");
    }
    
    /**
     * 動作2
     */
    public void action2() {
        System.out.println("ReceiverB do action2");
    }
}

2、建立命令介面

/**
 * 命令介面
 */
public interface Command {

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

3、建立具體的命令，並實現命令介面

命令物件中，封裝了命令接收者和相關動作。

（1）命令A1

/**
 * 命令A1
 */
public class ConcreteCommandA1 implements Command{
    
    /**
     * 接收者A
     */
    ReceiverA receive;
    
    public ConcreteCommandA1(ReceiverA receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者A執行動作1
        receive.action1();
    }
}

（2）命令A2

/**
 * 命令A2
 */
public class ConcreteCommandA2 implements Command{
    
    /**
     * 接收者A
     */
    ReceiverA receive;
    
    public ConcreteCommandA2(ReceiverA receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者A執行動作2
        receive.action2();
    }
}

（3）命令B1

/**
 * 命令B1
 */
public class ConcreteCommandB1 implements Command{
    
    /**
     * 接收者B
     */
    ReceiverB receive;
    
    public ConcreteCommandB1(ReceiverB receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者B執行動作1
        receive.action1();
    }
}

（4）命令B2

/**
 * 命令B2
 */
public class ConcreteCommandB2 implements Command{
    
    /**
     * 接收者B
     */
    ReceiverB receive;
    
    public ConcreteCommandB2(ReceiverB receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者B執行動作2
        receive.action2();
    }
}

4、建立呼叫者

呼叫者通過持有的命令物件，來呼叫接收者的動作。

/**
 * 呼叫者
 */
public class Invoker {

    /**
     * 命令物件
     */
    Command command;
    
    /**
     * 設定命令
     */
    public void setCommand(Command command) {
        this.command = command;
    }
    
    /**
     * 呼叫動作
     */
    public void invoke() {
        command.execute();
    }
}

5、呼叫者執行命令

public class Test {
    
    public static void main(String[] args) {
        // 命令呼叫者
        Invoker invoker = new Invoker();
        
        // 命令接收者
        ReceiverA receiverA = new ReceiverA();
        ReceiverB receiverB = new ReceiverB();
        
        // 建立命令，並指定接收者
        Command commandA1 = new ConcreteCommandA1(receiverA);
        Command commandA2 = new ConcreteCommandA2(receiverA);
        Command commandB1 = new ConcreteCommandB1(receiverB);
        Command commandB2 = new ConcreteCommandB2(receiverB);
        
        // 呼叫者執行命令
        invoker.setCommand(commandA1);
        invoker.invoke();
        invoker.setCommand(commandA2);
        invoker.invoke();
        invoker.setCommand(commandB1);
        invoker.invoke();
        invoker.setCommand(commandB2);
        invoker.invoke();
    }
}

三、舉個栗子

1、背景

假設你要設計一個家電自動化遙控器的 API。這個遙控器具有七個可程式設計的插槽（每個都可以指定到一個不同的家電裝置），每個插槽都有對應的“開”、“關”按鈕。

你希望每個插槽都能夠控制一個或一組裝置。並且，這個遙控器適用於目前的裝置和任何未來可能出現的裝置。

2、實現

（1）建立家電類

/**
 * 電燈（接收者）
 */
public class Light {
    
    /**
     * 電燈位置
     */
    String location;
    
    public Light(String location) {
        this.location = location;
    }
    
    /**
     * 開燈
     */
    public void on() {
        System.out.println(location + " light is on");
    }
    
    /**
     * 關燈
     */
    public void off() {
        System.out.println(location + " light is off");
    }
}

/**
 * 音響（接收者）
 */
public class Stereo {
    
    /**
     * 開啟音響
     */
    public void on() {
        System.out.println("Stereo is on");
    }
    
    /**
     * 關閉音響
     */
    public void off() {
        System.out.println("Stereo is off");
    }
    
    /**
     * 設定為播放CD
     */
    public void setCd() {
        System.out.println("Stereo is set for CD input");
    }
    
    /**
     * 設定為播放DVD
     */
    public void setDvd() {
        System.out.println("Stereo is set for DVD input");
    }
    
    /**
     * 設定音量
     */
    public void setVolume(int volume) {
        System.out.println("Stereo volume set to " + volume);
    }
}

（2）建立命令介面

/**
 * 命令介面
 */
public interface Command {

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

（3）建立具體的命令，並繼承命令介面

/**
 * 無命令
 */
public class NoCommand implements Command {
    
    @Override
    public void execute() {}
}

/**
 * 開燈命令
 */
public class LightOnCommand implements Command {
    
    Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }

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

/**
 * 關燈命令
 */
public class LightOffCommand implements Command {
    
    Light light;
    
    public LightOffCommand(Light light) {
        this.light = light;
    }

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

/**
 * 開啟音響播放CD命令
 */
public class StereoOnWithCDCommand implements Command {
    
    Stereo stereo;
    
    public StereoOnWithCDCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.on();
        stereo.setCd();
        stereo.setVolume(11);
    }
}

/**
 * 關閉音響命令
 */
public class StereoOffCommand implements Command {
    
    Stereo stereo;
    
    public StereoOffCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.off();
    }
}

（4）建立遙控器類

/**
 * 遙控器（呼叫者）
 */
public class RemoteControl {

    Command[] onCommands;
    Command[] offCommands;
    
    public RemoteControl() {
        onCommands = new Command[7];
        offCommands = new Command[7];
        // 初始化插槽命令為無命令狀態
        Command noCommand = new NoCommand();
        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
    }
    
    /**
     * 設定插槽命令
     */
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }
    
    /**
     * “開”按鈕被按下
     */
    public void onButtonWasPushed(int slot) {
        // 執行開命令
        onCommands[slot].execute();
    }
    
    /**
     * “關”按鈕被按下
     */
    public void offButtonWasPushed(int slot) {
        // 執行關命令
        offCommands[slot].execute();
    }
}

（5）使用遙控器控制家電

public class Test {
    
    public static void main(String[] args) {
        // 遙控器
        RemoteControl remoteControl = new RemoteControl();
        
        // 家電
        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        Stereo stereo = new Stereo();
        
        // 建立命令，並指定家電
        Command livingRoomLightOn = new LightOnCommand(livingRoomLight);
        Command livingRoomLightOff = new LightOffCommand(livingRoomLight);
        Command kitchenLightOn = new LightOnCommand(kitchenLight);
        Command kitchenLightOff = new LightOffCommand(kitchenLight);
        Command stereoOnWithCD = new StereoOnWithCDCommand(stereo);
        Command stereoOff = new StereoOffCommand(stereo);
        
        // 設定插槽命令
        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
        remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
        remoteControl.setCommand(2, stereoOnWithCD, stereoOff);
        
        // 遙控器執行命令
        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);
        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);
        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);
    }
}

四、命令模式的更多用途

1、佇列請求

命令可以將運算塊打包（一個接收者和一組動作），然後將它傳來傳去，就像是一般的物件一樣。即使在命令物件被建立許久之後，運算依然可以被呼叫。事實上，它甚至可以在不同的執行緒中被呼叫。

因此，命令模式可以用來實現佇列請求。具體做法是：在工作佇列的一端新增命令，另一端通過執行緒取出命令，呼叫它的 execute() 方法，等呼叫完成後，將此命令物件丟棄，再取出下一個命令……

2、日誌請求

某些應用需要我們將所有的動作都記錄在日誌中，並能在系統宕機後，重新呼叫這些動作恢復到之前的狀態。

命令模式能夠支援這一點。具體做法是：當我們執行命令時，利用序列化將命令物件儲存在磁碟中。一旦系統宕機，再利用反序列化將命令物件重新載入，並依次呼叫這些物件的 execute() 方法。

相關推薦

《Head First 設計模式》：命令模式

正文 一、定義 命令模式將“請求”封裝成物件（命令物件），以便使用不同的“請求”來引數化其他物件。

《Head First 設計模式》：觀察者模式

正文 一、定義 觀察者模式定義了物件之間的一對多依賴，這樣一來，當一個物件改變狀態時，它的所有依賴者都會收到通知並自動更新。

《Head First 設計模式》：裝飾者模式

正文 一、定義 裝飾者模式動態地將責任（功能）附加到物件上。若要擴充套件功能，裝飾者提供了比繼承更有彈性的替代方案。

《Head First 設計模式》：工廠方法模式

正文 一、定義 工廠方法模式定義了一個建立物件的介面，但由子類決定要例項化的類是哪一個。工廠方法讓類把例項化推遲到子類。

《Head First 設計模式》：抽象工廠模式

正文 一、定義 抽象工廠模式提供一個介面，用於建立相關或依賴物件的家族，而不需要明確指定具體類。

《Head First 設計模式》：單件模式

正文 一、定義 單件模式確保一個類只有一個例項，並提供一個全域性訪問點。

《Head First 設計模式》：介面卡模式

正文 一、定義 介面卡模式將一個類的介面（被適配者），轉換成客戶期望的另一個介面。介面卡讓原本介面不相容的類可以合作無間。

《Head First 設計模式》：外觀模式

正文 一、定義 外觀模式提供了一個統一的介面，用來訪問子系統中的一群介面。外觀定義了一個高層介面，讓子系統更容易使用。

《Head First 設計模式》：迭代器模式

正文 一、定義 迭代器模式提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部的表示。

《Head First 設計模式》：組合模式

正文 一、定義 組合模式允許你將物件合成樹形結構來表現“整體/部分”層次結構。組合能讓客戶以一致的方式處理組合物件以及個體物件。

“Head First 設計模式“ ：外觀模式

外觀模式 外觀模式定義： 外觀模式提供了一個統一的介面，用來訪問子系統中的一群介面。外觀定義了一個高層介面，讓子系統更容易使用。類圖如下：

“Head First 設計模式“ ：介面卡模式

介面卡模式 介面卡模式定義：將一個類的介面，轉化成客戶期望的另一個介面，介面卡讓原本介面不相容的類可以合作無間。物件介面卡類圖如下：角色說明：● Target，目標介面● Adapter，介面卡● Adaptee，被

“Head First 設計模式“ ：工廠模式

工廠模式 工廠模式是建立型模式模式，解決new物件時的一些列問題，如：依賴，耦合，後期維護等

“Head First 設計模式“ ：觀察者模式

觀察者模式 觀察者模式定義了物件之間的一對多依賴，這樣一來，當一個物件改變狀態時，它的所有依賴者都會收到通知並自動更新。一方可稱為主題（subject），另一方可稱為觀察者（observer），一個主題可擁

“Head First 設計模式“ ：裝飾模式

裝飾模式 裝飾者模式：動態地將責任附加到物件上。若要擴充套件功能，裝飾者提供了比繼承更有彈性的替代方案。

Head First 設計模式 —— 06. 命令 (Command) 模式

命令模式 將“請求”封裝成物件，以便使用不同的請求、佇列或者日誌來引數化其他物件。命令模式也支援可撤銷的操作。 P206

設計模式—— 十五 ：命令模式

@目錄什麼是命令模式？為什麼要用命令模式？使用命令模式前使用命令模式後命令模式優缺點優點缺點命令模式使用場景

《head First設計模式》閱讀筆記01_策略模式

1.模擬鴨子系統引出策略模式 1.1.系統設計構思 1.2.系統程式碼實現 1.2.1.定義鴨子行為介面及實現

設計模式學習筆記（十七）：命令模式

1 概述 1.1 引言 日常生活中，可以通過開關控制一些電器的開啟和關閉，比如電燈和排氣扇。可以將開關理解成一個請求傳送者，電燈是請求的最紅接收者以及處理者，開關與電燈之間不存在直接的耦合關係，兩者通過電線連

Head First 設計模式筆記 4.單例模式

技術標籤：Head First設計模式設計模式軟體架構 單例模式比較簡單，用於建立全域性唯一的一個物件。這裡直接貼出它的定義