查看: 2202|回复: 0

[IOS开发教程] iOS消息发送和转发示例详解

发表于 2018-4-13 08:00:05

前言

Objective-C 是一门动态语言,它将很多静态语言在编译和链接时期做的事情,放到了运行时来处理。之所以能具备这种特性,离不开 Runtime 这个库。Runtime 很好的解决了如何在运行时期找到调用方法这样的问题。下面话不多说了,来一起学习学习吧。

消息发送

在 Objective-C 中,方法调用称为向对象发送消息:

  1. // MyClass 类
  2. @interface MyClass: NSObject
  3. - (void)printLog;
  4. @end
  5. @implementation MyClass
  6. - (void)printLog {
  7. NSLog(@"print log !");
  8. }
  9. @end
  10. MyClass *myClass = [[MyClass alloc] init];
  11. [myClass printLog];
  12. // 输出: 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. MyClass *myClass = [[MyClass alloc] init];
  2. Class class = [myClass class];
  3. Class metaClass = object_getClass(class);
  4. Class metaOfMetaClass = object_getClass(metaClass);
  5. Class rootMetaClass = object_getClass(metaOfMetaClass);
  6. Class superclass = class_getSuperclass(class);
  7. Class superOfSuperclass = class_getSuperclass(superclass);
  8. Class superOfMetaOfSuperclass = class_getSuperclass(object_getClass(superclass));
  9. NSLog(@"MyClass 实例对象是:%p",myClass);
  10. NSLog(@"MyClass 类对象是:%p",class);
  11. NSLog(@"MyClass 元类对象是:%p",metaClass);
  12. NSLog(@"MyClass 元类对象的元类对象是:%p",metaOfMetaClass);
  13. NSLog(@"MyClass 根元类对象是:%p",rootMetaClass);
  14. NSLog(@"MyClass 父类是:%@",class_getSuperclass(class));
  15. NSLog(@"MyClass 父类的父类是:%@",superOfSuperclass);
  16. NSLog(@"MyClass 父类的元类的父类是:%@",superOfMetaOfSuperclass);
  17. NSLog(@"NSObject 元类对象是:%p",object_getClass([NSObject class]));
  18. NSLog(@"NSObject 父类是:%@",[[NSObject class] superclass]);
  19. NSLog(@"NSObject 元类对象的父类是:%@",[object_getClass([NSObject class]) superclass]);
  20. //输出:
  21. MyClass 实例对象是:0x60c00000b8d0
  22. MyClass 类对象是:0x109ae3fd0
  23. MyClass 元类对象是:****0x109ae3fa8
  24. MyClass 元类对象的元类对象是:****0x10ab02e58**
  25. MyClass 根元类对象是:0x10ab02e58
  26. MyClass 父类是:NSObject
  27. MyClass 父类的父类是:(null)
  28. MyClass 父类的元类的父类是:NSObject
  29. NSObject 元类对象是:0x10ab02e58
  30. NSObject 父类是:(null)
  31. NSObject 元类对象的父类是:NSObject
复制代码

可以发现,输出结果是完全符合我们的结论的!

现在我们能知道各种对象之间的关系:

实例对象通过 isa 指针,找到类对象 Class;类对象同样通过 isa 指针,找到元类对象;元类对象也是通过 isa 指针,找到根元类对象;最后,根元类对象的 isa 指针,指向自己。可以发现 NSObject 是整个消息机制的核心,绝大数对象都继承自它。

寻找流程

上文提到了,一个 Objective-C 方法会被编译成 objc_msgSend,这个函数有两个默认参数,id 类型的 self, SEL 类型的 op。我们先看看 id 的定义:

  1. typedef struct objc_object *id;
  2. struct objc_object {
  3. Class _Nonnull isa OBJC_ISA_AVAILABILITY;
  4. };
复制代码

我们可以看到,在 objc_object 结构体中,只有一个指向 Class 类型的 isa 指针。

我们再看看 Class 的定义:

  1. struct objc_class {
  2. Class _Nonnull isa OBJC_ISA_AVAILABILITY;
  3. #if !__OBJC2__
  4. Class _Nullable super_class OBJC2_UNAVAILABLE;
  5. const char * _Nonnull name OBJC2_UNAVAILABLE;
  6. long version OBJC2_UNAVAILABLE;
  7. long info OBJC2_UNAVAILABLE;
  8. long instance_size OBJC2_UNAVAILABLE;
  9. struct objc_ivar_list * _Nullable ivars OBJC2_UNAVAILABLE;
  10. struct objc_method_list * _Nullable * _Nullable methodLists OBJC2_UNAVAILABLE;
  11. struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE;
  12. struct objc_protocol_list * _Nullable protocols OBJC2_UNAVAILABLE;
  13. #endif
  14. } OBJC2_UNAVAILABLE;
复制代码

里面有很多参数,很显眼的能看到这一行:

  1. struct objc_method_list * _Nullable * _Nullable methodLists OBJC2_UNAVAILABLE;
复制代码

看名字也容易理解,这个 methodLists 就是用来存放方法列表的。我们再看看 objc_method_list 这个结构体:

  1. struct objc_method_list {
  2. struct objc_method_list * _Nullable obsolete OBJC2_UNAVAILABLE;
  3. int method_count OBJC2_UNAVAILABLE;
  4. #ifdef __LP64__
  5. int space OBJC2_UNAVAILABLE;
  6. #endif
  7. /* variable length structure */
  8. struct objc_method method_list[1] OBJC2_UNAVAILABLE;
  9. }
复制代码

里面的 objc_method ,也就是我们熟悉的 Method:

  1. struct objc_method {
  2. SEL _Nonnull method_name OBJC2_UNAVAILABLE;
  3. char * _Nullable method_types OBJC2_UNAVAILABLE;
  4. IMP _Nonnull method_imp OBJC2_UNAVAILABLE;
  5. }
复制代码

Method 里面保存了三个参数:

  • 方法的名称
  • 方法的类型
  • 方法的具体实现,由 IMP 指针指向

经过层层挖掘,我们能明白实例对象调用方法的大致逻辑:

  1. MyClass *myClass = [[MyClass alloc] init];
  2. [myClass printLog];
复制代码
  • 先被编译成 ((void (*)(id, SEL))(void *) objc_msgSend)(myClass, @selector(printLog));
  • 沿着入参 myClass 的 isa 指针,找到 myClass 的类对象(Class),也就是 MyClass
  • 接着在 MyClass 的方法列表 methodLists 中,找到对应的 Method
  • 最后找到 Method 中的 IMP 指针,执行具体实现

类对象的类方法又是怎么找到并执行的?

由上文,我们已经知道,实例对象是通过 isa 指针,找到其类对象(Class)中保存的方法列表中的具体实现的。

比如:

  1. MyClass *myClass = [[MyClass alloc] init];
  2. [myClass printLog];
复制代码

可以理解为:printLog 方法就是保存在 MyClass 中的。

那么如果是个类方法,又是保存在什么地方的呢?

我们回顾下 Class 的定义:

  1. struct objc_class {
  2. Class _Nonnull isa OBJC_ISA_AVAILABILITY;
  3. #if !__OBJC2__
  4. Class _Nullable super_class OBJC2_UNAVAILABLE;
  5. const char * _Nonnull name OBJC2_UNAVAILABLE;
  6. long version OBJC2_UNAVAILABLE;
  7. long info OBJC2_UNAVAILABLE;
  8. long instance_size OBJC2_UNAVAILABLE;
  9. struct objc_ivar_list * _Nullable ivars OBJC2_UNAVAILABLE;
  10. struct objc_method_list * _Nullable * _Nullable methodLists OBJC2_UNAVAILABLE;
  11. struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE;
  12. struct objc_protocol_list * _Nullable protocols OBJC2_UNAVAILABLE;
  13. #endif
  14. } OBJC2_UNAVAILABLE;
复制代码

可以发现到这一行:

  1. Class _Nonnull isa OBJC_ISA_AVAILABILITY;
复制代码

这里的 isa 同样是指向一个 Class 的指针。上文中,我们也知道了类对象的 isa 指针是指向元类对象的。那么不难得出:

类对象的类方法,是保存在元类对象中的!

类对象和元类对象都是 Class 类型,仅仅服务的对象不同罢了。找到了元类对象,自然就找到了元类对象中的 methodLists,接下来就和实例对象的方法寻找调用一样的流程了。

关于父类(superclass)

在 Objective-C 中,子类调用一个方法,如果没有子类没有实现,父类实现了,会去调用父类的实现。上文中,找到 methodLists 后,寻找 Method 的过程如下:

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

上文中,我们大概知道,方法是通过 isa 指针,查找 Class 中的 methodLists 的。如果子类没实现对应的方法实现,还会沿着父类去查找。整个工程,可能有成万上亿个方法,是如何解决性能问题的呢?

例如:

  1. for (int i = 0; i < 100000; ++i) {
  2. MyClass *myObject = myObjects[i];
  3. [myObject methodA];
  4. }
复制代码

这种高频次的调用 methodA,如果每调用一次都需要遍历,性能是非常差的。所以引入了 Class Cache 机制:

Class Cache 认为,当一个方法被调用,那么它之后被调用的可能性就越大。

查找方法时,会先从缓存中查找,找到直接返回 ;找不到,再去 Class 的方法列表中找。

在上文中 Class 的定义中,我们可以发现 cache:

  1. struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE;
复制代码

说明了缓存是存在类中的,每个类都有一份方法缓存,而不是每个类的 object 都保存了一份。

消息转发

如果方法列表(methodLists)没找到对应的 selector 呢?

  1. // ViewController.m 中 (未实现 myTestPrint 方法)
  2. [self performSelector:@selector(myTestPrint:) withObject:@",你好 !"];
复制代码

系统会提供三次补救的机会。

第一次

  1. + (BOOL)resolveInstanceMethod:(SEL)sel {} (实例方法)
  2. + (BOOL)resolveClassMethod:(SEL)sel {} (类方法)
复制代码

这两个方法,一个针对实例方法;一个针对类方法。返回值都是 Bool。

使用示例:

  1. // ViewController.m 中
  2. void myMethod(id self, SEL _cmd,NSString *nub) {
  3. NSLog(@"ifelseboyxx%@",nub);
  4. }
  5. + (BOOL)resolveInstanceMethod:(SEL)sel {
  6. #pragma clang diagnostic push
  7. #pragma clang diagnostic ignored "-Wundeclared-selector"
  8. if (sel == @selector(myTestPrint:)) {
  9. #pragma clang diagnostic pop
  10. class_addMethod([self class],sel,(IMP)myMethod,"v@:@");
  11. return YES;
  12. }else {
  13. return [super resolveInstanceMethod:sel];
  14. }
  15. }
复制代码

我们只需要在 resolveInstanceMethod: 方法中,利用 class_addMethod 方法,将未实现的 myTestPrint: 绑定到 myMethod 上就能完成转发,最后返回 YES。

第二次

  1. - (id)forwardingTargetForSelector:(SEL)aSelector {}
复制代码

这个方法要求返回一个 id。使用场景一般是将 A 类的某个方法,转发到 B 类的实现中去。

使用示例:

想转发到 Person 类中的 -myTestPrint: 方法中:

  1. @interface Person : NSObject
  2. @end
  3. @implementation Person
  4. - (void)myTestPrint:(NSString *)str {
  5. NSLog(@"ifelseboyxx%@",str);
  6. }
  7. @end
复制代码
  1. // ViewController.m 中
  2. - (id)forwardingTargetForSelector:(SEL)aSelector {
  3. #pragma clang diagnostic push
  4. #pragma clang diagnostic ignored "-Wundeclared-selector"
  5. if (aSelector == @selector(myTestPrint:)) {
  6. #pragma clang diagnostic pop
  7. return [Person new];
  8. }else{
  9. return [super forwardingTargetForSelector:aSelector];
  10. }
  11. }
复制代码

第三次

  1. - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {}
  2. - (void)forwardInvocation:(NSInvocation *)anInvocation {}
复制代码

第一个要求返回一个方法签名,第二个方法转发具体的实现。二者相互依赖,只有返回了正确的方法签名,才会执行第二个方法。

这次的转发作用和第二次的比较类似,都是将 A 类的某个方法,转发到 B 类的实现中去。不同的是,第三次的转发相对于第二次更加灵活,forwardingTargetForSelector: 只能固定的转发到一个对象;forwardInvocation: 可以让我们转发到多个对象中去。

使用实例:

想转发到 Person 类以及 Animal 类中的 -myTestPrint: 方法中:

  1. @interface Person : NSObject
  2. @end
  3. @implementation Person
  4. - (void)myTestPrint:(NSString *)str {
  5. NSLog(@"ifelseboyxx%@",str);
  6. }
  7. @end
复制代码
  1. @interface Animal : NSObject
  2. @end
  3. @implementation Animal
  4. - (void)myTestPrint:(NSString *)str {
  5. NSLog(@"tiger%@",str);
  6. }
  7. @end
复制代码
  1. // ViewController.m 中
  2. - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
  3. #pragma clang diagnostic push
  4. #pragma clang diagnostic ignored "-Wundeclared-selector"
  5. if (aSelector == @selector(myTestPrint:)) {
  6. #pragma clang diagnostic pop
  7. return [NSMethodSignature signatureWithObjCTypes:"v@:@"];
  8. }
  9. return [super methodSignatureForSelector:aSelector];
  10. }
  11. - (void)forwardInvocation:(NSInvocation *)anInvocation {
  12. Person *person = [Person new];
  13. Animal *animal = [Animal new];
  14. if ([person respondsToSelector:anInvocation.selector]) {
  15. [anInvocation invokeWithTarget:person];
  16. }
  17. if ([animal respondsToSelector:anInvocation.selector]) {
  18. [anInvocation invokeWithTarget:animal];
  19. }
  20. }
复制代码

?? 如果到了第三次机会,还没找到对应的实现,就会 crash:

  1. unrecognized selector sent to instance 0x7f9f817072b0
复制代码

总结

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

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



回复

使用道具 举报