iOS消息发送和转发示例详解 - IOS - 服务器之家

米米素材网

这篇文章主要给大家介绍了关于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