第11章：设计模式

一、六大设计原则

     1、单一职责原则

一个类只负责一件事

     2、依赖倒置原则

抽象不应该依赖于具体实现，具体实现可以依赖于抽象。

     3、开放-关闭原则

对修改关闭，对扩展开放。比如常见的就是可继承，不可修改。

     4、里氏替换原则

父类可以被子类无缝替换，且原有功能不受任何影响。比如kvo的实现。

     5、接口隔离原则

使用多个专门协议、而不是一个庞大臃肿的协议，且协议中的方法应该尽量少。比如tableview的delegate、datasource

     6、迪米特法则

一个对象应该对其他对象有尽可能少的了解。这样就能做到高内聚、低耦合。

 

二、责任链模式

     1、首先看一个需求变更问题：原来业务的调用顺序是“业务A”=>“业务B”=>“业务C”，突然产品经理要求变成“业务C”=>“业务B”=>“业务A”，如何从技术的角度来动态调整以应对这种变化呢？使用责任链模式可以实现动态下发，这就解决了这个调用顺序动态调整问题。

     2、责任链的类构成：其实就是类A中有一个成员变量b，其类型也是类A。代码说明如下：

#import 

@class BusinessObject;
typedef void(^CompletionBlock)(BOOL handled);
typedef void(^ResultBlock)(BusinessObject *handler, BOOL handled);

@interface BusinessObject : NSObject

// 下一个响应者(响应链构成的关键)
@property (nonatomic, strong) BusinessObject *nextBusiness;
// 响应者的处理方法==我理解的是：这个函数由调用者调用，传入的block是调用者想要在业务处理完成时执行的动作，动作处理完成时会给handler和handled这两个参数来告诉block最后是谁处理的、是否处理完成
- (void)handle:(ResultBlock)result;

// 各个业务在该方法当中做实际业务处理==我理解的是：这个函数不应该对外公开，因为其由handle:调用，并且completion在handle:中也有固定的逻辑，如果外部调用的话handle:函数岂不是一点用处都没有，是个摆设！
- (void)handleBusiness:(CompletionBlock)completion;
@end
#import "BusinessObject.h"

@implementation BusinessObject

// 责任链入口方法
- (void)handle:(ResultBlock)result
{
    CompletionBlock completion = ^(BOOL handled){
        // 当前业务处理掉了，上抛结果
        if (handled) {
            result(self, handled);
        }
        else{
            // 沿着责任链，指派给下一个业务处理
            if (self.nextBusiness) {
                //我不理解的是责任链各节点之间如何传值，如果不能解决传值问题，那么岂不是前面的节点其处理一点意义都没有？那要他干嘛？？？？？？
                [self.nextBusiness handle:result];
            }
            else{
                // 没有业务处理, 上抛
                result(nil, NO);
            }
        }
    };
    
    // 当前业务进行处理
    [self handleBusiness:completion];
}

- (void)handleBusiness:(CompletionBlock)completion
{
    /*
     业务逻辑处理，如网络请求、本地照片查询等
     */
}
@end

 

三、桥接模式

     1、何为桥接模式？我理解的就是：建立类A和类B之间的一个依赖关系，不管类A的子类和类B的子类是如何组合的，他们都是建立在“类A和类B依赖关系”之上的，不需要再次建立依赖关系，最多只是建立新需求需要的新的A、B的子类。类关系图如下：

     代码说明如下：

@interface BaseObjectA : NSObject
		// 桥接模式的核心实现
		@property (nonatomic, strong) BaseObjectB *objB;
		// 获取数据
		- (void)handle;
		@end
		@implementation BaseObjectA
		- (void)handle
		{
		    // override to subclass
		    [self.objB fetchData];
		}
		@end

		@interface BaseObjectB : NSObject
		- (void)fetchData;
		@end
		@implementation BaseObjectB
		- (void)fetchData
		{
		    // override to subclass
		}
		@end

		//demo中调用代码如下
		// 创建一个具体的ClassA
    		_objA = [[ObjectA1 alloc] init];
    		// 创建一个具体的ClassB
    		BaseObjectB *b1 = [[ObjectB1 alloc] init];
    		// 将一个具体的ClassB1 指定给抽象的ClassB
    		_objA.objB = b1;
    		// 获取数据
    		[_objA handle];

     2、看一个业务解耦面试问题：一个列表上有三套网络数据，且列表在不同的地方使用的是不同的数据，那么设计来解耦“列表、数据”的对应关系呢，使得组合变更时业务以来逻辑动态适应？使用桥接模式即可。

 

四、适配器模式

     1、面试问题：一个现有类需要适应变化该怎么做？适配器模式解决。

     2、适配器分类

1）、对象适配器：比较常见。其类构成如下：

     “适配对象”的某个成员变量为“被适配对象”。适配对象将被适配对象适配后对外提供服务。

2）、类适配器

 

五、单例模式

     主要考察初中级人员。这个模式大家都会用，但是很多人不一定使用的完全正确。单例模式一定要会手写，完整的代码和注意事项如下：

@implementation Mooc
+ (id)sharedInstance
{
    // 静态局部变量
    static Mooc *instance = nil;
    
    // 通过dispatch_once方式 确保instance在多线程环境下只被创建一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 创建实例==此处通过super调用，因为此处用self的话，如果有人使用allocWithZone创建实例就会造成循环引用
        instance = [[super allocWithZone:NULL] init];
    });
    return instance;
}
// 重写方法【必不可少==原因是防止用户通过allocWithZone创建对象，而不使用单例】
+ (id)allocWithZone:(struct _NSZone *)zone{
    return [self sharedInstance];
}
// 重写方法【必不可少==原因是防止用户通过copyWithZone copy单例对象来创建对象，而不使用单例】
- (id)copyWithZone:(nullable NSZone *)zone{
    return self;
}
@end

 

六、命令模式

     命令模式是对行为进行参数化的一种设计模式，其作用是降低代码重合度。比如微博中很多页面都有“转发、评论、赞”，这三个操作就可以封装为命令模式，在不同的页面点击按钮时触发命令。代码如下：

#import 

@class Command;
typedef void(^CommandCompletionCallBack)(Command* cmd);

@interface Command : NSObject
@property (nonatomic, copy) CommandCompletionCallBack completion;

- (void)execute;
- (void)cancel;

- (void)done;
@end
#import "Command.h"
#import "CommandManager.h"
@implementation Command
- (void)execute{
    //override to subclass;
    [self done];
}
- (void)cancel{
    self.completion = nil;
}
- (void)done
{
    dispatch_async(dispatch_get_main_queue(), ^{
        if (_completion) {
            _completion(self);
        }
        //释放
        self.completion = nil;
        [CommandManager removeCommand:self];
    });
}
@end
#import 
#import "Command.h"
@interface CommandManager : NSObject
// 命令执行完成后从管理器中删除
+ (void)removeCommand:(Command *)cmd;
// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance;
// 执行命令
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion;
// 取消命令
+ (void)cancelCommand:(Command *)cmd;
@end
#import "CommandManager.h"
@interface CommandManager()
// 命令管理容器
@property (nonatomic, strong) NSMutableArray  *arrayCommands;
@end
@implementation CommandManager
// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance
{
    static CommandManager *instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[super allocWithZone:NULL] init];
    });
    return instance;
}
// 【必不可少】
+ (id)allocWithZone:(struct _NSZone *)zone{
    return [self sharedInstance];
}
// 【必不可少】
- (id)copyWithZone:(nullable NSZone *)zone{
    return self;
}
// 初始化方法
- (id)init
{
    self = [super init];
    if (self) {
        // 初始化命令容器
        _arrayCommands = [NSMutableArray array];
    }
    return self;
}
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion
{
    if (cmd) {
        // 如果命令正在执行不做处理，否则添加并执行命令
        if (![self _isExecutingCommand:cmd]) {
            // 添加到命令容器当中
            [[[self sharedInstance] arrayCommands] addObject:cmd];
            // 设置命令执行完成的回调
            cmd.completion = completion;
            //执行命令
            [cmd execute];
        }
    }
}
// 取消命令
+ (void)cancelCommand:(Command *)cmd
{
    if (cmd) {
        // 从命令容器当中移除
        [[[self sharedInstance] arrayCommands] removeObject:cmd];
        // 取消命令执行
        [cmd cancel];
    }
}
// 判断当前命令是否正在执行
+ (BOOL)_isExecutingCommand:(Command *)cmd
{
    if (cmd) {
        NSArray *cmds = [[self sharedInstance] arrayCommands];
        for (Command *aCmd in cmds) {
            // 当前命令正在执行
            if (cmd == aCmd) {
                return YES;
            }
        }
    }
    return NO;
}
// 命令执行完成后从管理器中删除
+ (void)removeCommand:(Command *)cmd
{
    if (cmd) {
        // 从命令容器当中移除
        [[[self sharedInstance] arrayCommands] removeObject:cmd];
        // 取消命令执行
        [cmd cancel];
    }
}
@end