一. 设计原则
- 单一职责原则:
一个类只负责一个事件:UIView只负责事件传递和事件相应; CALayer负责视图展示和动画.- 依赖倒置原则:
抽象不应该依赖于具体实现, 具体实现可以依赖于抽象; 如上层业务调用应依赖定义的接口(如增删改查)- 开闭原则:
对修改关闭, 对扩展开放; 我们对类的定义要考虑扩展和灵活性- 里氏替换原则:
父类可以被子类无缝替换, 且原有功能不受任何影响; 比如KVO,当开始监听A类的变量时, 就会自动生成NSKVONotify_A子类, 系统自动指向NSKVONotify_A , 但对外暴露的还是在操作父类, 实际上系统内部是对子类的操作- 接口隔离原则:
使用多个专门的协议, 而不是一个庞大臃肿的协议, 协议中的方法应当尽量少; 如UITableViewDelegate/ UITableViewDataSource- 迪米特法则:
让每一个对象尽量少知道其他对象都有什么, 高内聚, 低耦合
二. 设计模式
- 责任链:
基础数据结构类中的一个成员变量的类型就是这个类本身- 桥接
- 适配器
- 单利
- 命令
1责任链:
基础数据结构类中的一个成员变量的类型就是这个类本身
参考
#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
#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
2 桥接
#import <Foundation/Foundation.h>
#import "BaseObjectB.h"
@interface BaseObjectA : NSObject
// 桥接模式的核心实现
@property (nonatomic, strong) BaseObjectB *objB;
// 获取数据
- (void)handle;
@end
#import "BaseObjectA.h"
@implementation BaseObjectA
/*
A1 --> B1、B2、B3 3种
A2 --> B1、B2、B3 3种
A3 --> B1、B2、B3 3种
*/
- (void)handle
{
// 默认实现
[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
#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
3 适配器模式
一个现有类需要适应变化的问题?
- 对象适配器
- 类适配器
- (void)request{
//适配逻辑
[被适配对象 某方法]
//适配逻辑
}
#import "Target.h"
@implementation Target
- (void)operation
{
// 原有的具体业务逻辑
}
@end
#import "Target.h"
// 适配对象
@interface CoolTarget : NSObject
// 被适配对象
@property (nonatomic, strong) Target *target;
// 对原有方法包装
- (void)request;
@end
#import "CoolTarget.h"
@implementation CoolTarget
- (void)request
{
// 额外处理
[self.target operation];
// 额外处理
}
@end
4 单利模式[安全写法]
#import "Mooc.h"
@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
5命令模式
命令模式是做行为化参数, 降低代码重合度
例如: 多个新闻页面都会有转发/评论/赞
#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
#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
#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
