iOS 设计模式

MVC

MVC全称Model-View-Controller，是Xerox PARC在20世纪80年代为编程语言Smalltalk－80发明的一种软件设计模式，至今已广泛应用于用户交互应用程序中。

• Model封装了应用程序的数据，并定义操控和处理该数据的逻辑和运算。 Model不允许与View打交道。当Model中的数据发生变化时，与之对应的视图应更新。

• View是应用程序中用户可以看见的对象。View不允许直接引用Modal， 它只能被Controller 所控制。视图对象知道如何将自己绘制出来，并可能对用户的操作作出响应。

• Controller在应用程序的一个或多个视图对象和一个或多个模型对象之间，控制器对象充当媒介。Model中的数据通过Controller传递给View显示， View 上产生的事件 （ 比如 Touch事件）需要通知 Controller将新的或更改过的数据传给Model。

常见的View向Controller通信的方法是：

1. 设置View对应的Action Target。如设置UIButton的Touch up inside的Action Target。
2. 设置View的Delegate，如UIAlertViewDelegate,
3. UIActionSheetDelegate，UITextFieldDelegate等。 设置View的data source,如UITableViewDataSource。

单例模式

概念

整个程序只有该类的一个实例，这个实例不能被重复创建。

实现

在iOS开发我们经常碰到只需要某类一个实例的情况，最常见的莫过于对硬件参数的访问类，比如UIAccelerometer.这个类可以帮助我们获得硬件在各个方向轴上的加速度，但是我们仅仅需要它的一个实例就够了，再多，只会浪费内存。

所以苹果提供了一个UIAccelerometer的实例化方法＋sharedAccelerometer,从名字上我们也能看出此方法让整个应用共享一个UIAccelerometer实例（PS：iOS 的开放中，我们往往能从方法名中就了解这个方法的作用），它内部的如何实现我们暂且不谈，先来看看还有哪些类同样使用了单例模式。

• UIApplication类提供了 ＋sharedAPplication方法创建和获取UIApplication单例
• NSBundle类提供了 +mainBunle方法获取NSBundle单例
• NSFileManager类提供了 ＋defaultManager方法创建和获得NSFileManager单例。（PS：有些时候我们得放弃使用单例模式，使用－init方法去实现一个新的实例，比如使用委托时）
• NSNotificationCenter提供了 ＋defaultCenter方法创建和获取NSNotificationCenter单例（PS：该类还遵循了另一个重要的设计模式：观察者模式）

等等，苹果的SDK中大量的遵循此设计模式，那么它的内部是如何实现的呢？

首先给大家介绍一下GCD技术，是苹果针对于多核CPU的多任务解决方案。你不需要了解更多，只需要知道是一组基于C语言开发的API。GCD提供了一个dispatch_once函数，这个函数的作用就是保证block里的语句在整个应用的生命周期里只执行一次。

OK，接下来就给出一个使用了单例模式新建和获取实例的类模版，代码如下：

//Singleton.h@interface Singleton : NSObject+ (Singleton *)sharedSingleton; //声明一个可以新建和获取单个实例对象的方法@end//Singleton.m#import "Singleton.h"@implementation Singleton    static Singleton *sharedSingleton = nil;//声明一个static类型的类变量+ (Singleton *)sharedSingleton{    static dispatch_once_t once;//声明一个只执行一次的任务    dispatch_once(&once,^{        sharedSingleton = [[self alloc] init];//调用dispatch_once执行该任务指定的代码块，在该代码块中实例化上文声明的类变量        //dosometing    });    return sharedSingleton;//返回在整个应用的生命周期中只会被实例化一次的变量}

OK，这就是iOS开发中单例模式的机制，下面我们就看看如何在实际开发中使用此模式？（PS：为了尽可能的突出核心内容，我们会对设计中的其他模式或内容一笔带过）

假如我们需要在iOS应用中实现分层的架构设计，即我们需要把数据的持久层，展示层，和逻辑层分开。为了突出重点，我们直接把目光转到持久层，而根据MVC的设计模式，我们又可以把持久层细分为DAO层（放置访问数据对象的四类方法）和Domain层（各种实体类，比如学生），这样就可以使用DAO层中的方法，配合实体类Domain层对数据进行清晰的增删改查。那么我们如何设计呢？

从使用者的角度看，我们期望获得DAO层的类实例，然后调用它的增删改查四大方法。可是这个类实例，我们似乎只需要一个就足够了，再多的话不利于管理且浪费内存。OK，我们可以使用单例模式了，代码如下：

//StudentDAO.h@interface StudentDAO:NSObject@property (nonatomic,strong) NSMutaleArray *StudentsInfo;+ (StudentDAO *)sharedStudentDAO;-(int) create:(Student*)student;-(int) remove:(Student*)student;-(int) modify:(Student*)student;-(NSMutaleArray) findAll;@end

//StudentDAO.m#import "StudentDAO.h"#import "Student.h"@implementation StudentDAOstatic StudentDAO *studentDao = nil;+ (StudentDAO)sharedStudentDAO{    static dispatch_once_t once;    dispatch_once(&once,^{        Student  *student1 = [[Student alloc]init];        student1.name = "MexiQQ";        student1.studentNum = "201200301101";        Student  *student2 = [[Student alloc]init];        student2.name = "Ricardo_LI";        student2.studentNum = "201200301102";        studentDao = [[self alloc] init];        studentDao._StudentsInfo = [[NSMutaleArray alloc]init];        [studentDao._StudentsInfo addObject:student1];        [studentDao._StudentsInfo addObject:student2];    });    return studentDao;}    //插入的方法-(int)create:(Student*)stu{    [self._StudentsInfo addObject:stu];    return 0;}    //删除的方法-(int)remove:(Student*)stu{    for(Student* s in self._StudentsInfo){        if([stu.studentNum isEqual:s.studentNum]){            [self._StudentsInfo removeObject:s]            break;        }    }}-(int)modify...... //省略不写-(NSMutaleArray)findAll...... //省略不写

观察者模式

概念

一个对象状态改变，通知正在对他进行观察的对象，这些对象根据各自要求做出相应的改变。

通知机制

如图所示，在通知机制中对某个通知感兴趣的所有对象都可以成为接受者。首先，这些对象需要向通知中心（NSNotificationCenter）发出addObserver:selector:name:object:消息进行注册，在投送对象投送通知送给通知中心时，通知中心就会把通知广播给注册过的接受者。所有的接受者不知道通知是谁投送的，不去关心它的细节。投送对象和接受者是一对多的关系。接受者如果对通知不再关注，会给通知中心发送removeObserver:name:Object:消息解除注册，以后不再接受通知。

新建一个Single view Project,对项目中的文件做以下修改：

// AppDelegate.m- (void)applicationDidEnterBackground:(UIApplication *)application {    [[NSNotificationCenter defaultCenter]postNotificationName:@"APPTerminate" object:self];}

////  ViewController.m//  TestNotification////#import "ViewController.h"@interface ViewController ()@end@implementation ViewController- (void)viewDidLoad {    [super viewDidLoad];    //注意此处的selector有参数，要加冒号    [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(doSomething:) name:@"APPTerminate" object:nil];    // Do any additional setup after loading the view, typically from a nib.}- (void)didReceiveMemoryWarning {    [super didReceiveMemoryWarning];    [[NSNotificationCenter defaultCenter]removeObserver:self];    // Dispose of any resources that can be recreated.}#pragma mark -处理通知-(void)doSomething:(NSNotification*)notification{    NSLog(@"收到通知");}@end

KVO机制

该机制下观察者的注册是在被观察者的内部进行的，不同于通知机制（由观察者自己注册），需要被观察者和观察者同时实现一个协议：NSKeyValueObserving，被观察者通过addObserver:forKeypath:options:context方法注册观察者，以及要被观察的属性。

新建一个single view project，同时新建一个继承自NSObject的TestWatche类。
对文件进行如下修改：

//  AppDelegate.h#import <UIKit/UIKit.h>#import <CoreData/CoreData.h>#import "TestWatche.h"@interface AppDelegate : UIResponder <UIApplicationDelegate>@property (strong, nonatomic) UIWindow *window;@property (readonly, strong, nonatomic) NSManagedObjectContext *managedObjectContext;@property (readonly, strong, nonatomic) NSManagedObjectModel *managedObjectModel;@property (readonly, strong, nonatomic) NSPersistentStoreCoordinator *persistentStoreCoordinator;@property (strong,nonatomic) NSString *state;@property (strong,nonatomic) TestWatche *watcher;- (void)saveContext;- (NSURL *)applicationDocumentsDirectory;@end

// AppDelegate.m- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {    // Override point for customization after application launch.    self.watcher = [TestWatche alloc];    [self addObserver:self.watcher forKeyPath:@"state" options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew context:@"pass content"];    self.state = @"launch";    return YES;}- (void)applicationDidEnterBackground:(UIApplication *)application {    self.state = @"backgroud";}

//  TestWatche.m#import "TestWatche.h"@implementation TestWatche-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{    NSLog(@"state change:%@",change);}@end

委托模式

个人认为委托模式大多数人解释的复杂了，其实就像是java中的接口，类可以实现或不实现协议（接口）中的方法。通过此种方式，达到最大的解耦目的，方便项目的扩展。不过你需要设置应用的委托对象，以确定协议中的方法为谁服务。

拿最常用的UITableViewDelegate UITableViewDataSource来举例：

实现一个页面有一个UItableView，UItableView的每一栏（cell）的数据由我们指定，那么我们该如何做呢？苹果也自然想到了这一点，于是定义了一个接口，这个接口有许多的方法，只需要我们把要服务的对象传进去，就可以使用这些方法了，这个接口就是委托和协议。而UITableViewDelegate 和 UITableViewDataSource 就是专为UITableView而写的委托和协议。

工厂模式

工厂方法模式：定义创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类。

使用场景

1.编译时无法准确预期要创建的对象的类；
2.类想让子类决定在运行时创建什么；
3.类有若干辅助类为其子类，而你想将返回哪个子类这一信息局部话；

具体实现

1.创建一个统一的父类MyTableViewCell，类型是UITableViewCell。它的初始化函数是：

-(id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier{    self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];    if (self) {    }    return self;}

2.定义MyTableViewCell的子类：MyBlueTableViewCell，MyBlackTableViewCell
3.在各个子类中重载父类的方法
在MyBlueTableViewCell中：

-(id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier{    self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];    if (self) {        self.backgroundColor = [UIColor blueColor];    }    return self;}

在MyBlackTableViewCell中：

-(id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier{    self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];    if (self) {        self.backgroundColor = [UIColor blackColor];    }    return self;}

在初始化MyBlueTableViewCell、MyBlackTableViewCell时，系统会执行相应类中的函数

MyBlueTableViewCell *blueCell = [[MyBlueTableViewCell alloc]initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"cellIdentifier"];MyBlackTableViewCell *blackCell = [[MyBlackTableViewCell alloc]initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"cellIdentifier"];

KVC模式

全称是Key-value coding，翻译成键值编码。顾名思义，在某种程度上跟map的关系匪浅。它提供了一种使用字符串而不是访问器方法去访问一个对象实例变量的机制。

例如一个Person对象有两个key：name， phone。然后有两个value分别对应name和 phone。key 只是一个字符串，它对应的值可以是任意类型的对象。从最基础的层次上看，KVC 有两个方法：一个是设置 key 的值，另一个是获取 key 的值。

- (void) changePhone:(Person*)person{    // get number    NSString *oldPhone = [person valueForKey:@"phone"];    // set number    [person setValue:@"13800138000" forKey:@"phone"];}

如果给Person增加一个Key : spouse , spouse也是一个Person类型的对象，从Person中提取ta的spouse的name :

void logMarriage(Person *p){    NSString *personsName = [p valueForKey:@"name"];    NSString *spousesName = [p valueForKeyPath:@"spouse.name"];    NSLog(@"%@ is happily married to %@", personsName, spousesName);}

【参考文献】
[1] 《iOS开发——设计模式那点事》
[2] 《 iOS设计模式-工厂方法》
[3] 《KVC 与 KVO 理解》