iOS －－runtime理解与应用

1.什么是Runtime？

我所理解的runtime是一个使用C编写的库,为C添加了面向对象的特性,它是一个库(Runtime Library中文:运行时库).在这个库中能够用C函数来实现方法,对象也能够用C语言的结构体来表示…全部oc的方法的背后都是经过runtime来运行的.

2.runtime的使用

（1）利用runtime的消息发送机制调用方法

首先新建一个类RuntimeModel，并实现对象方法eat，在RuntimeViewController中调用eat方法，使用oc来语言来实现很简单了

RuntimeModel * model=[[RuntimeModel alloc]init];
[model eat];
复制代码

接下来一点点用runtime实现上面的代码，导入runtime的头文件#import <objc/message.h>，因为xcode5.0开始苹果不建议咱们使用底层的代码，因此target->build setting->搜索msg->将YES改成NO，这样接下来咱们用runtime的时候才会出现提示。 咱们使用objc_msgSend(<#id self#>, <#SEL op, ...#>)这个方法，能够看到须要两个参数，第一个参数是id类型，表明谁要发送消息，第二个参数是要把消息发送给谁，咱们用runtime来实现[model eat];这个方法。

objc_msgSend(model, sel_registerName("eat"));
复制代码

而初始化对象一样是调用了alloc init这两个方法。将导入的头文件RuntimeModel去掉，用纯c语言的代码实现上面的功能。

objc_msgSend(objc_msgSend(objc_msgSend(objc_getClass("RuntimeModel"), sel_registerName("alloc")), sel_registerName("init")), sel_registerName("eat"));
复制代码

运行，咱们能够看到在eat方法中的nslog被调用了，虽然咱们实现了功能，可是怎么才能知道咱们的oc语言在运行时确实是被转换成了c语言的代码呢？ 新建工程，建立命令行工具。

新建一个person类，而后进入main.m中。 调用头文件，在main中实例化person。 person * p=[[person alloc]init];关闭项目，打开终端，进入刚才建的文件夹下， ls打开能够看到刚才咱们新建的类和main.m文件，接下来执行命令行 clang -rewrite-objc main.m 这时咱们能够看到，在刚才的工程中出现一个 main.cpp的文件，打开而且拖到最下面。

（2）交换方法

作为oc的程序员最悲惨的就是，运行－－崩溃在main里面，我尼玛！！！ 例如：

NSURL * url=[NSURL URLWithString:@"www.baidu.com.啦啦"];
复制代码

当咱们没有进行编码的时候，这个url在编译的时候是有效的，可是一旦运行起来，这个url就会变为nil。由于检测不到这是一个无效的url，会继续发送网络请求。 怎么办呢？在下面用if作一个判断？但是要在每个url下面都作判断。这时候最早想到的必定是重写。 建立一个url的分类，重写URLWithString:<#(nonnull NSString *)#>可是，咱们看：

+(instancetype)URLWithString:(NSString *)URLString
{
    //  首先建立一个URL
    NSURL * url= ????????
    if (url==nil) {
        NSLog(@"有问题");
    }
    return url;
}
复制代码

咱们该怎么建立呢，死循环了是否是，因此runtime就起做用了。 在分类中自定义一个方法

+(instancetype)TY_URLWithStr:(NSString *)Str;
{
    NSURL * url =[NSURL URLWithString:Str];
    if (url == nil) {
        NSLog(@"是空！！！！");
    }
    return url;
}
复制代码

可是咱们并非要每一次建立url都调用这个方法，由于程序里有不少建立url的地方，咱们还继续使用系统自带的方法。在分类中实现load方法，当程序加载这个类的时候最早调用这个方法。导入头文件，开始进行方法交换。

+(void)load
{
    //  Method : 成员方法
    //class_getClassMethod   拿到类方法
    //class_getInstanceMethod   拿到对象方法
    Method URLWithStr = class_getClassMethod([NSURL class], @selector(URLWithString:));
    Method TYURLWithStr = class_getClassMethod([NSURL class], @selector(TY_URLWithStr:));
    //  开始交换方法
    method_exchangeImplementations(URLWithStr, TYURLWithStr);
}
复制代码

记得将上面咱们自定义的方法中建立url的方法改变回去，否则再次死循环，改成

+(instancetype)TY_URLWithStr:(NSString *)Str;
{
    NSURL * url =[NSURL TY_URLWithStr:Str];
    if (url == nil) {
        NSLog(@"是空！！！！");
    }
    return url;
}
复制代码

是否是有种一叶落而知天下秋的感受。

（3）遍历属性列表简化序列化

oc的序列化在这里就很少说了，让咱们来讲一种常见的状况，当须要归档的属性过多时，咱们须要一条条的写出来，十分繁琐，有没有可能简化一些呢，若是单纯的用for循环去作，那么不一样的类型该怎么处理呢，这时候咱们的runtime又来了。首先建立一个Person类，多弄一些虚拟属性。

//  .h
@property(nonatomic,strong) NSString * name;
@property(nonatomic,strong) NSString * name1;
@property(nonatomic,assign) int age;
@property(nonatomic,assign) int age1;
@property(nonatomic,assign) double age2;

// .m
-(void)encodeWithCoder:(NSCoder *)Coder
{
    
}

-(instancetype)initWithCoder:(NSCoder *)aDecoder
{
    self=[super init];
    if (self) {
        
    }
    return self;
}
复制代码

实现思路：

-(void)encodeWithCoder:(NSCoder *)Coder
{
    for (int i = 0; i < 属性数量; i++) {
    [Coder encodeObject:属性值 forKey:属性名称];
    }
}
复制代码

那么 回到controller中，导入runtime头文件，使用一个方法class_copyIvarList(<#__unsafe_unretained Class cls#>, <#unsigned int *outCount#>)获取属性列表，第一个参数，传入一个类[Person class]，第二个参数，传入一个指针，在上面定义unsigned int count = 0;，而后传入&count。这个count就是获取的属性的数量。同时在c语言中是不分.h.m的，因此不管是在哪一个文件中定义的属性，均可以取到。

unsigned int count = 0;
class_copyIvarList([Person class], &count);
复制代码

而后咱们须要定义一个Ivar类型的指针，这个指针会指向每个属性，下面这个图说明一下，他并非同时指向每个属性，而是一个一个分别指向来获取属性。

咱们使用一个方法经过这个ivars去获取属性名称。

unsigned int count = 0;
    Ivar * ivars = class_copyIvarList([Person class], &count);
    Ivar ivar = ivars[0];
    const char * name = ivar_getName(ivar);
    NSLog(@"%s",name);
复制代码

打印看到第一个属性名，能够改变ivars[第几个]，去获取第几个。并且即便角标越界，依然不会崩溃。 那么咱们回到person类中，直接用刚才的代码实现咱们最开始提出的问题。

//  归档
-(void)encodeWithCoder:(NSCoder *)Coder
{
    unsigned int count = 0;
    Ivar * ivars = class_copyIvarList([Person class], &count);
    for (int i = 0; i < count; i++) {
        Ivar ivar= ivars[i];
        const char * name = ivar_getName(ivar);
        NSString * key = [[NSString alloc]initWithUTF8String:name];
        //  使用KVC  拿出属性的值
        [Coder encodeObject:[self valueForKey:key] forKey:key];
    }
}
//  解档
-(instancetype)initWithCoder:(NSCoder *)Decoder
{
    self=[super init];
    if (self) {
        unsigned int count = 0;
        Ivar * ivars = class_copyIvarList([Person class], &count);
        for (int i = 0; i < count; i++) {
            Ivar ivar= ivars[i];
            const char * name = ivar_getName(ivar);
            NSString * key = [[NSString alloc]initWithUTF8String:name];
            //  使用KVC  拿出属性的值
            id value = [Decoder decodeObjectForKey:key];
            //  设置属性
            [self setValue:value forKey:key];
        }

    }
    return self;
}
复制代码

经过上面的讲述，这段代码就很容易理解了。咱们用的是kvc的赋值和取值，因此任何类型的归档解档都是没有问题的。

（4）刨析KVO底层实现

咱们先用oc实现一个简单的KVO监听。

//   controller.m
self.c=[[Cat alloc]init];
self.d=[[Dog alloc]init];
    //  注册监听
[self.d addObserver:self.c forKeyPath:@"age" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];

//   cat.m
//  监听到了object的对象keyPath属性变化为乐change
-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
{
    NSLog(@"监听到了%@的对象%@属性变化为乐%@",object,keyPath,change);
}
复制代码

这是KVO最简单的应用，那么接下来咱们看一下KVO底层究竟是怎么实现的呢？ 首先在KVO运行的时候会动态的添加一个类，继承与被观察者的类。名字叫作NSKVONotifying_Dog这个类。类名可不是瞎编的哦。而后在.m文件中，调用父类的set方法：

-(void)setAge:(int)age
{
    [super setAge:age];
    // 在子类中调用这两个方法
    //  这个是 将要被改变的值是什么
    [self willChangeValueForKey:@"age"];
    //   这个是   改变以后的新值是什么
    [self didChangeValueForKey:@"age"];
}
复制代码

这样就会监听到改变而且传值，可是为何说KVO是这样实现的呢？ 将刚才新建的NSKVONotifying_Dog类删掉，在controller中实现点击改变值的方法

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    self.d.age=99;
}
复制代码

在赋值的地方打断点，若是程序运行到这里，d的类型变为刚才那个方法的类型，那么就说明KVO就是这样实现的。

（5）动态添加方法

首先建立一个Person类，而后在controller中实例化person直接能够这样直接调用一个不存在的方法

Person * p=[[Person alloc]init];
    [p performSelector:@selector(eat)];
复制代码

这样虽然编译能够过，可是运行起来就会崩溃 这时候我没回到person.m中，来看两个方法

//  当这个类被调用没有实现的类方法  就会来到这里
+(BOOL)resolveClassMethod:(SEL)sel
{
    return [super resolveClassMethod:sel];
}
//  当这个类被调用没有实现的对象方法  就会来到这里
+(BOOL)resolveInstanceMethod:(SEL)sel
{
    return [super resolveInstanceMethod:sel];
}
复制代码

方法中的参数就是被调用的方法名，而后咱们须要实现一个名为eat的函数

void eat(){
    NSLog(@"lalal");
}
复制代码

这时候，咱们将要用到一个方法class_addMethod(<#__unsafe_unretained Class cls#>, <#SEL name#>, <#IMP imp#>, <#const char *types#>)第一个参数：类类型，第二个参数：方法编号，第三个参数：方法实现（函数指针），第四个参数：返回值类型。关于这第四个参数，这是c语音，咱们该怎么写返回类型呢？去查一下官方文档关于第四个参数的描述。

那么咱们来实现代码

+(BOOL)resolveInstanceMethod:(SEL)sel
{
    if (sel == @selector(eat)) {
        class_addMethod([Person class], sel, (IMP)eat, "v");
    }
    return [super resolveClassMethod:sel];
    return [super resolveInstanceMethod:sel];
}

void eat(){
    NSLog(@"lalal");
}
复制代码

这样就完成了一个动态添加方法，而后咱们接着看文档，文档中有一段代码示例

］

咱们能够看到，当动态添加方法是会传入两个参数，实际上每个函数被调用时都会传入这两个参数，叫作隐式参数。参数一：调用了哪一个类的，参数二：调用了哪一个方法，咱们用nslog打印一下这两个参数，在这以前须要改一下上面的第四个参数为"v@:"，由于咱们返回值类型改变了。打印一下：

接下来，就是如何传递参数，咱们在调用方法的时候传入一个参数

Person * p=[[Person alloc]init];
    [p performSelector:@selector(eat:) withObject:@"6666"];
复制代码

回去Person类，将判断的方法名改成eat:，并将eat函数增长一个参数：

+(BOOL)resolveInstanceMethod:(SEL)sel
{
    //  方法名的判断
    if (sel == @selector(eat:)) {
        class_addMethod([Person class], sel, (IMP)eat, "v@:");
    }
    return [super resolveClassMethod:sel];
    return [super resolveInstanceMethod:sel];
}

void eat(id self, SEL _cmd ,id obj){
    NSLog(@"%@ ",obj);
}
复制代码

控制台：

参数完美传递过来。