iOS底層原理總結 - Category的本質

xx_cc發表於2018-05-06
原文網址 : https://juejin.im/post/5aef0a3b518825670f7bc0f3
iOSGo

iOS底層原理總結 - Category的本質

面試題

  1. Category的實現原理，以及Category為什麼只能加方法不能加屬性。
  2. Category中有load方法嗎？load方法是什麼時候呼叫的？load 方法能繼承嗎？
  3. load、initialize的區別，以及它們在category重寫的時候的呼叫的次序。

Category的本質

首先我們寫一段簡單的程式碼，之後的分析都基於這段程式碼。

Presen類 
// Presen.h
#import <Foundation/Foundation.h>
@interface Preson : NSObject
{
    int _age;
}
- (void)run;
@end

// Presen.m
#import "Preson.h"
@implementation Preson
- (void)run
{
    NSLog(@"Person - run");
}
@end

Presen擴充套件1
// Presen+Test.h
#import "Preson.h"
@interface Preson (Test) <NSCopying>
- (void)test;
+ (void)abc;
@property (assign, nonatomic) int age;
- (void)setAge:(int)age;
- (int)age;
@end

// Presen+Test.m
#import "Preson+Test.h"
@implementation Preson (Test)
- (void)test
{
}

+ (void)abc
{
}
- (void)setAge:(int)age
{
}
- (int)age
{
    return 10;
}
@end

Presen分類2
// Preson+Test2.h
#import "Preson.h"
@interface Preson (Test2)
@end

// Preson+Test2.m
#import "Preson+Test2.h"
@implementation Preson (Test2)
- (void)run
{
    NSLog(@"Person (Test2) - run");
}
@end
複製程式碼

我們之前講到過例項物件的isa指標指向類物件，類物件的isa指標指向元類物件，當p呼叫run方法時，類物件的isa指標找到類物件的isa指標，然後在類物件中查詢物件方法，如果沒有找到，就通過類物件的superclass指標找到父類物件，接著去尋找run方法。

那麼當呼叫分類的方法時，步驟是否和呼叫物件方法一樣呢？ 分類中的物件方法依然是儲存在類物件中的，同物件方法在同一個地方，那麼呼叫步驟也同呼叫物件方法一樣。如果是類方法的話，也同樣是儲存在元類物件中。 那麼分類方法是如何儲存在類物件中的，我們來通過原始碼看一下分類的底層結構。

分類的底層結構

如何驗證上述問題？通過檢視分類的原始碼我們可以找到category_t 結構體。

struct category_t {
    const char *name;
    classref_t cls;
    struct method_list_t *instanceMethods; // 物件方法
    struct method_list_t *classMethods; // 類方法
    struct protocol_list_t *protocols; // 協議
    struct property_list_t *instanceProperties; // 屬性
    // Fields below this point are not always present on disk.
    struct property_list_t *_classProperties;

    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }

    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};
複製程式碼

從原始碼基本可以看出我們平時使用categroy的方式，物件方法，類方法，協議，和屬性都可以找到對應的儲存方式。並且我們發現分類結構體中是不存在成員變數的，因此分類中是不允許新增成員變數的。分類中新增的屬性並不會幫助我們自動生成成員變數，只會生成get set方法的宣告，需要我們自己去實現。

通過原始碼我們發現，分類的方法，協議，屬性等好像確實是存放在categroy結構體裡面的，那麼他又是如何儲存在類物件中的呢？ 我們來看一下底層的內部方法探尋其中的原理。 首先我們通過命令列將Preson+Test.m檔案轉化為c++檔案，檢視其中的編譯過程。

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Preson+Test.m
複製程式碼

在分類轉化為c++檔案中可以看出_category_t結構體中，存放著類名，物件方法列表，類方法列表，協議列表，以及屬性列表。

c++檔案中category_t結構體

緊接著，我們可以看到_method_list_t型別的結構體，如下圖所示

物件方法列表結構體

上圖中我們發現這個結構體_OBJC_$_CATEGORY_INSTANCE_METHODS_Preson_$_Test從名稱可以看出是INSTANCE_METHODS物件方法，並且一一對應為上面結構體內賦值。我們可以看到結構體中儲存了方法佔用的記憶體，方法數量，以及方法列表。並且從上圖中找到分類中我們實現對應的物件方法，test , setAge, age三個方法

接下來我們發現同樣的_method_list_t型別的類方法結構體，如下圖所示

類物件方法列表

同上面物件方法列表一樣，這個我們可以看出是類方法列表結構體 _OBJC_$_CATEGORY_CLASS_METHODS_Preson_$_Test，同物件方法結構體相同，同樣可以看到我們實現的類方法，abc。

接下來是協議方法列表

協議方法列表

通過上述原始碼可以看到先將協議方法通過_method_list_t結構體儲存，之後通過_protocol_t結構體儲存在_OBJC_CATEGORY_PROTOCOLS_$_Preson_$_Test中同_protocol_list_t結構體一一對應，分別為protocol_count 協議數量以及儲存了協議方法的_protocol_t結構體。

最後我們可以看到屬性列表

屬性列表結構體
屬性列表結構體_OBJC_$_PROP_LIST_Preson_$_Test同_prop_list_t結構體對應，儲存屬性的佔用空間，屬性屬性數量，以及屬性列表，從上圖中可以看到我們自己寫的age屬性。

最後我們可以看到定義了_OBJC_$_CATEGORY_Preson_$_Test結構體，並且將我們上面著重分析的結構體一一賦值，我們通過兩張圖片對照一下。

_category_t

_OBJC_$_CATEGORY_Preson_$_Test

上下兩張圖一一對應，並且我們看到定義_class_t型別的OBJC_CLASS_$_Preson結構體，最後將_OBJC_$_CATEGORY_Preson_$_Test的cls指標指向OBJC_CLASS_$_Preson結構體地址。我們這裡可以看出，cls指標指向的應該是分類的主類類物件的地址。

通過以上分析我們發現。分類原始碼中確實是將我們定義的物件方法，類方法，屬性等都存放在catagory_t結構體中。接下來我們在回到runtime原始碼檢視catagory_t儲存的方法，屬性，協議等是如何儲存在類物件中的。

首先來到runtime初始化函式

runtime初始化函式

接著我們來到 &map_images讀取模組（images這裡代表模組），來到map_images_nolock函式中找到_read_images函式，在_read_images函式中我們找到分類相關程式碼

Discover categories程式碼

從上述程式碼中我們可以知道這段程式碼是用來查詢有沒有分類的。通過_getObjc2CategoryList函式獲取到分類列表之後，進行遍歷，獲取其中的方法，協議，屬性等。可以看到最終都呼叫了remethodizeClass(cls);函式。我們來到remethodizeClass(cls);函式內部檢視。

remethodizeClass函式內部
通過上述程式碼我們發現attachCategories函式接收了類物件cls和分類陣列cats，如我們一開始寫的程式碼所示，一個類可以有多個分類。之前我們說到分類資訊儲存在category_t結構體中，那麼多個分類則儲存在category_list中。

我們來到attachCategories函式內部。

attachCategories函式內部實現

上述原始碼中可以看出，首先根據方法列表，屬性列表，協議列表，malloc分配記憶體，根據多少個分類以及每一塊方法需要多少記憶體來分配相應的記憶體地址。之後從分類陣列裡面往三個陣列裡面存放分類陣列裡面存放的分類方法，屬性以及協議放入對應mlist、proplists、protolosts陣列中，這三個陣列放著所有分類的方法，屬性和協議。 之後通過類物件的data()方法，拿到類物件的class_rw_t結構體rw，在class結構中我們介紹過，class_rw_t中存放著類物件的方法，屬性和協議等資料，rw結構體通過類物件的data方法獲取，所以rw裡面存放這類物件裡面的資料。 之後分別通過rw呼叫方法列表、屬性列表、協議列表的attachList函式，將所有的分類的方法、屬性、協議列表陣列傳進去，我們大致可以猜想到在attachList方法內部將分類和本類相應的物件方法，屬性，和協議進行了合併。

我們來看一下attachLists函式內部。

attachLists函式內部實現

上述原始碼中有兩個重要的陣列 array()->lists： 類物件原來的方法列表，屬性列表，協議列表。 addedLists：傳入所有分類的方法列表，屬性列表，協議列表。

attachLists函式中最重要的兩個方法為memmove記憶體移動和memcpy記憶體拷貝。我們先來分別看一下這兩個函式

// memmove ：記憶體移動。
/*  __dst : 移動記憶體的目的地
*   __src : 被移動的記憶體首地址
*   __len : 被移動的記憶體長度
*   將__src的記憶體移動__len塊記憶體到__dst中
*/
void	*memmove(void *__dst, const void *__src, size_t __len);

// memcpy ：記憶體拷貝。
/*  __dst : 拷貝記憶體的拷貝目的地
*   __src : 被拷貝的記憶體首地址
*   __n : 被移動的記憶體長度
*   將__src的記憶體拷貝__n塊記憶體到__dst中
*/
void	*memcpy(void *__dst, const void *__src, size_t __n);
複製程式碼

下面我們圖示經過memmove和memcpy方法過後的記憶體變化。

未經過記憶體移動和拷貝時

經過memmove方法之後，記憶體變化為

// array()->lists 原來方法、屬性、協議列表陣列
// addedCount 分類陣列長度
// oldCount * sizeof(array()->lists[0]) 原來陣列佔據的空間
memmove(array()->lists + addedCount, array()->lists, 
                  oldCount * sizeof(array()->lists[0]));
複製程式碼

memmove方法之後記憶體變化

經過memmove方法之後，我們發現，雖然本類的方法，屬性，協議列表會分別後移，但是本類的對應陣列的指標依然指向原始位置。

memcpy方法之後，記憶體變化

// array()->lists 原來方法、屬性、協議列表陣列
// addedLists 分類方法、屬性、協議列表陣列
// addedCount * sizeof(array()->lists[0]) 原來陣列佔據的空間
memcpy(array()->lists, addedLists, 
               addedCount * sizeof(array()->lists[0]));
複製程式碼

memmove方法之後，記憶體變化

我們發現原來指標並沒有改變，至始至終指向開頭的位置。並且經過memmove和memcpy方法之後，分類的方法，屬性，協議列表被放在了類物件中原本儲存的方法，屬性，協議列表前面。

那麼為什麼要將分類方法的列表追加到本來的物件方法前面呢，這樣做的目的是為了保證分類方法優先呼叫，我們知道當分類重寫本類的方法時，會覆蓋本類的方法。 其實經過上面的分析我們知道本質上並不是覆蓋，而是優先呼叫。本類的方法依然在記憶體中的。我們可以通過列印所有類的所有方法名來檢視

- (void)printMethodNamesOfClass:(Class)cls
{
    unsigned int count;
    // 獲得方法陣列
    Method *methodList = class_copyMethodList(cls, &count);
    // 儲存方法名
    NSMutableString *methodNames = [NSMutableString string];
    // 遍歷所有的方法
    for (int i = 0; i < count; i++) {
        // 獲得方法
        Method method = methodList[i];
        // 獲得方法名
        NSString *methodName = NSStringFromSelector(method_getName(method));
        // 拼接方法名
        [methodNames appendString:methodName];
        [methodNames appendString:@", "];
    }
    // 釋放
    free(methodList);
    // 列印方法名
    NSLog(@"%@ - %@", cls, methodNames);
}
- (void)viewDidLoad {
    [super viewDidLoad];    
    Preson *p = [[Preson alloc] init];
    [p run];
    [self printMethodNamesOfClass:[Preson class]];
}
複製程式碼

通過下圖中列印內容可以發現，呼叫的是Test2中的run方法，並且Person類中儲存著兩個run方法。

列印所有方法

總結：

問： Category的實現原理，以及Category為什麼只能加方法不能加屬性?

答：分類的實現原理是將category中的方法，屬性，協議資料放在category_t結構體中，然後將結構體內的方法列表拷貝到類物件的方法列表中。 Category可以新增屬性，但是並不會自動生成成員變數及set/get方法。因為category_t結構體中並不存在成員變數。通過之前對物件的分析我們知道成員變數是存放在例項物件中的，並且編譯的那一刻就已經決定好了。而分類是在執行時才去載入的。那麼我們就無法再程式執行時將分類的成員變數中新增到例項物件的結構體中。因此分類中不可以新增成員變數。

load 和 initialize

load方法會在程式啟動就會呼叫，當裝載類資訊的時候就會呼叫。 呼叫順序看一下原始碼。

load方法呼叫順序
通過原始碼我們發現是優先呼叫類的load方法，之後呼叫分類的load方法。

我們通過程式碼驗證一下： 我們新增Student繼承Presen類，並新增Student+Test分類，分別重寫只+load方法，其他什麼都不做通過列印發現

load方法列印
確實是優先呼叫類的load方法之後呼叫分類的load方法，不過呼叫類的load方法之前會保證其父類已經呼叫過load方法。

之後我們為Preson、Student 、Student+Test 新增initialize方法。 我們知道當類第一次接收到訊息時，就會呼叫initialize，相當於第一次使用類的時候就會呼叫initialize方法。呼叫子類的initialize之前，會先保證呼叫父類的initialize方法。如果之前已經呼叫過initialize，就不會再呼叫initialize方法了。當分類重寫initialize方法時會先呼叫分類的方法。但是load方法並不會被覆蓋，首先我們來看一下initialize的原始碼。

initialize呼叫原始碼

上圖中我們發現，initialize是通過訊息傳送機制呼叫的，訊息傳送機制通過isa指標找到對應的方法與實現，因此先找到分類方法中的實現，會優先呼叫分類方法中的實現。

我們再來看一下load方法的呼叫原始碼

load方法的呼叫原始碼
我們看到load方法中直接拿到load方法的記憶體地址直接呼叫方法，不在是通過訊息傳送機制呼叫。

分類load方法的呼叫原始碼
我們可以看到分類中也是通過直接拿到load方法的地址進行呼叫。因此正如我們之前試驗的一樣，分類中重寫load方法，並不會優先呼叫分類的load方法，而不呼叫本類中的load方法了。

總結

問：Category中有load方法嗎？load方法是什麼時候呼叫的？load 方法能繼承嗎？

答：Category中有load方法，load方法在程式啟動裝載類資訊的時候就會呼叫。load方法可以繼承。呼叫子類的load方法之前，會先呼叫父類的load方法

問：load、initialize的區別，以及它們在category重寫的時候的呼叫的次序。

答：區別在於呼叫方式和呼叫時刻 呼叫方式：load是根據函式地址直接呼叫，initialize是通過objc_msgSend呼叫 呼叫時刻：load是runtime載入類、分類的時候呼叫（只會呼叫1次），initialize是類第一次接收到訊息的時候呼叫，每一個類只會initialize一次（父類的initialize方法可能會被呼叫多次）

呼叫順序：先呼叫類的load方法，先編譯那個類，就先呼叫load。在呼叫load之前會先呼叫父類的load方法。分類中load方法不會覆蓋本類的load方法，先編譯的分類優先呼叫load方法。initialize先初始化父類，之後再初始化子類。如果子類沒有實現+initialize，會呼叫父類的+initialize（所以父類的+initialize可能會被呼叫多次），如果分類實現了+initialize，就覆蓋類本身的+initialize呼叫。

本文是對底層原理學習的總結，如果有不對的地方請指正，歡迎大家一起交流學習 xx_cc 。需要這套視訊一起交流學習的可以加我Q：2336684744

相關文章