iOS设计模式之策略模式下
2024-06-21 本文已影响0人
点滴86
策略模式
策略模式的设计意图和应用场景。
问题与解决思路
假设有这样一个需求，希望写一个小程序，实现对一个文件进行排序的功能。文件中只包含整型数，并且，相邻的数字通过逗号来区隔。
这不是很简单吗，只需要将文件中的内容读取出来，并且通过逗号分隔成一个一个的数字，放到内存数组中，然后编写某种排序算法（比如快排），或者直接使用编程语言提供的排序函数，对数组进行排序，最后再将数组中的数据写入文件就可以了。
但是，如果文件很大呢》比如10GB大小，因为内存有限（比如只有8GB大小），没办法一次性加载文件中的所有数据到内存中，这个时候，就要利用外部排序算法了。
如果文件更大，比如有100GB大小，为了利用CPU多核的优势，可以在外部排序的基础之上进行优化，加入多线程并发排序的功能，这就有点类似”单机版“的MapReduce。
如果文件非常大，比如有1TB大小，即便是单机多线程排序，这也算很慢了。这个时候，可以使用真正的MapReduce框架，利用多机的处理能力，提高排序的效率。
代码实现与分析
解决思路讲完了，不难理解。接下来，看一下如何将解决思路翻译成代码实现。先用最简单直接的方式将它实现出来。具体代码如下：
@interface DMStrategySorter : NSObject
@end
@implementation DMStrategySorter
- (void)sortFile:(NSString *)filePath
{
long GB = 1000 * 1000 * 1000;
NSFileManager *fileManager = [NSFileManager defaultManager];
NSError *error = nil;
unsigned long long fileSize = [fileManager attributesOfItemAtPath:filePath error:&error].fileSize;
if (fileSize < 6 * GB) { // [0, 6GB)
[self quickSort:filePath];
} else if (fileSize < 10 * GB) { // [6GB, 10GB)
[self externalSort:filePath];
} else if (fileSize < 10 * GB) { // [10GB, 100GB)
[self concurrentExternalSort:filePath];
} else { // [100GB, ~)
[self mapreduceSort:filePath];
}
}
- (void)quickSort:(NSString *)filePath
{
// 快速排序
}
- (void)externalSort:(NSString *)filePath
{
// 外部排序
}
- (void)concurrentExternalSort:(NSString *)filePath
{
// 多线程外部排序
}
- (void)mapreduceSort:(NSString *)filePath
{
// 利用mapreduce多机排序
}
@end
代码优化与重构
将DMStrategySorter类中的某些代码拆分出来，独立成职责更加单一的小类。重构之后的代码如下：
@protocol DMStrategySortAlg <NSObject>
- (void)sort:(NSString *)filePath;
@end
@interface DMStrategyQuickSort : NSObject <DMStrategySortAlg>
@end
@implementation DMStrategyQuickSort
- (void)sort:(NSString *)filePath
{
// 快速排序
}
@end
@interface DMStrategyExternalSort : NSObject <DMStrategySortAlg>
@end
@implementation DMStrategyExternalSort
- (void)sort:(NSString *)filePath
{
// 外部排序
}
@end
@interface DMStrategyConcurrentExternalSort : NSObject <DMStrategySortAlg>
@end
@implementation DMStrategyConcurrentExternalSort
- (void)sort:(NSString *)filePath
{
// 多线程外部排序
}
@end
@interface DMStrategyMapreduceSort : NSObject <DMStrategySortAlg>
@end
@implementation DMStrategyMapreduceSort
- (void)sort:(NSString *)filePath
{
// 利用mapreduce多机排序
}
@end
@interface DMStrategySorter : NSObject
@end
@implementation DMStrategySorter
- (void)sortFile:(NSString *)filePath
{
long GB = 1000 * 1000 * 1000;
NSFileManager *fileManager = [NSFileManager defaultManager];
NSError *error = nil;
unsigned long long fileSize = [fileManager attributesOfItemAtPath:filePath error:&error].fileSize;
id<DMStrategySortAlg> strategySort = nil;
if (fileSize < 6 * GB) { // [0, 6GB)
strategySort = [[DMStrategyQuickSort alloc] init];
} else if (fileSize < 10 * GB) { // [6GB, 10GB)
strategySort = [[DMStrategyExternalSort alloc] init];
} else if (fileSize < 10 * GB) { // [10GB, 100GB)
strategySort = [[DMStrategyConcurrentExternalSort alloc] init];
} else { // [100GB, ~)
strategySort = [[DMStrategyMapreduceSort alloc] init];
}
[strategySort sort:filePath];
}
@end
经过拆分之后，每个类的代码都不会太多，每个类的逻辑都不会太复杂，代码的可读性、可维护性提高了。除此之外，将排序算法设计成独立的类，跟具体的业务逻辑（代码中的if-else那部分逻辑）解耦，也让排序算法能够复用。这一步实际上就是策略模式的第一步，也就是将策略的定义分离出来。
实际上，上面的代码还可继续优化，每种排序类都是无状态的，没必要在每次使用的时候都重新创建一个新的对象。所以，可以使用工厂模式对对象的创建进行封装。按照这个思路，对代码进行重构。重构之后的代码如下：
@interface DMStrategySortAlgFactory : NSObject
- (id<DMStrategySortAlg>)getStrategySortAlgByType:(NSString *)type;
@end
@interface DMStrategySortAlgFactory ()
@property (nonatomic, strong) NSMutableDictionary<NSString *, id<DMStrategySortAlg>> *sortAlgDict;
@end
@implementation DMStrategySortAlgFactory
- (id<DMStrategySortAlg>)getStrategySortAlgByType:(NSString *)type
{
id<DMStrategySortAlg> sortAlg = [self.sortAlgDict objectForKey:type];
return sortAlg;
}
- (NSMutableDictionary<NSString *,id<DMStrategySortAlg>> *)sortAlgDict
{
if (_sortAlgDict == nil) {
_sortAlgDict = [[NSMutableDictionary<NSString *, id<DMStrategySortAlg>> alloc] init];
DMStrategyQuickSort *quickSort = [[DMStrategyQuickSort alloc] init];
[_sortAlgDict setObject:quickSort forKey:@"DMQuickSort"];
DMStrategyExternalSort *externalSort = [[DMStrategyExternalSort alloc] init];
[_sortAlgDict setObject:externalSort forKey:@"DMExternalSort"];
DMStrategyConcurrentExternalSort *concurrentExternalSort = [[DMStrategyConcurrentExternalSort alloc] init];
[_sortAlgDict setObject:concurrentExternalSort forKey:@"DMConcurrentExternalSort"];
DMStrategyMapreduceSort *mapreduceSort = [[DMStrategyMapreduceSort alloc] init];
[_sortAlgDict setObject:mapreduceSort forKey:@"DMMapreduceSort"];
}
return _sortAlgDict;
}
@end
@interface DMStrategySorter : NSObject
@end
@implementation DMStrategySorter
- (void)sortFile:(NSString *)filePath
{
long GB = 1000 * 1000 * 1000;
NSFileManager *fileManager = [NSFileManager defaultManager];
NSError *error = nil;
unsigned long long fileSize = [fileManager attributesOfItemAtPath:filePath error:&error].fileSize;
id<DMStrategySortAlg> strategySort = nil;
DMStrategySortAlgFactory *sortAlgFactory =[[DMStrategySortAlgFactory alloc] init];
if (fileSize < 6 * GB) { // [0, 6GB)
strategySort = [sortAlgFactory getStrategySortAlgByType:@"DMQuickSort"];
} else if (fileSize < 10 * GB) { // [6GB, 10GB)
strategySort = [sortAlgFactory getStrategySortAlgByType:@"DMExternalSort"];
} else if (fileSize < 10 * GB) { // [10GB, 100GB)
strategySort = [sortAlgFactory getStrategySortAlgByType:@"DMConcurrentExternalSort"];
} else { // [100GB, ~)
strategySort = [sortAlgFactory getStrategySortAlgByType:@"DMMapreduceSort"];
}
[strategySort sort:filePath];
}
@end
进过上面两次重构之后，现在的代码实际上已经符合策略模式的代码结构了。通过策略模式将策略的定义、创建、使用解耦，让每一部分都不至于太复杂。不过DMStrategySorter类中的- (void)sortFile:(NSString *)filePath 方法还是有一堆if-else逻辑。这里的if-else逻辑分支不多、也不复杂，这样写完全没问题。但是如果特别想将if-else分支判断移除掉，也是有办法的。实际上这也是基于查表法来解决的，其中的”algs“就是表。代码如下：
@interface DMStrategySortAlgRange : NSObject
@property (nonatomic, assign) long minValue;
@property (nonatomic, assign) long maxValue;
@property (nonatomic, strong) NSString *sortAlgType;
- (BOOL)inRange:(long)fileSize;
@end
@implementation DMStrategySortAlgRange
- (BOOL)inRange:(long)fileSize
{
BOOL bFlag = NO;
if (fileSize >= self.minValue && fileSize < self.maxValue) {
bFlag = YES;
}
return bFlag;
}
@end
@interface DMStrategySorter : NSObject
@end
@interface DMStrategySorter ()
@property (nonatomic, strong) NSMutableArray<DMStrategySortAlgRange *> *algs;
@end
@implementation DMStrategySorter
- (void)sortFile:(NSString *)filePath
{
long GB = 1000 * 1000 * 1000;
NSFileManager *fileManager = [NSFileManager defaultManager];
NSError *error = nil;
unsigned long long fileSize = [fileManager attributesOfItemAtPath:filePath error:&error].fileSize;
id<DMStrategySortAlg> strategySort = nil;
DMStrategySortAlgFactory *sortAlgFactory =[[DMStrategySortAlgFactory alloc] init];
for (DMStrategySortAlgRange *sortAlgRange in self.algs) {
if ([sortAlgRange inRange:fileSize]) {
strategySort = [sortAlgFactory getStrategySortAlgByType:sortAlgRange.sortAlgType];
}
}
[strategySort sort:filePath];
}
- (NSMutableArray<DMStrategySortAlgRange *> *)algs
{
if (_algs == nil) {
long GB = 1000 * 1000 * 1000;
_algs = [[NSMutableArray<DMStrategySortAlgRange *> alloc] init];
{
// 快排
DMStrategySortAlgRange *sortAlgRange = [[DMStrategySortAlgRange alloc] init];
sortAlgRange.minValue = 0;
sortAlgRange.maxValue = 6 * GB;
sortAlgRange.sortAlgType = @"DMQuickSort";
[_algs addObject:sortAlgRange];
}
{
// 外部排序
DMStrategySortAlgRange *sortAlgRange = [[DMStrategySortAlgRange alloc] init];
sortAlgRange.minValue = 6 * GB;
sortAlgRange.maxValue = 10 * GB;
sortAlgRange.sortAlgType = @"DMExternalSort";
[_algs addObject:sortAlgRange];
}
{
// 多线程外部排序
DMStrategySortAlgRange *sortAlgRange = [[DMStrategySortAlgRange alloc] init];
sortAlgRange.minValue = 10 * GB;
sortAlgRange.maxValue = 100 * GB;
sortAlgRange.sortAlgType = @"DMConcurrentExternalSort";
[_algs addObject:sortAlgRange];
}
{
// 利用mapreduce多机排序
DMStrategySortAlgRange *sortAlgRange = [[DMStrategySortAlgRange alloc] init];
sortAlgRange.minValue = 100 * GB;
sortAlgRange.maxValue = LONG_MAX;
sortAlgRange.sortAlgType = @"DMMapreduceSort";
[_algs addObject:sortAlgRange];
}
}
return _algs;
}
@end
现在的代码实现更加优美了。把可变的部分隔离到了策略工厂类和DMStrategySorter类中。当要添加一个新的排序算法时，只需要修改策略工程类和DMStrategySorter中的部分代码，其他代码都不需要修改，这样就将代码改动最小化、集中化了。
