iOS~runtime理解

 

Runtime是想要作好iOS開發，或者說是真正的深入的掌握OC這門語言所必需理解的東西。最近在學習Runtime，有本身的一些心得，整理以下，
一爲 查閱方便
二爲 或許能給他人一些啓發，
三爲 但願獲得你們對這篇整理不足之處的一些指點。

什麼是Runtime

• 咱們寫的代碼在程序運行過程當中都會被轉化成runtime的C代碼執行，例如[target doSomething];會被轉化成objc_msgSend(target, @selector(doSomething));。
• OC中一切都被設計成了對象，咱們都知道一個類被初始化成一個實例，這個實例是一個對象。實際上一個類本質上也是一個對象，在runtime中用結構體表示。
• 相關的定義：

/// 描述類中的一個方法
typedef struct objc_method *Method;

/// 實例變量
typedef struct objc_ivar *Ivar;

/// 類別Category
typedef struct objc_category *Category;

/// 類中聲明的屬性
typedef struct objc_property *objc_property_t;

• 類在runtime中的表示

//類在runtime中的表示
struct objc_class {
    Class isa;//指針，顧名思義，表示是一個什麼，
    //實例的isa指向類對象，類對象的isa指向元類

#if !__OBJC2__
    Class super_class;  //指向父類
    const char *name;  //類名
    long version;
    long info;
    long instance_size
    struct objc_ivar_list *ivars //成員變量列表
    struct objc_method_list **methodLists; //方法列表
    struct objc_cache *cache;//緩存
    //一種優化，調用過的方法存入緩存列表，下次調用先找緩存
    struct objc_protocol_list *protocols //協議列表
    #endif
} OBJC2_UNAVAILABLE;
/* Use `Class` instead of `struct objc_class *` */

獲取列表

有時候會有這樣的需求，咱們須要知道當前類中每一個屬性的名字（好比字典轉模型，字典的Key和模型對象的屬性名字不匹配）。
咱們能夠經過runtime的一系列方法獲取類的一些信息（包括屬性列表，方法列表，成員變量列表，和遵循的協議列表）。

unsigned int count;
    //獲取屬性列表
    objc_property_t *propertyList = class_copyPropertyList([self class], &count);
    for (unsigned int i=0; i<count; i++) {
        const char *propertyName = property_getName(propertyList[i]);
        NSLog(@"property---->%@", [NSString stringWithUTF8String:propertyName]);
    }

    //獲取方法列表
    Method *methodList = class_copyMethodList([self class], &count);
    for (unsigned int i; i<count; i++) {
        Method method = methodList[i];
        NSLog(@"method---->%@", NSStringFromSelector(method_getName(method)));
    }

    //獲取成員變量列表
    Ivar *ivarList = class_copyIvarList([self class], &count);
    for (unsigned int i; i<count; i++) {
        Ivar myIvar = ivarList[i];
        const char *ivarName = ivar_getName(myIvar);
        NSLog(@"Ivar---->%@", [NSString stringWithUTF8String:ivarName]);
    }

    //獲取協議列表
    __unsafe_unretained Protocol **protocolList = class_copyProtocolList([self class], &count);
    for (unsigned int i; i<count; i++) {
        Protocol *myProtocal = protocolList[i];
        const char *protocolName = protocol_getName(myProtocal);
        NSLog(@"protocol---->%@", [NSString stringWithUTF8String:protocolName]);
    }

在Xcode上跑一下看看輸出吧，須要給你當前的類寫幾個屬性，成員變量，方法和協議，否則獲取的列表是沒有東西的。
注意，調用這些獲取列表的方法別忘記導入頭文件#import <objc/runtime.h>。

方法調用

讓咱們看一下方法調用在運行時的過程（參照前文類在runtime中的表示）

若是用實例對象調用實例方法，會到實例的isa指針指向的對象（也就是類對象）操做。
若是調用的是類方法，就會到類對象的isa指針指向的對象（也就是元類對象）中操做。

1. 首先，在相應操做的對象中的緩存方法列表中找調用的方法，若是找到，轉向相應實現並執行。
2. 若是沒找到，在相應操做的對象中的方法列表中找調用的方法，若是找到，轉向相應實現執行
3. 若是沒找到，去父類指針所指向的對象中執行1，2.
4. 以此類推，若是一直到根類還沒找到，轉向攔截調用。
5. 若是沒有重寫攔截調用的方法，程序報錯。

以上的過程給我帶來的啓發：

• 重寫父類的方法，並無覆蓋掉父類的方法，只是在當前類對象中找到了這個方法後就不會再去父類中找了。
• 若是想調用已經重寫過的方法的父類的實現，只需使用super這個編譯器標識，它會在運行時跳過在當前的類對象中尋找方法的過程。

攔截調用

在方法調用中說到了，若是沒有找到方法就會轉向攔截調用。
那麼什麼是攔截調用呢。
攔截調用就是，在找不到調用的方法程序崩潰以前，你有機會經過重寫NSObject的四個方法來處理。

+ (BOOL)resolveClassMethod:(SEL)sel;
+ (BOOL)resolveInstanceMethod:(SEL)sel;
//後兩個方法須要轉發到其餘的類處理
- (id)forwardingTargetForSelector:(SEL)aSelector;
- (void)forwardInvocation:(NSInvocation *)anInvocation;

• 第一個方法是當你調用一個不存在的類方法的時候，會調用這個方法，默認返回NO，你能夠加上本身的處理而後返回YES。
• 第二個方法和第一個方法類似，只不過處理的是實例方法。
• 第三個方法是將你調用的不存在的方法重定向到一個其餘聲明瞭這個方法的類，只須要你返回一個有這個方法的target。
• 第四個方法是將你調用的不存在的方法打包成NSInvocation傳給你。作完你本身的處理後，調用invokeWithTarget:方法讓某個target觸發這個方法。

動態添加方法

重寫了攔截調用的方法而且返回了YES，咱們要怎麼處理呢？
有一個辦法是根據傳進來的SEL類型的selector動態添加一個方法。

首先從外部隱式調用一個不存在的方法：

//隱式調用方法
[target performSelector:@selector(resolveAdd:) withObject:@"test"];

而後，在target對象內部重寫攔截調用的方法，動態添加方法。

void runAddMethod(id self, SEL _cmd, NSString *string){
    NSLog(@"add C IMP ", string);
}
+ (BOOL)resolveInstanceMethod:(SEL)sel{

    //給本類動態添加一個方法
    if ([NSStringFromSelector(sel) isEqualToString:@"resolveAdd:"]) {
        class_addMethod(self, sel, (IMP)runAddMethod, "v@:*");
    }
    return YES;
}

其中class_addMethod的四個參數分別是：

1. Class cls 給哪一個類添加方法，本例中是self
2. SEL name 添加的方法，本例中是重寫的攔截調用傳進來的selector。
3. IMP imp 方法的實現，C方法的方法實現能夠直接得到。若是是OC方法，能夠用+ (IMP)instanceMethodForSelector:(SEL)aSelector;得到方法的實現。
4. "v@:*"方法的簽名，表明有一個參數的方法。

關聯對象

如今你準備用一個系統的類，可是系統的類並不能知足你的需求，你須要額外添加一個屬性。
這種狀況的通常解決辦法就是繼承。
可是，只增長一個屬性，就去繼承一個類，老是以爲太麻煩類。
這個時候，runtime的關聯屬性就發揮它的做用了。

//首先定義一個全局變量，用它的地址做爲關聯對象的key
static char associatedObjectKey;
//設置關聯對象
objc_setAssociatedObject(target, &associatedObjectKey, @"添加的字符串屬性", OBJC_ASSOCIATION_RETAIN_NONATOMIC); //獲取關聯對象
NSString *string = objc_getAssociatedObject(target, &associatedObjectKey);
NSLog(@"AssociatedObject = %@", string);

objc_setAssociatedObject的四個參數：

1. id object給誰設置關聯對象。
2. const void *key關聯對象惟一的key，獲取時會用到。
3. id value關聯對象。
4. objc_AssociationPolicy關聯策略，有如下幾種策略：

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

若是你熟悉OC，看名字應該知道這幾種策略的意思了吧。

objc_getAssociatedObject的兩個參數。

1. id object獲取誰的關聯對象。
2. const void *key根據這個惟一的key獲取關聯對象。

其實，你還能夠把添加和獲取關聯對象的方法寫在你須要用到這個功能的類的類別中，方便使用。

//添加關聯對象
- (void)addAssociatedObject:(id)object{
    objc_setAssociatedObject(self, @selector(getAssociatedObject), object, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
//獲取關聯對象
- (id)getAssociatedObject{
    return objc_getAssociatedObject(self, _cmd);
}

注意：這裏面咱們把getAssociatedObject方法的地址做爲惟一的key，_cmd表明當前調用方法的地址。

方法交換

方法交換，顧名思義，就是將兩個方法的實現交換。例如，將A方法和B方法交換，調用A方法的時候，就會執行B方法中的代碼，反之亦然。
話很少說，這是參考Mattt大神在NSHipster上的文章本身寫的代碼。

#import "UIViewController+swizzling.h"
#import <objc/runtime.h>

@implementation UIViewController (swizzling)

//load方法會在類第一次加載的時候被調用
//調用的時間比較靠前，適合在這個方法裏作方法交換
+ (void)load{
    //方法交換應該被保證，在程序中只會執行一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{

        //得到viewController的生命週期方法的selector
        SEL systemSel = @selector(viewWillAppear:);
        //本身實現的將要被交換的方法的selector
        SEL swizzSel = @selector(swiz_viewWillAppear:);
        //兩個方法的Method
        Method systemMethod = class_getInstanceMethod([self class], systemSel);
        Method swizzMethod = class_getInstanceMethod([self class], swizzSel);

        //首先動態添加方法，實現是被交換的方法，返回值表示添加成功仍是失敗
        BOOL isAdd = class_addMethod(self, systemSel, method_getImplementation(swizzMethod), method_getTypeEncoding(swizzMethod));
        if (isAdd) {
            //若是成功，說明類中不存在這個方法的實現
            //將被交換方法的實現替換到這個並不存在的實現
            class_replaceMethod(self, swizzSel, method_getImplementation(systemMethod), method_getTypeEncoding(systemMethod));
        }else{
            //不然，交換兩個方法的實現
            method_exchangeImplementations(systemMethod, swizzMethod);
        }

    });
}

- (void)swiz_viewWillAppear:(BOOL)animated{
    //這時候調用本身，看起來像是死循環
    //可是其實本身的實現已經被替換了
    [self swiz_viewWillAppear:animated];
    NSLog(@"swizzle");
}

@end

在一個本身定義的viewController中重寫viewWillAppear

- (void)viewWillAppear:(BOOL)animated{
    [super viewWillAppear:animated];
    NSLog(@"viewWillAppear");
}

Run起來看看輸出吧！

個人理解：

• 方法交換對於我來講更像是實現一種思想的最佳技術：AOP面向切面編程。
• 既然是切面，就必定不要忘記，交換完再調回本身。
• 必定要保證只交換一次，不然就會很亂。
• 最後，聽說這個技術很危險，謹慎使用。

完

 

 

 

文／興宇是誰（簡書做者） 原文連接：http://www.jianshu.com/p/927c8384855a 著做權歸做者全部，轉載請聯繫做者得到受權，並標註「簡書做者」。