Objective-C Runtime 及消息发送与转发

什么是 Runtime

Objective-C语言是一门动态语言，它将很多静态语言在编译和链接时期做的事放到了运行时来处理。之所以能具备这种特性，离不开运行时系统即objc Runtime，objc Runtime即 Runtime库。Runtime很好的解决了如何在运行时期找到调用方法这样的问题。

类与对象基础数据结构

Class

Objective-C类是由Class类型来表示的，它实际上是一个指向objc_class结构体的指针。它的定义如下：
typedef struct objc_class *Class;
我们再来看objc/runtime.h中objc_class结构体的定义如下：

struct objc_class {
  Class isa  OBJC_ISA_AVAILABILITY;
  #if !__OBJC2__
  Class super_class                     OBJC2_UNAVAILABLE;  // 父类
  const char *name                        OBJC2_UNAVAILABLE;  // 类名
  long version                            OBJC2_UNAVAILABLE;  // 类的版本信息，默认为0
  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;

其中，有几个字段是我们需要掌握的。
1.isa：需要注意的是在Objective-C中，所有的类自身也是一个对象，这个对象的Class里面也有一个isa指针，它指向metaClass(元类)。
2.super_class：指向该类的父类，如果该类已经是最顶层的根类(如NSObject或NSProxy)，则super_class为NULL。
3.methodLists：看名字也容易理解，这个methodLists就是用来存放方法列表的。
4.cache：用于缓存最近使用的方法。
5.version：我们可以使用这个字段来提供类的版本信息。这对于对象的序列化非常有用，它可是让我们识别出不同类定义版本中实例变量布局的改变。

元类（Meta Class）

所有的类自身也是一个对象，我们可以向这个对象发送消息(即调用类方法)。既然是对象，那么它也是一个objc_object指针，它包含一个指向其类的一个isa指针。那么这些就有一个问题了，这个isa指针指向什么呢？这个类的isa指针必须指向一个包含这些类方法的一个objc_class结构体。这就引出了meta-class的概念：meta-class是一个类对象的类。
当我们向一个对象发送消息时，runtime会在这个对象所属的这个类的方法列表中查找方法；而向一个类发送消息时，会在这个类的meta-class的方法列表中查找。
meta-class之所以重要，是因为它存储着一个类的所有类方法。每个类都会有一个单独的meta-class，因为每个类的类方法基本不可能完全相同。
再深入一下，meta-class也是一个类，也可以向它发送一个消息，那么它的isa又是指向什么呢？为了不让这种结构无限延伸下去，Objective-C的设计者让所有的meta-class的isa指向基类的meta-class，以此作为它们的所属类。即，任何NSObject继承体系下的meta-class都使用NSObject的meta-class作为自己的所属类，而基类的meta-class的isa指针是指向它自己。这样就形成了一个完美的闭环。
通过上面的描述，再加上对objc_class结构体中super_class指针的分析，我们就可以描绘出类及相应meta-class类的一个继承体系了，如下图所示：

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 是整个消息机制的核心，绝大数对象都继承自它。

methodLists

我们再来看看objc_method_list这个结构体

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

struct objc_method {
  SEL _Nonnull method_name OBJC2_UNAVAILABLE;         //方法的名称
  char * _Nullable method_types  OBJC2_UNAVAILABLE;   //方法的类型
  IMP _Nonnull method_imp  OBJC2_UNAVAILABLE;         // 方法的具体实现
}

由此我们可以得出实例对象调用方法的大致逻辑：

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）中保存的方法列表中的具体实现的。printLog方法就是保存在MyClass中的。
那么如果是个类方法，又是保存在什么地方的呢？我们也知道了类对象的isa指针是指向元类对象的。那么不难得出：

类对象的类方法，是保存在元类对象中的！

cache

我们大概知道，方法是通过isa指针，查找Class 中的methodLists的。如果子类没实现对应的方法实现，还会沿着父类去查找。整个工程，可能有成万上亿个方法，是如何解决性能问题的呢？如果每调用一次都需要遍历methodLists，性能是非常差的。所以引入了 Class Cache 机制：Class Cache 认为，当一个方法被调用，那么它之后被调用的可能性就越大。
查找方法时，会先从缓存中查找，找到直接返回 ；找不到，再去Class的方法列表中找。
在上文中 Class 的定义中，我们可以发现 cache：
struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE;
说明了缓存是存在类中的，每个类都有一份方法缓存，而不是每个类的 object 都保存了一份。

父类（superclass）

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

ps: 其实这里的寻找过程远没有这么简单，可能会遍历很多遍，因为我们可能会在运行时动态的添加方法（比如category）。遍历的过程中同样不时的去查询缓存表。

消息转发

如果方法列表（methodLists）没找到对应的 selector 呢？
[self performSelector:@selector(myTestPrint:) withObject:@"嘻嘻"];
系统会提供三次补救的机会。

第一次

+ (BOOL)resolveInstanceMethod:(SEL)sel {} (实例方法)
+ (BOOL)resolveClassMethod:(SEL)sel {} (类方法)

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

// 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。

第二次

- (id)forwardingTargetForSelector:(SEL)aSelector {}
这个方法要求返回一个id。使用场景一般是将 A 类的某个方法，转发到 B 类的实现中去。
使用示例：
想转发到 Person 类中的-myTestPrint:方法中：

@interface Person : NSObject
@end

@implementation Person
- (void)myTestPrint:(NSString *)str {
  NSLog(@"ifelseboyxx%@",str);
}
@end
// 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];
  }
}

第三次

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {}
- (void)forwardInvocation:(NSInvocation *)anInvocation {}
第一个要求返回一个方法签名，第二个方法转发具体的实现。二者相互依赖，只有返回了正确的方法签名，才会执行第二个方法。
这次的转发作用和第二次的比较类似，都是将 A 类的某个方法，转发到 B 类的实现中去。不同的是，第三次的转发相对于第二次更加灵活，forwardingTargetForSelector:只能固定的转发到一个对象；forwardInvocation:可以让我们转发到多个对象中去。
使用实例：
想转发到 Person 类以及Animal类中的-myTestPrint:方法中：

@interface Person : NSObject
@end

@implementation Person
- (void)myTestPrint:(NSString *)str {
  NSLog(@"ifelseboyxx%@",str);
}
@end
@interface Animal : NSObject
@end

@implementation Animal
- (void)myTestPrint:(NSString *)str {
  NSLog(@"tiger%@",str);
}
@end

// 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：
unrecognized selector sent to instance 0x7f9f817072b0

消息发送和消息转发的过程