runtime介绍以及在项目中的实际运用

2017-06-19 本文已影响54人 acBool

Objective-C 是一门动态语言，相比C语言来说，增加了面向对象的特性和消息传递机制。消息传递机制的基础就是runtime,也就是常说的运行时机制。

网上关于runtime的介绍已经非常多了，因此本文对runtime不对做过多的介绍，而是结合我个人在项目中遇到的实际问题，介绍一些runtime在项目中的实际应用。

runtime介绍

在开始说runtime在项目中的实际运用之前，还是先简单介绍下runtime。

runtime的核心是消息传递。对比Objective-C和C/C++, 调用一个方法/函数在Objective-C中被称之为发送消息。如 [A testMethod]，可以翻译成向A对象发送了 testMethod的消息。为何在Objective-C中，函数调用被称之为发消息？以及Objective-C中的发消息和C/C++ 中的函数调用有什么区别？

我们知道，C语言是 "静态语言", 所谓静态语言，指的是一个方法/函数和内存中的一段代码绑定在一起，程序执行时，调用一个方法，实际上就是直接执行对应内存中的代码段。而且，函数名和代码段绑定这个过程在编译阶段就已经确定好了。而在Objective-C中，[object testMethod] 不会立即执行 testMethod方法，而是会向 object 发送一个 testMethod的消息，最终消息的接收的者，可能是 object对象，也可能不是object对象，这个过程是在运行时发生的。也就是说，在编译阶段，[object testMethod] 程序是不知道 testMethod 消息的最终接收者是谁的，消息的接收者，在运行时才能够确定。

消息传递

上面也提到了，[object testMethod] 会向object发送一个testMethod的消息，但是消息最终的接收者不一定是object对象，寻找消息最终接收者的过程实际上就是一个消息传递的过程。首先看一下Objective-C中object 和 class 的定义。

在objc.h中可以看到object的定义,如下：

struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

在runtime.h中可以看到Class的定义，如下：

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;

消息传递的关键是isa指针以及方法列表，也就是objc_method_list。消息传递的过程大致如下：

首先根据object对象的isa指针获取到该对象所属的类，然后在类对象的方法列表中寻找，是否有对应的方法。如果有，则找到，object即为消息最终的接收者；如果没找到，进行第2步。
第上一步获取到的类对象，根据super_class指针，可以获取到该类的父类，在父类的方法列表中寻找是否有对应的方法。如果有，则找到返回；如果没有，则重复该操作。
倘若一直找到基类（NSObject）都没有找到对应的方法，也就是没有对象能够接收该消息，此时会发生 unrecognize selector 的崩溃。在发生崩溃之前，还有三次机会来挽救：
（1）resolveInstanceMethod: 该方法返回一个bool值，如果返回YES，则重新启动一次消息传递的过程，如果返回NO，进入下一步操作。在项目开发中，如果有未识别的消息，可以在该方法中添加对应的消息，然后返回YES即可避免崩溃。示例代码如下：

 +(BOOL)resolveInstanceMethod:(SEL)sel
{
    BOOL isInstanced = [self resolveInstanceMethod:sel];
    if(!isInstanced){
        class_addMethod([self class],sel,(IMP)emptyMethod,"v@:");
        return YES;
    }
    return isInstanced;
}

在emptyMethod中不做任何操作即可避免崩溃。
（2）forwardingTargetForSelector: 该方法返回一个对象，提供了将消息转发给其他对象的机会。只要该方法返回的不是nil和self，消息传递的过程会重新启动。示例代码如下：

 -(id)forwardingTargetForSelector:(SEL)aSelector
{
    if(aSelector == @selector(testSelector:)){
        return testObject;
    }
    return [super forwardingTargetForSelector:aSelector];
}

返回testObject之后，相当于 [testObject testSelector]，消息传递会重新启动。
(3) methodSignatureForSelector 和 forwardingInvocation 方法。methodSignatureForSelector 会返回一个方法签名类，如果返回的是nil,则直接抛出 unrecognized selector的异常；否则runtime会根据返回的方法签名类创建一个 NSInvocation对象，之后调用forwardingInvocation。forwardingInvocation所做的工作和forwardingTargetForSelector 类似，也是将消息转发给其他对象。

至此，消息传递的过程结束。下面介绍在项目中使用到runtime的地方。

runtime的实际运用

避免nsnull崩溃

问题背景：在项目开发中，由于各种各样的原因，服务器接口常常会返回null，而在Objective-C中，向null 发送消息会引发 unrecognized selector的异常，引起app崩溃，产品体验非常不好。
解决方案：一种解决方案是获得服务器接口返回的数据后，进行判断，如果是null，则赋值一个空字符串，或者进行相应的处理，避免崩溃。但是一个完整项目里面使用的接口是非常多的，而且一个接口返回的字段也是非常多的，倘若对每个接口的每个字段都进行判断，一方面会写大量的重复代码，另一方面也破坏了代码的美观，且没有从根本上解决问题，属于治标不治本。
另一种方法是使用runtime解决。在Objective-C中，向nil发送消息是不会发生崩溃的。因此如果向null 发送了消息，可以通过消息转发，把消息最终的接收者设置为nil即可避免崩溃。通过上面的介绍，可以在最后一步，也就是 forwardingInvocation 中将消息的接收者设置为nil，不过 forwardingInvocation 需要配合 methodSignatureForSelector 方法使用。在 methodSignatureForSelector 方法中返回方法签名类，然后在 forwardingInvocation 进行消息转发即可。示例代码如下：

- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
{
    @synchronized([self class])
    {
        //look up method signature
        NSMethodSignature *signature = [super methodSignatureForSelector:selector];
        if (!signature)
        {
            //not supported by NSNull, search other classes
            // 在这里构造NSMethodSignature
        }
        return signature;
    }
}

- (void)forwardInvocation:(NSInvocation *)invocation
{
    invocation.target = nil;
    [invocation invoke];
}

避免数组越界崩溃

日常开发中，经常会碰到数组越界的情况，不幸的是，数组越界同样会直接引发崩溃，造成非常不好的体验。解决数组越界的方法很多，可以在使用的时候提前判断，比如说在使用 [array objectAtIndex: i] 之前，先进行下面类似的判断

id object = nil;
if(array.count > i - 1)
    object = array[i];

可以预见的是，项目中用到数组的地方会非常多，若每次使用之前都判断一下，会写大量重复冗余的代码。
另一种方法是写NSArray、NSMutableArray 的 category,在分类方法中判断一次就可以。这种方法的一个缺点是需要在项目中所有的调用都需要调用分类中的方法，这点需要和项目中的同事约定好，否则仍然避免不了数组越界引起崩溃的问题。
使用 Method Swizzling 可以解决数组越界的问题。Objective-C是动态语言，支持在运行时交换两个方法的实现。利用这一特性，可以写一个新的方法，如 hookObjectAtIndex 替换 objectAtIndex 方法，在hookObjectAtIndex 方法中判断数组越界的情况。这样，在项目中还是使用NSArray 的 objectAtIndex，但是实际执行的是 hookObjectAtIndex方法。示例代码如下：

+ (void)load
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        /* 数组有内容obj类型才是__NSArrayI ,NSArray在runtime中对应的是__NSArrayI */
        NSArray* obj = [[NSArray alloc] initWithObjects:@0, @1, nil];
        [obj swizzleInstanceMethod:@selector(objectAtIndex:) withMethod:@selector(hookObjectAtIndex:)];
        [obj release]; 
    });
}

- (id) hookObjectAtIndex:(NSUInteger)index {
    if (index < self.count) {
        return [self hookObjectAtIndex:index];
    }
    return nil;
}

两个注意点：

Method Swizzling应该写在 + load 方法中，原因：+ load 方法在类加载时就会被执行；
Method Swizzling 应该总是在 dispatch_once 中执行，原因： Method Swizzling 的修改是影响全局的，因此只需要执行一次就可以了，dispatch_once 可以保证这一点。
PS：Method Swizzling 的功能非常强大，解决NSArray 越界崩溃只是一方面应用。

字典转模型

在项目开发中，服务器会返回json类型数据，这就需要我们在程序中将字典转为模型以方便使用。字典转模型通常有两种方法：

自己写字典转模型的过程。示例代码如下：

 - (instancetype)initWithDict:(NSDictionary *)dict
{
    if(self = [super init]){
        self.url = dict[@"url"];
        self.width = dict[@"width"];
        self.height = dict[@"height"];
    }
    return self;
}

这种方法的缺点是：倘若属性比较多，需要写较多的代码，我们项目中有接口返回将近20个字段，解析起来非常麻烦；如果模型增加了新的属性，需要增加相应的代码。

另一种方法是使用一些第三方库，如YYModel、MJExtension等，可以帮助我们自动的将字典转为模型，省去了我们自己将属性和字典值对应的过程，以及增加属性时，不需要写新的代码。这些第三方库的实现原理使用到了runtime的知识。
通过上面的介绍知道，在Class的数据结构中有变量列表（struct objc_ivar_list *ivars），可以通过runtime获取到对象所属类的变量列表，然后将属性和字典中的值对应即可转成模型。示例代码如下：

       -(instancetype)initWithDict:(NSDictionary *)dict {

        if (self = [self init]) {
        //(1)获取类的属性及属性对应的类型
        NSMutableArray * keys = [NSMutableArray array];
        NSMutableArray * attributes = [NSMutableArray array];
        /*
         * 例子
         * name = value3 attribute = T@"NSString",C,N,V_value3
         * name = value4 attribute = T^i,N,V_value4
         */
        unsigned int outCount;
        objc_property_t * properties = class_copyPropertyList([self class], &outCount);
        for (int i = 0; i < outCount; i ++) {
            objc_property_t property = properties[i];
            //通过property_getName函数获得属性的名字
            NSString * propertyName = [NSString stringWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
            [keys addObject:propertyName];
            //通过property_getAttributes函数可以获得属性的名字和@encode编码
            NSString * propertyAttribute = [NSString stringWithCString:property_getAttributes(property) encoding:NSUTF8StringEncoding];
            [attributes addObject:propertyAttribute];
        }
        //立即释放properties指向的内存
        free(properties);

        //(2)根据类型给属性赋值
        for (NSString * key in keys) {
            if ([dict valueForKey:key] == nil) continue;
            [self setValue:[dict valueForKey:key] forKey:key];
        }
    }
    return self;
}

KVO的实现

KVO是Objective-C对观察者模式的一种实现，通过KVO，当被观察者对象的某个属性发生改变时，观察者就会收到通知，并做相应的处理。KVO的实现依赖于runtime。
苹果通过 isa-swizzling 的方式实现KVO。通过上面的介绍，我们知道在Object 对象的定义中有一个 isa 指针，指向的是该对象所属的类，KVO就是通过修改 isa 指针的指向实现的。具体过程：
当观察一个对象A时，假设该对象所属的类是TestA，KVO机制动态的创建了一个新的类，名称为NSKVONotifying_TestA，在新的类中重写了所观察属性的 setter 方法。新的setter方法会在调用原setter方法之前和之后通知观察者，观察者会做出相应的处理。在新建完NSKVONotifying_TestA类后，KVO机制会修改对象的 isa 指针，指向 NSKVONotifying_TestA 类，这样在调用 setter方法时，会调用 NSKVONotifying_TestA 的setter方法。新setter方法的实现大致如下：

 - (void)setNow:(NSDate *)aDate {
   [self willChangeValueForKey:@"now"];
   [super setValue:aDate forKey:@"now"];
   [self didChangeValueForKey:@"now"];
}

新建类以及修改对象的 isa 指针这些过程都是在运行时实现的，在应用层面上我们完全感知不到。假设我们在项目中手动创建类NSKVONotifying_TestA,程序运行到注册KVO的代码时就会崩溃，这也能够间接的证实，KVO机制确实创建了新的 NSKVONotifying_TestA 类。

总结

SmallTalk 语言的创始人Alan Kay 曾说过，面向对象不是 SmallTalk 的核心，消息传递才是，The big idea is "messaging"。runtime在消息传递中扮演着非常重要的角色，理解和掌握runtime非常的有必要。而且，在项目的实际开发中，利用runtime也确实可以帮助解决很多问题。本文是结合我自己在项目中遇到的问题所做的总结，文中如有错误的地方，欢迎大家指正~如果大家在项目中使用runtime解决了其他问题，也欢迎在评论区交流。

参考文章

http://tech.glowing.com/cn/objective-c-runtime/
http://blog.ibireme.com/2013/11/26/objective-c-messaging/