iOS 模塊分解—「Runtime面試、工作」看我就 🐒 了 ^_^.

引導

---

相信對於從事開發人員來說 runtime 這個名稱都不陌生，就像我起初只知道「 runtime 叫運行時 」，後來知道 runtime 同樣可以像 KVC 一樣訪問私有成員變量，還有「 給類動態添加屬性：LNTextField.placeholderColor || 交換方法：imageNamed => ln_imageNamed 」，還有深入的 「 消息機制的調用流程 || 字典轉模型 || 實現NSCoding歸解檔 」以及我們常說的“黑魔法” 是什麼？
|
runtime 是編程中比較難的模塊，想要深入學習，這個模塊你必須掌握，同樣還有寫的另一篇 runloop 模塊，下面是我對 runtime 的整理，從零開始，由淺入深，且帶了幾個 Runtime 實踐場景 --> 大廠來的工友們可選擇性路過。

目錄： 👙

1. runtime.h 釋義
2. 消息機制

1.isa指針釋義
2.方法調用，是否真的是轉換爲消息機制？
2.objc_msgSend 參數概念釋義

1. 消息機制（方法調用流程）
2. 常見作用
3. 開發場景「工作掌握」

1.交換方法
2.給系統分類動態添加屬性
3.字典轉模型（Runtime 考慮三種情況實現）

1. 其它作用「面試熟悉」

1.動態添加方法
2.動態變量控制
3.實現NSCoding的自動歸檔和解檔
4.runtime 部分函數
5.method swizzling（俗稱黑魔法）

1. 一道面試題的註解
2. 模塊博文推薦(❤️數量較多)
3. Runtime & Runloop 常面問題整理（附答案）
4. Demo 重要的部分代碼中都有相應的註解和文字打印，運行程序可以很直觀的表現
5. [iOS 模塊註解—「Runloop面試、工作」看我就 🐒 了 ^_^.]()

釋義

---

Objective-C 是基於 C 的，它爲 C 添加了面向對象的特性。它將很多靜態語言在編譯和鏈接時期做的事放到了 runtime 運行時來處理，可以說 runtime 是我們 Objective-C 幕後工作者。
1.runtime（簡稱運行時），是一套 純C(C和彙編)寫的API。而 OC 就是運行時機制，也就是在運行時候的一些機制，其中最主要的是 消息機制。

2.對於 C 語言，函數的調用在編譯的時候會決定調用哪個函數。

3.運行時機制原理：OC的函數調用稱爲消息發送，屬於 動態調用過程。在 編譯的時候 並不能決定真正調用哪個函數，只有在真 正運行的時候 纔會根據函數的名稱找到對應的函數來調用。

4.事實證明：在編譯階段，OC 可以 調用任何函數，即使這個函數並未實現，只要聲明過就不會報錯，只有當運行的時候纔會報錯，這是因爲OC是運行時動態調用的。而 C 語言 調用未實現的函數 就會報錯。

消息機制

---

我們寫 OC 代碼，它在運行的時候也是轉換成了 runtime 方式運行的。任何方法調用本質：就是發送一個消息（用 runtime發送消息，OC 底層實現通過 runtime 實現），每一個 OC 的方法，底層必然有一個與之對應的 runtime 方法。

驗證示例：方法調用，是否真的是轉換爲消息機制？

消息機制原理：對象根據方法編號SEL去映射表查找對應的方法實現。
註解：
1.必須要導入頭文件 #import <objc/message.h>
2.我們導入系統的頭文件，一般用尖括號。
3.OC 解決消息機制方法提示步驟【查找build setting -> 搜索msg -> objc_msgSend（YES --> NO）】
4.最終生成消息機制，編譯器做的事情，最終代碼，需要把當前代碼用xcode重新編譯，【clang -rewrite-objc main.m 查看最終生成代碼】，示例：cd main.m --> 輸入前面指令，就會生成 .opp文件(C++代碼)
5.這裏一般不會直接導入<objc/runtime.h>

示例代碼：OC 方法 <--> runtime 方法

說明：
eat(無參) 和 run(有參NSInteger) 是 LNPerson模型類中的私有方法「runtime 作用：可以調用私有方法」
示例分別以 OC寫法 和 最底層寫法 對照驗證.
- (void)msgSend
{
    // 方法一：
    //id objc = [NSObject alloc];
    LNPerson *person = objc_msgSend(objc_getClass("LNPerson"), sel_registerName("alloc"));
    
    //objc = [objc init];
    person = objc_msgSend(person, sel_registerName("init"));
    
    // 調用
    //[objc eat];
    //[objc run:10];
    objc_msgSend(person,@selector(eat)); // 無參
    objc_msgSend(person,@selector(run:),10); // 有殘
}
/
 註解：
    // 用最底層寫
    objc_getClass(const char *name) 獲取當前類
    sel_registerName(const char *str) 註冊個方法編號
    objc_msgSend(id self：誰發送消息, SEL op：發送什麼消息, ...)
    讓LNPerson這個類對象發送了一個alloc消息，返回一個分配好的內存對象給你，再發送一個消息初始化.
 */

// 方法二：
#pragma mark - 也許下面這種好理解一點
- (void)test
{
    // id objc = [NSObject alloc];
    id objc = objc_msgSend([NSObject class], @selector(alloc));
    
    // objc = [objc init];
    objc = objc_msgSend(objc, @selector(eat));
    
}

objc_msgSend 參數概念

/
 objc_msgSend(<#id  _Nullable self#>, <#SEL  _Nonnull op, ...#>)

 1、objc_msgSend
    這是個最基本的用於發送消息的函數。
    其實編譯器會根據情況在`objc_msgSend`， `objc_msgSend_stret`,，`objc_msgSendSuper`， 或 `objc_msgSendSuper_stret` 四個方法中選擇一個來調用。如果消息是傳遞給超類，那麼會調用名字帶有 `Super` 的函數；如果消息返回值是數據結構而不是簡單值時，那麼會調用名字帶有`stret`的函數。
 
 2、SEL
    `objc_msgSend`函數第二個參數類型爲`SEL`，它是`selector`在Objc中的表示類型（Swift中是Selector類）。`selector`是方法選擇器，可以理解爲區分方法的 `ID`，而這個 `ID` 的數據結構是`SEL`:
    `typedef struct objc_selector *SEL;`
    其實它就是個映射到方法的C字符串，你可以用 Objc 編譯器命令`@selector()``或者 Runtime` 系統的`sel_registerName`函數來獲得一個`SEL`類型的方法選擇器。
 
 3、id
    `objc_msgSend`第一個參數類型爲`id`，大家對它都不陌生，它是一個指向類實例的指針：
    `typedef struct objc_object *id;`
    那`objc_object`又是啥呢：
    `struct objc_object { Class isa; };`
    `objc_object`結構體包含一個`isa`指針，根據`isa`指針就可以順藤摸瓜找到對象所屬的類。
 */

消息機制「方法調用流程」

---

面試：消息機制方法調用流程❓
怎麼去調用eat方法，
對象方法：(保存到類對象的方法列表) ，類方法：(保存到元類(Meta Class)中方法列表)。

1.OC 在向一個對象發送消息時，runtime 庫會根據對象的 isa指針找到該對象對應的類或其父類中查找方法。。
2.註冊方法編號（這裏用方法編號的好處，可以快速查找）。
3.根據方法編號去查找對應方法。
4.找到只是最終函數實現地址，根據地址去方法區調用對應函數。

補充：一個objc 對象的 isa 的指針指向什麼？有什麼作用？
每一個對象內部都有一個isa指針，這個指針是指向它的真實類型，根據這個指針就能知道將來調用哪個類的方法。

isa指針相關釋義

上面也提到OC底層都是轉化爲runtime方式來實現的，類和類的實例（對象）都相對於的isa指針。
我們可以在Xcode中使用 [Shift＋Cmd＋O ] 快速打開文件objc.h 能看到類的定義：



總結：runtime 對象，類，元類的isa指針關係圖
1、每一個對象本質上都是一個類的實例。其中類定義了成員變量和成員方法的列表。對象通過對象的isa指針指向所屬類。
2、每一個類本質上都是一個對象，類其實是元類（meteClass）的實例。元類定義了類方法的列表。類通過類的isa指針指向元類。
3、元類保存了類方法的列表。當類方法被調用時，先會從本身查找類方法的實現，如果沒有，元類會向他父類查找該方法。同時注意的是：元類（meteClass）也是類，它也是對象。元類通過isa指針最終指向的是一個根元類(root meteClass)。
4、根元類的isa指針指向本身，這樣形成了一個封閉的內循環。

常見作用

---

/
 1.動態交換兩個方法的實現
 2.動態添加屬性
 3.實現字典轉模型的自動轉換
 4.動態添加方法
 5.攔截並替換方法
 6.實現 NSCoding 的自動歸檔和解檔

補充常用runtime示例：Demo中有體現
    1.添加屬性和交換方法示例：UITextField佔位文字顏色placeholderColor
    2.交換方法示例：交換dealloc方法實現，添加功能那個控制器被銷燬了
 */

開發場景「工作掌握」

---

runtime 交換方法

場景：當第三方框架 或者 系統原生方法功能不能滿足我們的時候，我們可以在保持系統原有方法功能的基礎上，添加額外的功能。

需求：加載一張圖片直接用[UIImage imageNamed:@"image"];是無法知道到底有沒有加載成功。給系統的imageNamed添加額外功能（是否加載圖片成功）。
方案一：繼承系統的類，重寫方法.（弊端：每次使用都需要導入）
方案二：使用 runtime，交換方法.

步驟：
1.給系統的方法添加分類
2.自己實現一個帶有擴展功能的方法
3.交換方法,只需要交換一次,

場景代碼：方法+調用+打印輸出

#import "UIImage+Image.h"
#import <objc/message.h>

@implementation UIImage (Image)

/
 看清楚下面是不會有死循環的
    調用 imageNamed => ln_imageNamed
    調用 ln_imageNamed => imageNamed
 */
// 加載圖片 且 帶判斷是否加載成功
+ (UIImage *)ln_imageNamed:(NSString *)name {
    
    UIImage *image = [UIImage ln_imageNamed:name];
    if (image) {
        NSLog(@"runtime交互方法 -> 圖片加載成功");
    } else {
        NSLog(@"runtime交互方法 -> 圖片加載失敗");
    }
    return image;
}

/
 註解：
    不能在分類中重寫系統方法imageNamed，因爲會把系統的功能給覆蓋掉，而且分類中不能調用super
    所以第二步，我們要 自己實現一個帶有擴展功能的方法.
 + (UIImage *)imageNamed:(NSString *)name {
 
 }
 */

/
 作用：把類加載進內存的時候調用,只會調用一次
 調用：方法應先交換，再去調用
 */
+ (void)load {
    
    // 1.獲取 imageNamed方法地址
    Method imageNamedMethod = class_getClassMethod(self, @selector(imageNamed:));
    // 2.獲取 ln_imageNamed方法地址
    Method ln_imageNamedMethod = class_getClassMethod(self, @selector(ln_imageNamed:));
    
    // 3.交換方法地址，相當於交換實現方式;「method_exchangeImplementations 交換兩個方法的實現」
    method_exchangeImplementations(imageNamedMethod, ln_imageNamedMethod);
}

- - -
//方案一：先搞個分類，定義一個能加載圖片並且能打印的方法+ (instancetype)imageWithName:(NSString *)name;
//方案二：交換 imageNamed 和 ln_imageNamed 的實現，就能調用 imageNamed，間接調用 ln_imageNamed 的實現。
- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.imageView.image = [UIImage imageNamed:@"CoerLN"];
}

- - -
// 打印輸出
2016-03-17 17:52:14.693 runtime[12761:543574] runtime交互方法 -> 圖片加載成功

總結：
我們所做的就是在方法調用流程第三步的時候，交換兩個方法地址指向。而且我們改變指向要在系統的imageNamed:方法調用前，所以將代碼寫在了分類的load方法裏。最後當運行的時候系統的方法就會去找我們的方法的實現。

給系統分類動態添加屬性

場景：給系統的類添加額外屬性的時候，可以使用runtime動態添加屬性方法。
原理：給一個類聲明屬性，其實本質就是給這個類添加關聯，並不是直接把這個值的內存空間添加到類存空間。
註解：給系統 NSObject 添加一個分類，我們知道在分類中是不能夠添加成員屬性的，雖然我們用了@property，但是僅僅會自動生成get和set方法的聲明，並沒有帶下劃線的屬性和方法實現生成。但是我們可以通過runtime就可以做到給它方法的實現。

需求：給系統 NSObject 類動態添加屬性 name 字符串。

場景代碼：方法+調用+打印

#import <Foundation/Foundation.h>
@interface NSObject (Property)

@property NSString *name;
@end

- - -
#import "NSObject+Property.h"
#import <objc/message.h>
//#import <objc/runtime.h>

@implementation NSObject (Property)

- (NSString *)name
{
    // 利用參數key 將對象object中存儲的對應值取出來
    return objc_getAssociatedObject(self, @"name");
}

- (void)setName:(NSString *)name
{
    /**
     將某個值跟某個對象關聯起來，將某個值存儲到某個對象中
     objc_setAssociatedObject(<#id  _Nonnull object#>：給哪個對象添加屬性, <#const void * _Nonnull key#>：屬性名稱, <#id  _Nullable value#>：屬性值, <#objc_AssociationPolicy policy#>：保存策略)
     */
    objc_setAssociatedObject(self, @"name", name, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    NSLog(@"name---->%p",name);
}
@end

// 調用
NSObject *objc = [[NSObject alloc] init];
objc.name = @"CoderLN";
NSLog(@"runtime動態添加屬性name==%@",objc.name);

// 打印輸出
2016-03-17 19:37:10.530 runtime[12761:543574] runtime動態添加屬性name == CoderLN

總結：
其實，屬性賦值的本質，就是讓屬性與一個對象產生關聯，所以要給NSObject的分類的name屬性賦值就是讓name和NSObject產生關聯，而runtime可以做到這一點。

字典轉模型

字典轉模型的方式：

• 給模型中屬性，在 .m 依次賦值（初學者）。

• 字典轉模型 KVC 實現

  • KVC 字典轉模型弊端：必須保證，模型中的屬性和字典中的key 一一對應。
  • 如果不一致，就會調用[<Status 0x7fa74b545d60> setValue:forUndefinedKey:] 報key找不到的錯。
  • 分析：模型中的屬性和字典的key不一一對應，系統就會調用setValue:forUndefinedKey:報錯。
  • 解決：重寫對象的setValue:forUndefinedKey:，把系統的方法覆蓋，就能繼續使用KVC，字典轉模型了。

• 字典轉模型 Runtime 實現

  • 思路：利用運行時，遍歷模型中所有屬性，根據模型的屬性名，去字典中查找key，取出對應的值，給模型的屬性賦值（從提醒：字典中取值，不一定要全部取出來）；提供一個NSObject分類，專門字典轉模型，以後所有模型都可以通過這個分類實現字典轉模型。
  • 考慮情況：

1.當字典的key和模型的屬性匹配不上。
2.模型中嵌套模型（模型屬性是另外一個模型對象）。
3.數組中裝着模型（模型的屬性是一個數組，數組中是一個個模型對象）。

- **註解**：

根據上面的三種特殊情況，先是字典的key和模型的屬性不對應的情況。不對應有兩種，一種是字典的鍵值大於模型屬性數量，這時候我們不需要任何處理，因爲runtime是先遍歷模型所有屬性，再去字典中根據屬性名找對應值進行賦值，多餘的鍵值對也當然不會去看了；另外一種是模型屬性數量大於字典的鍵值對，這時候由於屬性沒有對應值會被賦值爲nil，就會導致crash，我們只需加一個判斷即可。考慮三種情況下面一一註解

• MJExtension 字典轉模型實現

  • 底層也是對 runtime 的封裝，纔可以把一個模型中所有屬性遍歷出來。（我之所以看不懂，是MJ封裝了很多層而已^_^.）。

示例：runtime 字典轉模型考慮三種情況

1、runtime 字典轉模型-->字典的 key 和模型的屬性不匹配「模型屬性數量大於字典鍵值對數」，這種情況處理如下：

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

@implementation NSObject (Model)

// 思路：利用runtime 遍歷模型中所有屬性，根據模型中屬性,去字典中取出對應的value給模型屬性賦值
+ (instancetype)modelWithDict:(NSDictionary *)dict
{
    // 1.創建對應的對象
    id objc = [[self alloc] init];
    
    // 2.利用runtime給對象中的屬性賦值
    /**
      獲取類中的所有成員變量
        class_copyIvarList(Class _Nullable cls：表示獲取哪個類中的成員變量, unsigned int * _Nullable outCount：表示這個類有多少成員變量，傳入一個Int變量地址，會自動給這個變量賦值)
      返回值Ivar * =
        指的是一個ivar數組，會把所有成員屬性放在一個數組中，通過返回的數組就能全部獲取到
     */
    // 成員變量個數
    unsigned int count = 0;
    // 獲取類中的所有成員變量
    Ivar *ivarList = class_copyIvarList(self, &count);

    // 遍歷所有成員變量
    for (int i = 0; i < count; i++) {
        // 根據角標，從數組取出對應的成員變量（Ivar：成員變量,以下劃線開頭）
        Ivar ivar = ivarList[i];
        
        // 獲取成員變量名字
        NSString *ivarName = [NSString stringWithUTF8String:ivar_getName(ivar)];
        
        // 處理成員變量名，字典中的key(去掉 _ ,從第一個角標開始截取)
        NSString *key = [ivarName substringFromIndex:1];
        
        // 根據成員屬性名去字典中查找對應的value
        id value = dict[key];
        
        //【如果模型屬性數量大於字典鍵值對數理，模型屬性會被賦值爲nil】
        // 而報錯 (could not set nil as the value for the key age.)
        if (value) {
            // 給模型中屬性賦值
            [objc setValue:value forKey:key];
        }
    }
    return objc;
}

註解：
這裏在獲取模型類中的所有屬性名，是採取 class_copyIvarList 先獲取成員變量（以下劃線開頭） ，然後再處理成員變量名，字典中的key(去掉 _ ,從第一個角標開始截取) 得到屬性名。

原因：

{
    int _a; // 成員變量
}
@property (nonatomic, assign) NSInteger attitudes_count; // 屬性

`Ivar：成員變量，以下劃線開頭`，
`Property 屬性`
`class_copyPropertyList` 獲取類裏面屬性 
`class_copyIvarList` 獲取類中的所有成員變量 
這裏有成員變量，就不會漏掉屬性；如果有屬性，可能會漏掉成員變量；
使用`runtime`字典轉模型獲取模型屬性名的時候，最好獲取成員屬性名`Ivar`因爲可能會有個屬性是沒有`setter`和`getter`方法的。

2、runtime 字典轉模型-->模型中嵌套模型「模型屬性是另外一個模型對象」，這種情況處理如下：

// 思路：利用runtime 遍歷模型中所有屬性，根據模型中屬性,去字典中取出對應的value給模型屬性賦值
+ (instancetype)modelWithDict2:(NSDictionary *)dict
{
    // 1.創建對應的對象
    id objc = [[self alloc] init];
    
    // 2.利用runtime給對象中的屬性賦值
    // 成員變量個數
    unsigned int count = 0;
    // 獲取類中的所有成員變量
    Ivar *ivarList = class_copyIvarList(self, &count);
    
    // 遍歷所有成員變量
    for (int i = 0; i < count; i++) {
        // 根據角標，從數組取出對應的成員變量（Ivar：成員變量,以下劃線開頭）
        Ivar ivar = ivarList[i];
        
        // 獲取成員變量名字
        NSString *ivarName = [NSString stringWithUTF8String:ivar_getName(ivar)];
        // 獲取成員變量類型
        NSString *ivarType = [NSString stringWithUTF8String:ivar_getTypeEncoding(ivar)];
        
        // 替換: @\"User\" -> User
        ivarType = [ivarType stringByReplacingOccurrencesOfString:@"\"" withString:@""];
        ivarType = [ivarType stringByReplacingOccurrencesOfString:@"@" withString:@""];
        
        // 處理成員變量名->字典中的key(去掉 _ ,從第一個角標開始截取)
        NSString *key = [ivarName substringFromIndex:1];
        
        // 根據成員屬性名去字典中查找對應的value
        id value = dict[key];
        
        // 二級轉換：如果字典中還有字典，也需要把對應的字典轉換成模型
        // 判斷下value是否是字典,並且是自定義對象才需要轉換
        if ([value isKindOfClass:[NSDictionary class]] && ![ivarType hasPrefix:@"NS"]) {
            
            // 字典轉換成模型 userDict => User模型, 轉換成哪個模型
            // 根據字符串類名生成類對象
            Class modelClass = NSClassFromString(ivarType);
            
            if (modelClass) { // 有對應的模型才需要轉
                // 把字典轉模型
                value = [modelClass modelWithDict2:value];
            }
        }
        
        // 給模型中屬性賦值
        if (value) {
            [objc setValue:value forKey:key];
        }
    }
    return objc;
}

3、runtime 字典轉模型-->數組中裝着模型「模型的屬性是一個數組，數組中是字典模型對象」，這種情況處理如下：

// 思路：利用runtime 遍歷模型中所有屬性，根據模型中屬性,去字典中取出對應的value給模型屬性賦值
+ (instancetype)modelWithDict3:(NSDictionary *)dict
{
    // 1.創建對應的對象
    id objc = [[self alloc] init];
    
    // 2.利用runtime給對象中的屬性賦值
    // 成員變量個數
    unsigned int count = 0;
    // 獲取類中的所有成員變量
    Ivar *ivarList = class_copyIvarList(self, &count);
    
    // 遍歷所有成員變量
    for (int i = 0; i < count; i++) {
        // 根據角標，從數組取出對應的成員變量（Ivar：成員變量,以下劃線開頭）
        Ivar ivar = ivarList[i];
        
        // 獲取成員變量名字
        NSString *ivarName = [NSString stringWithUTF8String:ivar_getName(ivar)];
        
        // 處理成員屬性名->字典中的key(去掉 _ ,從第一個角標開始截取)
        NSString *key = [ivarName substringFromIndex:1];
        
        // 根據成員屬性名去字典中查找對應的value
        id value = dict[key];
        
        
        //--------------------------- <#我是分割線#> ------------------------------//
        //
        
        // 三級轉換：NSArray中也是字典，把數組中的字典轉換成模型.
        // 判斷值是否是數組
        if ([value isKindOfClass:[NSArray class]]) {
            // 判斷對應類有沒有實現字典數組轉模型數組的協議
            // arrayContainModelClass 提供一個協議，只要遵守這個協議的類，都能把數組中的字典轉模型
            if ([self respondsToSelector:@selector(arrayContainModelClass)]) {
                
                // 轉換成id類型，就能調用任何對象的方法
                id idSelf = self;
                
                // 獲取數組中字典對應的模型
                NSString *type =  [idSelf arrayContainModelClass][key];
                
                // 生成模型
                Class classModel = NSClassFromString(type);
                NSMutableArray *arrM = [NSMutableArray array];
                // 遍歷字典數組，生成模型數組
                for (NSDictionary *dict in value) {
                    // 字典轉模型
                    id model =  [classModel modelWithDict3:dict];
                    [arrM addObject:model];
                }
                
                // 把模型數組賦值給value
                value = arrM;     
            }
        }
        
        // 如果模型屬性數量大於字典鍵值對數理，模型屬性會被賦值爲nil,而報錯
        if (value) {
            // 給模型中屬性賦值
            [objc setValue:value forKey:key];
        }
    }
    return objc;
}

總結：
我們既然能獲取到屬性類型，那就可以攔截到模型的那個數組屬性，進而對數組中每個模型遍歷並字典轉模型，但是我們不知道數組中的模型都是什麼類型，我們可以聲明一個方法，該方法目的不是讓其調用，而是讓其實現並返回模型的類型。

這裏提到的你如果不是很清楚，建議參考我的Demo，重要的部分代碼中都有相應的註解和文字打印，運行程序可以很直觀的表現。

其它作用「面試熟悉」

---

動態添加方法

場景：如果一個類方法非常多，加載類到內存的時候也比較耗費資源，需要給每個方法生成映射表，可以使用動態給某個類，添加方法解決。

註解：OC 中我們很習慣的會用懶加載，當用到的時候纔去加載它，但是實際上只要一個類實現了某個方法，就會被加載進內存。當我們不想加載這麼多方法的時候，就會使用到 runtime 動態的添加方法。

需求：runtime 動態添加方法處理調用一個未實現的方法 和 去除報錯。

場景代碼：方法+調用+打印輸出

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

@implementation Person

/**
 調用：只要一個對象調用了一個未實現的方法就會調用這個方法,進行處理
 作用：動態添加方法,處理未實現
 註解：任何方法默認都有兩個隱式參數,self,_cmd（當前方法的方法編號）
 */
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    
    if (sel == NSSelectorFromString(@"roll:")) {
        /**
         class_addMethod(<#Class  _Nullable __unsafe_unretained cls#>：給哪個類添加方法, <#SEL  _Nonnull name#>：添加哪個方法，即添加方法的方法編號, <#IMP  _Nonnull imp#>：方法實現 => 函數 => 函數入口 => 函數名（添加方法的函數實現（函數地址））, <#const char * _Nullable types#>：方法類型，(返回值+參數類型) v:void @:對象->self :表示SEL->_cmd)
         */
        // 給類添加roll:滾了多遠方法
        class_addMethod(self, sel, (IMP)LNRoll, "v@:@");
        
        return YES;
    }
    
    if ([NSStringFromSelector(sel) isEqualToString:@"go:"]) {
        // 給類添加go:走了多遠方法
        class_addMethod(self, sel, (IMP)LNGO, "v@:@");
        return YES;
    }
    
    return [super resolveInstanceMethod:sel];
}

// 調用
Person *p = [[Person alloc] init];
// 執行某個方法
[p performSelector:@selector(roll:) withObject:@"11"];
[p performSelector:@selector(go:) withObject:@10];

// 打印輸出
2016-03-17 19:05:03.917 runtime[12761:543574] 我滾了 11 米遠的屎蛋
2016-03-17 19:05:04.617 runtime[12761:543574] 我走了 10 公里纔到的家 

---

實現NSCoding的自動歸檔和解檔

如果你實現過自定義模型數據持久化的過程，那麼你也肯定明白，如果一個模型有許多個屬性，那麼我們需要對每個屬性都實現一遍encodeObject 和 decodeObjectForKey方法，如果這樣的模型又有很多個，這還真的是一個十分麻煩的事情。下面來看看簡單的實現方式。

假設現在有一個Movie類，有3個屬性。先看下 .h文件

// Movie.h文件
//1. 如果想要當前類可以實現歸檔與反歸檔，需要遵守一個協議NSCoding
@interface Movie : NSObject<NSCoding>

@property (nonatomic, copy) NSString *movieId;
@property (nonatomic, copy) NSString *movieName;
@property (nonatomic, copy) NSString *pic_url;
@end

如果是正常寫法，.m 文件應該是這樣的：

// Movie.m文件
@implementation Movie

- (void)encodeWithCoder:(NSCoder *)aCoder
{
    [aCoder encodeObject:_movieId forKey:@"id"];
    [aCoder encodeObject:_movieName forKey:@"name"];
    [aCoder encodeObject:_pic_url forKey:@"url"];

}

- (id)initWithCoder:(NSCoder *)aDecoder
{
    if (self = [super init]) {
        self.movieId = [aDecoder decodeObjectForKey:@"id"];
        self.movieName = [aDecoder decodeObjectForKey:@"name"];
        self.pic_url = [aDecoder decodeObjectForKey:@"url"];
    }
    return self;
}
@end

如果這裏有100個屬性，那麼我們也只能把100個屬性都給寫一遍嗎。
不過你會使用runtime後，這裏就有更簡便的方法，如下。

#import "Movie.h"
#import <objc/runtime.h>
@implementation Movie

- (void)encodeWithCoder:(NSCoder *)encoder

{
    unsigned int count = 0;
    Ivar *ivars = class_copyIvarList([Movie class], &count);

    for (int i = 0; i<count; i++) {
        // 取出i位置對應的成員變量
        Ivar ivar = ivars[i];
        // 查看成員變量
        const char *name = ivar_getName(ivar);
        // 歸檔
        NSString *key = [NSString stringWithUTF8String:name];
        id value = [self valueForKey:key];
        [encoder encodeObject:value forKey:key];
    }
    free(ivars);
}

- (id)initWithCoder:(NSCoder *)decoder
{
    if (self = [super init]) {
        unsigned int count = 0;
        Ivar *ivars = class_copyIvarList([Movie class], &count);
        for (int i = 0; i<count; i++) {
        // 取出i位置對應的成員變量
        Ivar ivar = ivars[i];
        // 查看成員變量
        const char *name = ivar_getName(ivar);
       // 歸檔
       NSString *key = [NSString stringWithUTF8String:name];
      id value = [decoder decodeObjectForKey:key];
       // 設置到成員變量身上
        [self setValue:value forKey:key];

        }
        free(ivars);
    } 
    return self;
}
@end

這樣的方式實現，不管有多少個屬性，寫這幾行代碼就搞定了。
下面看看更加簡便的方法：兩句代碼搞定。

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

#define encodeRuntime(A) \
\
unsigned int count = 0;\
Ivar *ivars = class_copyIvarList([A class], &count);\
for (int i = 0; i<count; i++) {\
Ivar ivar = ivars[i];\
const char *name = ivar_getName(ivar);\
NSString *key = [NSString stringWithUTF8String:name];\
id value = [self valueForKey:key];\
[encoder encodeObject:value forKey:key];\
}\
free(ivars);\
\

#define initCoderRuntime(A) \
\
if (self = [super init]) {\
unsigned int count = 0;\
Ivar *ivars = class_copyIvarList([A class], &count);\
for (int i = 0; i<count; i++) {\
Ivar ivar = ivars[i];\
const char *name = ivar_getName(ivar);\
NSString *key = [NSString stringWithUTF8String:name];\
id value = [decoder decodeObjectForKey:key];\
[self setValue:value forKey:key];\
}\
free(ivars);\
}\
return self;\
\

- - -
@implementation Movie
- (void)encodeWithCoder:(NSCoder *)encoder {
    encodeRuntime(Movie)
}

- (id)initWithCoder:(NSCoder *)decoder {
    initCoderRuntime(Movie)
}
@end

優化：
上面是encodeWithCoder 和 initWithCoder這兩個方法抽成宏。我們可以把這兩個宏單獨放到一個文件裏面，這裏以後需要進行數據持久化的模型都可以直接使用這兩個宏。

runtime 下Class的各項操作

1.runtime 部分函數

#warning - 以下爲功能模塊相關的方法示例, 具體方法作用、使用、註解請移步 -> github.com/CoderLN
以下的這些方法應該算是`runtime`在實際場景中所應用的大部分的情況了，平常的編碼中差不多足夠用了。

 0、class_copyPropertyList 獲取類中所有的屬性
        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]);
        }

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

 0、class_copyIvarList 獲取類中所有的成員變量（outCount 會返回成員變量的總數）
        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]);
        }
 
 0、class_copyProtocolList 獲取協議列表
    __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]);
    }
 
 0、object_getClass 獲得類方法
        Class PersonClass = object_getClass([Person class]);
        SEL oriSEL = @selector(test1);
        Method oriMethod = _class_getMethod(xiaomingClass, oriSEL);
 
 0、class_getInstanceMethod 獲得實例方法
        Class PersonClass = object_getClass([xiaoming class]);
        SEL oriSEL = @selector(test2);
        Method cusMethod = class_getInstanceMethod(xiaomingClass, oriSEL);
 
 0、class_addMethod 動態添加方法
        BOOL addSucc = class_addMethod(xiaomingClass, oriSEL, method_getImplementation(cusMethod), method_getTypeEncoding(cusMethod));
 
 0、class_replaceMethod 替換原方法實現
        class_replaceMethod(toolClass, cusSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
 
 0、method_exchangeImplementations 交換兩個方法的實現
        method_exchangeImplementations(method1, method2);

 0、根據名字得到類變量的Ivar指針，但是這個在OC中好像毫無意義
    Ivar oneCVIvar = class_getClassVariable([Person class], name);

 0、根據名字得到實例變量的Ivar指針
    Ivar oneIVIvar = class_getInstanceVariable([Person class], name);

 0、找到後可以直接對私有成員變量賦值（強制修改name屬性）
    object_setIvar(_per, oneIVIvar, @"age");


 0、動態添加方法
    class_addMethod([person class]：Class cls 類型, @selector(eat)：待調用的方法名稱, (IMP)myAddingFunction：(IMP)myAddingFunction，IMP是一個函數指針，這裏表示指定具體實現方法myAddingFunction, 0：0代表沒有參數);

 0、獲得某個類的類方法
    Method class_getClassMethod(Class cls , SEL name)

 0、獲得成員變量的名字
    const char *ivar_getName(Ivar v);

 0、將某個值跟某個對象關聯起來，將某個值存儲到某個對象中
    void objc_setAssociatedObject(id object：表示關聯者，是一個對象，變量名理所當然也是object , const void *key：獲取被關聯者的索引key ,id value ：被關聯者 ,objc_AssociationPolicy policy：關聯時採用的協議，有assign，retain，copy等協議，一般使用OBJC_ASSOCIATION_RETAIN_NONATOMIC)

 0、利用參數key 將對象object中存儲的對應值取出來
    id objc_getAssociatedObject(id object , const void *key)
 */

method swizzling（俗稱黑魔法）

---

• 簡單說就是進行方法交換
• 在Objective-C中調用一個方法，其實是向一個對象發送消息，查找消息的唯一依據是selector的名字。利用Objective-C的動態特性，可以實現在運行時偷換selector對應的方法實現，達到給方法掛鉤的目的
• 每個類都有一個方法列表，存放着方法的名字和方法實現的映射關係，selector的本質其實就是方法名，IMP有點類似函數指針，指向具體的Method實現，通過selector就可以找到對應的IMP 。

• 交換方法的幾種實現方式

  • 利用 method_exchangeImplementations 交換兩個方法的實現
  • 利用 class_replaceMethod 替換方法的實現
  • 利用 method_setImplementation 來直接設置某個方法的IMP。

這裏可以參考簡友這篇：Runtime Method Swizzling開發實例彙總

一道面試題的註解

---

下面的代碼輸出什麼?

@implementation Son : NSObject
- (id)init
{
    self = [super init];
    if (self) {
        NSLog(@"%@", NSStringFromClass([self class]));
        NSLog(@"%@", NSStringFromClass([super class]));
    }
    return self;
}
@end

先思考一下，會打印出來什麼❓

---

答案：都輸出 Son

• class 獲取當前方法的調用者的類，superClass 獲取當前方法的調用者的父類，super 僅僅是一個編譯指示器，就是給編譯器看的，不是一個指針。
• 本質：只要編譯器看到super這個標誌，就會讓當前對象去調用父類方法，本質還是當前對象在調用

這個題目主要是考察關於objc中對 self 和 super 的理解：

• self 是類的隱藏參數，指向當前調用方法的這個類的實例。而 super 本質是一個編譯器標示符，和 self 是指向的同一個消息接受者
• 當使用 self 調用方法時，會從當前類的方法列表中開始找，如果沒有，就從父類中再找；
• 而當使用 super時，則從父類的方法列表中開始找。然後調用父類的這個方法
• 調用 [self class] 時，會轉化成 objc_msgSend 函數

id objc_msgSend(id self, SEL op, ...)
- 調用 `[super class]`時，會轉化成 `objc_msgSendSuper` 函數.

id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
第一個參數是 objc_super 這樣一個結構體，其定義如下
 struct objc_super {
 __unsafe_unretained id receiver;
 __unsafe_unretained Class super_class;
 };

第一個成員是 receiver, 類似於上面的 objc_msgSend函數第一個參數self
第二個成員是記錄當前類的父類是什麼，告訴程序從父類中開始找方法，找到方法後，最後內部是使用 objc_msgSend(objc_super->receiver, @selector(class))去調用， 此時已經和[self class]調用相同了，故上述輸出結果仍然返回 Son

objc Runtime 開源代碼對- (Class)class方法的實現
-(Class)class { return object_getClass(self); 
}

Runtime 模塊博文推薦 (❤️數量較多)

---

作者	Runtime 模塊推薦閱讀博文
[西木]()	完整總結 http://www.jianshu.com/p/6b90...
[天口三水羊]()	objc_msgSend http://www.jianshu.com/p/9e1b...
[夜千尋墨]()	詳解 http://www.jianshu.com/p/46dd...
[袁崢Seemygo]()	快速上手 http://www.jianshu.com/p/e071...
[鄭欽洪_]()	實現自動化歸檔 http://www.jianshu.com/p/bd24...
[HenryCheng]()	消息機制 http://www.jianshu.com/p/f630...
[賣報的小畫家Sure]()	Method Swizzling開發實例彙總 http://www.jianshu.com/p/f6da...
[滕大鳥]()	OC最實用的runtime總結 http://www.jianshu.com/p/ab96...
[黑花白花]()	Runtime在實際開發中的應用 http://www.jianshu.com/p/851b...

Runtime & Runloop 常面問題整理（附答案）

同一個面試問題並非只有一個答案，而同一個答案並不是在任何面試場合都有效，關鍵在於應聘者掌握了規律後，對面試的具體情況進行把握，有意識地揣摩面試官提出問題的心理 (真實問答)，要 get 的到問的點，然後答其所問，算是“ 投其所好 ”吧。
摘錄：
http://www.jianshu.com/p/56e4...
http://www.jianshu.com/p/f9eb...

Runtime

01 / objc在向一個對象發送消息時，發生了什麼？

參考1：根據對象的 isa 指針找到類對象 id，在查詢類對象裏面的 methodLists 方法函數列表，如果沒有在好到，在沿着 superClass ,尋找父類，再在父類 methodLists 方法列表裏面查詢，最終找到 SEL ,根據 id 和 SEL 確認 IMP（指針函數）,在發送消息；

02 / 問題：什麼時候會報unrecognized selector錯誤？iOS有哪些機制來避免走到這一步？

參考1：當發送消息的時候，我們會根據類裏面的 methodLists 列表去查詢我們要動用的SEL，當查詢不到的時候，我們會一直沿着父類查詢，當最終查詢不到的時候我們會報 unrecognized selector 錯誤，當系統查詢不到方法的時候，會調用 +(BOOL)resolveInstanceMethod:(SEL)sel 動態解釋的方法來給我一次機會來添加，調用不到的方法。或者我們可以再次使用 -(id)forwardingTargetForSelector:(SEL)aSelector 重定向的方法來告訴系統，該調用什麼方法，一來保證不會崩潰。

03 / 問題：能否向編譯後得到的類中增加實例變量？能否向運行時創建的類中添加實例變量？爲什麼？

參考1：1、不能向編譯後得到的類增加實例變量 2、能向運行時創建的類中添加實例變量。

分析：1. 編譯後的類已經註冊在 runtime 中,類結構體中的 objc_ivar_list 實例變量的鏈表和 instance_size 實例變量的內存大小已經確定，runtime會調用 class_setvarlayout 或 class_setWeaklvarLayout 來處理strong weak 引用.所以不能向存在的類中添加實例變量。2. 運行時創建的類是可以添加實例變量，調用class_addIvar函數. 但是的在調用 objc_allocateClassPair 之後，objc_registerClassPair 之前,原因同上.

04 / 問題：runtime如何實現weak變量的自動置nil？

參考1：runtime 對註冊的類， 會進行佈局，對於 weak 對象會放入一個 hash 表中。 用 weak 指向的對象內存地址作爲 key，當此對象的引用計數爲0的時候會 dealloc，假如 weak 指向的對象內存地址是a，那麼就會以a爲鍵， 在這個 weak 表中搜索，找到所有以a爲鍵的 weak 對象，從而設置爲 nil。

05 / 問題：給類添加一個屬性後，在類結構體裏哪些元素會發生變化？

參考1：instance_size ：實例的內存大小；objc_ivar_list *ivars:屬性列表

RunLoop

01 / 問題：runloop是來做什麼的？runloop和線程有什麼關係？主線程默認開啓了runloop麼？子線程呢？

參考1：runloop: 從字面意思看：運行循環、跑圈，其實它內部就是do-while循環，在這個循環內部不斷地處理各種任務（比如Source、Timer、Observer）事件。runloop和線程的關係：一個線程對應一個RunLoop，主線程的RunLoop默認創建並啓動，子線程的RunLoop需手動創建且手動啓動（調用run方法）。RunLoop只能選擇一個Mode啓動，如果當前Mode中沒有任何Source(Sources0、Sources1)、Timer，那麼就直接退出RunLoop。

02 / 問題：runloop的mode是用來做什麼的？有幾種mode？

參考1：model:是runloop裏面的運行模式，不同的模式下的runloop處理的事件和消息有一定的差別。系統默認註冊了5個Mode:（1）kCFRunLoopDefaultMode: App的默認 Mode，通常主線程是在這個 Mode 下運行的。（2）UITrackingRunLoopMode: 界面跟蹤 Mode，用於 ScrollView 追蹤觸摸滑動，保證界面滑動時不受其他 Mode 影響。（3）UIInitializationRunLoopMode: 在剛啓動 App 時第進入的第一個 Mode，啓動完成後就不再使用。（4）GSEventReceiveRunLoopMode: 接受系統事件的內部 Mode，通常用不到。（5）kCFRunLoopCommonModes: 這是一個佔位的 Mode，沒有實際作用。注意iOS 對以上5中model進行了封裝 NSDefaultRunLoopMode、NSRunLoopCommonModes

03 / 問題：爲什麼把NSTimer對象以NSDefaultRunLoopMode（kCFRunLoopDefaultMode）添加到主運行循環以後，滑動scrollview的時候NSTimer卻不動了？

參考1：nstime對象是在 NSDefaultRunLoopMode下面調用消息的，但是當我們滑動scrollview的時候，NSDefaultRunLoopMode模式就自動切換到UITrackingRunLoopMode模式下面，卻不可以繼續響應nstime發送的消息。所以如果想在滑動scrollview的情況下面還調用nstime的消息，我們可以把nsrunloop的模式更改爲NSRunLoopCommonModes.

04 / 問題：蘋果是如何實現Autorelease Pool的？

參考1：Autorelease Pool作用：緩存池，可以避免我們經常寫relase的一種方式。其實就是延遲release，將創建的對象，添加到最近的autoreleasePool中，等到autoreleasePool作用域結束的時候，會將裏面所有的對象的引用計數器 - autorelease.

附上寫的小樣 Demo，重要的部分代碼中都有相應的註解和文字打印，運行程序可以很直觀的表現

不知名開發者

---

• 各位廠友，由於「時間 & 知識」有限，總結的文章難免有「未全、不足」，該模塊將系統化學習，後替換、補充文章內容 ~
• 熬夜寫者不易，學會交流和分享。