前言
objective-c 是一门动态语言，它将很多静态语言在编译和链接时期做的事情，放到了运行时来处理。之所以能具备这种特性，离不开 runtime 这个库。runtime 很好的解决了如何在运行时期找到调用方法这样的问题。下面话不多说了，来一起学习学习吧。
在 objective-c 中，方法调用称为向对象发送消息：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
// myclass 类
@interface myclass: nsobject
- (void)printlog;
@end
@implementation myclass
- (void)printlog {
nslog(@"print log !");
}
@end
myclass *myclass = [[myclass alloc] init];
[myclass printlog];
// 输出： print log !
|
上面代码中的 [myclass printlog] 也可以这么写：
|
1
|
((void (*)(id, sel))(void *) objc_msgsend)(myclass, @selector(printlog));
|
[myclass printlog] 经过编译后就是调用 objc_msgsend 方法。
我们看看这个方法的文档定义：
|
1
|
id objc_msgsend(id self, sel op, ...);
|
self：消息的接收者 op： 消息的方法名，c 字符串 … ：参数列表
runtime 是如何找到实例方法的具体实现的？
基础概念
讲之前，我们需要先明白一些基础概念：objective-c 是一门面向对象的语言，对象又分为实例对象、类对象、元类对象以及根元类对象。它们是通过一个叫 isa 的指针来关联起来，具体关系如下图：
以我们上文的代码为例：
|
1
|
myclass *myclass = [[myclass alloc] init];
|
整理下相互间的关系：
- myclass 是实例对象
- myclass 是类对象
- myclass 的元类就是 nsobject 的元类
- nsobject 就是 root class (class)
- nsobject 的 superclass 为 nil
- nsobject 的元类就是它自己
- nsobject 的 superclass 就是 nsobject
对应上图中的位置关系如下：
接着，我们用代码来验证下上文的关系：
|
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
|
myclass *myclass = [[myclass alloc] init];
class class = [myclass class];
class metaclass = object_getclass(class);
class metaofmetaclass = object_getclass(metaclass);
class rootmetaclass = object_getclass(metaofmetaclass);
class superclass = class_getsuperclass(class);
class superofsuperclass = class_getsuperclass(superclass);
class superofmetaofsuperclass = class_getsuperclass(object_getclass(superclass));
nslog(@"myclass 实例对象是：%p",myclass);
nslog(@"myclass 类对象是：%p",class);
nslog(@"myclass 元类对象是：%p",metaclass);
nslog(@"myclass 元类对象的元类对象是：%p",metaofmetaclass);
nslog(@"myclass 根元类对象是：%p",rootmetaclass);
nslog(@"myclass 父类是：%@",class_getsuperclass(class));
nslog(@"myclass 父类的父类是：%@",superofsuperclass);
nslog(@"myclass 父类的元类的父类是：%@",superofmetaofsuperclass);
nslog(@"nsobject 元类对象是：%p",object_getclass([nsobject class]));
nslog(@"nsobject 父类是：%@",[[nsobject class] superclass]);
nslog(@"nsobject 元类对象的父类是：%@",[object_getclass([nsobject class]) superclass]);
//输出：
myclass 实例对象是：0x60c00000b8d0
myclass 类对象是：0x109ae3fd0
myclass 元类对象是：****0x109ae3fa8
myclass 元类对象的元类对象是：****0x10ab02e58**
myclass 根元类对象是：0x10ab02e58
myclass 父类是：nsobject
myclass 父类的父类是：(null)
myclass 父类的元类的父类是：nsobject
nsobject 元类对象是：0x10ab02e58
nsobject 父类是：(null)
nsobject 元类对象的父类是：nsobject
|
可以发现，输出结果是完全符合我们的结论的！
现在我们能知道各种对象之间的关系：
实例对象通过 isa 指针，找到类对象 class；类对象同样通过 isa 指针，找到元类对象；元类对象也是通过 isa 指针，找到根元类对象；最后，根元类对象的 isa 指针，指向自己。可以发现 nsobject 是整个消息机制的核心，绝大数对象都继承自它。
寻找流程
上文提到了，一个 objective-c 方法会被编译成 objc_msgsend，这个函数有两个默认参数，id 类型的 self, sel 类型的 op。我们先看看 id 的定义：
|
1
2
3
4
|
typedef struct objc_object *id;
struct objc_object {
class _nonnull isa objc_isa_availability;
};
|
我们可以看到，在 objc_object 结构体中，只有一个指向 class 类型的 isa 指针。
我们再看看 class 的定义：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
struct objc_class {
class _nonnull isa objc_isa_availability;
#if !__objc2__
class _nullable super_class objc2_unavailable;
const char * _nonnull name objc2_unavailable;
long version objc2_unavailable;
long info objc2_unavailable;
long instance_size objc2_unavailable;
struct objc_ivar_list * _nullable ivars objc2_unavailable;
struct objc_method_list * _nullable * _nullable methodlists objc2_unavailable;
struct objc_cache * _nonnull cache objc2_unavailable;
struct objc_protocol_list * _nullable protocols objc2_unavailable;
#endif
} objc2_unavailable;
|
里面有很多参数，很显眼的能看到这一行：
|
1
|
struct objc_method_list * _nullable * _nullable methodlists objc2_unavailable;
|
看名字也容易理解，这个 methodlists 就是用来存放方法列表的。我们再看看 objc_method_list 这个结构体：
|
1
2
3
4
5
6
7
8
9
10
|
struct objc_method_list {
struct objc_method_list * _nullable 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;
}
|
里面的 objc_method ，也就是我们熟悉的 method：
|
1
2
3
4
5
|
struct objc_method {
sel _nonnull method_name objc2_unavailable;
char * _nullable method_types objc2_unavailable;
imp _nonnull method_imp objc2_unavailable;
}
|
method 里面保存了三个参数：
- 方法的名称
- 方法的类型
- 方法的具体实现，由 imp 指针指向
经过层层挖掘，我们能明白实例对象调用方法的大致逻辑：
|
1
2
|
myclass *myclass = [[myclass alloc] init];
[myclass printlog];
|
-
先被编译成
((void (*)(id, sel))(void *) objc_msgsend)(myclass, @selector(printlog)); - 沿着入参 myclass 的 isa 指针，找到 myclass 的类对象（class），也就是 myclass
- 接着在 myclass 的方法列表 methodlists 中，找到对应的 method
- 最后找到 method 中的 imp 指针，执行具体实现
类对象的类方法又是怎么找到并执行的？
由上文，我们已经知道，实例对象是通过 isa 指针，找到其类对象（class）中保存的方法列表中的具体实现的。
比如：
|
1
2
|
myclass *myclass = [[myclass alloc] init];
[myclass printlog];
|
可以理解为：printlog 方法就是保存在 myclass 中的。
那么如果是个类方法，又是保存在什么地方的呢？
我们回顾下 class 的定义：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
struct objc_class {
class _nonnull isa objc_isa_availability;
#if !__objc2__
class _nullable super_class objc2_unavailable;
const char * _nonnull name objc2_unavailable;
long version objc2_unavailable;
long info objc2_unavailable;
long instance_size objc2_unavailable;
struct objc_ivar_list * _nullable ivars objc2_unavailable;
struct objc_method_list * _nullable * _nullable methodlists objc2_unavailable;
struct objc_cache * _nonnull cache objc2_unavailable;
struct objc_protocol_list * _nullable protocols objc2_unavailable;
#endif
} objc2_unavailable;
|
可以发现到这一行：
|
1
|
class _nonnull isa objc_isa_availability;
|
这里的 isa 同样是指向一个 class 的指针。上文中，我们也知道了类对象的 isa 指针是指向元类对象的。那么不难得出：
类对象的类方法，是保存在元类对象中的！
类对象和元类对象都是 class 类型，仅仅服务的对象不同罢了。找到了元类对象，自然就找到了元类对象中的 methodlists，接下来就和实例对象的方法寻找调用一样的流程了。
关于父类（superclass）
在 objective-c 中，子类调用一个方法，如果没有子类没有实现，父类实现了，会去调用父类的实现。上文中，找到 methodlists 后，寻找 method 的过程如下：
如何提高方法查找的效率？
上文中，我们大概知道，方法是通过 isa 指针，查找 class 中的 methodlists 的。如果子类没实现对应的方法实现，还会沿着父类去查找。整个工程，可能有成万上亿个方法，是如何解决性能问题的呢？
例如：
|
1
2
3
4
|
for (int i = 0; i < 100000; ++i) {
myclass *myobject = myobjects[i];
[myobject methoda];
}
|
这种高频次的调用 methoda，如果每调用一次都需要遍历，性能是非常差的。所以引入了 class cache 机制：
class cache 认为，当一个方法被调用，那么它之后被调用的可能性就越大。
查找方法时，会先从缓存中查找，找到直接返回 ；找不到，再去 class 的方法列表中找。
在上文中 class 的定义中，我们可以发现 cache：
|
1
|
struct objc_cache * _nonnull cache objc2_unavailable;
|
说明了缓存是存在类中的，每个类都有一份方法缓存，而不是每个类的 object 都保存了一份。
消息转发
如果方法列表（methodlists）没找到对应的 selector 呢？
|
1
2
|
// viewcontroller.m 中 （未实现 mytestprint 方法）
[self performselector:@selector(mytestprint:) withobject:@"，你好 ！"];
|
系统会提供三次补救的机会。
第一次
|
1
2
|
+ (bool)resolveinstancemethod:(sel)sel {} (实例方法)
+ (bool)resolveclassmethod:(sel)sel {} (类方法)
|
这两个方法，一个针对实例方法；一个针对类方法。返回值都是 bool。
使用示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
// viewcontroller.m 中
void mymethod(id self, sel _cmd,nsstring *nub) {
nslog(@"ifelseboyxx%@",nub);
}
+ (bool)resolveinstancemethod:(sel)sel {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-wundeclared-selector"
if (sel == @selector(mytestprint:)) {
#pragma clang diagnostic pop
class_addmethod([self class],sel,(imp)mymethod,"v@:@");
return yes;
}else {
return [super resolveinstancemethod:sel];
}
}
|
我们只需要在 resolveinstancemethod: 方法中，利用 class_addmethod 方法，将未实现的 mytestprint: 绑定到 mymethod 上就能完成转发，最后返回 yes。
第二次
|
1
|
- (id)forwardingtargetforselector:(sel)aselector {}
|
这个方法要求返回一个 id。使用场景一般是将 a 类的某个方法，转发到 b 类的实现中去。
使用示例：
想转发到 person 类中的 -mytestprint: 方法中：
|
1
2
3
4
5
6
7
|
@interface person : nsobject
@end
@implementation person
- (void)mytestprint:(nsstring *)str {
nslog(@"ifelseboyxx%@",str);
}
@end
|
|
1
2
3
4
5
6
7
8
9
10
11
|
// viewcontroller.m 中
- (id)forwardingtargetforselector:(sel)aselector {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-wundeclared-selector"
if (aselector == @selector(mytestprint:)) {
#pragma clang diagnostic pop
return [person new];
}else{
return [super forwardingtargetforselector:aselector];
}
}
|
第三次
|
1
2
|
- (nsmethodsignature *)methodsignatureforselector:(sel)aselector {}
- (void)forwardinvocation:(nsinvocation *)aninvocation {}
|
第一个要求返回一个方法签名，第二个方法转发具体的实现。二者相互依赖，只有返回了正确的方法签名，才会执行第二个方法。
这次的转发作用和第二次的比较类似，都是将 a 类的某个方法，转发到 b 类的实现中去。不同的是，第三次的转发相对于第二次更加灵活，forwardingtargetforselector: 只能固定的转发到一个对象；forwardinvocation: 可以让我们转发到多个对象中去。
使用实例：
想转发到 person 类以及 animal 类中的 -mytestprint: 方法中：
|
1
2
3
4
5
6
7
|
@interface person : nsobject
@end
@implementation person
- (void)mytestprint:(nsstring *)str {
nslog(@"ifelseboyxx%@",str);
}
@end
|
|
1
2
3
4
5
6
7
|
@interface animal : nsobject
@end
@implementation animal
- (void)mytestprint:(nsstring *)str {
nslog(@"tiger%@",str);
}
@end
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
// viewcontroller.m 中
- (nsmethodsignature *)methodsignatureforselector:(sel)aselector {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-wundeclared-selector"
if (aselector == @selector(mytestprint:)) {
#pragma clang diagnostic pop
return [nsmethodsignature signaturewithobjctypes:"v@:@"];
}
return [super methodsignatureforselector:aselector];
}
- (void)forwardinvocation:(nsinvocation *)aninvocation {
person *person = [person new];
animal *animal = [animal new];
if ([person respondstoselector:aninvocation.selector]) {
[aninvocation invokewithtarget:person];
}
if ([animal respondstoselector:aninvocation.selector]) {
[aninvocation invokewithtarget:animal];
}
}
|
⚠️ 如果到了第三次机会，还没找到对应的实现，就会 crash：
|
1
|
unrecognized selector sent to instance 0x7f9f817072b0
|
总结
好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对快网idc的支持。
相关文章
- ASP.NET自助建站系统中如何实现多语言支持？ 2025-06-10
- 64M VPS建站：如何选择最适合的网站建设平台？ 2025-06-10
- ASP.NET本地开发时常见的配置错误及解决方法？ 2025-06-10
- ASP.NET自助建站系统的数据库备份与恢复操作指南 2025-06-10
- 个人网站服务器域名解析设置指南：从购买到绑定全流程 2025-06-10
