設計模式系列 6– 命令模式

生活場景分析

今天來學習命令模式，先從一個生活中的例子入手吧，這樣理解起來也比較容易。大家應該有用過那種萬能遙控器吧，就是那種能遙控各種品牌的空調或者電視的遙控器，我們只要在遙控器上設定具體的電器品牌，就可以遙控了，可以切換到任何支援的品牌的電器。

我們今天也來做一個萬能遙控器，如下圖所示：

請忽略這清奇的畫風，我們來看看具體的要求：

每排兩個按鈕，分別實現開啟和關閉電器的作用，除了如圖所示前三排按鈕對應的電器分別是：電燈、cd、冰箱。我們可以完成這些電器的開啟和關閉功能。我們可以隨意設定每排的電器然後實現該電器的開啟關閉功能，也就是說遙控器不關心每排對應的電器具體是什麼，使用者可以隨意設定排按鈕對應的電器，遙控器都可以對該電器實現開啟和關閉的功能。

我們來分析下：

我們的要求是使用者可以隨意設定每排按鈕對應的具體電器，然後按下開啟或者關閉按鈕，就可以執行該電器的開啟和關閉功能，換成任何其他電器都可以執行開啟和關閉功能。我們用程式設計的思維抽象思考下，開啟和關閉電器是一個請求命令，而具體的電器是命令的執行者也就是接受者，要想實現一個請求命令可以被任意命令接受者執行，那麼就必須對二者進行解耦，讓請求命令不必關心具體的命令接受者和命令執行的具體細節，只管發出命令，然後就可以被具體的命令接受者接受並執行。

那麼如何實現二者的解耦呢？要讓兩者互相不知道，那麼就必須引入一種中間量，這就是命令物件，它會把每個按鈕都和一個具體的命令物件關聯起來，命令物件會暴露一個介面給按鈕使用，同時每個命令物件都會和具體的命令接受者關聯，呼叫命令接受者的功能。此時按下按鈕，就會呼叫關聯的命令物件的公開介面，然後命令物件內部在呼叫具體的命令接受者（電器）的公開方法，執行功能。

回到上面的例子就是，使用者設定了每排按鈕對應的電器如上圖所示，此時使用者按下第一排的開啟按鈕，發出開啟命令，觸發該按鈕關聯的命令物件，命令物件呼叫具體的命令接受者電燈，呼叫電燈的開啟功能。這樣遙控器只管發出命令，至於命令被誰執行，怎麼執行就不關他的事。

---

具體程式碼實現

1、定義命令物件的公共介面（按鈕執行的動作）

這裡定義按鈕的共同方法，實現開啟功能

#import <Foundation/Foundation.h>

@protocol CommandInterface <NSObject>
-(void)execute;
@end複製程式碼

2、定義具體命令物件（每個按鈕關聯的操作）

下面我們來實現每個按鈕對應的具體命令物件，這些物件需要實現上面的協議方法，然後呼叫具體的命令接受者的公開方法完成功能。

比如第一排的開啟按鈕，關聯的操作是開啟電燈。其他的按鈕類似

#import <Foundation/Foundation.h>
#import "CommandInterface.h"
#import "Light.h"

@interface LightOnCommand : NSObject<CommandInterface>
@property(strong,nonatomic)Light *light;
-(instancetype)initWithLight:(Light *)light;
@end

===============


#import "LightOnCommand.h"

@implementation LightOnCommand
-(instancetype)initWithLight:(Light *)light{
    if (self == [super init]) {
        self.light = light;
    }

    return self;
}

-(void)execute{
    [self.light lightOn];
}

@end複製程式碼

#import <Foundation/Foundation.h>
#import "CommandInterface.h"
#import "Light.h"

@interface LightOffCommand : NSObject<CommandInterface>
@property(strong,nonatomic)Light *light;
-(instancetype)initWithLight:(Light *)light;

@end

===========

#import "LightOffCommand.h"

@implementation LightOffCommand
-(instancetype)initWithLight:(Light *)light{
    if (self == [super init]) {
        self.light = light;
    }

    return self;
}
-(void)execute{
    [self.light lightOff];
}

@end複製程式碼

#import <Foundation/Foundation.h>
#import "CommandInterface.h"
#import "CDPlayer.h"

@interface CDPlayOnCommand : NSObject<CommandInterface>
@property(strong,nonatomic)CDPlayer *player;
-(instancetype)initWithPlayer:(CDPlayer *)player;
@end


===============
#import "CDPlayOnCommand.h"

@implementation CDPlayOnCommand
-(instancetype)initWithPlayer:(CDPlayer *)player{
    if (self == [super init]) {
        self.player = player;
    }

    return self;
}
-(void)execute{
    [self.player CDOn];
    [self.player setVolume:11];
}

@end複製程式碼

#import <Foundation/Foundation.h>
#import "CDPlayer.h"
#import "CommandInterface.h"

@interface CDPlayerOffCommand : NSObject<CommandInterface>
@property(strong,nonatomic)CDPlayer *player;
-(instancetype)initWithPlayer:(CDPlayer *)player;
@end

==========

#import "CDPlayerOffCommand.h"

@implementation CDPlayerOffCommand
-(instancetype)initWithPlayer:(CDPlayer *)player{
    if (self == [super init]) {
        self.player = player;
    }

    return self;
}
-(void)execute{
    [self.player CDOff];
    [self.player setVolume:0];
}

@end複製程式碼

3、定義命令接受者

每個命令接受者（各種電器）是具體功能的實現者，命令物件會呼叫此處定義的公開方法去實現協議的方法-excute

比如電燈的開啟和關閉功能，在這裡具體去實現

#import <Foundation/Foundation.h>

@interface Light : NSObject
-(void)lightOn;
-(void)lightOff;
@end


===========

#import "Light.h"

@implementation Light

-(void)lightOn{
    NSLog(@"燈被開啟");
}

-(void)lightOff{
    NSLog(@"燈被關閉");
}
@end複製程式碼

#import <Foundation/Foundation.h>

@interface CDPlayer : NSObject
-(void)CDOn;
-(void)CDOff;
-(void)setVolume:(NSInteger)volume;
@end

=========
#import "CDPlayer.h"

@implementation CDPlayer
-(void)CDOn{
    NSLog(@"CD播放器被開啟");
}

-(void)CDOff{
    NSLog(@"CD播放器被關閉");
}

-(void)setVolume:(NSInteger)volume{
    NSLog(@"設定聲音大小為：%zd",volume);
}

@end複製程式碼

4、設定命令呼叫者（遙控器）

我們現在需要定義遙控器每排按鈕的命令，我們把開啟和關閉的命令物件分別存入到兩個不同的陣列，然後根據按鈕的排數去陣列中取出響應的命令執行。

同時此處定義了一個公開的方法setCommandWithSlot供命令裝配者來給自己的每個按鈕繫結具體的命令物件。

#import <Foundation/Foundation.h>
#import "CommandInterface.h"

@interface RemoteControl : NSObject
@property(strong,nonatomic)id<CommandInterface> slot;

-(void)onButtonClickWithSlot:(NSInteger)slot;
-(void)offButtonClickWithSlot:(NSInteger)slot;

-(void)setCommandWithSlot:(NSInteger )slot onCommand:(id<CommandInterface>)onCommand offCommand:(id<CommandInterface>)offCommand;
@end

====================
#import "RemoteControl.h"
#import "noCommand.h"


@interface RemoteControl()
@property(nonatomic,strong)NSMutableArray<id<CommandInterface>> *onCommandArr;
@property(nonatomic,strong)NSMutableArray<id<CommandInterface>> *offCommandArr;
@end

@implementation RemoteControl
-(void)onButtonClickWithSlot:(NSInteger)slot{
    [self.onCommandArr[slot] execute];
}

-(void)offButtonClickWithSlot:(NSInteger)slot{
    [self.offCommandArr[slot] execute];
}


- (instancetype)init
{
    self = [super init];
    if (self) {
        self.onCommandArr = [NSMutableArray array];
        self.offCommandArr = [NSMutableArray array];
        self.completeCommandsArr  = [NSMutableArray array];
        id<CommandInterface>noCommands = [[noCommand alloc]init];
        for (int i = 0; i< 4; i++) {
            self.offCommandArr[i] = noCommands;
            self.onCommandArr[i] =  noCommands;
        }
        self.undoCommand = [[noCommand alloc]init];
    }
    return self;
}


-(void)setCommandWithSlot:(NSInteger )slot onCommand:(id<CommandInterface>)onCommand offCommand:(id<CommandInterface>)offCommand
{
    self.onCommandArr[slot] = onCommand;
    self.offCommandArr[slot] = offCommand;

}
@end複製程式碼

注意到我們在init方法初始化的時候，給兩個命令物件陣列都預先存入了nocommand物件，這是因為每排按鈕最好預設繫結一個命令物件，實現空操作，這樣如果需要重新繫結某個按鈕的命令物件，就可以覆蓋nocommand物件即可，如果沒有覆蓋就是預設的空操作，這樣客戶端如果呼叫到繫結nocommand命令物件的按鈕也不會報錯。

nocommand實現如下：

#import <Foundation/Foundation.h>
#import "CommandInterface.h"
@interface noCommand : NSObject<CommandInterface>

@end

============
#import "noCommand.h"

@implementation noCommand
-(void)execute{
    NSLog(@"該插槽沒有安裝命令");
}

@end複製程式碼

5、定義命令裝配者

我們通過上面幾個步驟定義了命令物件和命令呼叫者（遙控器），現在我們需要把這些命令物件對應安裝到遙控器的不同按鈕上。

#import <Foundation/Foundation.h>
#import "RemoteControl.h"

@interface RemoteLoader : NSObject
- (instancetype)initWithRm:(RemoteControl*)RM;
@end

============
#import "RemoteLoader.h"
#import "Light.h"
#import "LightOnCommand.h"
#import "LightOffCommand.h"
#import "CDPlayer.h"
#import "CDPlayOnCommand.h"
#import "CDPlayerOffCommand.h"
#import "macroCommand.h"


@interface RemoteLoader ()
@property(strong,nonatomic)RemoteControl *RM;
@end

@implementation RemoteLoader

- (instancetype)initWithRm:(RemoteControl*)remote
{
    self = [super init];
    if (self) {
        self.RM = remote;
        [self configSlotCommand];
    }
    return self;
}

-(void)configSlotCommand{
    Light *light = [Light new];
    LightOnCommand *lightOn = [[LightOnCommand alloc]initWithLight:light];
    LightOffCommand *LightOff = [[LightOffCommand alloc]initWithLight:light];
    [self.RM setCommandWithSlot:0 onCommand:lightOn offCommand:LightOff];

    CDPlayer *player = [CDPlayer new];
    CDPlayOnCommand *playerOn = [[CDPlayOnCommand alloc]initWithPlayer:player];
    CDPlayerOffCommand *playerOff = [[CDPlayerOffCommand alloc]initWithPlayer:player];
    [self.RM setCommandWithSlot:1 onCommand:playerOn offCommand:playerOff];


}


@end複製程式碼

6、客戶端呼叫

現在我們已經完成了遙控器的實現，這裡我們只實現第一排和第二排按鈕，分別是電燈和CD的開啟關閉操作。下面我們來看看呼叫

        RemoteControl *remote = [[RemoteControl alloc]init];
        RemoteLoader *loader = [[RemoteLoader alloc]initWithRm:remote];
        [remote onButtonClickWithSlot:0];
        NSLog(@"-----------------------");

        [remote offButtonClickWithSlot:0];
        NSLog(@"-----------------------");

        [remote onButtonClickWithSlot:1];
        NSLog(@"-----------------------");

        [remote offButtonClickWithSlot:1];
        NSLog(@"-----------------------");

        [remote onButtonClickWithSlot:3];
        NSLog(@"-----------------------");複製程式碼

輸出如下：

2016-12-03 13:00:18.208 命令模式[37394:323525] 燈被開啟
2016-12-03 13:00:18.208 命令模式[37394:323525] -----------------------
2016-12-03 13:00:18.208 命令模式[37394:323525] 燈被關閉
2016-12-03 13:00:18.208 命令模式[37394:323525] -----------------------
2016-12-03 13:00:18.208 命令模式[37394:323525] CD播放器被開啟
2016-12-03 13:00:18.208 命令模式[37394:323525] 設定聲音大小為：11
2016-12-03 13:00:18.208 命令模式[37394:323525] -----------------------
2016-12-03 13:00:18.208 命令模式[37394:323525] CD播放器被關閉
2016-12-03 13:00:18.208 命令模式[37394:323525] 設定聲音大小為：0
2016-12-03 13:00:18.209 命令模式[37394:323525] -----------------------
2016-12-03 13:00:18.209 命令模式[37394:323525] 該插槽沒有安裝命令
-----------------------複製程式碼

此時如果想要更換每排按鈕對應的電器只需要修改RemoteLoader即可，假設現在把第一排按鈕對應的電器換成CD播放器，第二排的電器換成電燈，只需要做如下設定即可

-(void)configSlotCommand{
    Light *light = [Light new];
    LightOnCommand *lightOn = [[LightOnCommand alloc]initWithLight:light];
    LightOffCommand *LightOff = [[LightOffCommand alloc]initWithLight:light];
    [self.RM setCommandWithSlot:1 onCommand:lightOn offCommand:LightOff];

    CDPlayer *player = [CDPlayer new];
    CDPlayOnCommand *playerOn = [[CDPlayOnCommand alloc]initWithPlayer:player];
    CDPlayerOffCommand *playerOff = [[CDPlayerOffCommand alloc]initWithPlayer:player];
    [self.RM setCommandWithSlot:0 onCommand:playerOn offCommand:playerOff];

}

改為：

-(void)configSlotCommand{
    Light *light = [Light new];
    LightOnCommand *lightOn = [[LightOnCommand alloc]initWithLight:light];
    LightOffCommand *LightOff = [[LightOffCommand alloc]initWithLight:light];
    [self.RM setCommandWithSlot:0 onCommand:lightOn offCommand:LightOff];

    CDPlayer *player = [CDPlayer new];
    CDPlayOnCommand *playerOn = [[CDPlayOnCommand alloc]initWithPlayer:player];
    CDPlayerOffCommand *playerOff = [[CDPlayerOffCommand alloc]initWithPlayer:player];
    [self.RM setCommandWithSlot:1 onCommand:playerOn offCommand:playerOff];

}複製程式碼

想把現有的每排按鈕對應的電器換成其他電器也非常容易，重新建立一個命令物件，然後設定到對應的排數即可。

---

執行過程分析

下面我們使用UML圖的方式來分析下，上面的過程是如何完成的。

---

小結

通過上面的例子我們可以看到命令呼叫者和命令接受者之間完全解耦了，二者都不需要知道對方，只需要通過命令物件這個中間量來聯絡即可，這樣不管命令接受者如何變化，只需要改變命令呼叫者的每個命令關聯的命令物件即可，而無需更改命令呼叫者的任何程式碼，而客戶端是面向的命令呼叫者程式設計，那麼客戶端程式碼也不需要修改，只需要擴充套件即可。

---

撤銷操作和巨集命令

想象下我們下班回家，一進家門，開啟電燈，然後開啟CD播放器，開始播放音樂，多麼美妙。但是使用上面的程式碼我們需要一個個的電器去開啟，太麻煩，能不能實現按一個按鈕就開啟電燈和CD播放器呢？這就需要用到巨集命令，所謂巨集命令就是把許多命令物件集中起來一起執行。

另外我們我們還可以實現命令撤銷功能，這裡的命令撤銷功能比較簡單，只需要執行相反操作就可以了，比如執行的動作是開燈，那麼撤銷操作就是關燈。

實際使用過程中的撤銷功能可能比較複雜，因為需要記錄下命令執行前的狀態，然後撤銷功能必須回到當初的狀態，這個當我們講到備忘錄模式的時候再回頭講如何實現

1、實現巨集命令

#import <Foundation/Foundation.h>
#import "CommandInterface.h"

@interface macroCommand : NSObject<CommandInterface>
@property(strong,nonatomic)NSArray<id<CommandInterface>> *commandsArr;
- (instancetype)initWithCommands:(NSArray<id<CommandInterface>>*)commands;
@end

============

#import "macroCommand.h"

@implementation macroCommand

- (instancetype)initWithCommands:(NSArray<id<CommandInterface>>*)commands
{
    self = [super init];
    if (self) {
        self.commandsArr = commands;
    }
    return self;
}

-(void)execute{
    for (id<CommandInterface>command in self.commandsArr) {
        [command execute];
    }
}

//和單個命令的撤銷操作類似，就不在演示了
-(void)undo{
    NSLog(@"巨集命令懶得寫撤銷操作");
}
@end複製程式碼

把巨集命令物件對應到第三排按鈕，修改remoteLoader類

-(void)configSlotCommand{
    Light *light = [Light new];
    LightOnCommand *lightOn = [[LightOnCommand alloc]initWithLight:light];
    LightOffCommand *LightOff = [[LightOffCommand alloc]initWithLight:light];
    [self.RM setCommandWithSlot:1 onCommand:lightOn offCommand:LightOff];

    CDPlayer *player = [CDPlayer new];
    CDPlayOnCommand *playerOn = [[CDPlayOnCommand alloc]initWithPlayer:player];
    CDPlayerOffCommand *playerOff = [[CDPlayerOffCommand alloc]initWithPlayer:player];
    [self.RM setCommandWithSlot:0 onCommand:playerOn offCommand:playerOff];

    NSArray *onCommandArr = [NSArray arrayWithObjects:lightOn,playerOn, nil];
    NSArray *offCommandArr = [NSArray arrayWithObjects:LightOff,playerOff, nil];
    macroCommand *onMacro = [[macroCommand alloc]initWithCommands:onCommandArr];
    macroCommand *offMacro = [[macroCommand alloc]initWithCommands:offCommandArr];
    [self.RM setCommandWithSlot:2 onCommand:onMacro offCommand:offMacro];

}複製程式碼

2、實現命令撤銷功能

給命令物件介面新增undo功能

#import <Foundation/Foundation.h>

@protocol CommandInterface <NSObject>
-(void)execute;
-(void)undo;
@end複製程式碼

給每個電器新增撤銷功能

下面是給lightOnCommand命令物件新增undo功能，執行和excute相反的操作即可。其他命令物件類似。

#import "LightOnCommand.h"

@implementation LightOnCommand
-(instancetype)initWithLight:(Light *)light{
    if (self == [super init]) {
        self.light = light;
    }

    return self;
}

-(void)execute{
    [self.light lightOn];
}

-(void)undo{
    [self.light lightOff];
}
@end複製程式碼

給remoteControl新增撤銷功能

#import "RemoteControl.h"
#import "noCommand.h"


@interface RemoteControl()
@property(nonatomic,strong)NSMutableArray<id<CommandInterface>> *onCommandArr;
@property(nonatomic,strong)NSMutableArray<id<CommandInterface>> *offCommandArr;
@property(nonatomic,strong)id<CommandInterface> undoCommand;
@property(nonatomic,strong)NSMutableArray <id<CommandInterface>> *completeCommandsArr;
@end

@implementation RemoteControl
-(void)onButtonClickWithSlot:(NSInteger)slot{
    [self.onCommandArr[slot] execute];
    self.undoCommand = self.onCommandArr[slot];
    [self.completeCommandsArr addObject:self.onCommandArr[slot]];
}

-(void)offButtonClickWithSlot:(NSInteger)slot{
    [self.offCommandArr[slot] execute];
    self.undoCommand = self.offCommandArr[slot];
    [self.completeCommandsArr addObject:self.offCommandArr[slot]];
}

//撤銷最後一步操作
-(void)undoButtonClick{
    [self.undoCommand undo];
}

//撤銷全部操作
-(void)undoAllOperation{
    for (id<CommandInterface>command in self.completeCommandsArr) {
        [command undo];
    }
}

- (instancetype)init
{
    self = [super init];
    if (self) {
        self.onCommandArr = [NSMutableArray array];
        self.offCommandArr = [NSMutableArray array];
        self.completeCommandsArr  = [NSMutableArray array];
        id<CommandInterface>noCommands = [[noCommand alloc]init];
        for (int i = 0; i< 4; i++) {
            self.offCommandArr[i] = noCommands;
            self.onCommandArr[i] =  noCommands;
        }
        self.undoCommand = [[noCommand alloc]init];
    }
    return self;
}


-(void)setCommandWithSlot:(NSInteger )slot onCommand:(id<CommandInterface>)onCommand offCommand:(id<CommandInterface>)offCommand
{
    self.onCommandArr[slot] = onCommand;
    self.offCommandArr[slot] = offCommand;

}
@end複製程式碼

上面是一個生活中的例子，我們上面用到的解決問題的思路在設計模式中我們叫做：命令模式。

下面我們來具體看看命令模式的真面目

---

定義

將一個請求封裝為一個物件,從而使你可用不同的請求對客戶進行引數化;對請求排隊或記錄請求日誌,以及支援可撤消的操作。

通過上面的案例我們可以總結出，命令模式的本質就是把請求封裝成物件，既然是物件，那麼就可以對這個物件進行傳遞、呼叫、巨集命令、佇列化、持久化等一系列操作。

命令模式讓命令的發起者和命令的接受者完全解耦，在他們之間通過命令物件來實現連通。這樣就有如下好處：

• 把請求封裝起來，可以動態的進行佇列化、持久化等操作，滿足各種業務需求
• 可以把多個簡單的命令組合成一個巨集命令，從而簡化操作，完成複雜的功能
• 擴充套件性良好。由於命令的發起者和接受者完全解耦，那麼這個時候新增和修改任何命令，只需要設定好對應的命令和命令物件即可，無需對原有系統進行修改

在實際場景中，如果出現有如下需求，那麼就可以考慮使用命令模式了

---

UML結構圖及說明

把這幅圖和上面的執行過程圖好好對比下，可以加深理解

提醒下：實際開發過程中，client和invoker可以融合在一起實現。

---

動機

有時必須向某物件提交請求,但並不知道關於請求的接受者的任何資訊。比如上面的遙控器需要執行開啟或者關閉電器的操作，但是它並不知道這個命令被那個具體的電器執行。

這個時候我們就可以使用命令模式來完成這一需求。通過將請求本身變成一個物件來使工具箱物件可向未指定的應用物件提出請求。 這個物件可被儲存並像其他的物件一樣被傳遞。這一模式的關鍵是一個抽象的 command類, 它定義了一個執行操作的介面。其最簡單的形式是一個抽象的 excute操作。具體的 command 子類將接收者作為其一個例項變數,並實現 excute 操 作 , 指 定 接 收 者 採 取 的 動 作 。 而 接 收 者 有執行該請求所需的具體資訊。

通過上面的講解相信大家對命令模式已經有了一個感性認識，下面我們來看看命令模式在實際應用中的兩個例子加深理解。

---

命令日誌化

1、需求分析

大家應該遇到過window莫名其妙的開機無法進入系統的情況，此時進入安全模式，可以選擇最後一次正確的操作，然後系統開始回滾操作，最後就可以正常進入系統了。

命令日誌化就可以實現類似的功能，我們可以把執行過得命令儲存起來，當系統出現問題或者執行過程中斷，我們可以把命令取出來進行再次執行，也就是回滾操作。

實現起來也比較簡單，就是對執行過的命令物件進行序列化，然後儲存起來，在需要使用的時候再次執行即可。

在iOS中我們可以通過NSCoding的兩個協議方法實現物件序列化

- (void)encodeWithCoder:(NSCoder *)aCoder 
- (id)initWithCoder:(NSCoder *)aDecoder複製程式碼

我們現在要實現如下要求，假設程式啟動的時候執行如下命令：

RemoteControl *remote = [[RemoteControl alloc]init];
        RemoteLoader *loader = [[RemoteLoader alloc]initWithRm:remote];
        //測試每個按鈕的命令
        [remote onButtonClickWithSlot:0];
        [remote offButtonClickWithSlot:0];
        [remote onButtonClickWithSlot:1];
        [remote offButtonClickWithSlot:1];
        //測試巨集命令
        [remote onButtonClickWithSlot:2];
        [remote offButtonClickWithSlot:2];複製程式碼

此時輸出如下：

2016-12-04 11:57:38.505 命令模式[39084:534547] 燈被開啟
2016-12-04 11:57:38.505 命令模式[39084:534547] 燈被關閉
2016-12-04 11:57:38.505 命令模式[39084:534547] CD播放器被開啟
2016-12-04 11:57:38.505 命令模式[39084:534547] 設定聲音大小為：11
2016-12-04 11:57:38.506 命令模式[39084:534547] CD播放器被關閉
2016-12-04 11:57:38.506 命令模式[39084:534547] 設定聲音大小為：0
2016-12-04 11:57:38.506 命令模式[39084:534547] 燈被開啟
2016-12-04 11:57:38.507 命令模式[39084:534547] CD播放器被開啟
2016-12-04 11:57:38.507 命令模式[39084:534547] 設定聲音大小為：11
2016-12-04 11:57:38.507 命令模式[39084:534547] 燈被關閉
2016-12-04 11:57:38.507 命令模式[39084:534547] CD播放器被關閉
2016-12-04 11:57:38.507 命令模式[39084:534547] 設定聲音大小為：0複製程式碼

當殺死程式，再次啟動的時候，我們不用執行上面的程式碼，只需要取出我們事先儲存的命令物件進行回滾，就可以再現上面的輸出。

2、序列化命令物件和命令接受者

下面來看看如何實現：

因為我們需要序列化每個命令物件和命令接受者，這裡我們採用NSCoding的方式來實現，為了方便，我把序列化操作抽成了一個巨集，儲存在serialObject.h檔案

如下所示：

#define SERIALIZE_CODER_DECODER()     

- (id)initWithCoder:(NSCoder *)coder    
{   
NSLog(@"%s",__func__);  
Class cls = [self class];   
while (cls != [NSObject class]) {   
/*判斷是自身類還是父類*/    
BOOL bIsSelfClass = (cls == [self class]);  
unsigned int iVarCount = 0; 
unsigned int propVarCount = 0;  
unsigned int sharedVarCount = 0;    
Ivar *ivarList = bIsSelfClass ? class_copyIvarList([cls class], &iVarCount) : NULL;/*變數列表，含屬性以及私有變數*/   
objc_property_t *propList = bIsSelfClass ? NULL : class_copyPropertyList(cls, &propVarCount);/*屬性列表*/   
sharedVarCount = bIsSelfClass ? iVarCount : propVarCount;   

for (int i = 0; i < sharedVarCount; i++) {  
const char *varName = bIsSelfClass ? ivar_getName(*(ivarList + i)) : property_getName(*(propList + i)); 
NSString *key = [NSString stringWithUTF8String:varName];   
id varValue = [coder decodeObjectForKey:key];   
NSArray *filters = @[@"superclass", @"description", @"debugDescription", @"hash"]; 
if (varValue && [filters containsObject:key] == NO) { 
[self setValue:varValue forKey:key];    
}   
}   
free(ivarList); 
free(propList); 
cls = class_getSuperclass(cls); 
}   
return self;    
}   

- (void)encodeWithCoder:(NSCoder *)coder    
{   
NSLog(@"%s",__func__);  
Class cls = [self class];   
while (cls != [NSObject class]) {   
/*判斷是自身類還是父類*/    
BOOL bIsSelfClass = (cls == [self class]);  
unsigned int iVarCount = 0; 
unsigned int propVarCount = 0;  
unsigned int sharedVarCount = 0;    
Ivar *ivarList = bIsSelfClass ? class_copyIvarList([cls class], &iVarCount) : NULL;/*變數列表，含屬性以及私有變數*/   
objc_property_t *propList = bIsSelfClass ? NULL : class_copyPropertyList(cls, &propVarCount);/*屬性列表*/ 
sharedVarCount = bIsSelfClass ? iVarCount : propVarCount;   

for (int i = 0; i < sharedVarCount; i++) {  
const char *varName = bIsSelfClass ? ivar_getName(*(ivarList + i)) : property_getName(*(propList + i)); 
NSString *key = [NSString stringWithUTF8String:varName];    
/*valueForKey只能獲取本類所有變數以及所有層級父類的屬性，不包含任何父類的私有變數(會崩潰)*/  
id varValue = [self valueForKey:key];   
NSArray *filters = @[@"superclass", @"description", @"debugDescription", @"hash"]; 
if (varValue && [filters containsObject:key] == NO) { 
[coder encodeObject:varValue forKey:key];   
}   
}   
free(ivarList); 
free(propList); 
cls = class_getSuperclass(cls); 
}   
}複製程式碼

在需要序列化的地方只需要匯入該.h檔案，然後寫一句SERIALIZE_CODER_DECODER()即可

下面我們來看看如何序列化LightOnCommand，如下操作即可

#import "LightOnCommand.h"
#import "serialObject.h"
#import  <objc/runtime.h>

@implementation LightOnCommand
-(instancetype)initWithLight:(Light *)light{
    if (self == [super init]) {
        self.light = light;
    }

    return self;
}

-(void)execute{
    [self.light lightOn];
}

-(void)undo{
    [self.light lightOff];
}

SERIALIZE_CODER_DECODER()

@end複製程式碼

其他的command物件都進行如此操作進行序列化，這裡就不再演示，注意命令接受這light和CDPlayer也需要序列化，做法和這裡類似，就不再贅述。

3、儲存序列化後的命令物件

#import "RemoteLoader.h"
#import "Light.h"
#import "LightOnCommand.h"
#import "LightOffCommand.h"
#import "CDPlayer.h"
#import "CDPlayOnCommand.h"
#import "CDPlayerOffCommand.h"
#import "macroCommand.h"


@interface RemoteLoader ()
@property(strong,nonatomic)RemoteControl *RM;
@property(strong,nonatomic)NSArray *completedCommandsArr;
@end

@implementation RemoteLoader

- (instancetype)initWithRm:(RemoteControl*)remote
{
    self = [super init];
    if (self) {
        self.RM = remote;
        [self configSlotCommand];
    }
    return self;
}

-(void)configSlotCommand{
    Light *light = [Light new];
    LightOnCommand *lightOn = [[LightOnCommand alloc]initWithLight:light];
    LightOffCommand *LightOff = [[LightOffCommand alloc]initWithLight:light];
    [self.RM setCommandWithSlot:0 onCommand:lightOn offCommand:LightOff];

    CDPlayer *player = [CDPlayer new];
    CDPlayOnCommand *playerOn = [[CDPlayOnCommand alloc]initWithPlayer:player];
    CDPlayerOffCommand *playerOff = [[CDPlayerOffCommand alloc]initWithPlayer:player];
    [self.RM setCommandWithSlot:1 onCommand:playerOn offCommand:playerOff];

    NSArray *onCommandArr = [NSArray arrayWithObjects:lightOn,playerOn, nil];
    NSArray *offCommandArr = [NSArray arrayWithObjects:LightOff,playerOff, nil];
    macroCommand *onMacro = [[macroCommand alloc]initWithCommands:onCommandArr];
    macroCommand *offMacro = [[macroCommand alloc]initWithCommands:offCommandArr];
    [self.RM setCommandWithSlot:2 onCommand:onMacro offCommand:offMacro];

    //序列化命令物件，然後儲存
    self.completedCommandsArr = @[lightOn,LightOff,playerOn,playerOff,onMacro,offMacro];
    NSData  *data1 = [NSKeyedArchiver archivedDataWithRootObject:self.completedCommandsArr];
    [[NSUserDefaults standardUserDefaults]setObject:data1 forKey:@"serialCommands"];
    [[NSUserDefaults standardUserDefaults]synchronize];

}

@end複製程式碼

4、客戶端呼叫

客戶端呼叫方法如下：

        NSData *data = [[NSUserDefaults standardUserDefaults]objectForKey:@"serialCommands"];
        NSArray *commands = [NSKeyedUnarchiver unarchiveObjectWithData:data];//反序列化
        for (id<CommandInterface> command in commands) {
            [command execute];
        }

        #########斷點###########

        //測試命令
        RemoteControl *remote = [[RemoteControl alloc]init];
        RemoteLoader *loader = [[RemoteLoader alloc]initWithRm:remote];
        //測試每個按鈕的命令
        [remote onButtonClickWithSlot:0];
        [remote offButtonClickWithSlot:0];
        [remote onButtonClickWithSlot:1];
        [remote offButtonClickWithSlot:1];
        //測試巨集命令
        [remote onButtonClickWithSlot:2];
        [remote offButtonClickWithSlot:2];複製程式碼

當第一次執行程式到斷點的時候，我們可以發現此時的commands陣列是空的，如圖所示

因為此時還沒有執行命令，當然也就沒有命令物件可以儲存。我們跳過斷點繼續執行，此時輸出如需求分析中所展示的一樣

現在再次啟動程式，執行到斷點處，檢視commands如下所示：

可以發現此時commands包含了上次執行的命令物件和命令接受者，同時，執行到斷點處的輸出也和需求分析中展示的一樣。說明我們成功的實現了命令回滾。

---

命令佇列化

既然命令物件可以被持久化，那麼當然也可以佇列化，說簡單點，就是把各種命令物件存放到佇列裡面，然後分發給命令接受者處理的過程就是命令佇列化。通常會用多執行緒來處理命令佇列。

命令物件在一頭被依次不斷放入一個佇列，然後在佇列的另一頭，多執行緒把這些命令物件取出來，呼叫它的execute()方法執行操作，操作完畢，丟棄，然後開始呼叫下一個命令物件，如此迴圈往復。

如果需要實現一個功能完全的佇列，會相當麻煩，因為要保證多執行緒之間的排程，簡單點的就是使用陣列當佇列，然後存入和取出命令物件的時候加上同步鎖來保證不會造成資源競爭。

實現比較簡單，就不演示了，大家可以自己去實現下試試。

---

Demo下載

命令模式Demo下載