方法调用
让我们看一下方法调用在运行时的过程（参照前文类在runtime中的表示）
如果用实例对象调用实例方法，会到实例的isa指针指向的对象（也就是类对象）操作。
如果调用的是类方法，就会到类对象的isa指针指向的对象（也就是元类对象）中操作。
- 首先，在相应操作的对象中的缓存方法列表中找调用的方法，如果找到，转向相应实现并执行。
- 如果没找到，在相应操作的对象中的方法列表中找调用的方法，如果找到，转向相应实现执行
- 如果没找到，去父类指针所指向的对象中执行1，2.
- 以此类推，如果一直到根类还没找到，转向拦截调用。
- 如果没有重写拦截调用的方法，程序报错。
以上的过程给我带来的启发：
- 重写父类的方法，并没有覆盖掉父类的方法，只是在当前类对象中找到了这个方法后就不会再去父类中找了。
- 如果想调用已经重写过的方法的父类的实现，只需使用
super这个编译器标识，它会在运行时跳过在当前的类对象中寻找方法的过程。
拦截调用（消息转发）
在方法调用中说到了，如果没有找到方法就会转向拦截调用。
那么什么是拦截调用呢。
拦截调用就是，在找不到调用的方法程序崩溃之前，你有机会通过重写NSObject的四个方法来处理。
1 + (BOOL)resolveClassMethod:(SEL)sel; 2 + (BOOL)resolveInstanceMethod:(SEL)sel; 3 //后两个方法需要转发到其他的类处理 4 - (id)forwardingTargetForSelector:(SEL)aSelector; 5 - (void)forwardInvocation:(NSInvocation *)anInvocation;
- 第一个方法是当你调用一个不存在的类方法的时候，会调用这个方法，默认返回NO，你可以加上自己的处理然后返回YES。
- 第二个方法和第一个方法相似，只不过处理的是实例方法。
- 第三个方法是将你调用的不存在的方法重定向到一个其他声明了这个方法的类，只需要你返回一个有这个方法的target。
- 第四个方法是将你调用的不存在的方法打包成
NSInvocation传给你。做完你自己的处理后，调用invokeWithTarget:方法让某个target触发这个方法。
1、动态方法解析
+ (BOOL)resolveInstanceMethod:(SEL)sel;
首先，当接受到未能识别的选择子时，运行时系统会调用该函数用以给对象一次机会来添加相应的方法实现，如果用户在该函数中动态添加了相应方法的实现，则跳转到方法的实现部分，并将该实现存入缓存中，以供下次调用。
2、备援接收者
- (id)forwardingTargetForSelector:(SEL)aSelector;
如果运行时在消息转发的第一步中未找到所调用方法的实现，那么当前接收者还有第二次机会进行未知选择子的处理。这时运行期系统会调用上述方法，并将未知选择子作为参数传入，该方法可以返回一个能处理该选择子的对象，运行时系统会根据返回的对象进行查找，若找到则跳转到相应方法的实现，则消息转发结束。
3、完整的消息转发
- (void)forwardInvocation:(NSInvocation *)anInvocation;
当运行时系统检测到第二步中用户未返回能处理相应选择子的对象时，那么来到这一步就要启动完整的消息转发机制了。该方法可以改变消息调用目标，运行时系统根据所改变的调用目标，向调用目标方法列表中查询对应方法的实现并实现跳转，这种方式和第二步的操作非常相似。当然你也可以修改方法的选择子，亦或者向所调用方法中追加一个参数等来跳转到相关方法的实现。
最后，如果消息转发的第三步还未能处理该未知选择子的话，那么最终会调用NSObject类的如下方法用以异常的抛出，表明该选择子最终未能处理。
- (void)doesNotRecognizeSelector:(SEL)aSelector;
1.Runtime简介
因为Objc是一门动态语言，所以它总是想办法把一些决定工作从编译连接推迟到运行时。也就是说只有编译器是不够的，还需要一个运行时系统 (runtime system) 来执行编译后的代码。这就是 Objective-C Runtime 系统存在的意义，它是整个Objc运行框架的一块基石。
Runtime其实有两个版本:“modern”和 “legacy”。我们现在用的 Objective-C 2.0 采用的是现行(Modern)版的Runtime系统，只能运行在 iOS 和 OS X 10.5 之后的64位程序中。而OS X较老的32位程序仍采用 Objective-C 1中的（早期）Legacy 版本的 Runtime 系统。这两个版本最大的区别在于当你更改一个类的实例变量的布局时，在早期版本中你需要重新编译它的子类，而现行版就不需要。
Runtime基本是用C和汇编写的，可见苹果为了动态系统的高效而作出的努力。你可以在这里下到苹果维护的开源代码。苹果和GNU各自维护一个开源的runtime版本，这两个版本之间都在努力的保持一致。
前言
关于Objective-C Runtime一篇好的文档 : Understanding the Objective-C Runtime
译文地址为: http://blog.cocoabit.com/blog/2014/10/06/yi-li-jieobjective-cruntime/
Objective-C Runtime源码是开源的，下载地址为: http://opensource.apple.com/tarballs/objc4/
习题内容
@唐巧_boy在微博上分享了他们技术讨论会关于objc runtime的讨论习题内容，习题来自 sunnyxx(博客)。以下是习题内容(图片转自@唐巧_boy微博):
自己做完这些题之后，也顺便复习了一些Objective－C Runtime的知识，现在整理一下，分享给大家。
该笔记分为四篇：
刨根问底Objective－C Runtime（1）－ Self & Super
刨根问底Objective－C Runtime（2）－ Object & Class & Meta Class
刨根问底Objective－C Runtime（3）－ 消息和Category
刨根问底Objective－C Runtime（4）- 成员变量与属性
刨根问底Objective－C Runtime（1）－ Self & Super
下面的代码输出什么？
|
1
2
3
4
5
6
7
8
9
10
11
12
|
@implementation Son : Father
- (id)init
{
self = [ super init];
if (self)
{
NSLog(@ "%@" , NSStringFromClass([self class]));
NSLog(@ "%@" , NSStringFromClass([ super class]));
}
return self;
}
@end
|
答案：都输出 Son
|
1
2
|
2014-11-05 11:06:18.060 Test[8566:568584] NSStringFromClass([self class]) = Son
2014-11-05 11:06:18.061 Test[8566:568584] NSStringFromClass([ super class]) = Son
|
解惑：这个题目主要是考察关于objc中对 self 和 super 的理解。
self 是类的隐藏参数，指向当前调用方法的这个类的实例。而 super 是一个 Magic Keyword， 它本质是一个编译器标示符，和 self 是指向的同一个消息接受者。上面的例子不管调用[self class]还是[super class]，接受消息的对象都是当前 Son ＊xxx 这个对象。而不同的是，super是告诉编译器，调用 class 这个方法时，要去父类的方法，而不是本类里的。
当使用 self 调用方法时，会从当前类的方法列表中开始找，如果没有，就从父类中再找；而当使用 super 时，则从父类的方法列表中开始找。然后调用父类的这个方法。
真的是这样吗？继续看：
使用clang重写命令:
|
1
|
$ clang -rewrite-objc test.m
|
发现上述代码被转化为:
|
1
2
|
NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_a5cecc_mi_0, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName( "class" ))));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_a5cecc_mi_1, NSStringFromClass(((Class (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){ (id)self, (id)class_getSuperclass(objc_getClass( "Son" )) }, sel_registerName( "class" ))));
|
从上面的代码中，我们可以发现在调用 [self class] 时，会转化成 objc_msgSend函数。看下函数定义：
|
1
|
id objc_msgSend(id self, SEL op, ...)
|
我们把 self 做为第一个参数传递进去。
而在调用 [super class]时，会转化成 objc_msgSendSuper函数。看下函数定义:
|
1
|
id objc_msgSendSuper(struct objc_super * super , SEL op, ...)
|
第一个参数是 objc_super 这样一个结构体，其定义如下:
|
1
2
3
4
|
struct objc_super {
__unsafe_unretained id receiver;
__unsafe_unretained Class super_class;
};
|
结构体有两个成员，第一个成员是 receiver, 类似于上面的 objc_msgSend函数第一个参数self 。第二个成员是记录当前类的父类是什么。
所以，当调用 ［self class] 时，实际先调用的是 objc_msgSend函数，第一个参数是 Son当前的这个实例，然后在 Son 这个类里面去找 - (Class)class这个方法，没有，去父类 Father里找，也没有，最后在 NSObject类中发现这个方法。而 - (Class)class的实现就是返回self的类别，故上述输出结果为 Son。
objc Runtime开源代码对- (Class)class方法的实现:
|
1
2
3
|
- (Class)class {
return object_getClass(self);
}
|
而当调用 [super class]时，会转换成objc_msgSendSuper函数。第一步先构造 objc_super 结构体，结构体第一个成员就是 self 。第二个成员是 (id)class_getSuperclass(objc_getClass(“Son”)) , 实际该函数输出结果为 Father。第二步是去 Father这个类里去找- (Class)class，没有，然后去NSObject类去找，找到了。最后内部是使用 objc_msgSend(objc_super->receiver, @selector(class))去调用，此时已经和[self class]调用相同了，故上述输出结果仍然返回 Son。
刨根问底Objective－C Runtime（2）－ Object & Class & Meta Clas
本篇笔记主要是讲述objc runtime中关于Object & Class & Meta Class的细节。
习题内容
下面代码的运行结果是?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@interface Sark : NSObject
@end
@implementation Sark
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
BOOL res1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];
BOOL res2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
BOOL res3 = [(id)[Sark class] isKindOfClass:[Sark class]];
BOOL res4 = [(id)[Sark class] isMemberOfClass:[Sark class]];
NSLog(@ "%d %d %d %d" , res1, res2, res3, res4);
}
return 0;
}
|
运行结果为：
|
1
|
2014-11-05 14:45:08.474 Test[9412:721945] 1 0 0 0
|
这里先看几个概念
什么是 id
id 在 objc.h 中定义如下:
|
1
2
|
/// A pointer to an instance of a class.
typedef struct objc_object *id;
|
就像注释中所说的这样 id 是指向一个 objc_object 结构体的指针。
id 这个struct的定义本身就带了一个 *, 所以我们在使用其他NSObject类型的实例时需要在前面加上 *， 而使用 id 时却不用。
那么objc_object又是什么呢
objc_object 在 objc.h 中定义如下:
|
1
2
3
4
|
/// Represents an instance of a class.
struct objc_object {
Class isa;
};
|
这个时候我们知道Objective-C中的object在最后会被转换成C的结构体，而在这个struct中有一个 isa 指针，指向它的类别 Class。
那么什么是Class呢
在 objc.h 中定义如下:
|
1
2
|
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;
|
我们可以看到 Class本身指向的也是一个C的struct objc_class。
继续看在runtime.h中objc_class定义如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE;
const char *name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list *ivars OBJC2_UNAVAILABLE;
struct objc_method_list **methodLists OBJC2_UNAVAILABLE;
struct objc_cache *cache OBJC2_UNAVAILABLE;
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
|
该结构体中，isa 指向所属Class， super_class指向父类别。
继续看
下载objc源代码，在 objc-runtime-new.h 中，我们发现 objc_class有如下定义:
|
1
2
3
4
5
6
|
struct objc_class : objc_object {
// Class ISA;
Class superclass;
...
...
}
|
豁然开朗，我们看到在Objective-C的设计哲学中，一切都是对象。Class在设计中本身也是一个对象。而这个Class对象的对应的类，我们叫它 Meta Class。即Class结构体中的 isa 指向的就是它的 Meta Class。
Meta Class
根据上面的描述，我们可以把Meta Class理解为 一个Class对象的Class。简单的说：
|
1
2
|
当我们发送一个消息给一个NSObject对象时，这条消息会在对象的类的方法列表里查找
当我们发送一个消息给一个类时，这条消息会在类的Meta Class的方法列表里查找
|
而 Meta Class本身也是一个Class，它跟其他Class一样也有自己的 isa 和 super_class 指针。看下图：
-
每个Class都有一个isa指针指向一个唯一的Meta Class
-
每一个Meta Class的isa指针都指向最上层的Meta Class（图中的NSObject的Meta Class）
-
最上层的Meta Class的isa指针指向自己，形成一个回路
-
每一个Meta Class的super class指针指向它原本Class的 Super Class的Meta Class。但是最上层的Meta Class的 Super Class指向NSObject Class本身
-
最上层的NSObject Class的super class指向 nil
解惑
为了更加清楚的知道整个函数调用过程，我们使用clang -rewrite-objc main.m重写，可获得如下代码：
|
1
2
3
4
|
BOOL res1 = ((BOOL (*)(id, SEL, Class))(void *)objc_msgSend)((id)((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "class" )), sel_registerName( "isKindOfClass:" ), ((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "class" )));
BOOL res2 = ((BOOL (*)(id, SEL, Class))(void *)objc_msgSend)((id)((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "class" )), sel_registerName( "isMemberOfClass:" ), ((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "class" )));
BOOL res3 = ((BOOL (*)(id, SEL, Class))(void *)objc_msgSend)((id)((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "Sark" ), sel_registerName( "class" )), sel_registerName( "isMemberOfClass:" ), ((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "class" )));
BOOL res4 = ((BOOL (*)(id, SEL, Class))(void *)objc_msgSend)((id)((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "Sark" ), sel_registerName( "class" )), sel_registerName( "isMemberOfClass:" ), ((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "class" )));
|
先看前两个调用：
-
最外层是 objc_msgSend函数，转发消息。
-
函数第一个参数是 (id)((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("class"))
-
函数第二个参数是转发的selector
-
函数第三个参数是 ((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("class"))
我们注意到第一个参数和第三个参数对应重写的是[NSObject class]，即使用objc_msgSend向 NSObject Class 发送 @selector(class) 这个消息
打开objc源代码，在 Object.mm 中发现+ (Class)class实现如下:
|
1
2
3
|
+ (Class)class {
return self;
}
|
所以即返回Class类的对象本身。看如下输出:
|
1
2
3
4
|
NSLog(@ "%p" , [NSObject class]);
NSLog(@ "%p" , [NSObject class]);
2014-11-05 18:48:30.939 Test[11682:865988] 0x7fff768d40f0
2014-11-05 18:48:30.940 Test[11682:865988] 0x7fff768d40f0
|
继续打开objc源代码，在 Object.mm 中，我们发现 isKindOfClass的实现如下:
|
1
2
3
4
5
6
7
8
|
- (BOOL)isKindOf:aClass
{
Class cls;
for (cls = isa; cls; cls = cls->superclass)
if (cls == (Class)aClass)
return YES;
return NO;
}
|
对着上面Meta Class的图和实现，我们可以看出
-
当 NSObject Class对象第一次进行比较时，得到它的isa为 NSObject的Meta Class， 这个时候 NSObject Meta Class 和 NSObject Class不相等。
-
然后取NSObject 的Meta Class 的Super class，这个时候又变成了 NSObject Class， 所以返回相等。
所以上述第一个输出结果是 YES 。
我们在看下 ‘isMemberOfClass’的实现:
|
1
2
3
4
|
- (BOOL)isMemberOf:aClass
{
return isa == (Class)aClass;
}
|
综上所述，当前的 isa 指向 NSObject 的 Meta Class， 所以和 NSObject Class不相等。
所以上述第二个输出结果为 NO 。
继续看后面两个调用:
-
Sark Class 的isa指向的是 Sark的Meta Class，和Sark Class不相等
-
Sark Meta Class的super class 指向的是 NSObject Meta Class， 和 Sark Class不相等
-
NSObject Meta Class的 super class 指向 NSObject Class，和 Sark Class 不相等
-
NSObject Class 的super class 指向 nil， 和 Sark Class不相等
所以后面两个调用的结果都输出为 NO 。
刨根问底Objective－C Runtime（3）－ 消息 和 Category
理解这些概念之间关系最好的方式是：一个类（Class）维护一张调度表（dispatch table）用于解析运行时发送的消息；调度表中的每个实体（entry）都是一个方法（Method），其中key值是一个唯一的名字——选择器（SEL），它对应到一个实现（IMP）——实际上就是指向标准C函数的指针。
本篇笔记主要是讲述objc runtime的 消息和Category。
习题内容
下面的代码会？Compile Error / Runtime Crash / NSLog…?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
@interface NSObject (Sark)
+ (void)foo;
@end
@implementation NSObject (Sark)
- (void)foo
{
NSLog(@ "IMP: -[NSObject(Sark) foo]" );
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
[NSObject foo];
[[NSObject new ] foo];
}
return 0;
}
|
答案：代码正常输出，输出结果如下：
|
1
2
|
2014-11-06 13:11:46.694 Test[14872:1110786] IMP: -[NSObject(Sark) foo]
2014-11-06 13:11:46.695 Test[14872:1110786] IMP: -[NSObject(Sark) foo]
|
使用clang -rewrite-objc main.m重写，我们可以发现 main 函数中两个方法调用被转换成如下代码：
|
1
2
|
((void (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "foo" ));
((void (*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass( "NSObject" ), sel_registerName( "new" )), sel_registerName( "foo" ));
|
我们发现上述两个方法最终转换成使用 objc_msgSend 函数传递消息。
这里先看几个概念
objc_msgSend函数定义如下:
|
1
|
id objc_msgSend(id self, SEL op, ...)
|
关于 id 的解释请看objc runtime系列第二篇博文： objc runtime中Object & Class & Meta Class的细节
什么是 SEL（选择器）
打开objc.h文件，看下SEL的定义如下:
|
1
|
typedef struct objc_selector *SEL;
|
SEL本质上是一个指向objc_selector结构体的指针。而 objc_selector 的定义并没有在runtime.h中给出定义。我们可以尝试运行如下代码:
|
1
2
3
4
5
6
7
|
SEL sel = @selector(foo);
NSLog(@ "%s" , (char *)sel);
NSLog(@ "%p" , sel);
const char *selName = [@ "foo" UTF8String];
SEL sel2 = sel_registerName(selName);
NSLog(@ "%s" , (char *)sel2);
NSLog(@ "%p" , sel2);
|
输出如下:
|
1
2
3
4
|
2014-11-06 13:46:08.058 Test[15053:1132268] foo
2014-11-06 13:46:08.058 Test[15053:1132268] 0x7fff8fde5114
2014-11-06 13:46:08.058 Test[15053:1132268] foo
2014-11-06 13:46:08.058 Test[15053:1132268] 0x7fff8fde5114
|
方法的selector用于表示运行时方法的名字。Objective-C在编译时，会依据每一个方法的名字、参数序列，生成一个唯一的整型标识(Int类型的地址)，这个标识就是SEL
Objective-C在编译时，会根据方法的名字生成一个用来区分这个方法的唯一的一个ID。只要方法名称相同，那么它们的ID就是相同的。
两个类之间，不管它们是父类与子类的关系，还是之间没有这种关系，只要方法名相同，那么它的SEL就是一样的。每一个方法都对应着一个SEL。编译器会根据每个方法的方法名为那个方法生成唯一的SEL。这些SEL组成了一个Set集合，当我们在这个集合中查找某个方法时，只需要去找这个方法对应的SEL即可。而SEL本质是一个字符串，所以直接比较它们的地址即可。
当然，不同的类可以拥有相同的selector。不同类的实例对象执行相同的selector时，会在各自的方法列表中去根据selector去寻找自己对应的IMP。
我们可以通过下面三种方法来获取SEL:
1. sel_registerName函数
2. Objective-C编译器提供的@selector()
3. NSSelectorFromString()方法
那么什么是IMP（实现）
继续看定义:
|
1
|
typedef id (*IMP)(id, SEL, ...);
|
IMP实际上是一个函数指针，指向方法实现的首地址。
这个函数使用当前CPU架构实现的标准的C调用约定。第一个参数是指向self的指针(如果是实例方法，则是类实例的内存地址；如果是类方法，则是指向元类的指针)，第二个参数是方法选择器(selector)，接下来是方法的实际参数列表。
前面介绍过的SEL就是为了查找方法的最终实现IMP的。由于每个方法对应唯一的SEL，因此我们可以通过SEL方便快速准确地获得它所对应的 IMP，查找过程将在下面讨论。取得IMP后，我们就获得了执行这个方法代码的入口点，此时，我们就可以像调用普通的C语言函数一样来使用这个函数指针 了。
通过取得IMP，我们可以跳过Runtime的消息传递机制，直接执行IMP指向的函数实现，这样省去了Runtime消息传递过程中所做的一系列查找操作，会比直接向对象发送消息高效一些。
那么 objc_msgSend 到底是怎么工作的呢？
在Objective-C中，消息直到运行时才会绑定到方法的实现上。编译器会把代码中[target doSth]转换成 objc_msgSend消息函数，这个函数完成了动态绑定的所有事情。它的运行流程如下:
-
检查selector是否需要忽略。(ps: Mac开发中开启GC就会忽略retain,release方法。)
-
检查target是否为nil。如果为nil，直接cleanup，然后return。(这就是我们可以向nil发送消息的原因。)
-
然后在target的Class中根据Selector去找IMP
寻找IMP的过程:
-
先从当前class的cache方法列表（cache methodLists）里去找
-
找到了，跳到对应函数实现
-
没找到，就从class的方法列表（methodLists）里找
-
还找不到，就到super class的方法列表里找，直到找到基类(NSObject)为止
-
最后再找不到，就会进入动态方法解析和消息转发的机制。(这部分知识，下次再细谈)
那么什么是方法列表呢？
上一篇博文中提到了objc_class结构体定义，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE;
const char *name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list *ivars OBJC2_UNAVAILABLE;
struct objc_method_list **methodLists OBJC2_UNAVAILABLE;
struct objc_cache *cache OBJC2_UNAVAILABLE;
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
struct objc_method_list {
struct objc_method_list *obsolete OBJC2_UNAVAILABLE;
int method_count OBJC2_UNAVAILABLE;
#ifdef __LP64__
int space OBJC2_UNAVAILABLE;
#endif
/* variable length structure */
struct objc_method method_list[1] OBJC2_UNAVAILABLE;
}
|
1) objc_method_list 就是用来存储当前类的方法链表，objc_method存储了类的某个方法的信息。
Method（方法）
|
1
|
typedef struct objc_method *Method;
|
Method 是用来代表类中某个方法的类型，它实际就指向objc_method结构体，如下:
|
1
2
3
4
5
|
struct objc_method {
SEL method_name OBJC2_UNAVAILABLE;
char *method_types OBJC2_UNAVAILABLE;
IMP method_imp OBJC2_UNAVAILABLE;
} OBJC2_UNAVAILABLE;
|
method_types是个char指针，存储着方法的参数类型和返回值类型。
SEL 和 IMP 就是我们上文提到的，所以我们可以理解为objc_class中 method list保存了一组SEL<->IMP的映射。
2）objc_cache 用来缓存用过的方法，提高性能。
Cache
|
1
|
typedef struct objc_cache *Cache OBJC2_UNAVAILABLE;
|
实际指向objc_cache结构体，如下:
|
1
2
3
4
5
|
struct objc_cache {
unsigned int mask /* total = mask + 1 */ OBJC2_UNAVAILABLE;
unsigned int occupied OBJC2_UNAVAILABLE;
Method buckets[1] OBJC2_UNAVAILABLE;
};
|
-
mask: 指定分配cache buckets的总数。在方法查找中，Runtime使用这个字段确定数组的索引位置
-
occupied: 实际占用cache buckets的总数
-
buckets: 指定Method数据结构指针的数组。这个数组可能包含不超过mask+1个元素。需要注意的是，指针可能是NULL，表示这个缓存bucket没有被占用，另外被占用的bucket可能是不连续的。这个数组可能会随着时间而增长。
objc_msgSend每调用一次方法后，就会把该方法缓存到cache列表中，下次的时候，就直接优先从cache列表中寻找，如果cache没有，才从methodLists中查找方法。
说完了 objc_msgSend， 那么题目中的Category又是怎么工作的呢?
继续看概念
我们知道Catagory可以动态地为已经存在的类添加新的方法。这样可以保证类的原始设计规模较小，功能增加时再逐步扩展。在runtime.h中查看定义:
|
1
|
typedef struct objc_category *Category;
|
同样也是指向一个 objc_category 的C 结构体，定义如下:
|
1
2
3
4
5
6
7
|
struct objc_category {
char *category_name OBJC2_UNAVAILABLE;
char *class_name OBJC2_UNAVAILABLE;
struct objc_method_list *instance_methods OBJC2_UNAVAILABLE;
struct objc_method_list *class_methods OBJC2_UNAVAILABLE;
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE;
} OBJC2_UNAVAILABLE;
|
通过上面的结构体，大家可以很清楚的看出存储的内容。我们继续往下看，打开objc源代码，在 objc-runtime-new.h中我们可以发现如下定义:
|
1
2
3
4
5
6
7
8
|
struct category_t {
const char *name;
classref_t cls;
struct method_list_t *instanceMethods;
struct method_list_t *classMethods;
struct protocol_list_t *protocols;
struct property_list_t *instanceProperties;
};
|
上面的定义需要提到的地方有三点:
-
name 是指 class_name 而不是 category_name
-
cls是要扩展的类对象，编译期间是不会定义的，而是在Runtime阶段通过name对应到对应的类对象
-
instanceProperties表示Category里所有的properties，这就是我们可以通过objc_setAssociatedObject和objc_getAssociatedObject增加实例变量的原因，不过这个和一般的实例变量是不一样的
为了验证上述内容，我们使用clang -rewrite-objc main.m重写，题目中的Category被编译器转换成了这样:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
// @interface NSObject (Sark)
// + (void)foo;
/* @end */
// @implementation NSObject (Sark)
static void _I_NSObject_Sark_foo(NSObject * self, SEL _cmd) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_dd1ee3_mi_0);
}
// @end
static struct _category_t _OBJC_$_CATEGORY_NSObject_$_Sark __attribute__ ((used, section ( "__DATA,__objc_const" ))) =
{
"NSObject" ,
0, // &OBJC_CLASS_$_NSObject,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_NSObject_$_Sark,
0,
0,
0,
};
static struct _category_t *L_OBJC_LABEL_CATEGORY_$ [1] __attribute__((used, section ( "__DATA, __objc_catlist,regular,no_dead_strip" )))= {
&_OBJC_$_CATEGORY_NSObject_$_Sark,
};
|
-
_OBJC_$_CATEGORY_NSObject_$_Sark是按规则生成的字符串，我们可以清楚的看到是NSObject类,且Sark是NSObject类的Category
-
_category_t结构体第二项 classref_t 没有数据，验证了我们上面的说法
-
由于题目中只有 - (void)foo方法，所以结构体中存储的list只有第三项instanceMethods被填充。
-
_I_NSObject_Sark_foo代表了Category的foo方法，I表示实例方法
-
最后这个类的Category生成了一个数组，存在了__objc_catlist里，目前数组的内容只有一个&_OBJC_$_CATEGORY_NSObject_$_Sark
最终这些Category里面的方法是如何被加载的呢?
1.打开objc源代码，找到 objc-os.mm, 函数_objc_init为runtime的加载入口，由libSystem调用，进行初始化操作。
2.之后调用objc-runtime-new.mm -> map_images加载map到内存
3.之后调用objc-runtime-new.mm->_read_images初始化内存中的map, 这个时候将会load所有的类，协议还有Category。NSOBject的+load方法就是这个时候调用的
这里贴上Category被加载的代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
// Discover categories.
for (EACH_HEADER) {
category_t **catlist =
_getObjc2CategoryList(hi, &count);
for (i = 0; i < count; i++) {
category_t *cat = catlist[i];
Class cls = remapClass(cat->cls);
if (!cls) {
// Category's target class is missing (probably weak-linked).
// Disavow any knowledge of this category.
catlist[i] = nil;
if (PrintConnecting) {
_objc_inform( "CLASS: IGNORING category \?\?\?(%s) %p with "
"missing weak-linked target class" ,
cat->name, cat);
}
continue ;
}
// Process this category.
// First, register the category with its target class.
// Then, rebuild the class's method lists (etc) if
// the class is realized.
BOOL classExists = NO;
if (cat->instanceMethods || cat->protocols
|| cat->instanceProperties)
{
addUnattachedCategoryForClass(cat, cls, hi);
if (cls->isRealized()) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform( "CLASS: found category -%s(%s) %s" ,
cls->nameForLogging(), cat->name,
classExists ? "on existing class" : "" );
}
}
if (cat->classMethods || cat->protocols
/* || cat->classProperties */ )
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform( "CLASS: found category +%s(%s)" ,
cls->nameForLogging(), cat->name);
}
}
}
}
|
1) 循环调用了 _getObjc2CategoryList方法，这个方法的实现是:
|
1
|
GETSECT(_getObjc2CategoryList, category_t *, "__objc_catlist" );
|
方法中最后一个参数__objc_catlist就是编译器刚刚生成的category数组
2) load完所有的categories之后，开始对Category进行处理。
从上面的代码中我们可以发现：实例方法被加入到了当前的类对象中, 类方法被加入到了当前类的Meta Class中 (cls->ISA)
Step 1. 调用addUnattachedCategoryForClass方法
Step 2. 调用remethodizeClass方法, 在remethodizeClass的实现里调用attachCategoryMethods
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
static void
attachCategoryMethods(Class cls, category_list *cats, bool flushCaches)
{
if (!cats) return ;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
method_list_t **mlists = (method_list_t **)
_malloc_internal(cats->count * sizeof(*mlists));
// Count backwards through cats to get newest categories first
int mcount = 0;
int i = cats->count;
BOOL fromBundle = NO;
while (i--) {
method_list_t *mlist = cat_method_list(cats->list[i].cat, isMeta);
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= cats->list[i].fromBundle;
}
}
attachMethodLists(cls, mlists, mcount, NO, fromBundle, flushCaches);
_free_internal(mlists);
}
|
这里把一个类的category_list的所有方法取出来生成了method list。这里是倒序添加的，也就是说，新生成的category的方法会先于旧的category的方法插入。
之后调用attachMethodLists将所有方法前序添加进类的method list中，如果原来类的方法列表是a，b，Category的方法列表是c，d。那么插入之后的方法列表将会是c，d，a，b。
小发现
看上面被编译器转换的代码，我们发现Category头文件被注释掉了，结合上面category的加载过程。这就是我们即使没有import category的头文件，都能够成功调用到Category方法的原因。
runtime加载完成后，Category的原始信息在类结构中将不会存在。
解惑
根据上面提到的知识，我们对题目中的代码进行分析。
1) objc runtime加载完后，NSObject的Sark Category被加载。而NSObject的Sark Category的头文件 + (void)foo 并没有实质参与到工作中，只是给编译器进行静态检查，所有我们编译上述代码会出现警告，提示我们没有实现 + (void)foo 方法。而在代码编译中，它已经被注释掉了。
2) 实际被加入到Class的method list的方法是 - (void)foo，它是一个实例方法，所以加入到当前类对象NSObject的方法列表中，而不是NSObject Meta class的方法列表中。
3) 当执行 [NSObject foo]时，我们看下整个objc_msgSend的过程:
结合上一篇Meta Class的知识：
-
objc_msgSend 第一个参数是 “(id)objc_getClass("NSObject")”，获得NSObject Class的对象。
-
类方法在Meta Class的方法列表中找，我们在load Category方法时加入的是- (void)foo实例方法，所以并不在NSOBject Meta Class的方法列表中
-
继续往 super class中找，在上一篇博客中我们知道，NSObject Meta Class的super class是NSObject本身。所以，这个时候我们能够找到- (void)foo 这个方法。
-
所以正常输出结果
4) 当执行[[NSObject new] foo]，我们看下整个objc_msgSend的过程:
-
[NSObject new]生成一个NSObject对象。
-
直接在该对象的类（NSObject）的方法列表里找。
-
能够找到，所以正常输出结果。
刨根问底Objective－C Runtime（4）－ 成员变量与属性
本篇笔记主要是讲述objc runtime的 成员变量和属性。
习题内容
下面代码会? Compile Error / Runtime Crash / NSLog…?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
@interface Sark : NSObject
@property (nonatomic, copy) NSString *name;
@end
@implementation Sark
- (void)speak
{
NSLog(@ "my name is %@" , self.name);
}
@end
@interface Test : NSObject
@end
@implementation Test
- (instancetype)init
{
self = [ super init];
if (self) {
id cls = [Sark class];
void *obj = &cls;
[(__bridge id)obj speak];
}
return self;
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
[[Test alloc] init];
}
return 0;
}
|
答案：代码正常输出，输出结果为：
|
1
|
2014-11-07 14:08:25.698 Test[1097:57255] my name is
|
为什么呢?
前几节博文中多次讲到了objc_class结构体，今天我们再拿出来看一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE;
const char *name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list *ivars OBJC2_UNAVAILABLE;
struct objc_method_list **methodLists OBJC2_UNAVAILABLE;
struct objc_cache *cache OBJC2_UNAVAILABLE;
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
|
其中objc_ivar_list结构体存储着objc_ivar数组列表，而objc_ivar结构体存储了类的单个成员变量的信息。
那么什么是Ivar呢？
Ivar 在objc中被定义为：
|
1
|
typedef struct objc_ivar *Ivar;
|
它是一个指向objc_ivar结构体的指针，结构体有如下定义：
|
1
2
3
4
5
6
7
8
|
struct objc_ivar {
char *ivar_name OBJC2_UNAVAILABLE;
char *ivar_type OBJC2_UNAVAILABLE;
int ivar_offset OBJC2_UNAVAILABLE;
#ifdef __LP64__
int space OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
|
这里我们注意第三个成员 ivar_offset。它表示基地址偏移字节。
在编译我们的类时，编译器生成了一个 ivar布局，显示了在类中从哪可以访问我们的 ivars 。看下图:
上图中，左侧的数据就是地址偏移字节，我们对 ivar 的访问就可以通过 对象地址 ＋ ivar偏移字节的方法。但是这又引发一个问题，看下图:
我们增加了父类的ivar，这个时候布局就出错了，我们就不得不重新编译子类来恢复兼容性。
而Objective－C Runtime中使用了Non Fragile ivars，看下图:
使用Non Fragile ivars时，Runtime会进行检测来调整类中新增的ivar的偏移量。 这样我们就可以通过 对象地址 ＋ 基类大小 + ivar偏移字节的方法来计算出ivar相应的地址，并访问到相应的ivar。
我们来看一个例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
@interface Student : NSObject
{
@private
NSInteger age;
}
@end
@implementation Student
- (NSString *)description
{
return [NSString stringWithFormat:@ "age = %d" , age];
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Student *student = [[Student alloc] init];
student->age = 24;
}
return 0;
}
|
上述代码，Student有两个被标记为private的ivar，这个时候当我们使用 -> 访问时，编译器会报错。那么我们如何设置一个被标记为private的ivar的值呢?
通过上面的描述，我们知道ivar是通过计算字节偏量来确定地址，并访问的。我们可以改成这样:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
@interface Student : NSObject
{
@private
int age;
}
@end
@implementation Student
- (NSString *)description
{
NSLog(@ "current pointer = %p" , self);
NSLog(@ "age pointer = %p" , &age);
return [NSString stringWithFormat:@ "age = %d" , age];
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Student *student = [[Student alloc] init];
Ivar age_ivar = class_getInstanceVariable(object_getClass(student), "age" );
int *age_pointer = (int *)((__bridge void *)(student) + ivar_getOffset(age_ivar));
NSLog(@ "age ivar offset = %td" , ivar_getOffset(age_ivar));
*age_pointer = 10;
NSLog(@ "%@" , student);
}
return 0;
}
|
上述代码的输出结果为:
|
1
2
3
4
|
2014-11-08 18:24:38.892 Test[4143:466864] age ivar offset = 8
2014-11-08 18:24:38.893 Test[4143:466864] current pointer = 0x1001002d0
2014-11-08 18:24:38.893 Test[4143:466864] age pointer = 0x1001002d8
2014-11-08 18:24:38.894 Test[4143:466864] age = 10
|
我们可以清晰的看到指针地址的变化和偏移量，和我们上述描述一致。
说完了Ivar， 那Property又是怎么样的呢？
使用clang -rewrite-objc main.m重写题目中的代码，我们发现Sark类中的name属性被转换成了如下代码:
|
1
2
3
4
5
6
7
8
9
|
struct Sark_IMPL {
struct NSObject_IMPL NSObject_IVARS;
NSString *_name;
};
// @property (nonatomic, copy) NSString *name;
/* @end */
// @implementation Sark
static NSString * _I_Sark_name(Sark * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_Sark$_name)); }
static void _I_Sark_setName_(Sark * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct Sark, _name), (id)name, 0, 1); }
|
类中的Property属性被编译器转换成了Ivar，并且自动添加了我们熟悉的Set和Get方法。
我们这个时候回头看一下objc_class结构体中的内容，并没有发现用来专门记录Property的list。我们翻开objc源代码，在objc-runtime-new.h中，发现最终还是会通过在class_ro_t结构体中使用property_list_t存储对应的propertyies。
而在刚刚重写的代码中，我们可以找到这个property_list_t:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
static struct /*_prop_list_t*/ {
unsigned int entsize; // sizeof(struct _prop_t)
unsigned int count_of_properties;
struct _prop_t prop_list[1];
} _OBJC_$_PROP_LIST_Sark __attribute__ ((used, section ( "__DATA,__objc_const" ))) = {
sizeof(_prop_t),
1,
name
};
static struct _class_ro_t _OBJC_CLASS_RO_$_Sark __attribute__ ((used, section ( "__DATA,__objc_const" ))) = {
0, __OFFSETOFIVAR__(struct Sark, _name), sizeof(struct Sark_IMPL),
(unsigned int)0,
0,
"Sark" ,
(const struct _method_list_t *)&_OBJC_$_INSTANCE_METHODS_Sark,
0,
(const struct _ivar_list_t *)&_OBJC_$_INSTANCE_VARIABLES_Sark,
0,
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Sark,
};
|
解惑
1）为什么能够正常运行，并调用到speak方法？
|
1
2
3
|
id cls = [Sark class];
void *obj = &cls;
[(__bridge id)obj speak];
|
obj被转换成了一个指向Sark Class的指针，然后使用id转换成了objc_object类型。这个时候的obj已经相当于一个Sark的实例对象(但是和使用[Sark new]生成的对象还是不一样的)，我们回想下Runtime的第二篇博文中objc_object结构体的构成就是一个指向Class的isa指针。
这个时候我们再回想下上一篇博文中objc_msgSend的工作流程，在代码中的obj指向的Sark Class中能够找到speak方法，所以代码能够正常运行。
2) 为什么self.name的输出为?
我们在测试代码中加入一些调试代码和Log如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
- (void)speak
{
unsigned int numberOfIvars = 0;
Ivar *ivars = class_copyIvarList([self class], &numberOfIvars);
for (const Ivar *p = ivars; p < ivars+numberOfIvars; p++) {
Ivar const ivar = *p;
ptrdiff_t offset = ivar_getOffset(ivar);
const char *name = ivar_getName(ivar);
NSLog(@ "Sark ivar name = %s, offset = %td" , name, offset);
}
NSLog(@ "my name is %p" , &_name);
NSLog(@ "my name is %@" , *(&_name));
}
@implementation Test
- (instancetype)init
{
self = [ super init];
if (self) {
NSLog(@ "Test instance = %@" , self);
void *self2 = (__bridge void *)self;
NSLog(@ "Test instance pointer = %p" , &self2);
id cls = [Sark class];
NSLog(@ "Class instance address = %p" , cls);
void *obj = &cls;
NSLog(@ "Void *obj = %@" , obj);
[(__bridge id)obj speak];
}
return self;
}
@end
|
输出结果如下:
|
1
2
3
4
5
|
2014-11-11 00:56:02.464 Test[10475:1071029] Test instance = 2014-11-11 00:56:02.464 Test[10475:1071029] Test instance pointer = 0x7fff5fbff7c8
2014-11-11 00:56:02.465 Test[10475:1071029] Class instance address = 0x1000023c8
2014-11-11 00:56:02.465 Test[10475:1071029] Void *obj = 2014-11-11 00:56:02.465 Test[10475:1071029] Sark ivar name = _name, offset = 8
2014-11-11 00:56:02.465 Test[10475:1071029] my name is 0x7fff5fbff7c8
2014-11-11 00:56:02.465 Test[10475:1071029] my name is
|
Sark中Propertyname最终被转换成了Ivar加入到了类的结构中，Runtime通过计算成员变量的地址偏移来寻找最终Ivar的地址，我们通过上述输出结果，可以看到 Sark的对象指针地址加上Ivar的偏移量之后刚好指向的是Test对象指针地址。
这里的原因主要是因为在C中，局部变量是存储到内存的栈区，程序运行时栈的生长规律是从地址高到地址低。C语言到头来讲是一个顺序运行的语言，随着程序运行，栈中的地址依次往下走。
看下图，可以清楚的展示整个计算的过程：
我们可以做一个另外的实验，把Test Class 的init方法改为如下代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
@interface Father : NSObject
@end
@implementation Father
@end
@implementation Test
- (instancetype)init
{
self = [ super init];
if (self) {
NSLog(@ "Test instance = %@" , self);
id fatherCls = [Father class];
void *father;
father = (void *)&fatherCls;
id cls = [Sark class];
void *obj;
obj = (void *)&cls;
[(__bridge id)obj speak];
}
return self;
}
@end
|
你会发现这个时候的输出变成了:
|
1
2
3
4
|
2014-11-08 21:40:36.724 Test[4845:543231] Test instance = 2014-11-08 21:40:36.725 Test[4845:543231] ivar name = _name, offset = 8
2014-11-08 21:40:36.726 Test[4845:543231] Sark instance = 0x7fff5fbff7b8
2014-11-08 21:40:36.726 Test[4845:543231] my name is 0x7fff5fbff7c0
2014-11-08 21:40:36.726 Test[4845:543231] my name is
|
关于C语言内存分配和使用的问题可参考这篇文章 http://www.th7.cn/Program/c/201212/114923.shtml。
（via：Chun Tips）