09-进阶之路-设计模式和六大设计原则

1.六大设置原则

学习链接

1. 单一职责原则
   一个类只负责一件事，诸如UIView和Calayer
2. 开闭原则
   对修改关闭，对扩展开放。诸如定义一个类，尽量考虑以后迭代的考虑。
3. 接口隔离原则
   使用多个专门的协议，不是一个。诸如UITableview的delegate和。UITableViewDataSource
4. 依赖倒置原则
   抽象不应该依赖具体实现，具体实现可以依赖抽象
5. 里氏替换原则（子类不影响父类）
   父类可以被子类无缝替换。诸如KVO
6. 迪米特法则（高内聚，低耦合）
   一个对象对另一个对象尽可能少的了解。

2.责任链模式

任务执行顺序可以很方便的更改

#import <Foundation/Foundation.h>

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

@interface BusinessObject : NSObject

// 下一个响应者(响应链构成的关键)
@property (nonatomic, strong) BusinessObject *nextBusiness;
// 响应者的处理方法
- (void)handle:(ResultBlock)result;

// 各个业务在该方法当中做实际业务处理
- (void)handleBusiness:(CompletionBlock)completion;
@end
//----------------------实现文件--------------------
@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
{
    /*
     业务逻辑处理
     如网络请求、本地照片查询等
     */
//    NSLog(@"  如网络请求、本地照片查询等");
}

@end
//----------------------使用--------------------
//aBusinessObject集成 BusinessObject 重写handleBusiness 方法
    BusinessObject *Aobject = [[aBusinessObject alloc] init];
    BusinessObject *Bobject = [[bBusinessObject alloc] init];
    BusinessObject *Cobject = [[cBusinessObject alloc] init];
    Aobject.nextBusiness = Bobject;
    Bobject.nextBusiness = Cobject;
    NSLog(@"%@  %@  %@",Aobject,Bobject,Cobject);

    [Aobject handle:^(BusinessObject *handler, BOOL handled) {
        NSLog(@"处理完成~~~~~~~~ %@  %d",handler,handled);

    }];

3.桥接的模式

解耦，

image

#import <Foundation/Foundation.h>
#import "BaseObjectB.h"
@interface BaseObjectA : NSObject

// 桥接模式的核心实现
@property (nonatomic, strong) BaseObjectB *objB;

// 获取数据
- (void)handle;

@end

//----------------------实现文件--------------------
@implementation BaseObjectA

 /*
    A1 --> B1、B2、B3         3种
    A2 --> B1、B2、B3         3种
    A3 --> B1、B2、B3         3种
  */
- (void)handle
{
    // override to subclass
    
    [self.objB fetchData];
}

@end
//------------------------------------------
#import <Foundation/Foundation.h>

@interface BaseObjectB : NSObject

- (void)fetchData;

@end
//-------------------实现-----------------------
#import "BaseObjectB.h"

@implementation BaseObjectB

- (void)fetchData
{
    // override to subclass
}

@end

//-------------------使用现-----------------------

@interface BridgeDemo()
@property (nonatomic, strong) BaseObjectA *objA;
@end

@implementation BridgeDemo

/*
 根据实际业务判断使用那套具体数据
 A1 --> B1、B2、B3         3种
 A2 --> B1、B2、B3         3种
 A3 --> B1、B2、B3         3种
 */
- (void)fetch
{
    // 创建一个具体的ClassA
    _objA = [[ObjectA1 alloc] init];
    
    // 创建一个具体的ClassB
    BaseObjectB *b1 = [[ObjectB1 alloc] init];
    // 将一个具体的ClassB1 指定给抽象的ClassB
    _objA.objB = b1;
    
    // 获取数据
    [_objA handle];
}

@end

4.适配器模式

对原有代码不用调整

// 适配对象
@interface CoolTarget : NSObject

// 被适配对象
@property (nonatomic, strong) Target *target;

// 对原有方法包装
- (void)request;

@end
//--------------------------------------
@implementation CoolTarget

- (void)request {
    // 额外处理
    [self.target operation];
    // 额外处理
}
@end

5.单例模式

@implementation Mooc

+ (id)sharedInstance
{
    // 静态局部变量
    static Mooc *instance = nil;
    
    // 通过dispatch_once方式 确保instance在多线程环境下只被创建一次
    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;
}

@end

6.命令模式

行为参数化、降低代码重合度
需要一个管理者和一个命令（继承使用）

#import <Foundation/Foundation.h>
#import "Command.h"
@interface CommandManager : NSObject
// 命令管理容器
@property (nonatomic, strong) NSMutableArray <Command*> *arrayCommands;

// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance;

// 执行命令
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion;

// 取消命令
+ (void)cancelCommand:(Command *)cmd;

@end
//---------------------------------------
#import "CommandManager.h"

@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;
}
@end
//----------------------------------------------
@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 sharedInstance].arrayCommands removeObject:self];
    });
}

@end
//---------------------使用-------------------------
//Command 采用继承重写 execute 的方式
    Command *command1 = [[Command alloc] init];
    Command *command2 = [[Command alloc] init];
    Command *command3 = [[Command alloc] init];
    
    [CommandManager executeCommand:command1 completion:^(Command *cmd) {
        NSLog(@"1");
    }] ;
    
    [CommandManager executeCommand:command2 completion:^(Command *cmd) {
           NSLog(@"2");
    }] ;
    
    [CommandManager executeCommand:command3 completion:^(Command *cmd) {
           NSLog(@"3");
    }] ;