iOS | Runtime原理及应用
Runtime介绍
高级编程语言想要成为可执行文件需先编译为汇编语言再汇编为机器语言，机器语言也是计算机能够识别的唯一语言，但是OC并不能直接编译为汇编语言，而是要先转写为纯c语言再进行编译和汇编操作，从OC到C语言的过渡就是runtime来实现的。然而我们使用OC进行面向对象开发，而C语言更多的是面向过程开发，这就需要将面向对象的类转变为面向过程的结构体。
Runtime消息传递
一个对象的方法像这样[obj foo]，编译器转成消息发送objc_msgSend(obj, foo), Runtime时执行的流程是这样的。
- 首先，通过
obj的isa指针找到它的class; - 在
class的method List找foo； - 如果
class中没有foo，就继续前往它的superclass中去查找; - 一旦找到foo这个函数，就去执行它的实现IMP。
但是这种实现有个问题，效率低。一个Class 往往只有20%的函数会被经常调用，可能占总调用次数的80%。每次消息都需要遍历一次objc_method_list 并不合理。如果把经常被调用的函数缓存下来，那可以大大提高函数查询的效率。这就是objc_class中另一个重要成员objc_cache做的事情，再找到foo之后，把foo的methed_name作为key，method_imp作为value缓存起来。当再次收到foo消息的时候，可以直接在cache里找到，避免去遍历objc_method_list。
objc_msgSend的方法定义如下：
OBJC_EXPORT id objc_msgSend(id self, SEL op, ...)
那消息传递是怎么实现的呢？我们看看对象(object)，类(class)，方法(method)这几个的结构体：
//对象
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
//类
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;
//方法列表
struct objc_method_list {
struct objc_method_list *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;
} OBJC2_UNAVAILABLE;
//方法
struct objc_method {
SEL method_name OBJC2_UNAVAILABLE;
char *method_types OBJC2_UNAVAILABLE;
IMP method_imp OBJC2_UNAVAILABLE;
}
- 系统首先找到消息的接受对象，然后通过对象的isa找到它的类。
- 在它的类中查找
method_list，是否有selector方法。 - 没有则查找父类的
method_list - 找到对应的
method，执行它的IMP - 转发IMP的return值。
消息传递中的概念：
类对象(objc_class)
oc类是由Class类型表示的，它实际上一个指向objc_class结构体的指针。
typedef struct objc_class *Class;
查看objc/runtime.h中objc_class结构体的定义如下：
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;
可以看出类对象就是一个结构体struct objc_class，这个结构体存放的数据称为元数据(metadata)，该结构体的第一个成员变量也是isa指针，这就说明了Class本身也是一个对象，我们称之为类对象，类对象在编译期产生用于创建实例对象，是单例。
实例(objc_object)
/// Represents an instance of a class.
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
/// A pointer to an instance of a class.
typedef struct objc_object *id;
类对象中的元数据存储的都是如何创建一个实例的相关信息，那么类对象和类方法应该从哪里创建呢？
就是从isa指针指向的结构体创建，类对象的isa指针指向的我们称之为元类(metaclass)。
元类中保存了创建类对象以及类方法所需要的所有信息。
元类(Meta Class)
整个系统形成了一个自闭环，struct objc_object 结构体实例的isa指针指向类对象。
类对象的 isa 指针指向元类，super_class 指针指向父类的类对象。
元类的 super_class 指针指向父类的元类，而元类的isa指针又指向了自己。
元类(Meta Class)是一个类对象的类。而所有的类自身也是一个对象，我们可以向这个对象发送消息(即调用类方法)。
为了调用类方法，这个类的isa指针必须指向一个包含这些类方法的一个objc_class 结构体。这就引出了 meta-class 的概念，元类中保存了创建类对象以及类方法所需要的所有信息。
任何NSObject 继承体系下的 meta-class 都使用 NSObject 的meta-class 作为自己的所属类，而基类的 meta-class 的 isa 指针是指向它自己。
Method(objc_method)
定义：
/// An opaque type that represents a method in a class definition.代表类定义中一个方法的不透明类型
typedef struct objc_method *Method;
struct objc_method {
SEL method_name OBJC2_UNAVAILABLE;
char *method_types OBJC2_UNAVAILABLE;
IMP method_imp OBJC2_UNAVAILABLE;
}
结构体中的内容：
- SEL method_name 方法名
- char *method_types 方法类型
- IMP method_imp 方法实现
SEL(objc_selector)
objc.h
/// An opaque type that represents a method selector.代表一个方法的不透明类型
typedef struct objc_selector *SEL;
Objc_msgSend函数的第二个参数为SEL，它是selector在oc中表示类型。selector 是方法选择器，可以理解为区分方法的ID，而这个ID的数据结构为SEL。
其实selector 就是映射到方法的 c 字符串，可以用 Objective-C 编译器命令@selector()或者 Runtime 系统的sel_registerName函数来获得一个 SEL 类型的方法选择器。
selector是一个string，是类似className+method的组合，命名规则有两条：
- 同一个类，selector不能重复
- 不同的类，selector可以重复
这也带来一个弊端，Objective-c中是没有函数重载的(函数名相同，参数不同)，因为selector只记录了函数的name没有记录参数，所以没办法区分不同的 method。
比如：
- (void)caculate(NSInteger)num;
- (void)caculate(CGFloat)num;
是会报错的。
我们只能通过命名来区别：
- (void)caculateWithInt(NSInteger)num;
- (void)caculateWithFloat(CGFloat)num;
在不同类中相同名字的方法所对应的方法选择器是相同的，即使方法名字相同而变量类型不同也会导致它们具有相同的方法选择器。
IMP
/// A pointer to the function of a method implementation. 指向一个方法实现的指针
typedef id (*IMP)(id, SEL, ...);
#endif
就是指向最终实现程序的内存地址的指针。
在iOS的Runtime中，Method通过selector和IMP两个属性，实现了快速查询方法及实现，相对提高了性能，又保持了灵活性。
类缓存(objc_cache)
当objective-c运行时通过跟踪它的isa指针检查对象时，可以找到一个实现很多方法的对象。然而，你可能只调用他们的一小部分，并且每次检查时，搜索所有选择器的类分派表没有意义。所以类实现一个缓存，每当你搜索一个类分派表，并找到相应的选择器，它把它放入它的缓存。所以当objc_msg查找一个类的选择器，它会先搜索类缓存。这是基于这样的理论：如果你在类上调用一个消息，你可能以后再次调用该消息。
为了加速消息分发，系统会对方法和对应的地址进行缓存，放在objc_cache中，所以实际运行中，大部分常用的方法都会被缓存起来，Runtime 系统实际上非常快，接近直接执行内存地址的程序速度。
Category(objc_category)
Category 是表示一个指向分类的结构体指针，其定义如下：
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;
};
- name：是指 class_name 而不是 category_name。
- cls：要扩展的类对象，编译期间是不会定义的，而是在Runtime阶段通过name对 应到对应的类对象。
- instanceMethods：category中所有给类添加的实例方法的列表。
- classMethods：category中所有添加的类方法的列表。
- protocols：category实现的所有协议的列表。
- instanceProperties：表示Category里所有的properties，这就是我们可以通过objc_setAssociatedObject和objc_getAssociatedObject增加实例变量的原因，不过这个和一般的实例变量是不一样的。
从上面的category_t的结构体中可以看出，分类中可以添加实例方法，类方法，甚至可以实现协议，添加属性，不可以添加成员变量。
Runtime消息转发
进行一次发送消息会在相关的类对象中搜索方法列表，如果找不到则会沿着继承树一直搜索直到继承树的根部(通常为NSObject)，如果还是找不到并且消息转发都失败了就会执行doesNotRecognizeSelector:方法报 unrecongnized selector。下面说一下消息转发：
- 动态方法解析
- 备用接收者
- 完整消息转发
动态方法解析：
首先，Objective-C运行时会调用 +resolveInstanceMethod:或者 +resolveClassMethod:，让你有机会提供一个函数实现。如果你添加了函数并返回YES， 那运行时系统就会重新启动一次消息发送的过程。
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
[self performSelector:@selector(foo:)];
}
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
if (sel == @selector(foo:))
{
class_addMethod([self class], sel, (IMP)fooMethod, "v@:");
return YES;
}
return [super resolveInstanceMethod:sel];
}
void fooMethod(id obj, SEL _cmd) {
NSLog(@"Doing foo");
}
2019-06-05 03:53:29.815835+0800 TestDemo[821:15514] Doing foo
可以看到虽然没有实现foo:这个函数，但是通过class_addMethod 动态添加了fooMethod 函数，并执行fooMethod 这个函数的IMP。如果resolve 方法返回NO，运行就会移到下一步：forwardingTargetForSelector。
备用接收者
如果目标对象实现了forwardingTargetForSelector，Runtime这时就会调用这个方法，给你把这个消息转发给其他对象的机会。所以说是备用接收者。
#import "ViewController.h"
#import "objc/runtime.h"
@interface Person : NSObject
@end
@implementation Person
- (void)foo {
NSLog(@"Doing foo");
}
@end
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
[self performSelector:@selector(foo)];
}
- (id)forwardingTargetForSelector:(SEL)aSelector
{
if (aSelector == @selector(foo))
{
return [Person new];
}
return [super forwardingTargetForSelector:aSelector];
}
@end
我们可以看到通过forwardingTargetForSelector把当前 ViewController 的方法转发给了 Person 去执行，并成功执行。
完整消息转发
如果在上一步还不能处理未知消息，则唯一能做的就是启用完整的消息转发机制了。首先它会发送-methodSignatureForSelector:消息获得函数的参数和返回值类型。如果-methodSignatureForSelector:返回nil ，Runtime则会发出 -doesNotRecognizeSelector: 消息，程序这时也就挂掉了。如果返回了一个函数签名，Runtime就会创建一个NSInvocation 对象并发送 -forwardInvocation:消息给目标对象。
#import "ViewController.h"
#import "objc/runtime.h"
@interface Person : NSObject
@end
@implementation Person
- (void)foo {
NSLog(@"Doing foo");
}
@end
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
[self performSelector:@selector(foo)];
}
- (id)forwardingTargetForSelector:(SEL)aSelector
{
return nil;
}
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
return NO;
}
void fooMethod(id obj, SEL _cmd) {
NSLog(@"Doing foooo");
}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
if ([NSStringFromSelector(aSelector) isEqualToString:@"foo"]) {
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
SEL sel = anInvocation.selector;
Person *p = [Person new];
if ([p respondsToSelector:sel]) {
[anInvocation invokeWithTarget:p];
}
else {
[self doesNotRecognizeSelector:sel];
}
}
@end
2019-06-05 04:14:05.722619+0800 TestDemo[1195:29921] Doing foo
从打印结果看，实现了完整的转发，通过签名，Runtime 生成了一个对象 anInvocation，发送给了forwardInvocation，我们在forwardInvocation方法里让Person对象去执行了foo函数。其中签名参数v@就是指void类型。
以上就是Runtime的三次转发流程。
Runtime应用
Runtime简直就是做大型框架的利器。它的应用场景很多，下面介绍一些常见的应用场景。
- 关联对象(OC Associated Objects)给分类增加属性
- 方法魔法(Method Swizzling)方法添加和替换和KVO实现
- 消息转发(热更新)解决Bug(JSPatch)
- 实现NSCoding的自动归档和自动解档
- 实现字典和模型的自动转换
关联对象给分类增加属性
关联对象Runtime提供了下面几个接口：
//关联对象
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
//获取关联的对象
id objc_getAssociatedObject(id object, const void *key)
//移除关联的对象
void objc_removeAssociatedObjects(id object)
参数解释：
id object：被关联的对象
const void *key：关联的key，要求唯一
id value：关联的对象
objc_AssociationPolicy policy：内存管理的策略
内存管理的策略：
| 内存策略 | 属性修饰 | 描述 |
|---|---|---|
| OBJC_ASSOCIATION_ASSIGN | @property (assign) 或 @property (unsafe_unretained) | 指定一个关联对象的弱引用。 |
| OBJC_ASSOCIATION_RETAIN_NONATOMIC | @property (nonatomic, strong) | @property (nonatomic, strong) 指定一个关联对象的强引用，不能被原子化使用。 |
| OBJC_ASSOCIATION_COPY_NONATOMIC | @property (nonatomic, copy) | 指定一个关联对象的copy引用，不能被原子化使用。 |
| OBJC_ASSOCIATION_RETAIN | @property (atomic, strong) | 指定一个关联对象的强引用，能被原子化使用。 |
| OBJC_ASSOCIATION_COPY | @property (atomic, copy) | 指定一个关联对象的copy引用，能被原子化使用。 |
#import "ViewController.h"
#import "objc/runtime.h"
@interface UIView (DefaultColor)
@property (nonatomic, strong) UIColor *defaultColor;
@end
@implementation UIView (DefaultColor)
static char kDefaultColorKey;
- (void)setDefaultColor:(UIColor *)defaultColor {
objc_setAssociatedObject(self, &kDefaultColorKey, defaultColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (id)defaultColor {
return objc_getAssociatedObject(self, &kDefaultColorKey);
}
@end
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
UIView *test = [UIView new];
test.defaultColor = [UIColor blackColor];
NSLog(@"%@", test.defaultColor);
}
@end
打印结果：
2019-06-05 09:30:29.002794+0800 TestDemo[1131:26732] UIExtendedGrayColorSpace 0 1
方法魔法(Method Swizzling)方法添加和替换和KVO实现
实际上添加方法刚才在讲消息转发的时候，动态方法解析的时候就提到了。
//class_addMethod(Class _Nullable __unsafe_unretained cls, SEL _Nonnull name, IMP _Nonnull imp, const char * _Nullable types)
class_addMethod([self class], sel, (IMP)fooMethod, "v@:");
- cls 被添加方法的类
- name 添加的方法的名称的SEL
- imp方法的实现，该函数必须至少有两个参数，self，_cmd
- 方法类型
#import "ViewController.h"
#import "objc/runtime.h"
@implementation ViewController
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalSelector = @selector(viewDidLoad);
SEL swizzledSelector = @selector(jkviewDidLoad);
Method originalMethod = class_getInstanceMethod(class,originalSelector);
Method swizzledMethod = class_getInstanceMethod(class,swizzledSelector);
//judge the method named swizzledMethod is already existed.
BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
// if swizzledMethod is already existed.
if (didAddMethod) {
class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
}
else {
method_exchangeImplementations(originalMethod, swizzledMethod);
}
});
}
- (void)jkviewDidLoad {
NSLog(@"替换的方法");
// 如果不执行下一步只会执行打印替换的方法
[self jkviewDidLoad];
}
- (void)viewDidLoad {
NSLog(@"自带的方法");
[super viewDidLoad];
}
@end
swizzling应该只在+load中完成。 在 Objective-C 的运行时中，每个类有两个方法都会自动调用。+load 是在一个类被初始装载时调用，+initialize 是在应用第一次调用该类的类方法或实例方法前调用的。两个方法都是可选的，并且只有在方法被实现的情况下才会被调用。
swizzling应该只在dispatch_once 中完成,由于swizzling 改变了全局的状态，所以我们需要确保每个预防措施在运行时都是可用的。原子操作就是这样一个用于确保代码只会被执行一次的预防措施，就算是在不同的线程中也能确保代码只执行一次。Grand Central Dispatch 的 dispatch_once满足了所需要的需求，并且应该被当做使用swizzling 的初始化单例方法的标准。
2019-06-05 09:50:39.256374+0800 TestDemo[1359:36735] 替换的方法
2019-06-05 09:50:39.256505+0800 TestDemo[1359:36735] 自带的方法
KVO实现
全称是Key-value observing，翻译成键值观察。提供了一种当其它对象属性被修改的时候能通知当前对象的机制。再MVC大行其道的Cocoa中，KVO机制很适合实现model和controller类之间的通讯。
KVO 的实现依赖于OC的Runtime，当观察某对象A时，KVO 机制动态创建一个对象A当前类的子类，并为这个新的子类重写了被观察属性 keyPath 的 setter 方法。setter 方法随后负责通知观察对象属性的改变状况。
Apple 使用了 isa-swizzling 来实现 KVO。当观察对象 A 时，KVO机制动态创建一个新的名为：NSKVONofifying_A 的新类，该类继承自对象 A 的本类，且 KVO 为NSKVONotifying_A 重写观察属性的 setter 方法，setter 方法会负责在调用原 setter 方法之前和之后，通知所有观察对象属性值的更改情况。
- NSKVONotifying_A类剖析：
NSLog(@"self->isa:%@",self->isa);
NSLog(@"self class:%@",[self class]);
在建立KVO监听前，打印结果为：
self->isa:A
self class:A
在建立KVO监听之后，打印结果为：
self->isa:NSKVONotifying_A
self class:A
在这个过程，被观察对象的 isa 指针从指向原来的 A 类，被KVO 机制修改为指向系统新创建的子类NSKVONotifying_A 类，来实现当前类属性值改变的监听；
所以当我们从应用层面上看来，完全没有意识到有新的类出现，这是系统“隐瞒”了对 KVO 的底层实现过程，让我们误以为还是原来的类。但是此时如果我们创建一个新的名为“NSKVONotifying_A”的类，就会发现系统运行到注册 KVO 的那段代码时程序就崩溃，因为系统在注册监听的时候动态创建了名为 NSKVONotifying_A 的中间类，并指向这个中间类了。
- 子类setter方法剖析
KVO 的键值观察通知依赖于 NSObject 的两个方法:willChangeValueForKey:和 didChangeValueForKey: ，在存取数值的前后分别调用 2 个方法：
被观察属性发生改变之前，willChangeValueForKey:被调用，通知系统该 keyPath 的属性值即将变更；
当改变发生后， didChangeValueForKey: 被调用，通知系统该keyPath 的属性值已经变更；之后， observeValueForKey:ofObject:change:context:也会被调用。且重写观察属性的setter 方法这种继承方式的注入是在运行时而不是编译时实现的。
KVO 为子类的观察者属性重写调用存取方法的工作原理在代码中相当于：
- (void)setName:(NSString *)newName {
[self willChangeValueForKey:@"name"]; //KVO 在调用存取方法之前总调用
[super setValue:newName forKey:@"name"]; //调用父类的存取方法
[self didChangeValueForKey:@"name"]; //KVO 在调用存取方法之后总调用
}