iOS基本功-Runtime基础知识

2019-07-21

Runtime的核心是什么
Runtime的结构
Runtime的消息发送机制
Runtime的常用方法
Runtime的几个常见场景

Runtime是何物

Objective-C 扩展了 C 语言，并加入了面向对象特性和 Smalltalk 式的消息传递机制。而这个扩展的核心是一个用 C 和编译语言写的 Runtime 库。它是 Objective-C 面向对象和动态机制的基石。

Objective-C 是一个动态语言，这意味着它不仅需要一个编译器，也需要一个运行时系统来动态得创建类和对象、进行消息传递和转发。理解 Objective-C 的 Runtime 机制可以帮我们更好的了解这个语言，适当的时候还能对语言进行扩展，从系统层面解决项目中的一些设计或技术问题。

简而言之，OC的最底层是C语言来实现的，在OC和C语言之间，苹果用C语言和汇编架构出了一层转换层，这个转换层的核心就是Runtime。

Runtime中的结构体

Runtime中有两个的结构体需要点一下，一个是Category结构体，一个是类结构体

Categoty结构体

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增加实例变量的原因，不过这个和一般的实例变量是不一样的。
从上面的的结构体中可以看出，分类中可以添加实例方法，类方法，甚至可以实现协议，添加属性，不可以添加成员变量。

类结构体

类结构的代码如下

//类
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;
}

从上面的代码可以看出，一个类结构体包含以下几个部分:
1 isa 指向他的meta class
2 super_class 指向这个实例的父类实例
3 name 存储类的类名
4 instace_size 实例对象的内存大小
5 ivars 属性信息列表
6 methodLists 方法信息列表
7 cache 缓存信息列表
8 protocols 代理信息列表
9 version
10 info

元类

元类(Meta Class)是一个类对象的类。所有的类自身也是一个对象，我们可以向这个对象发送消息(即调用类方法)。
为了调用类方法，这个类的isa指针必须指向一个包含这些类方法的一个objc_class结构体。这就引出了meta-class的概念，元类中保存了创建类对象以及类方法所需的所有信息。我们看下图：

iOS的消息发送处理流程

假设，现在我们创建了一个Person对象，向这个对象的work方法发送消息，那么这个时候系统是一个怎样的处理流程呢？
1 系统首先找到Person对象，然后通过对象的isa，找到他的类
2 在他的类中查找cache，是否有work方法
3 没有找到则查找methodLists。
4 再没有则查找super_class的cache、methodLists
5 再没有则继续查找该类的super_class的cache、methodLists…
6 找到对应的method，执行它的IMP
7 转发IMP的return值
8 如果最终也没有找到对应的method，那么执行doesNotRecognizeSelector:方法报unrecognized selector Exception

在没找到方法和报unrecognized selector Exception之间，系统做了什么？

上一个问题前5步执行完毕之后，到最后抛出Exception之间系统提供给我们三次挽救的机会

1 动态方法解析

如上图，在找不到方法后，首先OC会调用 +resolveInstanceMethod:或者 +resolveClassMethod:，让你有机会提供一个函数实现。如果你添加了函数并返回YES，那运行时系统就会重新启动一次消息发送的过程。可以在这里通过Runtime的class_addMethod方法动态添加一个方法以供调用。
示例代码：

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    //执行fool函数
    [self performSelector:@selector(fool:)];
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(fool:)) {//如果是执行fool函数，就动态解析，指定新的IMP
        class_addMethod([self class], sel, (IMP)foolMethod, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}

void foolMethod(id obj, SEL _cmd) {
    NSLog(@"Doing fool");//新的fool函数
}

如果resolveInstanceMethod方法返回 YES ，运行时就会移到下一步：

备用接收者

如果目标对象实现了-forwardingTargetForSelector:，Runtime 这时就会调用这个方法，给你把这个消息转发给其他对象的机会。
代码示例：

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    return YES;//返回YES，进入下一步转发
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(foo)) {
        return [Person new];//返回Person对象，让Person对象接收这个消息
    }
    return [super forwardingTargetForSelector:aSelector];
}

完整消息转发

如果在上一步还不能处理未知消息，则唯一能做的就是启用完整的消息转发机制了。
首先它会发送-methodSignatureForSelector:消息获得函数的参数和返回值类型。如果-methodSignatureForSelector:返回nil ，Runtime则会发出 -doesNotRecognizeSelector: 消息，程序这时也就挂掉了。如果返回了一个函数签名，Runtime就会创建一个NSInvocation 对象并发送 -forwardInvocation:消息给目标对象,可以在这个方法里面对消息进行最后的拯救。
代码示例：

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    return YES;//返回YES，进入下一步转发
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
    return nil;//返回nil，进入下一步转发
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if ([NSStringFromSelector(aSelector) isEqualToString:@"fool"]) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];//签名，进入forwardInvocation
    }
    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];
    }
}

OC中调用私有方法有哪些方式

1 使用 performSelector
2使用 objc_msgSend ，对比上面 objc_msgSend 好处是传递多个参数时更为方便
3 利用函数实现IMP，IMP类型结构与objc_msgSend底层是同一类型，与2中实现无差别
4 通过方法签名实例
参考博客

Runtime的常用方法

获取类名 class_getName(Class)

class_getName()函数返回的是一个char类型的指针，也就是C语言的字符串类型，所以我们要将其转换成NSString类型，然后再返回出去。

获取成员变量

1
2
3

class_copyIvarList(class, &count) 获取成员变量列表
ivar_getTypeEncoding() 获取成员变量类型
ivar_getName() 获取成员变量名字

在OC中的给类添加成员属性其实就是添加了一个成员变量和getter以及setter方法。所以获取的成员列表中肯定带有成员属性，不过成员属性的名称前方添加了下划线来与成员变量进行区分。我们也可以获取成员变量的类型，下方的_var1是NSInteger类型，动态获取到的是q字母，其实是NSInteger的符号。而i就表示int类型，c表示Bool类型，d表示double类型，f则就表示float类型。当然这些基本类型都是由一个字母代替的，如果是引用类型的话，则直接就是一个字符串了，比如NSArray类型就是”@NSArray”。
当然，获取成员属性也有一个专有的方法：

1	class_copyPropertyList(class,&count)

获取类的实例方法

1
2
3

class_copyMethodList(class,&count) 获取方法列表
method_getName() 获取方法名字
method_getImplementation() 获取方法实现

获取协议

1
2
3

class_copyProtocolList() 获取协议列表
protocol_getName() 获取协议名字
protocol_getImplementation() 获取协议实现

动态添加方法

1 2	class_addMethod(Class, SEL, IMP, const char *);

方法实现交换

Runtime的使用场景

知道了Runtime的方法API，那么他的使用场景就可以开始自由发挥了。这里列举几个：
1 实现字典和模型的自动转换(MJExtension)
2 关联对象(Objective-C Associated Objects)给分类增加属性
3 KVO实现
4 实现NSCoding的自动归档和自动解档
5 页面路径的收集

关联对象

什么是关联对象？

关联对象是指给某个OC对象通过一个唯一的key将另一个类的实例关联到自身上，那另一个类的实例就是这个类的关联对象。当然一个类可以有多个关联对象。
举个例子，关联对象就像是你放风筝时手中牵的风筝，自然，也是可以同时牵多只风筝的。

关联对象主要操作API

//关联对象
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)

还是看代码比较容易理解，一段示例代码如下：

- (NSObject *)property {
    return objc_getAssociatedObject(self, @selector(property));
}
- (void)setProperty:(NSObject *)value {
    objc_setAssociatedObject(self, @selector(property), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

来解释一下上面的代码，
objc_setAssociatedObject的意思就是给当前这个类（self）添加一个叫value的关联属性，而且属性的唯一Id叫 @selector(property)。关联策略是 retain_nonatomic
然后objc_getAssociatedObject 是根据唯一的key也就是@selector(property)来获取objc_setAssociatedObject 设置的东西，也就是value。
这样做就是给当前类，也就是self添加了一个属性了，这个类可以是系统类，也可以是自定义的类，当然也可以是分类，这段代码就是面试题如何给一个分类添加属性的答案。
上面提到的关联策略，是指该对象释放后对它的关联对象的内存管理策略，是个枚举。

enum {
    OBJC_ASSOCIATION_ASSIGN = 0,
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, 
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,
    OBJC_ASSOCIATION_RETAIN = 01401,
    OBJC_ASSOCIATION_COPY = 01403 
};

关于Category的重名方法调用顺序的几个问题

最近和人聊起过一个问题，就是关于Category方面的处理。
1 如果在Category中写了一个和原类中名字一样的方法，在调用这个方法的时候会调用Category的方法，而不调用原类的方法，这是为什么呢？
乍一看，像是方法名覆盖，其实不然，在Runtime层的处理方式是将Catogory的方法添加到methodLists里面，在添加的时候是倒序的添加的，查找的时候是从上往下查找的，一旦找到Category中的那个方法后就执行后续流程了，原类里的那个同名方法就没有执行的机会了
2 如果有多个Category都实现了和原类同一个方法名字一样的方法，也都引入了，这个时候，如果调用这个方法，会是哪一个有效呢？
关于这个问题，在load的时候，就把分类加载上来，加载到类的class_rw_t中，会遍历加载，当判断有分类要加载的时候，用了内存级别的操作，memmove和memcopy，。依旧是倒序添加，从上往下查找，既然是这样，那么就是由XCode工程的配置文件[Build Phases] - [Complie Sources]中的顺序决定的，顺序靠后的那个会生效。