美文网首页
iOS设计模式之策略模式下

iOS设计模式之策略模式下

作者: 点滴86 | 来源:发表于2024-06-21 16:17 被阅读0次

策略模式

策略模式的设计意图和应用场景。

问题与解决思路

假设有这样一个需求，希望写一个小程序，实现对一个文件进行排序的功能。文件中只包含整型数，并且，相邻的数字通过逗号来区隔。
这不是很简单吗，只需要将文件中的内容读取出来，并且通过逗号分隔成一个一个的数字，放到内存数组中，然后编写某种排序算法（比如快排），或者直接使用编程语言提供的排序函数，对数组进行排序，最后再将数组中的数据写入文件就可以了。
但是，如果文件很大呢》比如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中的部分代码，其他代码都不需要修改，这样就将代码改动最小化、集中化了。

相关文章

网友评论

      本文标题：iOS设计模式之策略模式下

      本文链接：https://www.haomeiwen.com/subject/hgxkcjtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|iOS设计模式之策略模式下|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！