一、多播代理的思想
在C#语言中就有这样一个概念叫做多播委托，它直接是针对对象的某个委托事件的代理，委托对象内部保存了所有代理实现(指针)，构成一个委托链，当这个委托事件触发的时候这个委托链上的所有实现方法都将被调用。iOS中的多代理概念雷同，其实就是委托对象中保持多个代理对象的引用，当触发事件的时候，让所有的代理对象调用相应的代理方法即可。
普通代理只能是一对一的回调，无法做到一对多的回调，而多播委托正式对delegate的一种扩展与延伸，多了一个注册和取消的过程。任何需要回调的对象都必须先注册。
1. 存储多个代理对象
- OC中常规代理通常使用弱引用来避免循环引用，因此我们的多播代理中也需要使用能够存储弱引用对象的容器，这里有几种思路：
- 使用NSValue的valueWithNonretainedObject:方法将对象打包，然后将打包后的NSValue对象添加到代理数组中。
- 创建一个新的类，在这个类中对代理对象进行弱引用（实质是对上一个思路的手动实现）。然后再将这个新类的实例添加到代理数组中。
- 使用NSHashTable存储代理对象，我们用到一个比较不常见的容器：NSHashTable
NSHashTable
iOS6以后，Foundation框架中新增了容器类：NSHashTable —— 它是可变的，没有一个不变的类与其对应。它的作用对应于NSMutableSet，但是它可以通过设置NSPointerFunctionsOptions参数来指定对象的引用类型：
NSHashTableStrongMemory：将容器内的对象引用计数+1一次(即strong)
NSHashTableCopyIn：将添加到容器的对象通过NSCopying中的方法，复制一个新的对象存入容器(即copy)
NSHashTableZeroingWeakMemory：使用weak存储对象，当对象被销毁的时候自动将其从集合中移除。(已弃用)
NSHashTableObjectPointerPersonality： 使用移位指针(shifted pointer)来做hash检测及确定两个对象是否相等(而不是使用NSObject中的hash方法)
NSHashTableWeakMemory：不会修改容器内对象元素的引用计数，并且对象释放后，会被自动移除(即weak)
NSHashTableWeakMemory的对象释放后，NSHashTable中其实是置空（NSHashTable可以保存空对象），但遍历时不会遍历到该对象，相对于移除了。
2. 添加代理对象
基于上面的选择，我们使用 NSHashTable 来管理存储和遍历代理对象，因此需要公开一个添加代理的方法：
- (void)addDelegate:(id <xxxProtocol>)newDelegate;
3. 调用代理方法
调用常规代理时，通常需要写以下写法：
if ([delegate respondsToSelector:@selector(<#方法名#>:)]) {
[delegate <#方法名#>:<#参数#>];
}
那么假如我们的代理协议中有多个方法，我们就需要对每个代理方法都写一次这样的代码，相当繁琐。 通常的简化方法是利用OC的消息转发机制，在方法转发过程中进行消息转发。
改进方案
上面的方案实现了简单的多播代理，但是有一些缺陷：
- 如果该MutableDelegate类中有一个方法和代理协议中定义的方法同名，将导致消息转发的过程不会触发。
- 如果项目中需要用到多个多播代理，则需要实现多次上面的方法
- 多线程问题
1. 定义多代理转发类
这个类用来封装多代理实现，我们使用NSProxy子类来实现它：
@interface MulitiDelegate : NSProxy
/**
创建
@return MulitiDelegate对象
*/
+ (instancetype)new;
/**
添加代理
*/
- (void)addDelegate:(id)delegate;
/**
移除代理
*/
- (void)removeDelete:(id)delegate;
@end
2. 处理多线程同步问题
使用信号量解决多线程集合对象的同步问题:
//...
/// 信号量
@property ( nonatomic, strong ) dispatch_semaphore_t semaphore;
//...
/// 初始化
+ (id)alloc{
MulitiDelegate *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);
}
#pragma mark - 消息转发部分
- (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;
}
// 未找到方法时，返回默认方法 "- (void)method"，防止崩溃
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
- (void)forwardInvocation:(NSInvocation *)invocation {
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
// 为了避免造成递归死锁，copy一份delegates而不是直接用信号量将for循环包裹
NSHashTable *copyDelegates = [_delegates copy];
dispatch_semaphore_signal(_semaphore);
SEL selector = invocation.selector;
for (id delegate in copyDelegates) {
if ([delegate respondsToSelector:selector]) {
// 异步调用时，拷贝一个Invocation，以免意外修改target导致crash
NSInvocation *dupInvocation = [self copyInvocation:invocation];
dupInvocation.target = delegate;
// 异步调用多代理方法，以免响应不及时
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[dupInvocation invoke];
});
}
}
}
- (NSInvocation *)copyInvocation:(NSInvocation *)invocation {
SEL selector = invocation.selector;
NSMethodSignature *methodSignature = invocation.methodSignature;
NSInvocation *copyInvocation = [NSInvocation invocationWithMethodSignature:methodSignature];
copyInvocation.selector = selector;
NSUInteger count = methodSignature.numberOfArguments;
for (NSUInteger i = 2; i < count; i++) {
void *value;
[invocation getArgument:&value atIndex:i];
[copyInvocation setArgument:&value atIndex:i];
}
[copyInvocation retainArguments];
return copyInvocation;
}
使用方式
这里用一个简单的一键切换主题的例子来说明多播代理的使用方式：
主题管理器（ThemesManager）
创建一个单例主题管理器来管理我们的主题颜色，并能够添加和移除代理:
@protocol ThemesDelegate <NSObject>
/// 主题颜色改变
- (void)themesColorChanged:(UIColor *)themesColor;
@end
@interface ThemesManager : NSObject
/// 主题颜色
@property ( nonatomic, copy ) UIColor *themesColor;
/// 获取单例
+ (instancetype)sharedManager;
/// 添加、移除代理
- (void)addDelegate:(id<ThemesDelegate>)delegate;
- (void)removeDelegate:(id<ThemesDelegate>)delegate;
@end
在.m文件中需要实现单例（单例的代码建议定义成一个通用的宏定义，方便其他地方一起使用），然后使用之前定义的多播代理来进行“广播”:
#import "ThemesManager.h"
#import "MulitiDelegate.h"
@interface ThemesManager()
/// 多播代理
@property ( nonatomic, strong ) MulitiDelegate *delegateProxy;
@end
@implementation ThemesManager
@synthesize themesColor = _themesColor;
static ThemesManager *_manager = nil;
+ (instancetype)sharedManager{
return [[self alloc]init];
}
+ (instancetype)allocWithZone:(struct _NSZone *)zone{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
if (_manager == nil) {
_manager = [super allocWithZone:zone];
}
});
return _manager;
}
- (nonnull id)copyWithZone:(nullable NSZone *)zone {
return _manager;
}
- (nonnull id)mutableCopyWithZone:(nullable NSZone *)zone {
return _manager;
}
- (MulitiDelegate *)delegateProxy{
if (!_delegateProxy) {
_delegateProxy = [MulitiDelegate new];
}
return _delegateProxy;
}
- (void)addDelegate:(id<ThemesDelegate>)delegate {
[self.delegateProxy addDelegate:delegate];
}
- (void)removeDelegate:(id<ThemesDelegate>)delegate {
[self.delegateProxy removeDelete:delegate];
}
- (void)setThemesColor:(UIColor *)themesColor{
_themesColor = [themesColor copy];
[(id<ThemesDelegate>)self.delegateProxy themesColorChanged:_themesColor];
}
- (UIColor *)themesColor{
if (!_themesColor) {
// 默认颜色
_themesColor = [UIColor colorWithWhite:0.8f alpha:1.f];
}
return _themesColor;
}
@end
控制器类
通常我们会有一个专门的改变主题的界面和一些其他界面，这里就简单的使用同一个界面跳转和改变主题颜色:
#import "ThemesManager.h"
@interface ViewController ()<ThemesDelegate>
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
self.title = [NSString stringWithFormat:@"%d",self.index];
[[ThemesManager sharedManager]addDelegate:self];
self.view.backgroundColor = [ThemesManager sharedManager].themesColor;
}
- (IBAction)changeThemes:(id)sender {
[ThemesManager sharedManager].themesColor = [self randomColor];
}
- (UIColor *)randomColor {
// 生成随机颜色
CGFloat hue = arc4random() % 100 / 100.0; //色调：0.0 ~ 1.0
CGFloat saturation = (arc4random() % 50 / 100) + 0.5; //饱和度：0.5 ~ 1.0
CGFloat brightness = (arc4random() % 50 / 100) + 0.5; //亮度：0.5 ~ 1.0
return [UIColor colorWithHue:hue saturation:saturation brightness:brightness alpha:1];
}
- (IBAction)nextVC:(id)sender {
// 使用Storyboard创建VC
UIStoryboard *story = [UIStoryboard storyboardWithName:@"Main" bundle:[NSBundle mainBundle]];
ViewController *newVC = [story instantiateViewControllerWithIdentifier:@"ViewController"];
newVC.index = self.index + 1;
[self.navigationController pushViewController:newVC animated:YES];
}
#pragma mark - ThemesDelegate
- (void)themesColorChanged:(UIColor *)themesColor{
// 需要注意的是这里是异步调用，改变颜色需要在主线程
dispatch_async(dispatch_get_main_queue(), ^{
self.view.backgroundColor = themesColor;
});
}
@end
调用流程
运行效果
XMPPframework 里的 GCDMulticastDelegate.h,GCDMulticastDelegate.m
参考Demo: EEMultiDelegate
利用消息转发机制实现多播委托
在实际的开发过程中，我们可能需要即需要类似delegate那样的回调方式，又想要类似KVO那样的一对多的功能。这种需求在IM类应用中很普遍，甚至可以说这样的回调方式是IM类应用的核心。
@interface MulticastDelegate : NSObject
-(void)regisetDelegate:(id)delegate;
@end
@implementation MulticastDelegate{
// delegate数组
NSMutableArray *delegates;
}
-(id)init{
self = [super init];
delegates = [NSMutableArray array];
return self;
}
// 注册delegate
-(void)regisetDelegate:(id)delegate{
// 其实就是把delegate存入数组
[delegates addObject:delegate];
}
// 方法签名
-(NSMethodSignature *)methodSignatureForSelector:(SEL)selector{
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
// 利用消息转发机制对delegate数组进行回调
-(void)forwardInvocation:(NSInvocation *)invocation{
SEL sel = invocation.selector;
[delegates enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) { if([obj respondsToSelector:sel]){
[invocation invokeWithTarget:obj];
}
}];
}
@end
复制代码
这里定义了一个叫做MulticastDelegate的类，这个类专门用于管理多播委托的，并且对外只提供了一个regisetDelegate:方法。而这个方法也很简单，就是将delegate加入数组中。
上面的代码中核心代码就是消息转发那块代码。也就是methodSignatureForSelector和forwardInvocation两个方法。当我们对一个对象调用了不存在的方法的时候就会触发消息转发机制，当消息转发进入到forwardInvocation的时候说明已经进入到最后一步，并且系统已经把方法的效用信息全部封装进了NSInvocation中了。这时候只需要将delegate数组中的delegate遍历执行即可。
整体的实现代码可以说很简单。下面是使用方式代码，既然叫做MulticastDelegate，那么用的时候肯定是要先定义个protocol了。那么第一步就是定义protocol
@protocol TestDelegate
-(void)print;
@end
然后就是注册回调
id mutiDelegate; // 注意是id类型。
mutiDelegate =[[MulticastDelegate alloc] init];
[mutiDelegate regisetDelegate:self];
最后就是调用。这一步的调用跟原来的一样，直接对mutiDelegate调用方法即可。
[mutiDelegate print];
在上面的MulticastDelegate的初始化过程中你应该注意到了，变量mutiDelegate是id类型，而不是MulticastDelegate。之所以这样做，是因为只有id类型的变量才能调用任意方法而Xcode不会警告，否则XCode都不能编译。
其实看了上面的代码，你会发现一个，我们平常设置delegate的时候都是weak属性，但是上面的代码中存入数组中的delegate是strong的，这不是形成循环引用了吗？
另外，在实际的开发过程中，甚至对回调线程也有要求，比如在注册回调的时候指定回调队列。这样就需要修改回调数组的存放的内容了。
// 定义一个存放delete 和 dispatch_queue_t 的class
@interface MulticastDelegateNode : NSObject
@property (nonatomic,weak,readonly)id delegate;
@property (nonatomic,readonly)dispatch_queue_t queue;
@end
@implementation MulticastDelegateNode
-(id)initWithDelegate:(id)delegate delegateQueue:(dispatch_queue_t)queue{
self = [super init];
_delegate = delegate;
_queue = queue;
return self;
}
@end
@implementation MulticastDelegate{
// delegate数组
NSMutableArray<MulticastDelegateNode *> *delegates;
}
-(id)init{
self = [super init];
delegates = [NSMutableArray array];
return self;
}
// 注册delegate
-(void)regisetDelegate:(id)delegate delegateQueue:(dispatch_queue_t)queue{
// 其实就是把delegate存入数组
MulticastDelegateNode *node = [[MulticastDelegateNode alloc] initWithDelegate:delegate delegateQueue:queue?:dispatch_get_main_queue()];
[delegates addObject:node];
}
// 方法签名
-(NSMethodSignature *)methodSignatureForSelector:(SEL)selector{
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
// 利用消息转发机制对delegate数组进行回调
-(void)forwardInvocation:(NSInvocation *)invocation{
SEL sel = invocation.selector;
[delegates enumerateObjectsUsingBlock:^(MulticastDelegateNode * _Nonnull node, NSUInteger idx, BOOL * _Nonnull stop) { if([node.delegate respondsToSelector:sel]){
dispatch_async(node.queue, ^{
[invocation invokeWithTarget:node.delegate];
});
}
}];
}
@end
上面的代码中额外定义了一个MulticastDelegateNode的class，主要是以weak的方式保存delegate，并且保存dispatch_queue_t。这样既解决了循环引用的问题，又能在指定的队列上执行回调。
NSProxy 实现多播委托
在 iOS 开发中，NSProxy 在 Objective-C 中是一个非常强大的工具，可以用来实现诸如转发、拦截消息等高级功能。如果你想使用 NSProxy 来实现多播委托（Multicast Delegate）模式，你可以通过创建一个代理对象，该对象能够将接收到的消息转发给多个目标对象。
步骤 1: 创建 NSProxy 子类
首先，你需要创建一个继承自 NSProxy 的子类。在这个子类中，你将重写 forwardInvocation: 方法来处理消息的转发。
#import <Foundation/Foundation.h>
@interface MulticastDelegateProxy : NSProxy
@property (nonatomic, strong) NSHashTable *targets;
- (void)addTarget:(id)target;
- (void)removeTarget:(id)target;
@end
步骤 2: 实现 MulticastDelegateProxy
接下来，实现 MulticastDelegateProxy 类，并重写 forwardInvocation: 和其他相关方法。
#import "MulticastDelegateProxy.h"
@implementation MulticastDelegateProxy
- (instancetype)init {
self = [super init];
if (self) {
_targets = [NSHashTable weakObjectsHashTable]; // 使用弱引用避免循环引用
}
return self;
}
- (void)forwardInvocation:(NSInvocation *)anInvocation {
for (id target in self.targets) {
if ([target respondsToSelector:[anInvocation selector]]) {
[anInvocation invokeWithTarget:target];
}
}
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
// 查找一个目标的方法签名，如果有多个目标，通常选择第一个能找到的方法签名返回
for (id target in self.targets) {
NSMethodSignature *signature = [target methodSignatureForSelector:aSelector];
if (signature) {
return signature;
}
}
return [NSObject instanceMethodSignatureForSelector:@selector(init)]; // 返回一个默认签名，实际应用中可能需要更合理的处理方式，如抛出异常等。
}
- (BOOL)respondsToSelector:(SEL)aSelector {
// 检查是否有任何一个目标响应这个选择器
for (id target in self.targets) {
if ([target respondsToSelector:aSelector]) {
return YES;
}
}
return [super respondsToSelector:aSelector]; // 或者返回 NO，取决于你的具体需求
}
- (void)addTarget:(id)target {
[self.targets addObject:target];
}
- (void)removeTarget:(id)target {
[self.targets removeObject:target];
}
@end
步骤 3: 使用 MulticastDelegateProxy
现在你可以创建 MulticastDelegateProxy 的实例，并添加或移除目标对象了。例如：
MulticastDelegateProxy *delegate = [[MulticastDelegateProxy alloc] init];
[delegate addTarget:someObject1]; // someObject1 是实现了相应方法的对象之一
[delegate addTarget:someObject2]; // someObject2 是另一个实现了相应方法的对象
[delegate someMethod]; // 调用方法，该方法会在 someObject1 和 someObject2 上被调用（如果它们实现了 someMethod）
或者
下面是一个使用 NSProxy 实现多播委托的示例：
// MultiDelegate.h
#import <Foundation/Foundation.h>
@interface MultiDelegate : NSProxy
- (instancetype)init;
- (void)addDelegate:(id)delegate;
- (void)removeDelegate:(id)delegate;
@end
// MultiDelegate.m
#import "MultiDelegate.h"
@interface MultiDelegate ()
@property (nonatomic, strong) NSHashTable *delegates;
@end
@implementation MultiDelegate
- (instancetype)init {
_delegates = [NSHashTable weakObjectsHashTable];
return self;
}
- (void)addDelegate:(id)delegate {
@synchronized (_delegates) {
[_delegates addObject:delegate];
}
}
- (void)removeDelegate:(id)delegate {
@synchronized (_delegates) {
[_delegates removeObject:delegate];
}
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel {
for (id delegate in _delegates) {
NSMethodSignature *signature = [delegate methodSignatureForSelector:sel];
if (signature) {
return signature;
}
}
// Provide a default method signature if no delegate can respond
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
- (void)forwardInvocation:(NSInvocation *)invocation {
SEL selector = invocation.selector;
@synchronized (_delegates) {
for (id delegate in _delegates) {
if ([delegate respondsToSelector:selector]) {
[invocation invokeWithTarget:delegate];
}
}
}
}
@end
使用示例：
@protocol CustomDelegate <NSObject>
- (void)eventOccurred;
@end
@interface TestClass : NSObject <CustomDelegate>
@end
@implementation TestClass
- (void)eventOccurred {
NSLog(@"Event occurred in %@", self);
}
@end
// 在你的控制器或主体类中
MultiDelegate *multiDelegate = [[MultiDelegate alloc] init];
TestClass *testObject1 = [[TestClass alloc] init];
TestClass *testObject2 = [[TestClass alloc] init];
[multiDelegate addDelegate:testObject1];
[multiDelegate addDelegate:testObject2];
// 当事件发生时调用
if ([multiDelegate respondsToSelector:@selector(eventOccurred)]) {
[multiDelegate performSelector:@selector(eventOccurred)];
}
- NSHashTable：这里我们使用 NSHashTable 来存储多个委托对象，并且使用 weakObjectsHashTable 类型以避免出现强引用循环。
- -addDelegate: 和 -removeDelegate:：用于添加和移除委托对象。
- -methodSignatureForSelector: 和 -forwardInvocation:：这两个方法是 NSProxy 子类的核心，用于消息转发。 -methodSignatureForSelector: 返回一个方法签名，-forwardInvocation: 实际将消息转发给所有响应该消息的委托对象。
这种方法提供了一种优雅的解决方案来处理一对多的委托模式，使得能够灵活地实现事件广播。
