类与类之间的通信我们有很多种方式，iOS中有代理，通知，block，单例类等等，每种方式都有其适用的场景
假设委托者皇上发起一个委托事件 要吃饭，这个事件的参数是今天要吃红烧肉，水煮鱼，肉末茄子，最终做饭这件事会被代理者实施，厨师甲做红烧肉，厨师乙做水煮鱼，厨师丙做肉末茄子
在iOS开发中面对上面这个需求，我们肯定能想到用通知模式来实现这个逻辑。其实更好的做法是使用多播代理模式
- 用通知的方式实现：用大喇叭广播：“皇上要吃饭了，并且要吃红烧肉，水煮鱼，肉末茄子”，虽然厨师甲乙丙听到之后就会开始去做给皇上做菜，但是这广播出去全城的人都知道了，这种消息传递方式会造成消息外露，不受控制；
- 用多播代理的方式实现：皇上通过吃饭总管告诉厨师甲乙丙它要吃饭了，甲乙丙收到消息后就去给皇上做菜了，这种消息传递很精准，并且不会导致消息外露。
一. 为什么不用通知
通知是一种零耦合的类之间通信方式，它的优点就是能够完全解耦，然而除了这个优点，通知也有不少值得吐槽的地方：
- 通知的接收范围为全局，这可能会暴露你原本想隐藏的实现细节，比如你封装的SDK中发出的通知，通知参数中包含敏感信息等；
- 通知的匹配完全依赖字符串，容易出现问题，当项目中大量使用通知以后难以维护，极端情况会出现通知名重复的问题；
- 相对于代理方式，通知不能像代理一样使用协议来
约束代理者的方法实现； - 通知携带的参数不能直观的表达出来，依靠字典操作也增加的出错的可能性，通知不能像代理方法那样有返回值；
- 通知参数传递对于基本类型需要
装箱和拆箱操作，不能传递nil参数； - 通知有时候会打破
高内聚低耦合中的高内聚的原则，对于原本就有单向依赖的2个类来说，他们是有内聚耦合关系的，使用通知反而将这种内聚关系打散了，并且不利于方法调试；
二. 多播代理的思想
在C#语言中就有这样一个概念叫做多播委托，它直接是针对对象的某个委托事件的代理，委托对象内部保存了所有代理实现(指针)，构成一个委托链，当这个委托事件触发的时候这个委托链上的所有实现方法都将被调用。iOS中的多代理概念雷同，其实就是委托对象中保持多个代理对象的引用，当触发事件的时候，让所有的代理对象调用相应的代理方法即可。
三. OC中构造多播代理
-
1.存储多个代理
遵循iOS常规代理的实现，我们需要一 个能够保存多个对象弱引用的结构，iOS中可以用多种方式实现，这里我推荐使用NSHashTable这个容器类，它可以指定加入到其中的对象为弱引用，并且当其中的对象被释放以后，该对象将会被自动从容器中移除掉
NSHashTable *delegates = [NSHashTable hashTableWithOptions:NSPointerFunctionsWeakMemory];
[delegates addObject:delegate];
-
2.遍历多代理，执行代理方法
当NSHashTable中的对象释放以后，会被从中自动移除(经测试hashTable的count并没有变)，我们遍历的时候就不会遍历到该nil对象
for (id<MyDelegate> delegate in _delegates) {
if ([delegate respondsToSelector:@selector(receiveMessage:)]) {
[delegate receiveMessage:@"a new message"];
}
}
-
3.设置(添加)代理
对于多代理我们只能用添加的方式，不能用直接赋值的方式
MyService *servie = [MyService new];
[servie addDelegate:self];
四. 简化多代理调用
上面实现的多代理调用出的四行代码都必不可少，如果一个类中有很多出代理方法的调用，那么我们就不得不写很多这样的代码，没得商量，这点必须要改进。改进方式有很多，使用方法转发应该是比较理想的方式
-
1.触发方法转发
[((id<MyDelegate>)self) receiveMessage:@"a new message"];
说明：这里self是指委托类，因为self本身没有遵循MyDelegate协议，所有如果需要调用receiveMessage方法就先把它强制转换为代理类型，调用方法后，self类中必然找不到receiveMessage方法，于是就会进入到方法转发流程，最终调用代理对象的方法。也许你会说这里可以继承协议然后调用处就不用这样麻烦的类型转换了，但是有一点你需要想到，如果协议中包含了
@required修饰的方法，我们就必须实现它了，否则编译器会爆出警告；
-
2.重写方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
for (id delegate in _delegates) {
if ([delegate respondsToSelector:aSelector]) {
NSMethodSignature *result = [delegate methodSignatureForSelector:aSelector];
if (result) {
return result;
}
}
}
return [super methodSignatureForSelector:aSelector];
}
说明：方法签名只是用来表示方法的参数个数，参数类型，和返回值类型的作用，所有的代理对象实现的同名代理方法签名都一样，遍历找到立即返回即可
-
3.重写转发方法
// 方法转发
- (void)forwardInvocation:(NSInvocation *)invocation {
SEL selector = invocation.selector;
for (id delegate in _delegates) {
if ([delegate respondsToSelector:selector]) {
invocation.target = delegate;
[invocation invoke];
}
}
}
说明：这里的invocation的target的值是当前类实例对象(委托者)，我们需要把这个值替换为delegate(代理者)，意思就是让delegate去执行该方法；
-
五. 最佳实践
第四节中我们在当前的委托类中通过调用自身并不存在的方法触发了方法转发，实现了封装遍历多代理调用代理方法的目的，但是这种方式有以下问题：
- 如果你有多个类都需要实现这样的多代理模式，那么这些类中都比不可少的需要包含上述重复的代码
- 如果该类中有一个方法和代理协议中定义的方法同名，那么我们的方法转发也就不能进行了，进而导致多代理调用无法执行
思考：我们需要一个专门的类来处理这些多代理的事情，所有需要多代理功能的类只要包含这个类的实例对象就可以了，我们把添加代理，触发调用多代理的代码实现都封装到这个类中即可（开源框架XMPPFramework中也是类似的实现）
-
1. 定义多代理转发类
这个类用来封装多代理实现，我们使用NSProxy子类来实现它
@interface EEMultiProxy : NSProxy
// 代理转发对象 工厂方法
+ (EEMultiProxy *)proxy;
// 添加代理对象
- (void)addDelegate:(id)delegate;
// 移除代理对象
- (void)removeDelete:(id)delegate;
@end
-
2. 处理多线程同步问题
为了适应多线程环境下的多代理调用，我们在EEMultiProxy中使用信号量去解决多线程集合对象的同步问题
// 由于NSProxy类没有init方法，所以对实例对象的初始化我们放在alloc方法中
+ (id)alloc {
EEMultiProxy *instance = [super alloc];
if (instance) {
instance->_semaphore = dispatch_semaphore_create(1);
instance->_delegates = [NSHashTable weakObjectsHashTable];
}
return instance;
}
- (void)addDelegate:(id)delegate {
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
[_delegates addObject:delegate];
dispatch_semaphore_signal(_semaphore);
}
- (void)removeDelete:(id)delegate {
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
[_delegates removeObject:delegate];
dispatch_semaphore_signal(_semaphore);
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
NSMethodSignature *methodSignature;
for (id delegate in _delegates) {
if ([delegate respondsToSelector:selector]) {
methodSignature = [delegate methodSignatureForSelector:selector];
break;
}
}
dispatch_semaphore_signal(_semaphore);
if (methodSignature) return methodSignature;
// Avoid crash, must return a methodSignature "- (void)method"
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
-
3. 异步调用多代理方法
重点1 - 多线程：每个代理类的对代理方法的实现都不一样，为了使这些代理类都能及时的响应代理调用，我们应该将代理方法的调用都放到异步线程中；
重点2 - 递归死锁：如果项目的多代理调用不采用异步派发，那么就有可能因为信号量的递归获取导致死锁。具体表现：代理协议实现类中的方法逻辑中又调用多代理proxy的方法对应方法，这就形成了在当前信号量中继续尝试获取当前信号量，造成信号量的递归等待从而形成死锁，所以如果我们使用同步调用代理对象方法，那么我们应该在遍历代理集合时先拷贝一份代理集合，及时释放信号量，然后再去遍历调用代理方法；
- (void)forwardInvocation:(NSInvocation *)invocation {
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
NSHashTable *copyDelegates = [_delegates copy];
dispatch_semaphore_signal(_semaphore);
SEL selector = invocation.selector;
for (id delegate in copyDelegates) {
if ([delegate respondsToSelector:selector]) {
// must use duplicated invocation when you invoke with async
NSInvocation *dupInvocation = [self duplicateInvocation:invocation];
dupInvocation.target = delegate;
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[dupInvocation invoke];
});
}
}
}
-
4. 复制invocation
因为invocation对象只有一个，每个delegate去调用的时候都会去设置invocation的target，因为我们是异步调用，有可能造成某个delegate对象的invocation调用前target被其他线程意外替换掉，很可能造成crash，所以这里需要对invocation进行复制，用来隔离每个异步调用；
- (NSInvocation *)duplicateInvocation:(NSInvocation *)invocation {
SEL selector = invocation.selector;
NSMethodSignature *methodSignature = invocation.methodSignature;
NSInvocation *dupInvocation = [NSInvocation invocationWithMethodSignature:methodSignature];
dupInvocation.selector = selector;
NSUInteger count = methodSignature.numberOfArguments;
for (NSUInteger i = 2; i < count; i++) {
void *value;
[invocation getArgument:&value atIndex:i];
[dupInvocation setArgument:&value atIndex:i];
}
[dupInvocation retainArguments];
return dupInvocation;
}
Demo示例链接：EEMultiDelegate
说明：本文中的多代理实现参考了框架XMPPFramework中的多代理实现
