013-Runtime

一、概述

1.多态

1）含义

计算机程序运行时，相同的消息可能会送给多个不同的类别之对象，而系统可依据对象所属类别，引发对应类别的方法，而触发不同的行为，这个就是多态；简单来说，所谓多态指的是相同的消息给予不同的对象会引发不同的动作

2）分类

静态多态：允许将不同的特殊行为和单个泛化记号相关联，由于这种关联处理于编译期而非运行期，因此被称为“静态”，比如函数重载

动态多态：即运行时多态，对于C++来说，通过类继承机制和虚函数机制生效于运行期，可以优雅地处理异质对象集合，只要其共同的基类定义了虚函数的接口；对于OC来说，通过借鉴于smallTalk的消息传递机制实现动态多态。一般来说，动态多态才是真正的多态

2.OC的多态实现

#import <Foundation/Foundation.h>

@interface Base: NSObject
@end

@implementation Base

- (void)f {
    NSLog(@"Base f");
}

@end

@interface Derived: Base
@end

@implementation Derived

- (void)f {
    NSLog(@"Derived f");
}

@end

int main(int argc, char *argv[]) {
    Derived *d = [[Derived alloc] init];
    Base *pb = d;
    Derived *pd = d;
    [pb f];     // 输出：Derived f
    [pd f];     // 输出：Derived f
    return 0;
}

分析：上述代码创建了Derived对象d，将Base类型指针pb和Derived类型指针pd指向d，可知pb和pd的编译时刻的类型分别是Base和Derived，而运行时刻类型均为Derived。从两个输出来看，可以发现，OC并没有使用虚函数，也没有虚函数的概念，但是OC自动完成了动态多态的实现

3.运行时机制

C语言是一种静态语言，而OC语言是一个依托于C的语言。为了保持C编译时的功能(如：类型检查)，并且增加灵活性，OC在C的基础上，借鉴了smalltalk的消息传递机制为其添加了运行时机制，这也就是runtime机制

换种方式来说，runtime机制是一个由C和汇编编写的Library，而这个Library给C增加了面向对象的特性，从而形成了OC语言

基于runtime，OC中对象的类型和对象所执行的方法都是在运行时阶段进行查找并确认的，这种机制被称为动态绑定

OC中与运行时机制进行交互的方面大致以下三种：

1）Objective-C源代码

大部分情况下你就只管写你的Objective-C代码就行，runtime系统自动地在幕后辛勤地劳作着

[pb f];

经过编译转换为：

((void (*)(id, SEL))(void *)objc_msgSend)((id)pb, sel_registerName("f"));

2）NSObject的方法

Cocoa中大多数的类都是继承自NSObject类，自然也就继承了它的方法。

有的NSObject中的方法起到了抽象接口的作用：如description方法需要你重载它并为你定义的类提供描述内容

有的NSObject中的方法能在运行时获得类的信息，并检查一些特性：如class返回对象的类，isKindOfClass:和isMemberOfClass:则检查对象是否在指定的类继承体系中，respondsToSelector:检查对象能否响应指定的消息，conformsToProtocol:检查对象是否实现了指定协议类的方法，methodForSelector:则返回指定方法实现的地址

3）Runtime的函数

4.静态语言和动态语言

C语言是静态语言，在经过编译之后，就知道代码要干嘛；而OC语言是一门面向对象的动态语言，它在依托C语言的情况下，还自行添加了动态特性，即在编译之后只是知道给对象发送消息，只有到运行时才了解要干嘛。

5.Runtime的应用

1）方法实现的替换：替换两个方法的实现，可以做一些埋点、容错等工作

2）关联属性：在运行时刻为某个class增加属性

3）Json映射：通过runtime的方法将Json映射到model

 

二、Runtime代码实例

1.OC的消息机制

Person.h文件

#import <Foundation/Foundation.h>

@interface Person : NSObject

- (void)eatWithFood:(NSString *)food;

@end

Person.m文件

#import "Person.h"
#import <objc/runtime.h>

@implementation Person

- (void)eatWithFood:(NSString *)food
{
    NSLog(@"吃%@", food);
}

@end

MsgSendController.m文件

#import "MsgSendController.h"
#import <objc/message.h>
#import "Person.h"

@interface MsgSendController ()

@end

@implementation MsgSendController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    self.title = @"消息发送机制";
    
    [self sendMsgC];
}

#pragma mark - 给对象发送消息
- (void)sendMsg
{
    Person *p = [[Person alloc] init];
    
    // 方法调用1
    [p eatWithFood:@"汉堡包"];
    
    // 方法调用2
    [p performSelector:@selector(eatWithFood:) withObject:@"汉堡包"];
    
    // 方法调用3
    /* 消息机制：给对象发送消息 */
    ((void(*)(id,SEL,NSString *))objc_msgSend)((id)p, @selector(eatWithFood:), @"汉堡包");
}

#pragma mark - 纯C代码
- (void)sendMsgC
{
    // 1.拆分类Person的对象初始化方法
    // Person *p = [Person alloc];
    // 换成C的消息机制
    // 类也是一个特殊的对象：类对象
    // Person *p = objc_msgSend([Person class], @selector(alloc));
    
    // p = [p init];
    // 换成C的消息机制
    // p = objc_msgSend(p, @selector(init));
    
    // 2.合并类Person的对象初始化方法
    Person *p = objc_msgSend(objc_msgSend([Person class], @selector(alloc)), @selector(init));
    
    // 3.调用类Person的对象方法eatWithFood:
    ((void(*)(id,SEL,NSString *))objc_msgSend)((id)p, @selector(eatWithFood:), @"汉堡包");
}

@end

2.交换方法实现

NSURL+URL.h文件

#import <Foundation/Foundation.h>

@interface NSURL (URL)

#pragma mark - 由于Objective-C中NSURL没有错误处理，所以我们只能重新写一个方法
+ (instancetype)LD_URLWithStr:(NSString *)str;

@end

NSURL+URL.m文件

#import "NSURL+URL.h"
#import <objc/message.h>

@implementation NSURL (URL)

#pragma mark - 文件加载时调用，在main函数调用之前就会调用
+ (void)load
{
    NSLog(@"NSURL+URL这个分类文件被加载");
    
    // 方法
    // method_exchangeImplementations  交换两个方法的实现
    // class_getClassMethod                   获取类方法
    // class_getInstanceMethod               获取实例方法
    
    // 交换方法的实现(其实就是交换的方法指针)
    // 参数1：类对象
    // 参数2：方法名
    Method URLMethod = class_getClassMethod([NSURL class], @selector(URLWithString:));
    Method LDURLMethod = class_getClassMethod([NSURL class], @selector(LD_URLWithStr:));
    method_exchangeImplementations(URLMethod, LDURLMethod);
}

#pragma mark - 由于Objective-C中NSURL没有错误处理，所以我们只能重新写一个方法
+ (instancetype)LD_URLWithStr:(NSString *)str
{
    // 这里面调用LD_URLWithStr:这个方法，根据runtime的方法交换其实在调用系统的URLWithString:
    NSURL *url = [NSURL LD_URLWithStr:str];
    if (!url) {
        NSLog(@"url为空，错误处理");
    }
    return url;
}

@end

RunTimeController.m文件

#import "RunTimeController.h"
#import <objc/runtime.h>
#import "NSURL+URL.h"   // 如果是使用runtime的话，就不必引入这个头文件

@interface RunTimeController ()

@end

@implementation RunTimeController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    self.title = @"交换方法实现";
    
    [self runtime];
}

#pragma mark - 分类来控制NSURL的错误处理
// 这样处理起来比较麻烦，只要项目中有用到NSURL，就必须引入分类头文件，且换成我们分类中的方法
// 所以说还是必须使用runtime
- (void)catgory
{
    NSURL *url = [NSURL LD_URLWithStr:@"http://哈哈"];
    NSURLRequest *request = [NSURLRequest requestWithURL:url];
    NSLog(@"网络请求1%@", request);
}

#pragma mark - RunTime
// 通过在分类NSURL+URL中去通过runtime交换方法实现来处理
// 具体的代码请看分类NSURL+URL
- (void)runtime
{
    // runtime：运行时
    // 相关头文件：<objc/runtime.h>
    // runtime是OC的底层实现，帮我们完成OC无法完成的事情
    // 1.利用runtime在程序运行的过程中，动态地创建一个类
    // 2.利用runtime在程序运行的过程中，动态地修改一个类(属性/方法)
    // 3.利用runtime在程序执行的过程中，动态地交换方法实现
    
    // 这里我们就可以大大方方的调用系统的
    // 由于runtime的方法交换，系统的URLWithString:方法会找到分类中LD_URLWithStr:方法的实现
    NSURL *URL = [NSURL URLWithString:@"http://哈哈"];
    NSURLRequest *request = [NSURLRequest requestWithURL:URL];
    NSLog(@"网络请求2%@", request);
}

@end

3.方法的懒加载

Boy.h文件

#import <Foundation/Foundation.h>

@interface Boy : NSObject

#pragma mark - 实例方法
- (void)eat;
- (void)drink;

#pragma mark - 类方法
+ (void)play:(NSString *)what;

@end

Boy.m文件

#import "Boy.h"
#import <objc/runtime.h>

@implementation Boy

#pragma mark - 当这个类被调用一个没有实现的对象方法时就会来到这里
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
    // 方法
    // class_addMethod   // 添加方法
    // class_addIvar         // 添加属性
    
    // 在这里添加该类没有实现的实例方法的实现
    // 参数1：类对象
    // 参数2：方法名
    // 参数3：方法实现，就是一个函数指针
    // 参数4：返回值类型(C字符串)
    class_addMethod([Boy class], @selector(eat), (IMP)eatfood, nil);
    // 参数4举例：v@:中的v代表返回值是void类型，@:代表两个参数
    class_addMethod([Boy class], @selector(drink), (IMP)drinkwater, "v@:");
    
    return [super resolveInstanceMethod:sel];
}

#pragma mark - 当这个类被调用一个没有实现的类方法时就会来到这里
+ (BOOL)resolveClassMethod:(SEL)sel
{
    // 获取当前类的class元类
    Class aMeta = objc_getMetaClass(class_getName([self class]));
    
    // 在这里添加该类没有实现的类方法的实现
    // 参数1：类对象
    // 参数2：方法名
    // 参数3：方法实现，就是一个函数指针
    // 参数4：返回值类型(C字符串)
    // 参数4举例：v@:*中的v代表返回值是void类型，@:*代表三个参数
    class_addMethod([aMeta class], @selector(play:), (IMP)play, "v@:*");
    
    return [super resolveClassMethod:sel];
}

#pragma mark - 函数实现
void eatfood() {
    printf("吃饭饭\n");
}

#pragma mark - 函数实现
// id obj, SEL _cmd这是两个隐形参数，所有函数都默认有的
void drinkwater(id obj, SEL _cmd) {
    NSLog(@"调用了%@的%@方法", obj, NSStringFromSelector(_cmd));
    printf("喝水\n");
}

#pragma mark - 函数实现
void play(id obj, SEL _cmd, char * what) {
    NSLog(@"调用了%@的%@方法", obj, NSStringFromSelector(_cmd));
    printf("玩%s\n", what);
}

@end

RunTimeMethodController.m文件

#import "RunTimeMethodController.h"
#import "Boy.h"

@interface RunTimeMethodController ()

@end

@implementation RunTimeMethodController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    self.title = @"方法懒加载";
    
    [self test];
}

#pragma mark - 调用Boy类中没有实现的方法，一般情况下，会出现崩溃，但是这里使用了runtime懒加载方法，所以不会
// 具体实现部分请看Boy类中的代码
- (void)test
{
    Boy *b = [[Boy alloc] init];
    [b eat];
    [b drink];
    [Boy play:@"足球"];
}

@end

4.KVO的底层实现

1）系统的KVO的常规用法

Dog.h文件

#import <Foundation/Foundation.h>

@interface Dog : NSObject

@property (nonatomic, assign) int age; // 年龄

@end

Dog.m文件

#import "Dog.h"

@implementation Dog

@end

Man.h文件

#import <Foundation/Foundation.h>

@interface Man : NSObject

@end

Man.m文件

#import "Man.h"

@implementation Man

#pragma mark - KVO监听事件
// 在RunTimeRespondController中注册了让Man对象监听Dog对象的age属性的变化
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
{
    NSLog(@"监听到%@的%@属性变化为:%@", object, keyPath, change);
}

@end

RunTimeRespondController.m文件

#import "RunTimeRespondController.h"
#import "Man.h"
#import "Dog.h"

@interface RunTimeRespondController ()

@property (nonatomic, strong) Man *m;
@property (nonatomic, strong) Dog *d;

@end

@implementation RunTimeRespondController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    self.title = @"KVO响应式编程";
    
    [self test];
}

#pragma mark - 注册KVO监听者
- (void)test
{
    // KVO底层实现原理
    // KVO的监听，其实就是重写被监听者的被监听属性的set方法
    // 底层找方法其实也就是通过isa指针
    // KVO在注册监听的时候，其实就是在注册完监听的时候，底层会自动创建一个继承自被监听对象的子类，并在这个子类中去重写这个被监听属性的set方法，并且这个被监听对象的isa指针指向的是它的子类，后面通过属性方法调用改变该被监听对象的值的时候，就回去找该属性的set方法，但由于这个被监听对象的isa指针指向它的子类，所以调用的set方法自然也就是子类中重写的set方法
    
    _m = [[Man alloc] init];
    _d = [[Dog alloc] init];
    
    // 注册监听
    // 让m对象监听d对象的age属性的变化
    [self.d addObserver:self.m forKeyPath:@"age" options:NSKeyValueObservingOptionNew context:nil];
}

#pragma mark - 点击屏幕
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    _d.age ++;
}

#pragma mark - 销毁KVO观察者
- (void)dealloc
{
    [self.d removeObserver:self.m forKeyPath:@"age"];
}

@end

2）自定义KVO的实现

Girl.h文件

#import <Foundation/Foundation.h>

@interface Girl : NSObject

@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;

@end

Girl.m文件

#import "Girl.h"

@implementation Girl

@end

NSObject+LDKVO.h文件

#import <Foundation/Foundation.h>

@interface NSObject (LDKVO)

#pragma mark - 扩展一个方法
// 仿照KVO的注册监听方法
- (void)LD_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context;

@end

NSObject+LDKVO.m文件

#import "NSObject+LDKVO.h"
#import <objc/message.h>

@implementation NSObject (LDKVO)

#pragma mark - 扩展一个方法
// 仿照KVO的注册监听方法
- (void)LD_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context
{
    // 方法
    // objc_allocateClassPair        // 动态添加一个类
    // objc_registerClassPair        // 动态注册一个类
    // class_addMethod               // 动态地给某一个类添加方法
    // class_addIvar                     // 动态地给某一个类添加属性
    // object_setClass                 // 修改某一个类的isa指针
    // objc_setAssociatedObject   // 关联属性
    // objc_getAssociatedObject   // 取得关联属性
    // objc_registerClassPair        // 注册类
    
    // 1.自定义一个类，继承[self class]
    // self：谁调用这个方法，谁就是self
    
    // 2.重写被监听属性keyPath的set方法
    
    // 3.通知观察者observer
    // 其实就是调用observer的observeValueForKeyPath方法
    
    // 动态添加一个继承[self class]的类
    NSString *oldClassName = NSStringFromClass([self class]);  // 拿到父类名称字符串
    NSString *newClassName = [NSString stringWithFormat:@"LDKVO_%@", oldClassName]; // 拼接继承父类的子类名称字符串
    const char * newName = [newClassName UTF8String];  // OC字符串转化为C的字符串
    Class myClass = objc_allocateClassPair([self class], newName, 0);
    
    // 动态地给子类添加被监听属性的set方法 -- 相当于给子类重写被监听属性的set方法
    class_addMethod(myClass, @selector(setAge:), (IMP)setAge, "v@:i");
    
    // 注册这个子类
    objc_registerClassPair(myClass);
    
    // 修改被观察对象的isa指针
    // 其实就是self的isa指针
    object_setClass(self, myClass);
    
    // 将观察者属性observer保存到当前类myClass里面去
    // 这里的self指的是myClass，因为上一步已经改变了self的isa指针
    objc_setAssociatedObject(self, (__bridge const void *)@"objc", observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

#pragma mark - 相当于重写被监听属性的set方法
void setAge(id self, SEL _cmd, int age) {
    // 保存当前类
    Class myClass = [self class];
    // 调用父类的监听属性的set方法，去设置新值
    // 这里将self的isa指针改成指向父类的
    object_setClass(self, class_getSuperclass([self class]));
    // 调用父类
    ((void(*)(id,SEL,int))objc_msgSend)((id)self, @selector(setAge:), age);
    // 拿出观察者属性
    id objc = objc_getAssociatedObject(self, (__bridge const void *)@"objc");
    // 通知观察者
    ((void(*)(id,SEL,id,NSString *,id,id))objc_msgSend)(objc, @selector(observeValueForKeyPath:ofObject:change:context:), self, @"age", nil, nil);
    // 改回子类
    object_setClass(self, myClass);
}

@end

CustomKVOController.h文件

#import "CustomKVOController.h"
#import "Girl.h"
#import "NSObject+LDKVO.h"

@interface CustomKVOController ()

@property (nonatomic, strong) Girl *g;

@end

@implementation CustomKVOController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    self.title = @"KVO底层-自定义KVO";
    
    [self test];
}

#pragma mark - 自定义KVO
- (void)test
{
    _g = [[Girl alloc] init];
    _g.name = @"Frank";
    _g.age = 18;
    
    // 注册监听
    // 用我们分类中的扩展方法
    [self.g LD_addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew context:nil];
}

#pragma mark - KVO监听事件
// 注册了让self监听Girl对象的age属性的变化
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
{
    NSLog(@"监听到%@的%@属性变化为:%@", object, keyPath, change);
}

#pragma mark - 点击屏幕
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    _g.age ++;
}

@end