Objective-C 中的命令模式运用与原理

命令模式基础概念

命令模式定义

命令模式（Command Pattern）是一种行为型设计模式，它将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。在 Objective-C 开发中，命令模式可以有效地解耦请求的发送者和接收者，提高代码的可维护性和扩展性。

命令模式结构

命令模式通常包含以下几个角色：

1. Command（抽象命令类）：声明执行操作的接口。在 Objective-C 中，这通常是一个协议或者一个抽象类。
2. ConcreteCommand（具体命令类）：实现抽象命令类中声明的接口，它持有一个接收者对象，并调用接收者的相应方法来执行具体的操作。
3. Receiver（接收者）：知道如何执行与请求相关的操作，任何类都可能作为一个接收者。
4. Invoker（调用者）：负责调用命令对象执行请求，它持有一个命令对象。
5. Client（客户端）：创建具体命令对象，并设置命令对象的接收者。

Objective-C 中命令模式的实现

简单示例场景

假设我们正在开发一个简单的智能家居系统，其中有一个电灯设备。我们希望通过不同的操作（打开、关闭）来控制电灯，并且这些操作可以被记录和撤销。我们将使用命令模式来实现这个功能。

定义抽象命令类

首先，我们定义一个抽象命令类 LightCommand，它是一个协议：

@protocol LightCommand <NSObject>
- (void)execute;
- (void)undo;
@end

这里定义了 execute 方法用于执行命令，undo 方法用于撤销命令。

定义接收者 - 电灯类

接下来，定义电灯类 Light，它就是命令的接收者：

@interface Light : NSObject
@property (nonatomic, assign, getter = isOn) BOOL on;
- (void)turnOn;
- (void)turnOff;
@end

@implementation Light
- (void)turnOn {
    self.on = YES;
    NSLog(@"Light is on.");
}

- (void)turnOff {
    self.on = NO;
    NSLog(@"Light is off.");
}
@end

Light 类有一个属性 on 来表示电灯的状态，并且有 turnOn 和 turnOff 方法来控制电灯的开关。

定义具体命令类

1. 打开电灯命令类

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

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

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

- (void)undo {
    [self.light turnOff];
}
@end

TurnOnLightCommand 类实现了 LightCommand 协议，它持有一个 Light 对象，并在 execute 方法中调用 Light 的 turnOn 方法，在 undo 方法中调用 Light 的 turnOff 方法。

2. 关闭电灯命令类

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

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

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

- (void)undo {
    [self.light turnOn];
}
@end

TurnOffLightCommand 类同理，在 execute 方法中关闭电灯，在 undo 方法中打开电灯。

定义调用者 - 遥控器类

@interface RemoteControl : NSObject
@property (nonatomic, strong) id<LightCommand> command;
- (void)pressButton;
- (void)undoButton;
@end

@implementation RemoteControl
- (void)pressButton {
    [self.command execute];
}

- (void)undoButton {
    [self.command undo];
}
@end

RemoteControl 类持有一个 LightCommand 对象，通过 pressButton 方法执行命令，通过 undoButton 方法撤销命令。

客户端使用

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Light *light = [[Light alloc] init];
        TurnOnLightCommand *turnOnCommand = [[TurnOnLightCommand alloc] initWithLight:light];
        TurnOffLightCommand *turnOffCommand = [[TurnOffLightCommand alloc] initWithLight:light];

        RemoteControl *remote = [[RemoteControl alloc] init];

        remote.command = turnOnCommand;
        [remote pressButton];

        remote.command = turnOffCommand;
        [remote pressButton];

        [remote undoButton];
    }
    return 0;
}

在客户端代码中，我们创建了电灯对象、打开和关闭电灯的命令对象以及遥控器对象。通过遥控器对象执行不同的命令，并展示了撤销操作。

命令模式在 iOS 开发中的实际应用场景

界面交互处理

在 iOS 应用开发中，用户在界面上的各种操作（如点击按钮、滑动屏幕等）都可以看作是命令。通过命令模式，我们可以将这些操作封装成命令对象，然后交给相应的处理类进行处理。例如，在一个电商应用中，用户点击“购买”按钮，这个点击操作可以封装成一个 PurchaseCommand，接收者可以是购物车管理类，它负责处理购买逻辑，如扣除库存、更新订单等。

任务队列管理

在多任务处理场景下，命令模式可以用于管理任务队列。我们可以将每个任务封装成一个命令对象，然后将这些命令对象添加到任务队列中。调用者（如任务调度器）按照一定的规则从队列中取出命令并执行。这样可以有效地管理并发任务，并且方便对任务进行暂停、恢复、撤销等操作。例如，在一个文件下载应用中，每个文件下载任务可以封装成一个 DownloadCommand，任务调度器负责从任务队列中取出下载任务并执行，同时可以根据用户需求暂停或恢复下载任务。

游戏开发

在游戏开发中，命令模式也有广泛的应用。玩家在游戏中的各种操作（如移动角色、释放技能等）都可以通过命令模式进行处理。每个操作封装成一个命令对象，接收者可以是游戏角色对象或游戏场景对象。这样可以方便地实现游戏操作的记录和回放功能，同时也提高了游戏代码的可维护性和扩展性。例如，在一个角色扮演游戏中，玩家控制角色向左移动的操作可以封装成一个 MoveLeftCommand，接收者是角色对象，它负责更新角色的位置。

命令模式的优势与劣势

优势

1. 解耦发送者和接收者：命令模式将请求的发送者和接收者分离，使得两者之间没有直接的依赖关系。发送者只需要关心如何发送命令，而接收者只需要关心如何执行命令。这样可以提高代码的可维护性和可扩展性，当发送者或接收者发生变化时，不会影响到另一方。
2. 支持命令的排队和记录：由于命令被封装成对象，我们可以很方便地将命令对象添加到队列中，实现命令的排队执行。同时，也可以记录命令的执行日志，以便于调试和审计。
3. 支持撤销和重做操作：通过在命令对象中实现 undo 方法，可以很方便地实现撤销操作。如果再加上一个 redo 方法，就可以实现重做操作。这在很多应用场景中（如文本编辑、绘图等）非常有用。

劣势

1. 增加系统复杂度：命令模式引入了多个新的类（抽象命令类、具体命令类、调用者等），增加了系统的复杂度。对于简单的应用场景，使用命令模式可能会显得过于繁琐。
2. 可能导致命令类过多：如果应用中有很多不同的操作，那么就需要定义很多具体命令类。这可能会导致代码量增加，并且管理起来也比较困难。

命令模式与其他设计模式的关系

与策略模式的比较

1. 相似点：命令模式和策略模式都将行为封装在对象中，使得行为可以在运行时进行切换。在命令模式中，不同的命令对象代表不同的操作；在策略模式中，不同的策略对象代表不同的算法。
2. 不同点：命令模式更侧重于将请求封装成对象，以便于对请求进行排队、记录和撤销等操作，它强调的是请求的发送者和接收者的解耦。而策略模式更侧重于算法的封装和切换，它强调的是对象行为的可替换性。例如，在一个图形绘制应用中，命令模式可以用于封装用户的绘图操作（如绘制直线、绘制矩形等），而策略模式可以用于封装不同的图形填充算法（如纯色填充、渐变填充等）。

与责任链模式的结合

在实际应用中，命令模式可以与责任链模式结合使用。责任链模式用于处理请求的传递和处理，而命令模式用于封装请求。当一个请求到达时，可以先通过责任链模式将请求传递给合适的处理者，然后处理者再使用命令模式来执行具体的操作。例如，在一个审批流程系统中，审批请求可以通过责任链模式依次传递给不同的审批人，每个审批人可以使用命令模式来执行审批操作（如批准、驳回等）。

命令模式在 iOS 框架中的体现

Target - Action 机制

iOS 中的 Target - Action 机制与命令模式有相似之处。在 Target - Action 机制中，UIControl（如按钮）是调用者，当用户与 UIControl 交互时，它会发送一个事件（相当于命令）给指定的 target（接收者），target 会调用相应的 action 方法（相当于执行命令）。虽然 Target - Action 机制没有像命令模式那样将命令封装成对象，但它在一定程度上实现了调用者和接收者的解耦。例如，在一个登录界面中，用户点击“登录”按钮，按钮作为调用者会将点击事件发送给视图控制器（接收者），视图控制器中的登录方法就是对应的 action。

NSOperation 框架

NSOperation 框架也体现了命令模式的思想。NSOperation 类相当于抽象命令类，它定义了执行任务的基本接口。NSInvocationOperation 和 NSBlockOperation 等具体的操作类相当于具体命令类，它们实现了 NSOperation 中的方法来执行具体的任务。NSOperationQueue 相当于调用者，它负责管理和执行 NSOperation 对象。通过 NSOperation 框架，我们可以方便地对任务进行排队、暂停、取消等操作，这与命令模式中对命令的管理是类似的。例如，在一个图片处理应用中，可以将图片加载、图片裁剪等操作封装成 NSOperation 对象，然后添加到 NSOperationQueue 中执行。

深入理解命令模式在 Objective - C 中的原理

内存管理与命令对象生命周期

在 Objective - C 中，命令对象作为普通的对象，其内存管理遵循引用计数原则。当客户端创建命令对象并将其传递给调用者时，需要注意对象的生命周期。如果调用者持有命令对象的强引用，那么在命令对象不再需要时，调用者需要负责释放该引用，以避免内存泄漏。例如，在我们之前的智能家居示例中，RemoteControl 持有 LightCommand 的强引用，当 RemoteControl 对象销毁时，应该确保 LightCommand 对象也能被正确释放。可以通过在 RemoteControl 的 dealloc 方法中设置 command 属性为 nil 来实现。

动态绑定与命令执行

在 Objective - C 中，方法调用是基于动态绑定的。当调用者调用命令对象的 execute 方法时，实际执行的是具体命令类中实现的 execute 方法。这种动态绑定机制使得命令模式更加灵活，我们可以在运行时根据需要创建不同的具体命令类对象，并将其传递给调用者。例如，在一个自动化测试框架中，可以根据测试用例的不同，动态创建不同的命令对象（如点击按钮命令、输入文本命令等），然后由测试执行器（调用者）来执行这些命令。

多线程环境下的命令模式

在多线程环境下使用命令模式需要注意线程安全问题。如果多个线程同时访问和操作命令对象，可能会导致数据竞争和不一致的问题。例如，如果一个命令对象在执行过程中修改了共享数据，而另一个线程同时也在访问或修改该数据，就可能出现错误。为了保证线程安全，可以使用锁机制（如 NSLock、@synchronized 等）来保护共享资源。在多线程任务队列场景下，NSOperationQueue 已经对任务的执行进行了线程安全的管理，我们在使用时只需要关注命令对象内部对共享资源的访问即可。

优化与扩展命令模式在 Objective - C 中的应用

命令参数化

在实际应用中，命令可能需要接受不同的参数。我们可以对命令对象进行参数化，使其更加灵活。例如，在一个文件操作应用中，复制文件命令可能需要接受源文件路径和目标文件路径作为参数。我们可以在抽象命令类中定义设置参数的方法，然后在具体命令类中实现这些方法并根据参数执行相应的操作。

@protocol FileCommand <NSObject>
- (void)setSourcePath:(NSString *)sourcePath;
- (void)setDestinationPath:(NSString *)destinationPath;
- (void)execute;
@end

@interface CopyFileCommand : NSObject <FileCommand>
@property (nonatomic, strong) NSString *sourcePath;
@property (nonatomic, strong) NSString *destinationPath;
- (void)setSourcePath:(NSString *)sourcePath {
    _sourcePath = sourcePath;
}
- (void)setDestinationPath:(NSString *)destinationPath {
    _destinationPath = destinationPath;
}
- (void)execute {
    // 执行文件复制操作，使用 _sourcePath 和 _destinationPath
    NSLog(@"Copying file from %@ to %@", _sourcePath, _destinationPath);
}
@end

命令组合

有时候，我们可能需要将多个命令组合成一个复合命令。例如，在一个复杂的图形绘制应用中，可能需要先绘制一个矩形，然后在矩形内绘制一个圆形，这两个操作可以组合成一个复合命令。我们可以定义一个 CompositeCommand 类，它实现命令接口，并且持有多个子命令对象。在 execute 方法中，依次执行子命令的 execute 方法。

@interface CompositeCommand : NSObject <LightCommand>
@property (nonatomic, strong) NSMutableArray<id<LightCommand>> *subCommands;
- (void)addCommand:(id<LightCommand>)command;
- (void)execute;
- (void)undo;
@end

@implementation CompositeCommand
- (instancetype)init {
    self = [super init];
    if (self) {
        _subCommands = [NSMutableArray array];
    }
    return self;
}
- (void)addCommand:(id<LightCommand>)command {
    [self.subCommands addObject:command];
}
- (void)execute {
    for (id<LightCommand> command in self.subCommands) {
        [command execute];
    }
}
- (void)undo {
    for (NSInteger i = self.subCommands.count - 1; i >= 0; i--) {
        id<LightCommand> command = self.subCommands[i];
        [command undo];
    }
}
@end

命令持久化

为了实现命令的记录和回放功能，我们可能需要将命令对象持久化到存储介质（如文件、数据库等）。在 Objective - C 中，可以使用归档（NSKeyedArchiver 和 NSKeyedUnarchiver）技术来实现命令对象的序列化和反序列化。例如，在一个文本编辑应用中，可以将用户的编辑操作（如插入文本、删除文本等命令）归档保存，然后在需要时进行反归档并回放这些操作。

@interface TextEditCommand : NSObject <NSCoding, LightCommand>
// 命令相关属性和方法
- (void)encodeWithCoder:(NSCoder *)aCoder {
    // 编码命令相关属性
}
- (instancetype)initWithCoder:(NSCoder *)aDecoder {
    self = [super init];
    if (self) {
        // 解码命令相关属性
    }
    return self;
}
@end

通过以上优化和扩展，可以使命令模式在 Objective - C 应用中更加高效、灵活和强大，满足各种复杂的业务需求。无论是在小型的工具应用还是大型的企业级应用中，命令模式都能发挥其独特的优势，帮助开发者构建可维护、可扩展的软件系统。同时，深入理解命令模式在 Objective - C 中的原理和实现细节，也有助于开发者更好地运用这一设计模式，并与其他设计模式相结合，创造出更加优秀的软件架构。在不断的实践和探索中，开发者可以根据具体的项目需求，对命令模式进行进一步的优化和创新，以适应快速变化的技术环境和业务场景。