尝试手写一个更好用的performSelector-msgSend

这其实是一个NSInvocation练习作业

尝试手写一个更好用的performSelector/msgSend

引子

  • 工作中难免会遇到一些场景,开发的时候不想引入整个头文件,但是又想调用一些方法
  • 动态创建,动态调用看起来比较酷
  • 这种使用场景确实不常见,导入了头文件最省事,最直接,但是这种方式我觉得能搞出很多好玩的东西

一个群里聊天的时候聊到了一个场景,tableView内的cell有N种样式,在cellForRow的时候,通过NSClassFromString从字符串创建对象,然后挨个对Cell的UI赋值,接下来问题就来了。

实在不想import如此繁多cell.h头文件应该怎么办?

  • 有一个办法,所有cell都有个基类,基类统一所有UI赋值的接口,子类重载这些UI赋值,这样创建出来的对象强转成基类,调用基类的接口。这样只需要import一个基类头文件就够了
    • 这样要求子类的接口必须和基类完全一致
    • 如果子类设计很多样,赋值UI的元素更多,就会不太合理
  • 还有一个办法performSelector,恩说实话,我觉得很不好用
  • 会有人说用运行时Objc_msgSend,恩,这个靠谱,听起来也挺易用的
  • 老老实实引入各种头文件,别搞什么动态创建,动态调用的花样了

聊聊performSelector

这里不是说performSelector中关于异步调用的那一部分,而是单说同步的:

1
2
3
- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;

这个是NSObject系统开放的performSelector同步接口,这个好用么?我以前觉得很不好用

  • 参数类型:我凑,不需要参数的接口用起来最直观,我也觉得还算好用,一旦需要参数,withObject:id是什么鬼?我传BOOL,传NSInteger怎么传啊?我包装成NSNumber对面能认识么?
  • 参数个数:为毛只能不带参数,1个参数,2个参数呢?我想调用的东西含参数特别多咋办啊?
  • 调用写法:每个参数还得用withObject来传,写出来一点都不酷

就像我说的,以前我几乎只会去用performSelector调用无参数的函数,一旦有参数,我都不爱用performSelector

聊聊objc_msgSend

大家都知道OC的消息机制,函数调用其实都是发送消息,这个太多的地方有讲了,我就不多说了。

一个我们想要调用的函数

1
- (int) doSomething:(int) x { ... }

在32位的时代,想要实现我要的效果,可以直接使用objc_msgSend

1
objc_msgSend(self,@selector(doSomething:), 0);

但是一旦在64位设备上执行,就会产生崩溃,原因参见苹果Converting Your App to a 64-Bit Binary,中Take Care with Functions and Function Pointers,这一部分。

简单的说,64位下runtime调用和32位变化十分大,尤其是读取函数参数列表,进行传参这部分,所以苹果列出了一句话

Always Define Function Prototypes

Function Pointers Must Use the Correct Prototype

直接的调用C函数指针的时候必须先进行严格的类型匹配强转,不能直接使用Imp这个通用型的指针。

而objc_msgSend的内部实现也是一个这样的过程,objc_msgSend学习

  • 先从runtime method cache里面查找selector,
  • 找不到再从 method list里查找,
  • 找到selector,获取具体实现的ImpC函数,
  • 调用Imp

所以在64位下,直接使用objc_msgSend一样会引起崩溃,必须进行一次强转

1
((void(*)(id, SEL,int))objc_msgSend)(self, @selector(doSomething:), 0);

所以以前32位的时候objc_msgSend是我们最方便的做法,现在64位了,他已经不是那么方便了,毕竟使用起来还需要人自行手写这部分强转工作

本着程序员偷懒大法,这部分能不能也省略了?变得更方便一些?

设计我的callSelector的接口

我希望我设计的接口是这样的

1
2
3
4
Class cls = NSClassFromString(@"testClassA");
id<vk_msgSend> abc = [[cls alloc]init];
NSError *err;
NSString *return1 = [abc vk_callSelector:@selector(testfunction:withB:) error:&err,4,3.5f];

  • 它是一个NSObject的Category,只要你对强转成遵从<vk_msgSend>的id对象,就能直接调用
  • 它像performSelector一样输入SEL做参数执行,但是传参非常容易,基础类型,struct都支持,不需要withObject,不需要转成id,只需要像NSLog()一样,按顺序输入可变参数就好。
  • 有一个error指针可以用来返回错误信息,也可以填nil不传
  • 它支持类方法
  • SEL参数还可以改传字符串

所以他的定义是这样的

1
2
3
4
5
6
7
+ (id)vk_callSelector:(SEL)selector error:(NSError *__autoreleasing *)error,...;
+ (id)vk_callSelectorName:(NSString *)selName error:(NSError *__autoreleasing *)error,...;
- (id)vk_callSelector:(SEL)selector error:(NSError *__autoreleasing *)error,...;
- (id)vk_callSelectorName:(NSString *)selName error:(NSError *__autoreleasing *)error,...;

实现这样的callSelector

可变参数接口透传的问题

既然接口设计的希望使用者怎么简单怎么来,使用者用可变参数的方式一字罗列所有参数,无需转id之类的。那我们也得按照可变参数去处理。

这里我遇到了一个问题,我一共设计4个接口,这4个接口其实大同小异,核心逻辑是一样的,所以我肯定是用一个公共的方法进行处理,但是,可变参函数怎么透传呢?

1
2
3
4
- (id)vk_callSelectorName:(NSString*)selName error:(NSError*__autoreleasing*)error,...{
SEL selector = NSSelectorFromString(selName);
[self vk_callSelector:selector error:error,...];
}

我希望这样就能搞定,把…原封不动的塞到下面那个函数,可是xcode不认呐亲╮(╯_╰)╭

后来公司讨论组里有位大神给出了建议,直接把va_list当做公共函数的参数,进行透传

设计公共方法的接口声明为,第一个参数就是va_list

1
static NSArray *vk_targetBoxingArguments(va_list argList, Class cls, SEL selector, NSError *__autoreleasing *error)

然后在调用的时候

1
2
3
4
5
va_list argList;
va_start(argList, error);
SEL selector = NSSelectorFromString(selName);
NSArray *boxingAruments = vk_targetBoxingArguments(argList, [self class], selector, error);
va_end(argList);

va_start获取va_list然后就可以一层层的透传给公共方法进行处理了

参数包装

虽然输入接口可以支持任意的类型,基础类型,struct,id,但是我内部实现的时候,还是把它们统一转换成了id,方便后续传递处理,这个步骤就是包装一下所有传进来的参数,也就是上面提到的vk_targetBoxingArguments

这个包装的过程涉及到va_list的取值过程va_arg了,这里我也踩了个大坑。容我细细道来

  • 从va_list里面一个一个的取出参数需要明确知道,每一个参数的类型,但是我们想做的是一个通用型的方法,这块就不能写死,可是从哪知道参数类型呢? – NSMethodSignature

NSMethodSignature我理解他其实就是SEL的typeEncode的对象封装,分别记录了这个SEL的返回值类型和各个参数类型

我们有调用对象,就能获取到对象的Class,我们有SEL,就能获取到NSMethodSignature

1
methodSignature = [cls instanceMethodSignatureForSelector:selector];
  • 有了NSMethodSignature我们就能按着循环去获取每个参数类型,从而读取va_list了。
1
2
3
4
5
for (int i = 2; i < [methodSignature numberOfArguments]; i++) {
const char *argumentType = [methodSignature getArgumentTypeAtIndex:i];
switch (argumentType[0] == 'r' ? argumentType[1] : argumentType[0]) {
//抽取参数
}

NSMethodSignature中前两个分别代表返回值和reciever,我们在抽取参数,所以直接从[2]下标开始取值,剩下的就是一个根据typeEcode,从va_list取值,然后包装成id,塞入数组的过程了,具体到每一种类型的case,可以参见源码。

1)取基础类型int,va_arg(argList, int)取值,包装成NSNumber(只举一个例子,其他见源码)

1
2
3
int value = va_arg(argList, int);
[argumentsBoxingArray addObject:@(value)];
break;

2)取CGSize,va_arg(argList, CGSize)取值,包装成NSValue(只举一个例子,其他见源码)

1
2
3
4
CGSize val = va_arg(argList, CGSize);
NSValue* value = [NSValue valueWithCGSize:val];
[argumentsBoxingArray addObject:value];
break;

3)取id,va_arg(argList, id),不包装,直接塞进去啦

这里要注意,如果传入的参数为nil,需要特殊处理一下,nil无法放入数组,所以我创建了一个vk_nilObject对象,来表明这个位置传进来nil了

1
2
3
4
5
6
id value = va_arg(argList, id);
if (value) {
[argumentsBoxingArray addObject:value];
}else{
[argumentsBoxingArray addObject:[vk_nilObject new]];
}

4)取SEL,va_arg(argList,SEL),处理成string

因为SEL本身的意义就是一个函数的名字类似string一样的键值,是用来查找函数用的,所以当成字符串处理啦

1
2
3
SEL value = va_arg(argList, SEL);
NSString *selValueName = NSStringFromSelector(value);
[argumentsBoxingArray addObject:selValueName];

5)取block,其实block就是id,所以和id的处理一模一样

1
//同id

6)取id*,va_arg(argList, void**)

这里需要注意一下,因为我取出来的是一个pointer,是不能直接放入数组里的,所以我创建了一个vk_pointer对象,持有一个void*属性,然后就可以塞进数组了

1
2
3
4
void *value = va_arg(argList, void**);
vk_pointer *pointerObj = [[vk_pointer alloc]init];
pointerObj.pointer = value;
[argumentsBoxingArray addObject:pointerObj];

  • 遇到了一个va_arg()的坑

我在调试中,发现当我对typeEncode的f取参数的时候

1
va_arg(argList, float)

xcode报了个warning

/Users/Awhisper/Desktop/GitHub/vk_msgSend/vk_msgSend/NSObject+vk_msgSend.m:280:49: Second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double'

一开始我看到warning没管,就继续编码去了,结果运行的时候,参数里含有float,发现了大问题

正如warning所说,此处编译器是按着double实现的,但是我用va_arg()取的时候按着float取,就直接导致我取出来的float值不对,是0,(一个比较小的double值取了前面几位自然都是0)

而float后面那个参数,id用va_arg(argList, id)取的时候直接崩溃,(指针已经乱了,从double的中间开始,按着id的长度取id,直接崩溃)

老老实实的修掉warning,改成用va_arg(argList, double)处理f,一切正常。

实现调用:NSInvocation

我们现在已经拿到了包装好的参数数组NSArray,可以开始调用函数了,使用NSInvocation

1 首先先要生成NSInvocation

1
2
3
Class cls = [target class];
NSMethodSignature *methodSignature = vk_getMethodSignature(cls, selector);
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature];

2 设置target和SEL

1
2
[invocation setTarget:target];
[invocation setSelector:selector];

3 循环压入参数

具体过程和Boxing一样,遍历methodSignature,按着typeEncode来从数组中取出id类型的参数,还原参数,压入invocation。

遍历的时候肯定是根据每个参数的typeEncode,去switch处理不同类型

1
2
3
4
5
6
7
for (int i = 2; i< [methodSignature numberOfArguments]; i++) {
const char *argumentType = [methodSignature getArgumentTypeAtIndex:i];
id valObj = argsArr[i-2];
switch (argumentType[0]=='r'?argumentType[1]:argumentType[0]) {
//switch case
}
}

这里我会详细分类别举例如何压入各种不同类型的参数,从[2]下表开始的原因和前边一致

1
[invocation setArgument:&value atIndex:i];`的作用就是压入参数

1)int等基础类型参数,对应上文的参数包装(只举一个例子,其他见源码)

1
2
3
int value = [valObj intValue];
[invocation setArgument:&value atIndex:i];
break;

2)CGSize基础结构体参数,对应上文参数包装(只举一个例子,其他见源码)

1
2
CGSize value = [val CGSizeValue];
[invocation setArgument:&value atIndex:i];

3)id参数,对应上文参数包装

上文提到如果传入的id为nil,被上文包装成了vk_nilObject对象扔进数组的,所以这里要针对这个处理一下

不是vk_nilObject的照常处理

是vk_nilObject,证明这个位置的参数传入方为空,所以我准备了一个空指针

1
static vk_nilObject *vknilPointer = nil;

把这个空指针传进去

1
2
3
4
5
if ([valObj isKindOfClass:[vk_nilObject class]]) {
[invocation setArgument:&vknilPointer atIndex:i];
}else{
[invocation setArgument:&valObj atIndex:i];
}

4)SEL参数,对应上文包装

上文提到,SEL被直接转成了string,所以我们这里要还原成SEL,然后直接压入参数

1
2
3
NSString *selName = valObj;
SEL selValue = NSSelectorFromString(selName);
[invocation setArgument:&selValue atIndex:i];

5)block参数,对应上文包装

上文提到block和id是一回事

1
//同id

6)id*的处理,对应上文包装,这里极其恶心,我会专门写一篇详细说一下,这里只写个大概吧
上文已经把void*包装成了 vk_pointer,所以我们取出vk* 然后压入参数

1
2
3
vk_pointer *value = valObj;
void* pointer = value.pointer;
[invocation setArgument:&pointer atIndex:i];

#你以为这样就可以了么?你太天真了

如果断点调试,整个call_selector的过程完全走完都不会有事,但是一旦放开断点,彻底走完就崩溃。
为啥呢?因为在使用invocation的时候 invoke的过程中,如果对象在invoke内被创建初始化了,invoke结束后,在下一个autorelease的时间点就会产生zombie的crash,send release to a dealloc object

为什么会这样,简单的说下我的理解不细说吧,invoke和直接函数调用不太一样,如果发生了alloc对象,那么这个对象系统会额外多一次autorelease,所以,不会立刻崩溃,但当autoreleasepool释放的时候,就会发生过度release。

给几个LINK有兴趣大家可以深入探讨一下
栈溢出1,栈溢出2

看一下我的解决办法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
vk_pointer *value = valObj;
void* pointer = value.pointer;
id obj = *((__unsafe_unretained id *)pointer);
if (!obj) {
if (argumentType[1] == '@') {
if (!_vkNilPointerTempMemoryPool) {
_vkNilPointerTempMemoryPool = [[NSMutableDictionary alloc] init];
}
if (!_markArray) {
_markArray = [[NSMutableArray alloc] init];
}
memset(pointer, 0, sizeof(id));
[_markArray addObject:valObj];
}
}
[invocation setArgument:&pointer atIndex:i];

我会先判断一下 void指向的对象是否存在,如果传入的是一个已经alloc init 好了的 mutableArray之类的对象,我会直接压入参数,因为invoke过程内,只是往mutableArray里面执行操作,并没有在void\指针处重新new的操作的话,是安全的不会崩溃的。

如果void*指向的对象不存在,相当于我传入了一个 NSError*,等着由invoke内部去创建,这样外面可以捕获,这种使用场景,就会导致crash,是因为过度release,那我的思路就是先把他持有一下。。。因为多了个release,那我再arc下不能强制retain,那我就add到一个字典里,让他被arc retain一下。

1
2
3
4
5
6
7
8
9
10
11
if ([_markArray count] > 0) {
for (vk_pointer *pointerObj in _markArray) {
void *pointer = pointerObj.pointer;
id obj = *((__unsafe_unretained id *)pointer);
if (obj) {
@synchronized(_vkNilPointerTempMemoryPool) {
[_vkNilPointerTempMemoryPool setObject:obj forKey:[NSNumber numberWithInteger:[(NSObject*)obj hash]]];
}
}
}
}

这段代码放在[invocation invoke]之后,因为只有执行之后我们才知道void*指向的位置是否创建了新对象,判断obj是否存在,如果存在则向一个全局的static字典_vkNilPointerTempMemoryPool写入这个对象。

  • 有人说?我为什么不是用栈溢出的答案?,栈溢出的答案却是是保证不crash了,但是传入的参数已经不是void** 而是一个 void***了,这样会导致被调用的函数虽然创建了NSError,但是执行完毕后,并没有赋值给有的指针,会导致外面看NSErro还是空(这么表述可能不对,这几天啃指针,这块已经把我弄得有点乱了,但是大家在函数外取个地址&error看一下,然后在函数内看传入的error地址,就会发现已经不对了)

  • 有人说,你这样不是内存泄露了么?一个对象在用过以后就永久被添加进了一个static字典里,我只能说是的,但是情况不是那么绝对,crash的原因是系统的一次额外的release,并且还发生在代码操作者无法掌控的autoreleasepool的drain时机,也就是说,在drain前,这个字典里的这个值是正常的(如果没有字典,此时并没崩溃),在drain后,这个字典里的值因为一次额外release了,此时这个字典内这个key还存在,但是他指向的对象已经野指针了(如果没有字典,此时就崩溃了,因为对一个dealloc对象 release),我试过在几秒之后肯定保证drain结束了,对字典执行removeAll,还是会崩溃!因为removeall的时候处理里面的值,发现那个值野指针了。

  • 有人有更好的办法不?我想不到了,也球建议

4 执行NSInvocation

1
[invocation invoke];

注意上文提到的invoke后处理一下 id* 的内存问题

4 取出返回值 具体可以看下一篇 NSInvocation内存处理

如同压入参数一样,还是通过typeEncode来判断返回类型

1
const char *returnType = [methodSignature methodReturnType];

从invocation按类型取出返回值,返回

1)int 等基础类型,注意我包装成了NSNumber* 返回的,后文有讲(只举一个例子,其他见源码)

1
2
3
4
int returnValue;
[invocation getReturnValue:&returnValue];
return @(returnValue);
break;

2)CGSize等基础类型,注意我包装成了NSValue* 返回的,后文有讲(只举一个例子,其他见源码)

1
2
3
4
CGSize result;
[invocation getReturnValue:&result];
NSValue * returnValue = [NSValue valueWithBytes:&(result) objCType:@encode(CGSize)];\
return returnValue;

3)id类型,这里面也有个坑
我是这么做的

1
2
3
4
5
6
7
8
9
10
void *result;
[invocation getReturnValue:&result];
if (result == NULL) {
return nil;
}
id returnValue;
returnValue = (__bridge id)result;
return returnValue;

为什么这么做,是因为getReturnValue只是拷贝返回值到指定的地址,你现在返回的是一个id,是一个指针,那么实际对象会在函数runloop结束后自动释放的,原因很类似之前的id*参数问题,但是这里是返回值。

一个详细介绍这一块的博客

还有一点瑕疵

注意我的返回值被强迫指定成了id,也就是说,如果原函数返回的是NSInteger,我会返回一个NSNumber。

为什么会这样?我搞不定如何在声明函数的时候,用一个兼容基础和id,所有类型的符号来定义函数。。

参数之所以可以兼容id与基础类型,是因为我用可变参数…绕过去了。。

但是返回值我就搞不定了,有人说用void *但我的初衷是希望使用者直接拿到最终的值,目前的困难不是如何把值传出去。而是传出去一个使用者不需要手动转换的最终结果。

void *这么看和用id 其实也差不多,使用者拿到后都得转一下。。。