设计模式（四）--代理设计模式

官方给出的定义

为其他对象提供一种代理以控制对这个对象的访问

通俗讲一个例子，同学A给同学B送东西，但是同学A临时有事去不了，这时同学A需要找了另外同学C帮他去送东西，我们就说C是A的代理，送东西这件事就是他们之间的协议

组成部分：
1、协议：用来指定代理双方要做什么事情（送东西）
2、代理：根据指定的协议，完成协议规定的事情（同学C）
3、委托：根据指定的协议，指定代理去完成的事情（同学A）

具体代理模式的实现

1、定义一个协议

#import <Foundation/Foundation.h>
@protocol DelegateProtocol <NSObject>
- (void)doSomething;
@end

2、定义委托类,并为其设置一个遵守协议的代理

#import <Foundation/Foundation.h>
#import "DelegateProtocol.h"
@interface StudentA : NSObject
@property(nonatomic,weak)id<DelegateProtocol> delegate;
@end
---------------------
#import "StudentA.h"
@implementation StudentA

@end

3、定义代理类，使其实现协议的方法

#import <Foundation/Foundation.h>
#import "DelegateProtocol.h"
@interface StudentC : NSObject<DelegateProtocol>

@end
------------

#import "StudentC.h"

@implementation StudentC
- (void)doSomething{
    NSLog(@"送东西");
}
@end

4、逻辑实现

#import "ViewController.h"
#import "StudentA.h"
#import "StudentC.h"
@interface ViewController ()
@property(strong,nonatomic)StudentA *stuA;
@property(strong,nonatomic)StudentC *stuC ;
@end
@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    self.stuA= [[StudentA alloc]init];
    self.stuC =[[StudentC alloc]init];
    //同学A的代理是同学C
    self.stuA.delegate = self.stuC;
    //判断代理对象是否实现协议方法
    if ([self.stuA.delegate respondsToSelector:@selector(doSomething)]) {
        //同学A的代理（C同学）调用其协议方法
        [self.stuA.delegate doSomething];
    }
}
@end

代理使用原理

其本质就是对象内存的传递和操作，在委托类（同学A）设置代理对象（同学C）后，实际上只是用一个id类型的指针将代理对象（同学C）进行了一个弱引用，委托类（同学A）让代理（同学C）执行协议，实际上就是在委托类（同学A）中向这个id类型指针指向的对象发送消息，而这个id类型指针指向的对象就是代理对象（同学C）

代理内存管理

一般定义属性的关键字都是strong，在设置代理的时候，strong会造成强引用，必定会影响一个对象的生命周期，最后无法释放

关于weak个assign，通过这俩种关键字修饰的指针变量，都不会改变被引用对象的引用计数，但是一个对象被释放后，weak会自动指向nil，而assign则不会，在iOS中，向nil发消息时不会导致崩溃，而assign则会导致野指针的错误

代理和block的区别

• 相同点
  都可以理解成回调函数，当某件事情发生时候执行一段事件
• 不同点
  1、delegate用于重量级的回调，方法的声明和实现是分开的，看起来不是很连贯
  2、 block用轻量级的回调，能够直接访问上下文，代码结构比较连贯
  3、block容易造成循环引用，delegate则不会