自己平时工作中用到runtime的地方不多，但是理解runtime能让自己知道简单一句代码背后的逻辑，能够加深自己对程序运行的理解。所以，在此总结了一下runtime的相关知识，着重于实际运用。自己能力有限，如有错误之处，希望批评指正。
C语言中,在编译期，函数的调用就会决定调用哪个函数【函数运行的结果，在编译完，就直接出来了】。而在OC的函数，属于动态调用过程，在编译期并不能决定真正调用那个函数，只有在真正运行时才会根据函数的名称找到对应的函数来调用执行。
目录：
- 一、相关概念理解
- 二、交换方法
- 三、消息转发
一、相关概念理解
- 1.1 self和super
.h
#import "Person.h"
@interface Son : Person
@end
.m
@implementation Son
- (instancetype)init
{
self = [super init];
if (self) {
NSLog(@"self---------%@",[self class]);
NSLog(@"super---------%@",[super class]);
}
return self;
}
结果:
Runtime_Demo[1564:87519] self---------Son
Runtime_Demo[1564:87519] super---------Son
解答:
self是类的一个隐藏参数，每个方法的实现第一个参数即为self，指向当前调用方法的这个类的实例。
super是一个"编译器标示符"，它负责告诉编译器，当调用方法时，直接去调用父类的方法，而不是本类中的方法。
但是有一点两个方法的方法调用者都是self
如下:
1，[self class]--->objc_msgSend(self,@selector(class))
当调用[self class]时，实际是调用objc_msgSend()函数，第一个参数Son，让后在Son这个类里找-(Class)class方法，没有找到，去父类Person里找，也没有，最后在NSObject类中找到这个方法。-(Class)class就是返回self的类。所以输出为Son。
- (Class)class {
return object_getClass(self);
}
2，[super class] ----> objc_msgSendSuper（struct objc_super *super,SEL,...）-----> objc_msgSend(objc_super->receiver, @selector(class))
objc_super->receiver是self。
struct objc_super {
__unsafe_unretained id receiver;
__unsafe_unretained Class super_class;
};
当调用[super class]时，会转成objc_msgSendSuper()函数。第一步是先构造objc_super结构体，结构体的第一个成员receiver就是当前Son类的实例self.第二个成员是class_getSuperclass([self class]);此处为Person。第二步去Person类里找-(Class)class方法，没有，然后去NSObject类去找，最后的调用方法是objc_msgSend(objc_super->receiver, @selector(class))。所以也输出Son。
所以，两个方法的结果一样。都是Son。
- 1.2 Object、Class、MetaClass
相关定义: - id
/// A pointer to an instance of a class.
typedef struct objc_object *id;
id 是指向一个 objc_object 结构体的指针。id这个struct的定义本身就带了一个,所以在使用其他OC类型的实例时，需要前面加上,而使用id时不需要。
- objc_object
/// Represents an instance of a class.
struct objc_object {
Class isa;
};
可以看出，OC中的object(对象)在最后会被转换成为C的结构体。而这个结构体里的成员isa指针，指向该对象的类Class。
- Class
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *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;
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;
Class本是指向一个C的结构体objc_class。objc_class结构体中，isa指向所属的Class。
- objc_class
struct objc_class : objc_object {
// Class ISA;
Class superclass;
...
...
}
从源码中看objc_class的定义，我们知道Class也是对象。Class对象对应的类，叫Meta Class。即Class结构体中的isa指向的就是他的Meta Class。
objc_class继承于objc_object，也就是说一个Objc类本身同时也是一个对象，为了处理类和对象的关系，runtime库创建了一种叫做元类(Meta class)的概念【每一个类都有一个自己对应的元类】，类对象所属类型就叫做元类，它用来表述类对象本身所具备的元数据。类方法就定义在此，因此这些方法可以理解成类对象的实例方法。每个类仅有一个类对象，而每个类对象仅有一个与之相关的元类。当发出一个[NSObject alloc]的消息时，事实上是把这个消息发给了一个类对象（Class Object），这个类对象必须是一个 元类的实例，而这个元类同时也是一个根元类（root meta class）的实例。所有元类的方法列表都有能够响应消息的类方法。所以当[NSObject alloc]这条消息发送给类对象的时候，objc_msgSend()会去它的元类里边查找能够响应消息的方法。
- Meta Class
Meta Class是一个Class对象的Class。Meta Class本身也是一个Class，他跟Class一样也有自己的isa和super_class指针。 - 每个Class都有一个isa指针指向一个唯一的Meta Class。（每一个类可以有无数个实例对象，但是类对象只有一个，对应的元类对象也只有一个）。
- 每一个Meta Class的isa指针都指向最上层的Meta Class(根元类 NSObject的Meta Class)。
- 最上层的Meta Class的isa指向自己。
- 每一个Meta Class的super class指针指向它本身Class的super Class的Meta Class。最上层Meta Class的super class指向NSObject Class本身。
- 最上层的NSObject Class的super class指向nil。
BOOL res1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];
BOOL res2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
BOOL res3 = [(id)[Person class] isKindOfClass:[Person class]];
BOOL res4 = [(id)[Person class] isMemberOfClass:[Person class]];
NSLog(@"%d %d %d %d",res1,res2,res3,res4);
结果:Runtime_Demo[1700:126651] 1 0 0 0
+ (Class)class {
return self;
}
- (BOOL)isKindOf:aClass
{
Class cls;
for (cls = isa; cls; cls = cls->superclass)
if (cls == (Class)aClass)
return YES;
return NO;
}
- (BOOL)isMemberOf:aClass
{
return isa == (Class)aClass;
}
[self class] 与object_getClass(self) 与object_getClass([self class])的区别:
根据self的类型分为:
1,当self为实例对象时，[self class]与object_getClass(self)等价，因为前者会调用后者。object_getClass([self class])得到元类。
2，当self为类对象时，[self class]返回自身。object_getClass(self)与object_getClass([self class])等价，返回元类。
第一题:
当 NSObject Class对象第一次进行比较时，得到它的isa为 NSObject的Meta Class， 这个时候 NSObject Meta Class 和 NSObject Class不相等。
然后取NSObject 的Meta Class 的Super class，这个时候又变成了 NSObject Class， 所以返回相等。所以打印结果为1。
第二题:
由NSObject的isa指向Meta Class对象，和NSObject Class不是一个。所以结果为NO。
第三题:
- [Person Class]是类对象，和Person的Meta Class不是一个。
- Person的Meta Class的super class指向的是NSObject Meta Class，和[Person Class]不相等。
- NSObject Meta Class的super class指向的是NSObject Class和[Person Class]不相等。
- NSObject Class 的super class指向的是nil，和[Person class]不相等，所以是NO。
第四题:
[Person Class]是类对象，和Person的Meta Class不是一个。说以结果为NO。
- 1.3 消息和Category
- SEL和IMP
typedef struct objc_selector *SEL;
#import "Person.h"
@implementation Person
- (void)speak
{
// NSLog(@"my name is %@",self.name);
SEL sel = @selector(speak);
NSLog(@"Person %s----%p",(char *)sel,sel);
}
+ (void)speak
{
SEL sel = @selector(speak);
NSLog(@"Person %s----%p",(char *)sel,sel);
}
@end
#import "Animal.h"
@implementation Animal
- (void)speak
{
SEL sel = @selector(speak);
NSLog(@"Animal %s----%p",(char*)sel,sel);
}
+ (void)speak
{
SEL sel = @selector(speak);
NSLog(@"Person %s----%p",(char *)sel,sel);
}
@end
[[[Person alloc]init]speak];
[[[Animal alloc]init]speak];
[Person speak];
[Animal speak];
2018-03-25 18:40:07.788162+0800 Runtime_Demo[2849:407354] Person speak----0x101c58780
2018-03-25 18:40:07.788302+0800 Runtime_Demo[2849:407354] Animal speak----0x101c58780
2018-03-25 18:40:07.788392+0800 Runtime_Demo[2849:407354] Person speak----0x101c58780
2018-03-25 18:40:07.788483+0800 Runtime_Demo[2849:407354] Person speak----0x101c58780
//可以看出，即便是在不同的类中，只要他们的方法名相同，不分实例方法还是类方法，对应的selector就是同一个字符串，但是通过selector找IMP是从各自的方法列表中找的。实例方法从对象的类的方法列表里查找实现，类方法会在类的Meta Class的方法列表里查找实现。
SEL是一个指向objc_selector 结构体的指针。
OC在编译时，会根据方法名字生成一个区别这个方法的唯一的ID。只要方法名称相同，它们的ID就是相同的。
两个类之间，不管它们是父类与子类的关系，还是之间没有这种关系，只要方法名相同，那么它的SEL就是一样的。每一个方法都对应着一个SEL。编译器会根据每个方法的方法名为那个方法生成唯一的SEL。这些SEL组成了一个Set集合，当我们在这个集合中查找某个方法时，只需要去找这个方法对应的SEL即可。而SEL本质是一个字符串，所以直接比较它们的地址即可
当然，不同的类可以拥有相同的selector。不同类的实例对象执行相同的selector时，会在各自的方法列表中去根据selector去寻找自己对应的IMP。
- IMP
typedef id (*IMP)(id, SEL, ...);
IMP本质就是一个函数指针，这个被指向的函数包含一个接收消息的对象id，调用方法的SEL，以及一些方法参数，并返回一个id。因此我们可以通过SEL获得它所对应的IMP，在取得了函数指针之后，也就意味着我们取得了需要执行方法的代码入口，这样我们就可以像普通的C语言函数调用一样使用这个函数指针。
- Category
- extension(也有叫匿名类别)和category
extension在编译器决议，它是类的一部分，在编译期和头文件里的@interface以及实现文件里的@implement一起形成一个完整的类，它伴随类的产生而产生，和类一起销毁。我们无法为系统的类添加extension。必须有一个类的源码才能为一个类添加extension。
category是在运行前决议的。
ecxtension可以添加实例变量，而category是无法添加实例变量的(在运行期，对象的内存布局已经确定，如果添加实例变量就会破坏类的内存布局。)
typedef struct category_t {
const char *name;//类的名字
classref_t cls;//类
struct method_list_t *instanceMethods;//给类添加的所有实例方法的列表
struct method_list_t *classMethods;//给类添加的类方法的列表
struct protocol_list_t *protocols;//实现的所有协议的列表
struct property_list_t *instanceProperties;//添加的所有属性
} category_t;
从category定义可以看出category可以添加实例方法，类方法，可以实现协议，添加属性，但是不能添加实例变量 【注:可以测试一个在category中添加绑定属性的类里，打印所有的成员变量，并没有包含在category里绑定的属性的下滑线_属性名】。
category的实例方法，协议以及属性添加到类上。
category的类方法和协议添加到类的meta class上。
如果在category中写的方法的名称methodA和类中原来的类的名称method一样的话。最终类的方法列表里会有两个method。
category的方法被放到了新方法列表的前面，而原来类的方法被放到了新方法列表的后面，这也就是我们平常所说的category的方法会“覆盖”掉原来类的同名方法，这是因为运行时在查找方法的时候是顺着方法列表的顺序查找的，它只要一找到对应名字的方法，就会结束查找。
在类的+load方法里，可以调用category中声明的方法，因为category附加到类上的工作会先于+load方法的执行。
+load的执行顺序是先类(从父类到子类)，再category，而多个category里的+load方法是根据编译顺序决定的。
关于更多category内容请看美团的一篇文章:深入理解Objective-C：Category
在Objective-C中，消息直到运行时才会绑定到方法的实现上。编译器会把代码中[target doSth]转换成 objc_msgSend消息函数，这个函数完成了动态绑定的所有事情。objc_msgSend()的运行流程如下:
1,检查selector是否需要忽略。(ps: Mac开发中开启GC就会忽略retain,release方法。)
2,检查target是否为nil。如果为nil，直接cleanup，然后return。(这就是我们可以向nil发送消息的原因。)
3,然后在target的Class中根据Selector去找IMP
寻找IMP的过程:
1,先从当前class的cache方法列表（cache methodLists）里去找
2,找到了，跳到对应函数实现
3,没找到，就从class的方法列表（methodLists）里找
4,还找不到，就到super class的方法列表里找，直到找到基类(NSObject)为止
5,最后再找不到，就会进入动态方法解析和消息转发的机制
二、交换方法
//下边的这个Swizzling模板是比较严谨的(AFNetWorking是这样用的)。
+ (void)load
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalSlector = @selector(viewWillAppear:);
SEL swizzledSelector = @selector(runtime_viewWillAppear:);
Method originalMethod = class_getInstanceMethod(class, originalSlector);
Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
//判断类中被交换的方法(viewWillAppear:)是否有实现。YES是没有实现，NO是有实现。如果返回YES的话，同时也会将新方法的实现(runtime_viewWillAppear：的实现)，作为viewWillAppear:的实现。
BOOL didAddMethod = class_addMethod(class, originalSlector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
if (didAddMethod) {
//被交换的方法(viewWillAppear:)在原来的类中没有实现???这个函数的作用不清楚，打印了这行函数，即便运行后，没有实现的方法的实现还是nil。
class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
}else{
//被交换的方法(viewWillAppear:)有实现。直接交换两个方法的实现。
method_exchangeImplementations(originalMethod, swizzledMethod);
}
});
}
接下来我用测试例子对判断分支的两种情况分别进行验证。
//MyClass
@interface MyClass : NSObject
- (void)superMethod;
@end
@implementation MyClass
- (void)superMethod
{
NSLog(@"super -- method");
}
@end
//MySubClass
@interface MySubClass : MyClass
@end
@implementation MySubClass
- (void)superMethod
{
NSLog(@"子类重写的实现");
}
@end
//MySubClass+Swizzling
@interface MySubClass (Swizzling)
@end
@implementation MySubClass (Swizzling)
+ (void)load
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalSlector = @selector(superMethod);
SEL swizzledSelector = @selector(swizzlingMethod);
Method originalMethod = class_getInstanceMethod(class, originalSlector);
Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
BOOL didAddMethod = class_addMethod(class, originalSlector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
if (didAddMethod) {
class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
}else{
method_exchangeImplementations(originalMethod, swizzledMethod);
}
});
}
- (void)swizzlingMethod
{
NSLog(@"swizzling 交换的方法");
}
- 1，要被交换的方法在本类中有实现。【即直接进入else分支，didAddMethod为NO】。
- 2，要被交换的方法在父类中实现。【 didAddMethod 为YES】
总结:
1,方法交互一般会用在埋点，用于统计分析用户在app某些页面的停留时间和一些关键性的操作的点击次数等。关于埋点请看:iOS动态性(二)可复用而且高度解耦的用户统计埋点实现。
2，对一些容易出错的方法添加一些功能，方便自己开发时debug。比如在从数组中取值的时候，容易越界崩溃。可以对objectAtIndex:等相关取值方法进行swizzling，添加一些自己的逻辑。
日常小tip：我们现在所做的项目就在viewDidAppear:方法中增加了当前控制器类别的打印，这样，我们再debug的时候，能很容易从控制台看到当前页面的控制器是哪个。
三、消息转发
OC中调用一个方法时，就是给该对象发送了一条消息，执行objc_msgSend()函数，关于objc_msgSend()的执行流程请看文章上节。
在以上所有步骤进行完之后，没有找到该方法的实现的话，进入消息转发流程。
消息转发流程分为三个步骤。
- 1，动态方法解析。【即为当前类动态添加方法的实现。】
涉及方法:
+ (BOOL)resolveInstanceMethod:(SEL)sel：针对实例方法。
void dynamicBindMethod(id self,SEL _cmd)
{
NSLog(@"C函数动态添加方法实现");
}
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
//这里就是给该类一个动态添加方法的机会。可以添加别的类的方法的实现，也可以直接在这里添加C函数的实现
if ([NSStringFromSelector(sel) isEqualToString:@"dynamicBindMethod"]) {
//因为该方法是类方法，所以第一个参数传self 和[self class]一样，都是返回类对象
// class_addMethod([self class], @selector(dynamicBindMethod), method_getImplementation(class_getInstanceMethod([SonBClass class], @selector(dynamicBindMethod))), "@:");
class_addMethod([self class], @selector(dynamicBindMethod), (IMP)dynamicBindMethod, "@:");
}
return [super resolveInstanceMethod:sel];
}
+ (BOOL)resolveClassMethod:(SEL)sel:针对类方法。
添加类方法时，一定要注意传入的是metaclass(元类)。因为类方法是在元类中的
+ (BOOL)resolveClassMethod:(SEL)sel
{
if ([NSStringFromSelector(sel) isEqualToString:@"dynamicBindClassMethod"]) {
//给类方法动态添加方法，因为类方法是存在meta class(元类中)的，所以第一个参数应该用元类对象objc_getClass(self)
class_addMethod(object_getClass(self), @selector(dynamicBindClassMethod), (IMP)dynamicBindClassMethod, "@:");
}
return [super resolveClassMethod:sel];
}
- 2，后备接收者。
涉及方法:
- (id)forwardingTargetForSelector:(SEL)aSelector
如果上一步在动态解析的方法中找到了所发送消息的实现，就不会来到这一步。
- (id)forwardingTargetForSelector:(SEL)aSelector
{
if ([NSStringFromSelector(aSelector) isEqualToString:@"dynamicBindMethod"]) {
//返回一个对象能处理该selector的对象。
//可以在这一步模拟多继承。不同的方法交给不同类的对象去执行。
return [[SonBClass alloc]init];
}
return [super forwardingTargetForSelector:aSelector];
}
- 3，完整转发。
如果第二步的备用接收者能够响应selector，就不会到这一步来了。
3.1，获得方法签名。
涉及方法:
- (NSMethodSignature*)methodSignatureForSelector:(SEL)aSelector
- (NSMethodSignature*)methodSignatureForSelector:(SEL)aSelector
{
NSMethodSignature *signature = [super methodSignatureForSelector:aSelector];
if (!signature) {
if ([SonBClass instancesRespondToSelector:aSelector]) {
//生成方法签名 【方法签名即方法所对应的返回值类型和参数类型】
signature = [SonBClass instanceMethodSignatureForSelector:aSelector];
}
}
return signature;
}
3.2，完整消息转发。
涉及方法:
- (void)forwardInvocation:(NSInvocation *)anInvocation
- (void)forwardInvocation:(NSInvocation *)anInvocation
{//anInvocation封装了待处理消息的所有相关信息
if ([SonBClass instancesRespondToSelector:anInvocation.selector]) {
[anInvocation invokeWithTarget:[[SonBClass alloc]init]];
}
//如果到这一步还不能没有找到待处理消息的实现，就会调用- (void)doesNotRecognizeSelector:(SEL)aSelector 导致程序崩溃。
}
- (void)forwardInvocation:(NSInvocation *)anInvocation方法就像一个未知消息的分发中心，将这些未知的消息转发给其它对象。也可以在这里模拟实现多继承的效果。
- 总结
runtime还有其他的用法，待整理中，先把相关概念和method swizzling和消息的传递以及转发机制理解了。
之后遇到runtime的消息转发机制的实际运用后，会持续更新。
如有错误，请批评指正。非常感谢文章中的引用及参考文章。谢谢！！！
参考:
南峰子的技术博客
神经病院Objective-C Runtime入院第一天(系列)
刨根问底Objective－C Runtime
玉令天下的博客