设计模式.png

一、六大设计原则

• 单一职责原则：一个类只负责一件事

• 依赖倒置原则：抽象不该依赖于具体实现，具体实现可以依赖抽象

• 开闭原则：对修改关闭，对扩展开放

• 里氏替换原则：父类可以被子类无缝替换，且原有功能不受影响（例如：KVO）

• 接口隔离原则：使用多个专门的协议、而不是一个庞大臃肿的协议（例如：UITableViewDelegate,UITableViewDataSource）

• 迪米特法则：一个对象应当对其他对象尽可能少的了解（高内聚、高耦合）

关于设计原则可以看这篇文章面向对象设计的六大设计原则（附 Demo 及 UML类图）

二、责任链模式

主要思想：对象引用了同一类型的另一个对象，形成一条链。链中的每个对象实现了相同的方法，处理对链中第一个对象发起的同一请求，如果一个对象不知道如何处理，就把请求传给下一个响应器。

代码示例：

@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
{
  /*
    业务逻辑处理
    如网络请求、本地照片查询等
    */
}
​
@end

三、桥接模式

桥接模式的目的是把抽象层次结构从其实现中分离出来，使其能够独立变更。

1363078-98ccc9b19a331319.png

Class A 和ClassB都是抽象类。ClassA中一个成员变量是ClassB的对象。ClassB中作为抽象类，只提供了默认的接口，并没有实现。B1、B2、B3是ClassB的三个子类，重写父类的接口方法，提供不同的实现，此时对于ClassB使用方来说，是感知到不使用了哪个实现。ClassA中有一个handle处理方法，默认调用成员变量ClassB对象中的接口方法。A1、A2、A3三个是ClassA的子类，对于子类来说可以覆写父类的handle方法，做一些自定义的操作。

代码示例： ClassA

#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
{
  // override to subclass
  // 处理objB中的方法。
  [self.objB fetchData];
}
​
@end

ClassA的子类A1、A2、A3重写父类中handle方法。

#import "ObjectA1.h"
​
@implementation ObjectA1
​
- (void)handle
{
  // before 业务逻辑操作

  [super handle];

  // after 业务逻辑操作
}
@end

ClassB 实现

#import <Foundation/Foundation.h>
​
@interface BaseObjectB : NSObject
​
- (void)fetchData;
​
@end

#import "BaseObjectB.h"
​
@implementation BaseObjectB
// 默认逻辑实现
- (void)fetchData
{
  // override to subclass
}
@end

ClassB的子类进行具体的逻辑实现。

#import "ObjectB1.h"
​
@implementation ObjectB1
​
- (void)fetchData{
  // 具体的逻辑处理
}
@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

使用方中定义了ClassA对象，可以使用A1、A2、A3来创建不同的对象，获取不同的实现组合。BaseObjectB也可以有不同的实现组合。通过桥接模式不同的组合可以实现对象之间的解耦。

桥接模式的优点：

• 分离抽象接口及其实现部分。

• 桥接模式有时类似于多继承方案，但是多继承方案违背了类的单一职责原则（即一个类只有一个变化的原因），复用性比较差，而且多继承结构中类的个数非常庞大，桥接模式是比多继承方案更好的解决方法。

• 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。

• 实现细节对客户透明，可以对用户隐藏实现细节。

四、适配器

适配器模式(Adapter Pattern)：将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。

本节主要学习对象适配器模式，简单的类结构如下。

1363078-6c858d3c2443e4d1.png

适配对象中一个成员变量指向被适配对象。

示例代码：类Target是被适配对象，CoolTarget为适配对象。

Target类

#import <Foundation/Foundation.h>
​
@interface Target : NSObject
​
- (void)operation;
​
@end

#import "Target.h"
​
@implementation Target
​
- (void)operation
{
  // 原有的具体业务逻辑
}
​
@end

CoolTarget类：

#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

适配器优点：

• 将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。

• 增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。

• 灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。

三、单例

单例模式(SingletonPattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

示例代码：

@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

注意点：为了防止使用者创建对象，需要从重写两个方法allocWithZone和copyWithZone:。另外instance = [[super allocWithZone:NULL] init];需要使用super方法调用防止在第一创建时循环调用。

四、命令模式

命令模式(CommandPattern)：将一个请求封装为一个对象，从而使我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。

代码实例：一个命令对象和一个命令管理者。

Command

@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

CommandManager
可以用CommandManager保证任务的顺序执行，使用一个正在执行任务数组和一个等待执行任务数组，可以参考SDWebImage图片下载思路

#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

命令模式的优点

• 降低系统的耦合度。

• 新的命令可以很容易地加入到系统中。

• 可以比较容易地设计一个命令队列和宏命令（组合命令）。

• 可以方便地实现对请求的Undo和Redo。