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);
}

控制台：

参数完美传递过来。