设计模式

设计模式

设计模式(遵循六大设计原则)

• 责任链
• 桥接
• 适配器
• 单例
• 命令

六大设计原则

• 单一职责原则
• 开闭原则
• 接口隔离原则
• 依赖倒置原则
• 里氏替换原则
• 迪米特法则

单一职责原则

• 一个类只负责一件事(UIView与CALayer)

开闭原则

• 对修改关闭、对扩展开放

接口隔离原则

• 使用多个专门的协议、而不是一个庞大臃肿的协议(如TableView的dataSource和deletegate)

依赖倒置原则

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

里氏替换原则(KVO)

• 父类可以被子类无缝替换，且原有功能不受任何影响

迪米特法则

• 一个对象应当对其他对象有尽可能少的了解
• 高内聚、低耦合

责任链(系统：事件响应机制)

• 一个关于需求变更的问题

代码实现

• .h文件

#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

• .m文件

#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

类构成

桥接

一个关于业务解耦的问题

类构成

代码

• BridgeDemo.h文件

#import <Foundation/Foundation.h>

@interface BridgeDemo : NSObject

- (void)fetch;

@end

• BridgeDemo.m文件

#import "BridgeDemo.h"

#import "BaseObjectA.h"
#import "BaseObjectB.h"

#import "ObjectA1.h"
#import "ObjectA2.h"

#import "ObjectB1.h"
#import "ObjectB2.h"

@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

• BaseObjectA.h文件

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

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

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

@end

• BaseObjectA.m文件

#import "BaseObjectA.h"

@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

适配器

• 一个现有类需要适应变化的问题
• 对象适配器(常见的)
• 类适配器

类构成(对象适配器)

- (void)request{
//适配逻辑
[被适配对象 某方法]
//适配逻辑
}

代码

• Target.h

#import <Foundation/Foundation.h>

@interface Target : NSObject

- (void)operation;

@end

• Target.m

#import "Target.h"

@implementation Target

- (void)operation
{
    // 原有的具体业务逻辑
}

@end

• CoolTarget.h

#import "Target.h"

// 适配对象
@interface CoolTarget : NSObject

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

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

@end

• CoolTarget.m

#import "CoolTarget.h"

@implementation CoolTarget

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

@end

单例

• 你可能用的并不正确的模式

+ (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:(struct _NSZone *)zone
{
return self;
}

命令模式

• 行为参数化
• 降低代码重合度

代码

• Command.h

#import <Foundation/Foundation.h>

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

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

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

- (void)done;

@end

• Command.m

#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

• CommandManager.h

#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

• CommandManager.m

#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

设计模式面试总结

• 请手写单例实现？(dispatch_once,allocWithZone,copyWithZone)
• 你都知道哪些设计原则，请谈谈你的理解。
• 能否用一幅图简单的表示桥接模式的主体结构。
• UI事件传递机制是怎样的？你对其中运用到的设计模式是怎样理解的？