生活场景分析

今天来学习命令模式，先从一个生活中的例子入手吧，这样理解起来也比较容易。大家应该有用过那种万能遥控器吧，就是那种能遥控各种品牌的空调或者电视的遥控器，我们只要在遥控器上设定具体的电器品牌，就可以遥控了，可以切换到任何支持的品牌的电器。

我们今天也来做一个万能遥控器，如下图所示：

image

请忽略这清奇的画风，我们来看看具体的要求：

每排两个按钮，分别实现打开和关闭电器的作用，除了如图所示前三排按钮对应的电器分别是：电灯、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图的方式来分析下，上面的过程是如何完成的。

image

小结

通过上面的例子我们可以看到命令调用者和命令接受者之间完全解耦了，二者都不需要知道对方，只需要通过命令对象这个中间量来联系即可，这样不管命令接受者如何变化，只需要改变命令调用者的每个命令关联的命令对象即可，而无需更改命令调用者的任何代码，而客户端是面向的命令调用者编程，那么客户端代码也不需要修改，只需要扩展即可。

撤销操作和宏命令

想象下我们下班回家，一进家门，打开电灯，然后打开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

上面是一个生活中的例子，我们上面用到的解决问题的思路在设计模式中我们叫做：命令模式。

下面我们来具体看看命令模式的真面目

定义

将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。

通过上面的案例我们可以总结出，命令模式的本质就是把请求封装成对象，既然是对象，那么就可以对这个对象进行传递、调用、宏命令、队列化、持久化等一系列操作。

命令模式让命令的发起者和命令的接受者完全解耦，在他们之间通过命令对象来实现连通。这样就有如下好处：

• 把请求封装起来，可以动态的进行队列化、持久化等操作，满足各种业务需求
• 可以把多个简单的命令组合成一个宏命令，从而简化操作，完成复杂的功能
• 扩展性良好。由于命令的发起者和接受者完全解耦，那么这个时候添加和修改任何命令，只需要设置好对应的命令和命令对象即可，无需对原有系统进行修改

在实际场景中，如果出现有如下需求，那么就可以考虑使用命令模式了

image

UML结构图及说明

image

把这幅图和上面的执行过程图好好对比下，可以加深理解

提醒下：实际开发过程中，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数组是空的，如图所示

image

因为此时还没有执行命令，当然也就没有命令对象可以存储。我们跳过断点继续执行，此时输出如需求分析中所展示的一样

现在再次启动程序，执行到断点处，查看commands如下所示：

image

可以发现此时commands包含了上次执行的命令对象和命令接受者，同时，执行到断点处的输出也和需求分析中展示的一样。说明我们成功的实现了命令回滚。

命令队列化

既然命令对象可以被持久化，那么当然也可以队列化，说简单点，就是把各种命令对象存放到队列里面，然后分发给命令接受者处理的过程就是命令队列化。通常会用多线程来处理命令队列。

命令对象在一头被依次不断放入一个队列，然后在队列的另一头，多线程把这些命令对象取出来，调用它的execute()方法执行操作，操作完毕，丢弃，然后开始调用下一个命令对象，如此循环往复。

image

如果需要实现一个功能完全的队列，会相当麻烦，因为要保证多线程之间的调度，简单点的就是使用数组当队列，然后存入和取出命令对象的时候加上同步锁来保证不会造成资源竞争。

实现比较简单，就不演示了，大家可以自己去实现下试试。

Demo下载

命令模式Demo下载