什么是 NSProxy
首先，我们看下官方给出的定义
NSProxy 是一个为对象定义接口的抽象父类，它为充当其他对象或尚不存在的对象的替代对象的对象定义API。通常，发送给代理的消息会转发到真实对象，或使代理加载（或将自身转换为）真实对象。 NSProxy 的子类可用于实现透明的分布式消息传递（例如 NSDistantObject）或用于懒惰实例化创建成本高昂的对象。NSProxy 实现了根类所需的基本方法，包括在 NSObject 协议中定义的方法。但是，作为抽象类，它不提供初始化方法，并且在收到任何未响应的消息时会引发异常。因此，具体的子类必须提供初始化或创建方法，并覆盖 forwardInvocation: 和 methodSignatureForSelector:方法以处理自身未实现的消息。子类的 forwardInvocation 的实现：应该执行处理调用所需的任何事情，例如通过网络转发调用或加载实际对象并将其传递给调用。 methodSignatureForSelector: 需要为给定消息提供参数类型信息；子类的实现应能够确定需要转发的消息的参数类型，并应相应构造一个 NSMethodSignature 对象。有关更多信息，请参见 NSDistantObject，NSInvocation 和 NSMethodSignature 类规范。
NSProxy是和NSObject同级的一个类（即常说的虚基类），它只是实现了<NSObject>的协议。是一个抽象类，没有指定初始化方法，子类化后需要提供初始化方法；使用时需要实现基类以及NSObject协议的一些方法（forwardInvocation:、methodSignatureForSelector:）
NS_ROOT_CLASS
@interface NSProxy <NSObject> {
__ptrauth_objc_isa_pointer Class isa;
}
+ (id)alloc;
+ (id)allocWithZone:(nullable NSZone *)zone NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
+ (Class)class;
- (void)forwardInvocation:(NSInvocation *)invocation;
- (nullable NSMethodSignature *)methodSignatureForSelector:(SEL)sel NS_SWIFT_UNAVAILABLE("NSInvocation and related APIs not available");
- (void)dealloc;
- (void)finalize;
@property (readonly, copy) NSString *description;
@property (readonly, copy) NSString *debugDescription;
+ (BOOL)respondsToSelector:(SEL)aSelector;
- (BOOL)allowsWeakReference API_UNAVAILABLE(macos, ios, watchos, tvos);
- (BOOL)retainWeakReference API_UNAVAILABLE(macos, ios, watchos, tvos);
// - (id)forwardingTargetForSelector:(SEL)aSelector;
@end
可以看到，它的第一个成员变量是 isa，因此它可以拿来当一个 NSObject 或其派生类来使用。
NSProxy 的使用
从上述知道，使用 NSProxy 必须通过它的子类实现，且子类需要提供初始化方法，并且重写 forwardInvocation: 和 methodSignatureForSelector: 方法来处理自己没有实现的消息。（即负责把消息转发给真正的 target 的代理类）
- 创建一个
LCProxy类，继承自NSProxy
/**------.h------*/
@interface LCProxy : NSProxy
- (instancetype)initWithTarget:(id)target;
+ (instancetype)proxyWithTransformObject:(id)target;
@end
/**------.m------*/
@interface LCProxy ()
@property (nonatomic, weak) NSObject *target;
@end
@implementation LCProxy
+ (instancetype)proxyWithTransformObject:(id)target {
return [[self alloc] initWithTarget:target];
}
- (instancetype)initWithTarget:(id)target {
self.target = target;
return self;
}
// 方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel {
if (self.target && [self.target respondsToSelector:sel]) {
return [self.target methodSignatureForSelector:sel];
}
return [super methodSignatureForSelector:sel];
}
// 调用方法实现
- (void)forwardInvocation:(NSInvocation *)invocation {
SEL sel = invocation.selector;
if (self.target && [self.target respondsToSelector:sel]) {
[invocation invokeWithTarget:self.target];
} else {
[super forwardInvocation:invocation];
}
}
@end
可以看到，我们重写了 methodSignatureForSelector: 和 forwardInvocation: 两个方法。第一个方法是用来做实现方法签名，将我们复制的对象进行方法签名，然后生成 NSInvocation 对象；第二个方法接着就会被调用，我们直接将 invocation 的 target 设置为我们复制的对象。实质上是利用了 runtime 的消息转发机制
使用场景
- 解决 NSTimer/CADisplayLink 的循环引用问题
在之前的文章 iOS 中关于 NSTimer 的强引用分析 有过分析为什么会有循环引用的问题，这里不再啰嗦了。
- 模拟多继承
@interface LCTeacher : NSObject
- (void)teacherSomething;
@end
@implementation LCTeacher
- (void)teacherSomething {
NSLog(@"%s", __func__);
}
@end
@interface LCStudent : NSObject
- (void)studySomething;
@end
@implementation LCStudent
- (void)studySomething {
NSLog(@"%s", __func__);
}
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
LCTeacher *teacher = [[LCTeacher alloc] init];
LCStudent *student = [[LCStudent alloc] init];
LCProxy *teacherProxy = [LCProxy proxyWithTransformObject:teacher];
[teacherProxy performSelector:NSSelectorFromString(@"teacherSomething") withObject:nil];
LCProxy *studentProxy = [LCProxy proxyWithTransformObject:student];
[studentProxy performSelector:NSSelectorFromString(@"studySomething") withObject:nil];
}
通过 LCProxy 这个类实现了复制 LCTeacher 和 LCStudent，可以分别调用各个类的方法了。
NSProxy 和 NSObject 的区别
NSProxy 和 NSObject 都定义了 forwardInvocation: 和 methodSignatureForSelector: 方法，但这两个方法并没有在 protocol NSObject 中声明；两者对这俩方法的调用逻辑更是完全不同
对于 NSObject，接收到消息后先去类的 methodlist 方法列表里找匹配的 selector，如果找不到，会沿着它的继承链去 superclass 的方法列表中查找；继承链中也找不到，依次会调用 +resolveInstanceMethod: 和 -forwardingTargetForSelector: 处理，如果还处理不了，才会走到 -methodSignatureForSelector:/-forwardInvocation: 给最后一次机会。
对于 NSProxy，接收 unknown selector 后，会回调 -forwardingTargetForSelector:，如果处理不了就会继续回调 -methodSignatureForSelector:/-forwardInvocation:，消息转发过程比 NSObject 要简单得多。
相对于 NSObject，NSProxy 的另外一个非常重要的不同点也值得注意：NSProxy 会将自省相关的 selector 直接 forward 到 -forwardInvocation: 回调中，这些自省方法包括:
- (BOOL)isKindOfClass:(Class)aClass;
- (BOOL)isMemberOfClass:(Class)aClass;
- (BOOL)conformsToProtocol:(Protocol *)aProtocol;
- (BOOL)respondsToSelector:(SEL)aSelector;
简单来说，这 4 个方法的实际接收者是 target 对象，而不是 NSProxy 对象本身。但是，NSProxy 并没有将 performSelector 系列方法也 forward 到 -forwardInvocation:，也就是说，[proxy performSelector:someSelector] 的真正处理者仍然是 proxy 自身，只是后续会将一些方法给 forward 到 -forwardInvocation: 回调，然后经由 target 对象处理。
关于 NSInvocation
在 iOS 中直接调用方法的方式一般使用两种方法
- 使用
NSObject的performSelector:..的方法，但是这个方法的弊端是传递的参数有限制 - 使用
NSInvocation
NSInvocation 的相关概念
NSMethodSignature：签名：在创建 NSMethodSignature 的时候，必须传递一个签名对象，签名对象的作用：用于获取参数的个数和方法的返回值
NSInvocation: 包装了一次消息传递的所有内容，包括target，select，argument、返回值等，会在运行时找到目标发送消息
注意这里传的参数是地址
API 接口
@interface NSInvocation : NSObject
// 通过 NSMethodSignature 对象创建 NSInvocation 对象，NSMethodSignature 为方法签名类
+ (NSInvocation *)invocationWithMethodSignature:(NSMethodSignature *)sig;
// 获取 NSMethodSignature 对象
@property (readonly, retain) NSMethodSignature *methodSignature;
// 保留参数，它会将传入的所有参数以及 target 都 retain 一遍
- (void)retainArguments;
// 判断参数是否还存在，调用 retainArguments 之前，值为 NO，调用之后值为 YES
@property (readonly) BOOL argumentsRetained;
// 设置消息调用者
@property (nullable, assign) id target;
// 设置要调用的消息
@property SEL selector;
// 获取消息返回值
- (void)getReturnValue:(void *)retLoc;
// 设置消息返回值
- (void)setReturnValue:(void *)retLoc;
// 获取消息参数
- (void)getArgument:(void *)argumentLocation atIndex:(NSInteger)idx;
// 设置消息参数
- (void)setArgument:(void *)argumentLocation atIndex:(NSInteger)idx;
// 发送消息，即执行方法
- (void)invoke;
// target 发送消息，即 target 执行方法
- (void)invokeWithTarget:(id)target;
@end
NSInvocation 的使用
- (void)viewDidLoad {
[super viewDidLoad];
// 创建签名对象
NSMethodSignature *methodSignature = [ViewController instanceMethodSignatureForSelector:@selector(sendMessageWithArgument1:argument2:)];
// 创建 NSInvocation 对象
NSInvocation *objInvocation = [NSInvocation invocationWithMethodSignature:methodSignature];
// 指定 target 对象
objInvocation.target = self;
// 执行的方法
objInvocation.selector = @selector(sendMessageWithArgument1:argument2:);
// 给执行的方法设置参数
NSString *argument1 = @"11111";
NSString *argument2 = @"22222";
[objInvocation setArgument:&argument1 atIndex:2];
[objInvocation setArgument:&argument2 atIndex:3];
// 执行方法
[objInvocation invoke];
// 获取返回值
NSString *result = nil;
[objInvocation getReturnValue:&result];
NSLog(@"The Result is : %@", result);
}
- (NSString *)sendMessageWithArgument1:(NSString *)argument1 argument2:(NSString *)argument2 {
NSLog(@"参数1:%@, 参数2:%@", argument1, argument2);
return @"返回结果";
}
运行，打印结果如下
2020-12-07 18:06:15.439405+0800 Test[4511:281661] 参数1:11111, 参数2:22222
2020-12-07 18:06:15.439593+0800 Test[4511:281661] The Result is : 返回结果
创建签名对象的时候不是使用
NSMethodSignature这个类创建，而是方法属于谁就用谁来创建
设置参数的索引时不能从 0 开始，因为 0 已经被self占用，1 已经被_cmd占用
传递参数时，接收的是一个指针，即传递值的时候需要传递地址，传递返回值也是传递地址
调用invocation的invoke方法，就代表需要执行NSInvocation对象中指定对象的指定方法，并且传递指定的参数
