创建型设计模式在iOS中的实践
一、单例模式
单例模式的定义与特点
单例（Singleton）模式的定义：指一个类全局只有一个实例，且该类能自行创建这个实例的一种模式。
单例模式有 3 个特点：
- 单例类只有一个实例对象；
- 该单例对象必须由单例类自行创建；
- 单例类对外提供一个访问该单例的全局访问点；
单例模式的结构与实现
单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。
下面来分析其基本结构和实现方法。
单例模式的结构
单例模式的主要角色如下。
- 单例类：包含一个实例且能自行创建这个实例的类。
- 访问类：使用单例的类。
单例模式在Objective-C中的设计
[UIApplication sharedApplication]-
[NSUserDefaults standardUserDefaults];
这是OC里良好设计的一个具体例子
创建属于自己的单例
创建的单例应该满足以下要求:
- 全局唯一
- 线程安全
- 性能开销小
我们将采用GCD来创建单例
.h文件
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface CLSingleton : NSObject
+ (instancetype)shareSingleton;
@end
NS_ASSUME_NONNULL_END
.m文件
#import "CLSingleton.h"
@interface CLSingleton()
@end
static CLSingleton *singleton = nil;
@implementation CLSingleton
+ (instancetype)shareSingleton
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
singleton = [[CLSingleton alloc] init];
});
return singleton;
}
+ (id)allocWithZone:(struct _NSZone *)zone{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
singleton = [super allocWithZone:zone];
});
return singleton;
}
- (nonnull id)copyWithZone:(nullable NSZone *)zone {
return singleton;
}
- (nonnull id)mutableCopyWithZone:(nullable NSZone *)zone {
return singleton;
}
@end
在iOS具体开发中的作用
- 提供全局的缓存数据的保存和访问入口（如token、username等）
- 提供全局状态的监听
- 避免创建大量重复的对象（如网络访问的管理类）
二、原型模式
原型模式的定义与特点
原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。
原型模式的结构与实现
模式的结构
原型模式包含以下主要角色。
- 抽象原型类：规定了具体原型对象必须实现的接口。
- 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
- 访问类：使用具体原型类中的 clone() 方法来复制新的对象。
原型模式在Objective-C中的设计
NSString *str = @"abc";
NSString *astr = [str copy];
@protocol NSCopying
- (id)copyWithZone:(nullable NSZone *)zone;
@end
@protocol NSMutableCopying
- (id)mutableCopyWithZone:(nullable NSZone *)zone;
@end
创建属于自己的原型
.h
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface CLPerson : NSObject<NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonnull,nonatomic,copy) NSString *pID;
@property (nonatomic, assign) NSUInteger age;
@end
NS_ASSUME_NONNULL_END
.m
#import "CLPerson.h"
@implementation CLPerson
- (instancetype)init
{
self = [super init];
if (self) {
self.name = @"abc";
self.pID = @"123456";
self.age = 15;
}
return self;
}
- (id)copyWithZone:(NSZone *)zone
{
CLPerson *person = [[[self class] alloc] init];
person.age = self.age;
person.name = self.name;
person.pID = self.pID;
return person;
}
@end
在iOS具体开发中的作用
- 提供复杂对象的快速创建（如具有包含多层嵌套对象的属性的对象的创建）
- 提供向局域外传递和使用对象的方式（如
[block copy]）
三、工厂模式
模式的定义与特点
工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。
我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。工厂方法模式的主要优点有：
- 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
其缺点是：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
模式的结构与实现
在典型的工厂方法模式由工厂和产品2个要素构成。根据单一职责原则，工厂负责创建产品，产品则负责被使用。本节来分析其基本结构和实现方法。
模式的结构
工厂方法模式的主要角色如下。
- 工厂（Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
- 产品（Product）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
工厂模式在Objective-C中的设计
在讲工厂模式的代表设计之前，需要了解下OC中的类簇这个概念
在这里不具体展开，可以参考以下这篇文章：类簇(class cluster)
言归正传，我们将通过NSString来看看什么是工厂模式
const char *cr = "bbc";
NSString *astr = [NSString stringWithCString:cr encoding:NSUTF8StringEncoding];
NSLog(@"%@,%@",[@"abc" class],[astr class]);
__NSCFConstantString,NSTaggedPointerString
可以看出来，NSString是一个类簇，这是一个抽象类，它提供了各种子类的创建方法，但外部统一通过NSString来调用，并且所有的子类都可以使用NSString对外提供的一系列实例方法。
NSLog(@"%@,%@",[str substringFromIndex:1],[astr substringFromIndex:1]);
bc,bc
比较有意思的是，NSString既是工厂string factory，又是产品string的抽象类
关于工厂的自定义创建，我将在下一节结合抽象工厂模式再进行具体的演示
四、抽象工厂模式
模式的定义与特点
抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
使用抽象工厂模式一般要满足以下条件。
- 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
- 系统一次只可能消费其中某一族产品，即同族的产品一起使用。
抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。
- 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
- 当增加一个新的产品族时不需要修改原代码，满足开闭原则。
抽象工厂模式的结构与实现
模式的结构
抽象工厂模式的主要角色如下。
-
抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。 -
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。 -
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。 -
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。
抽象工厂模式与工厂模式的异同
相同点：
- 都属于创建型模式
- 都能够实现创建和使用分离
不同点：
- 工厂模式用于创建同一种类的不同等级（或款式）的产品，而抽象工厂模式用于创建不同种类的产品。例如，如果轮胎是一个抽象的产品类，那么自行车轮胎、摩托车轮胎和汽车轮胎就是不同款式的产品；但如果认为汽车轮胎是抽象类，那么米其林轮胎和普利司通轮胎就是不同款式的产品。
- 工厂模式可以直接生产产品，抽象工厂模式需要通过抽象工厂先创建工厂，再生产产品，可以简单理解为，抽象工厂是工厂模式的二次工厂化
抽象工厂模式在Objective-C中的设计
用工厂模式创建了一个NSNumber
NSNumber *num = [NSNumber numberWithBool:YES];
用抽象工厂模式依次创建了NSString、NSInteger、CGFloat
NSString *str = num.stringValue;
NSInteger i = num.integerValue;
CGFloat f = num.floatValue;
创建属于自己的工厂、抽象工厂模式
值得说明的是，因为OC的动态性，可以只用创建一个抽象工厂类，即可实现一套方法创建不同种类不同款式的产品
1、设定两类抽象产品（产品族）：宝马汽车类和许可类
2、设定具体的产品（产品系列）：3系，5系，7系，汽车许可
3、设定抽象工厂
文件目录如下：
BMWCar.h
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface BMWCar : NSObject
- (NSString *)carName;
@end
@interface BMWCar3Series : BMWCar
@end
@interface BMWCar5Series : BMWCar
@end
@interface BMWCar7Series : BMWCar
@end
NS_ASSUME_NONNULL_END
BMWCar.m
#import "BMWCar.h"
@implementation BMWCar
- (BOOL)isKindOfClass:(Class)aClass
{
if (!aClass) {
return NO;
}
Class cls = self.class;
while (cls != aClass) {
cls = [cls superclass];
if (cls == NSObject.class) {
return NO;
}
}
return YES;
}
- (NSString *)carName
{
return [[self class] description];
}
@end
@implementation BMWCar3Series
@end
@implementation BMWCar5Series
@end
@implementation BMWCar7Series
@end
Lisence.h
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface Lisence : NSObject
- (NSInteger)lisenceNumber;
@end
@interface CarLisence : Lisence
@end
NS_ASSUME_NONNULL_END
Lisence.m
#import "Lisence.h"
@implementation Lisence
- (BOOL)isKindOfClass:(Class)aClass
{
if (!aClass) {
return NO;
}
Class cls = self.class;
while (cls != aClass) {
cls = [cls superclass];
if (cls == NSObject.class) {
return NO;
}
}
return YES;
}
- (NSInteger)lisenceNumber
{
return [[self class] hash];
}
@end
@implementation CarLisence
@end
Factory.h
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface Factory : NSObject
- (id)make:(NSString *)clsName;
@end
NS_ASSUME_NONNULL_END
Factory.m
#import "Factory.h"
@implementation Factory
- (id)make:(NSString *)clsName
{
if (clsName) {
Class cls = NSClassFromString(clsName);
return [[cls alloc] init];
}
return nil;
}
@end
调用：
Factory *fac = [[Factory alloc] init];
BMWCar7Series *car = [fac make:NSStringFromClass(BMWCar7Series.class)];
CarLisence *lis = [fac make:NSStringFromClass(CarLisence.class)];
NSLog(@"%@,%ld",car.carName,lis.lisenceNumber);
结果：
MainProject[55135:11368132] BMWCar7Series,4408563744
在iOS具体开发中的作用
- 提供快捷创建实例对象的方法，而不必关心具体的创建细节
- 提供复杂对象的创建和使用分离的方法，便于解耦（路由常用的方法）
五、建造者模式
模式的定义与特点
建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
该模式的主要优点如下：
- 各个具体的建造者相互独立，有利于系统的扩展。
- 客户端不必知道产品内部组成的细节，便于控制细节风险。
其缺点如下：
- 产品的组成部分必须相同，这限制了其使用范围。
- 如果产品的内部变化复杂，该模式会增加很多的建造者类。
建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。
模式的结构与实现
建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。
模式的结构
建造者（Builder）模式的主要角色如下。
-
产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个滅部件。 -
抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。 -
具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。 -
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。
建造者模式在Objective-C中的设计
事实上，在OC里，UITableViewController就实现了建造者（Builder）模式。我们看下UITableViewController的头文件：
@property (nonatomic, strong, null_resettable) UITableView *tableView;
@property (nonatomic) BOOL clearsSelectionOnViewWillAppear NS_AVAILABLE_IOS(3_2); // defaults to YES. If YES, any selection is cleared in viewWillAppear:
@property (nonatomic, strong, nullable) UIRefreshControl *refreshControl NS_AVAILABLE_IOS(6_0) __TVOS_PROHIBITED;
当在其他页面调用创建方法- (instancetype)initWithStyle:(UITableViewStyle)style的时候，就会自动建造UITableView和UIRefreshControl这两个部件实例，建造完毕后，统一返回UITableViewController这个实例对象
