【iOS小结】Runtime

2018-02-12 10:52:35来源:https://www.jianshu.com/p/d2575704e273作者:WellsCai人点击

分享


一.Runtime简介

C语言中,在编译期,函数的调用就会决定调用哪个函数。而OC的函数,属于动态调用过程,在编译期并不能决定真正调用哪个函数,只有在真正运行时才会根据函数的名称找到对应的函数来调用。
Objective-C 是一个动态语言,这意味着它不仅需要一个编译器,也需要一个运行时系统来动态得创建类和对象、进行消息传递和转发。Runtime 就是这么一个主要使用 C 和汇编写的运行时库。


二.深入解析Objective-C
1. 类和对象(如何面向对象)

我们可以在Runtime文件里看到类(objc_class)和对象(objc_object)的底层实现。Class 是一个 objc_class 结构类型的指针, id是一个 objc_object 结构类型的指针(这也就是为什么能用id类型表示任何对象的原因)。


/*   类   */
typedef struct objc_class *Class;
struct objc_class : objc_object {
Class isa;
Class superclass; // 父类的指针
cache_t cache; // 存储方法缓存的结构体cache_t
class_data_bits_t bits; // 最终指向一个存储数据的结构体class_ro_t
}
/* 对象 */
typedef struct objc_object *id;
struct objc_object {
Class _Nonnull isa;
};
/* 存储方法缓存的结构体 */
struct cache_t {
struct bucket_t *_buckets;//用来缓存 bucket 的总数
mask_t _mask;//目前实际占用的缓存 bucket 的个数
mask_t _occupied;//一个散列表,用来方法缓存,包含 key 以及方法实现 IMP
};
/* 存储数据(方法列表,成员变量列表,协议列表)的结构体 */
struct class_ro_t {
uint32_t flags;
uint32_t instanceStart;
uint32_t instanceSize; //实例大小
#ifdef __LP64__
uint32_t reserved;
#endif
const uint8_t * ivarLayout;

const char * name;
method_list_t * baseMethodList;//方法列表
protocol_list_t * baseProtocols;//协议列表
const ivar_list_t * ivars;//实例变量列表,const是存储在只读区,这也是分类添加不了实例变量的原因
const uint8_t * weakIvarLayout;
property_list_t *baseProperties;//属性列表
};

objc_object中有一个Class类型的指针isa,所以常说所有对象都会包含isa指针。objc_class继承于objc_object,其中也包含一个isa指针,所以说类本质上也是一个对象。
class保存了方法列表,还有指向父类的指针。但class也是object,也会有isa变量,那么它又指向哪儿呢?这里就引出了第三个类型: metaclass。object的isa指向class,class的isa指向metaclass。
以下是一副经典的图,清楚说明了对象、类、元类之间的关系。




对象、类、元类关系图.png

isa的走向(用来找方法)
当一个对象的实例方法被调用时,会通过isa找到相应的类,然后在该类的class_data_bits_t中去查找方法,class_data_bits_t是指向类的数据区域,在数据区域查找相应方法的实现。对象的实例方法调用时,通过对象的 isa 在类中获取方法的实现。类对象的类方法调用时,通过类的 isa 在元类中获取方法的实现。
superclass的走向(用来找父类)


所以我们可以从图中看出(蓝色字体是我举的例子):


所有类(包括元类)的superclass的指针最终指向NSObject,NSObject没有父类,所以superclass指针指向nil。
2.所有的isa指针最终指向NSObject元类,NSObject元类的isa指针指向自己,形成一个闭环。
2. 消息分发(如何发消息)

在 Objective-C 中的“方法调用”其实应该叫做消息传递。消息有“名称”和“选择子”,可以接受参数,而且可能有返回值。
给对象发送消息可以这样写:


id returnValue = [someObject messageName:paramter];

本例中,someObject叫做“接收者”,messageName叫做“选择子”,选择子和参数合起来叫“消息”。编译器看到此消息后,会将其转换成一条标准的C语言函数调用,所调用的函数是消息传递机制的核心函数objc_msgSend。


void objc_msgSend(id self,SEL cmd,...)

这是个参数可变的函数,第一个参数代表接收者,第二个参数代表选择子(SEL是选择子的类型),后续参数就是消息中的那些参数。编译器会把例子中的消息转换成如下函数。


objc_msgSend(someObject,@selector(messageName:),paramter);

objc_msgSend函数会依据接收者和选择子的类型来调用适当的方法。首先,需要在接收者所属的类中搜寻其方法列表,如果能找到与选择子名称相符的方法,就跳至其实现代码。若是找不到,那就沿继承体系继续向上查找,等找到合适的方法再进行跳转。如果最终还是找不到相符的方法,那就执行“消息转发”操作(后续会说明)。
当然,每个类里面都有一块缓存来保存匹配的结果,这样稍后还想该类发同一消息就可以从缓存中获取。


/*  存储方法缓存的结构体  */
struct cache_t {
struct bucket_t *_buckets;//用来缓存 bucket 的总数
mask_t _mask;//目前实际占用的缓存 bucket 的个数
mask_t _occupied;//一个散列表,用来方法缓存,包含 key 以及方法实现 IMP
};
/* 方法缓存的散列表 */
struct bucket_t {
private:
cache_key_t _key;
IMP _imp;


objc_msgSend方法会先从缓存表里,查找是否有该 SEL 对应的 IMP,有的话直接通过函数指针 IMP ,找到方法的具体实现函数执行,没有的话才去搜寻其方法列表。如果有找到去执行,并将该方法保存在bucket_t中。
当然,objc_msgSend只能处理部分消息的调用过程,有的消息则需要其他函数来处理。比如:


objc_msgSend_stret(要返回结构体)
objc_msgSend_fpret(要返回浮点型)
objc_msgSendSuper(要给超类发消息)
3. 消息转发(接收到无法解读的消息怎么办)

在上面提到的发送消息过程中,选择子在当前类和父类中都没有找到实现,就会进入消息转发。
消息转发有两个阶段。
① 动态方法解析
征询接收者,所属的类,看其是否能动态添加方法,以处理当前这个未知的选择子。对象在收到无法解读的消息后,会调用其所属类的以下方法:


//如果是对象方法调用这
+ (BOOL)resolveInstanceMethod:(SEL)sel;
//如果是类方法调用这
+ (BOOL)resolveClassMethod:(SEL)sel;

举个动态添加属性存取方法的例子:


id autoDictionaryGetter(id self,SEL _cmd);
void autoDictionarySetter(id self,SEL _cmd,id value);
+ (BOOL)resolveInstanceMethod:(SEL)sel{
NSString *selString = NSStringFromSelector(sel);
if (/* selector is from a @dynamic property */) {
if ([selString hasPrefix:@"set"]) {
/*
* i:返回值类型int,若是v则表示void
* @:参数id(self)
* ::SEL(_cmd)
* @:id(str)
*/
class_addMethod(self, sel, (IMP)autoDictionarySetter, "v@:@");
}else{
class_addMethod(self, sel, (IMP)autoDictionaryGetter, "@@:");
}
return YES;
}
return [super resolveInstanceMethod:sel];
}

当接收者没动态添加方法处理该未知选择子时,会询问能不能把这条消息转给其他接收者处理(备胎接收者)。


//参数是选择子,返回值是备胎接收者,若找不到,就返回nil
- (id)forwardingTargetForSelector:(SEL)aSelector;

我们常用“组合”来模拟“多继承”。假如有个在student对象包含teacher,student无法处理的消息可以转移给teacher让它去处理。


- (id)forwardingTargetForSelector:(SEL)aSelector{
if ([_teacher respondsToSelector:aSelector]) {
return _teacher;//备胎就是老师了
}
return [super forwardingTargetForSelector:aSelector];
}

②完整的消息转发机制
当以上方法没有实现响应,就会通过完整的消息转发机制来做了。
首先创建NSInvocation 对象,把尚未处理的那条消息相关的全部细节封装于其中。NSInvocation是命令模式的一种传统实现,它把一个目标,一个选择器,一个方法签名和所有的参数都塞进对象中。当NSInvocation被调用时,它会发送消息,OC运行时会找到正确的方法实现来执行。


NSMutableSet *set = [NSMutableSet set];
NSString *parameter = @"parameter";
SEL selector = @selector(addObject:);
NSMethodSignature *signature = [set methodSignatureForSelector:selector];
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
[invocation setTarget:set]; //设置目标
[invocation setSelector:selector]; //设置选择子
[invocation setArgument:&parameter atIndex:2];//设置参数(0是目标,1是选择子,2后是参数)
//[invocation retainArguments];保留参数不被释放
[invocation invoke];//调用

其中,NSMethodSignature(方法签名)了一个方法的返回类型和参数类型,但不包括方法名。


//可以这样手动创建,但一般不这么用
NSMethodSignature *signature = [NSMethodSignature signatureWithObjCTypes:"@@:"];
/* 正确的创建方法 */
SEL initSEL = @selector(init);
SEL allocSEL = @selector(alloc);
//从对象中获取实例方法签名
NSMethodSignature *initSig = [@"String" methodSignatureForSelector:initSEL];
//从类中获取实例方法签名
NSMethodSignature *initSig = [NSString instanceMethodForSelector:initSEL];
//从类中获取类方法签名
NSMethodSignature *allocSig = [NSString methodSignatureForSelector:allocSEL];

我们举个举个例子来说明,创建一个蹦床类来将消息弹给它的目标对象。


#import "Trampoline.h"
@interface Trampoline()
@property(nonatomic,strong)id target;
@end
@implementation Trampoline
- (id)initWithTarget:(id)target{
if (self = [super init]) {
_target = target;
}
return self;
}
#pragma mark - 消息转发机制
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
return [self.target methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation{
//让目标对象去调用该方法
[anInvocation setTarget:_target];
[anInvocation retainArguments];
//可以在主线程调用或直接调用
[anInvocation performSelectorOnMainThread:@selector(invoke) withObject:nil waitUntilDone:NO];
}

然后我们这样调用(当然前提是目标类能实现该方法):


id trampoline = [[Trampoline alloc] initWithTarget:student];
[trampoline doSomeThing];

不过,只改变调用目标,跟前面所说的备胎接收者所实现的方法等效。所以到这一步比较有用的实现方式是:在触发消息前,先以某种方式改变消息内容,比如追加另外的参数,或改变选择子等等。


以下这张流程图描述了转发机制处理消息的各个步骤。接收者在每一步中均有机会处理消息,步骤越往后,处理消息的代价越大。最好是在第一步就处理完,即使要把消息转给备援者,也要放在第二步较为简单,不用生成NSInvocation。





消息转发.png

我们来总结一下消息传递的所有流程(消息分发和消息转发):
① 检查对象是否为nil,如果是调用nil处理程序。
② 检查类缓存中是不是有方法实现了,如果找到,调用方法实现。
③ 比较请求的选择子和父类中定义的选择子,然后是父类的父类,以此类推,如果找到选择子,调用方法实现。
④ 调用resolveInstanceMethod:(或对应类方法)。返回YES,那么从新开始。这一次对象会找到这个选择子,因为已经经过class_addMethod。
⑤ 调用forwardingTargetForSelector:,如果返回非nil,就把消息发送到返回的对象上。不要返回self,会造成死循环。
⑥ 调用methodSignatureForSelector:,如果返回非nil,创建一个NSInvocation并传给forwardInvocation:。
⑦ 调用doesNotRecognizeSelector:,默认的实现是抛出异常。


三.Runtime的应用

runtime有很多api我们经常用到:
class


/* 修改类(以add开头) */
class_addIvar;
class_addProperty;
class_addMethod;
class_addProtocol;
/* 获取类中的所有内容(一般是数组)以copy开头*/
class_copyIvarList;
class_copyPropertyList;
class_copyMethodList;
class_copyProtocolList;
/* 获取类中的单个内容(以get开头)*/
class_getName;
class_getSuperclass;
class_getProperty;
class_getClassMethod;

/* 还有一些判断,替换,创建实例的方法*/
class_createInstance;
class_conformsToProtocol;
class_replaceMethod;
class_respondsToSelector;

objc
/* 获取设置实例变量 */
object_getIvar;
object_setIvar;
/* 获取设置类 */
object_getClass;
object_setClass;

ivar


ivar_getName;          //获取名字
ivar_getOffset; //获取内存地址
ivar_getTypeEncoding; //获取type encoding

property


property_getName;        //获取名字
property_getAttributes; //获取所有属性信息(是否是atomic,getter/setter名字,是否弱引用)

method


method_getName;
method_getReturnType;
/* 方法交换常用 */
method_setImplementation;
method_getImplementation;
method_exchangeImplementations;

sel


sel_getName;    //获取名字
sel_registerName; //注册方法

protocol
Protocols有点像Classes,运行时的方法是一样的。可以获取method, property, protocol列表, 检查是否实现了其他的protocol。


接下来,我们举几个runtime常见的应用:
① 方法交换(Method Swizzling)→交换IMP
② 动态继承、交换(ISA Swizzling)→改变ISA


方法交换(Method Swizzling)
我们知道了运行时会发消息给对象。一个对象的class保存了方法列表。class的方法列表其实是一个字典,key为selectors,IMPs为value,一个IMP是指向方法在内存中的实现。selector和IMP之间的关系是在运行时才决定的,而不是编译时。所以可以通过交换IMP来实现交换方法,从而达到重写某个方法而不用继承,同时还可以调用原先的实现的目的(面向切面编程的一个应用)。
我们先来看看一下Runtime中方法(Method)的构成,方法交换的本质就是交换Method里面的IMP指针。


typedef struct objc_method *Method;
struct objc_method {
SEL _Nonnull method_name; //选择子(方法名)
char * _Nullable method_types; //该方法参数的类型
IMP _Nonnull method_imp; //函数指针
}

接下来书写代码,将viewWillAppear:换成我们自己写的方法,同时也调用原来的方法,然后在方法中加入一些处理(比如监测、统计数据):


#import "UIViewController+MethodSwizzling.h"
#import <objc/runtime.h>
@implementation UIViewController (MethodSwizzling)
+ (void)load{
Method oldMethod = class_getInstanceMethod(self, @selector(viewWillAppear:));
Method newMethod = class_getInstanceMethod(self, @selector(yc_viewWillAppear:));
method_exchangeImplementations(oldMethod, newMethod);

}
- (void)yc_viewWillAppear:(BOOL)animated{
[self yc_viewWillAppear:animated];
NSLog(@"添加监测代码");
}
@end



方法交换原理图.png

动态继承、交换(ISA Swizzling)
我们可以在运行时创建一个新的类,我们能通过它创建新的子类,并添加新的方法。


//动态创建对象(类也是对象)(创建一个Student类,继承NSObject)
Class Student = objc_allocateClassPair([NSObject class], "Student", 0);
//使用Block作为方法的IMP
IMP myIMP = imp_implementationWithBlock(^(id _self,NSString *string){
NSLog(@"Hello %@",_self);
});
//为该类增加report的方法
class_addMethod(Student, @selector(report), myIMP, "v@:");
//注册该类
objc_registerClassPair(Student);
//创建student对象
id student = [[Student alloc] init];
[student report];

但是能这个动态创建子类有什么用呢?object内部有一个叫做isa的变量指向它的class。我们可以改变一个实例的isa指向,让它指向我们创建的类。可以通过以下命令来修改一个object的class:


object_setClass(myObject, [MySubclass class]);

我们来举个例子:


#import "MyNotificationCenter.h"
@implementation MyNotificationCenter
- (void)addObserver:(id)observer selector:(SEL)aSelector name:(NSNotificationName)aName object:(id)anObject{
NSLog(@"adding observer:%@",observer);
[super addObserver:observer selector:aSelector name:aName object:anObject];
}
@end

#import "NSObject+ISASwizzle.h"
#import <objc/runtime.h>
@implementation NSObject (ISASwizzle)
- (void)yc_setClass:(Class)aClass{
NSAssert(class_getInstanceSize([self class]) == class_getInstanceSize(aClass), @"Classes must to be same size to swizzle");
object_setClass(self, aClass);
}
@end

NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
[center yc_setClass:[MyNotificationCenter class]];
[center addObserver:self selector:@selector(test) name:@"test" object:nil];

这样在该类中的center实例就变成我们自己的实例,可以在添加观察者或调用其他方法时加入我们自己的代码。Cococa框架中的KVC也是基于此原理,当你开始观察一个object时,Cocoa会创建这个object的class的subclass,subclass重写监听属性的set方法,然后将这个object的isa指向新创建的subclass,从而属性改变时都会调用我们创建的subclass的该属性的set方法。
有一点需要注意的是,我们创建的子类大小要和原本的类大小一致,也就是说不能生成ivar或属性,因为被混写的对象已经分配好,如果添加ivar,那么它们就会指向已分配内存外的区域,那么很容易覆盖内存中这个对象后面对象的isa指针。


我们来总结一下方法交换和ISA交换的特点,以便清晰它们的使用范围:


方法交换
影响一个类的所有实例
所有对象的类都不变
需要特殊的覆盖方法来实现
ISA交换
只影响目标实例
对象的类会变化
覆盖方法是用子类的方法







最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台