正文

iOS消息发送和转发示例详解

︶ㄣ速达网 メ
米米素材网V管理员 / 阅读
0919

这篇文章主要给大家介绍了关于iOS消息发送和转发的相关资料，用Objective-C的术语来讲,这叫做“给某个对象发送某条消息”。文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面

前言

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 的指针来关联起来，具体关系如下图：

iOS消息发送和转发示例详解

以我们上文的代码为例：

?
1
myclass *myclass = [[myclass alloc] init];

整理下相互间的关系：

  • myclass 是实例对象
  • myclass 是类对象
  • myclass 的元类就是 nsobject 的元类
  • nsobject 就是 root class (class)
  • nsobject 的 superclass 为 nil
  • nsobject 的元类就是它自己
  • nsobject 的 superclass 就是 nsobject

对应上图中的位置关系如下：

iOS消息发送和转发示例详解

接着，我们用代码来验证下上文的关系：

?
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 的过程如下：

iOS消息发送和转发示例详解

如何提高方法查找的效率？

上文中，我们大概知道，方法是通过 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

总结

到这里，我们大概能了解消息发送与转发的过程了，附上流程图：

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对米米素材网的支持。

原文链接：https://juejin.im/post/5aa79411f265da237a4cb045