Category的本質-知識星球

作者：雪山飛狐_91ae
來自：https://www.jianshu.com/p/da463f413de7

一寫在開頭

Category大家應該用過，它主要是用在為物件的不同型別的功能分塊，比如說人這個物件，我們可以為其建立三個分類，分別對應學習，工作，休息。

下麵建立了一個Person類和兩個Person類的分類。分別是Person+Test和Person+Eat。這三個類中各有一個方法。

//Person類
- (void)run;
- (void)run{

    NSLog(@"run");
}

//Person+Test分類
- (void)test;
- (void)test{

    NSLog(@"test");
}

//Person+Eat分類
- (void)eat;
- (void)eat{

    NSLog(@"eat");
}

當我們需要使用這些分類的時候只需要引入這些分類的頭檔案即可：

#import "Person+Test.h"
#import "Person+Eat.h"

Person *person = [[Person alloc] init];
 [person run];
 [person test];
 [person eat];

我們都知道，函式呼叫的本質是訊息機制。[person run]的本質就是objc_mgs(person, @selector(run)),這個很好理解，由於物件方法是存放在類物件中的，所以向person物件傳送訊息就是透過person物件的isa指標找到其類物件，然後在類物件中找到這個物件方法。

[person test]和[person run]都是呼叫分類的物件方法，本質應該一樣。[person test]的本質就是objc_mgs(person， @selector(test))，給實體物件傳送訊息，person物件透過自己的isa指標找到類物件，然後在自己的類物件中查詢這個實體方法，那麼問題來了，person類物件中有沒有儲存分類中的這個物件方法呢？Person+Test這個分類會不會有自己的分類的類物件，將分類的物件方法儲存在這個類物件中呢？

我們要清楚的一點是每個類只有一個類物件，不管這個類有沒有分類。所以分類中的物件方法研究儲存在Person類的類物件中。後面我們會透過原始碼證實這一點。

二底層結構

我們在第一部分講了，分類中的物件方法和類方法最終會合併到類中，分類中的物件方法合併到類的類物件中，分類中的類方法合併到類的元類物件中。那麼這個合併是什麼時候發生的呢？是在編譯器編譯器就幫我們合併好了嗎？實際上是在執行期，進行的合併。

下麵我們透過將Objective-c的程式碼轉化為c++的原始碼窺探一下Category的底層結構。我們在命令列進入到存放Person+Test.m這個檔案的檔案夾中，然後在命令列輸入clang -rewrite-objc Person+Test.m,這樣Person+Test.m這個檔案就被轉化為了c++的原始碼Person+Test.cpp。

我們開啟這個.cpp檔案，由於這個檔案非常長，所以我們直接拖到最下麵，找到_category_t這個結構體。這個結構體就是每一個分類的結構：

struct _category_t {
    const char *name; //類名
    struct _class_t *cls;
    const struct _method_list_t *instance_methods; //物件方法串列
    const struct _method_list_t *class_methods; //實體方法串列
    const struct _protocol_list_t *protocols;  //協議串列
    const struct _prop_list_t *properties;  //屬性串列
};

我們接著往下找到這個結構體的初始化：

static struct _category_t _OBJC_$_CATEGORY_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "Person",
    0, // &OBJC;_CLASS_$_Person,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test,
    0,
    0,
};

透過結構體名稱_OBJC_$_CATEGORY_Person_$_Test我們可以知道這是Person+Test這個分類的初始化。類名對應的是”Person”,物件方法串列這個結構體對應的是&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test,類方法串列這個結構體對應的是&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test,其餘的初始化都是空。

然後我們找到&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test這個結構體：

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"test", "v16@0:8", (void *)_I_Person_Test_test}}
};

可以看到這個結構體中包含一個物件方法test，這正是Person+Test這個分類中的物件方法。

然後我們再找到&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test這個結構體：

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"test2", "v16@0:8", (void *)_C_Person_Test_test2}}
};

同樣可以看到這個結構體，它包含一個類方法test2，這個同樣是Person+Test中的類方法。

三利用runtime進行合併

由於整個合併的過程是透過runtime進行實現的，所以我們要瞭解這個過程就要透過檢視runtime原始碼去瞭解。下麵是檢視runtime原始碼的過程：

1.找到objc-os.mm這個檔案，這個檔案是runtime的入口檔案。
2.在objc-os.mm中找到_objc_init(void)這個方法，這個方法是執行時的初始化。
3.在_objc_init(void)中會呼叫_dyld_objc_notify_register(↦_images, load_images, unmap_image);,這個函式會傳入map_images這個引數，我們點進這個引數。
4.點選進去map_images我們發現其中呼叫了map_images_nolock(count, paths, mhdrs);這個函式，我們點進這個函式。
5.map_images_nolock(unsigned mhCount, const char * const mhPaths[], const struct mach_essay-header * const mhdrs[])這個函式非常長，我們直接拉到這個函式最下麵，找到_read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);這個函式，點選進去。
6.void _read_images(essay-header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)這個方法大概就是讀取模組的意思了。
這個函式也是非常長，我們大概在中間位置找到了這樣一行註釋

// Discover categories.

這個基本上就是我們要找的處理Category的模組了。

我們在這行註釋下麵找到這幾行程式碼：

if (cls->isRealized()) {
       remethodizeClass(cls);
       classExists = YES;
                }

 if (cls->ISA()->isRealized()) {
       remethodizeClass(cls->ISA());  //class的ISA指標指向的是元類物件
               }

這個程式碼裡面有一個關鍵函式remethodizeClass,透過函式名我們大概猜測這個方法是重新組織類中的方法，如果傳入的是類，則重新組織物件方法，如果傳入的是元類，則重新組織類方法。

7.然後我們點進這個方法裡面檢視：

static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;

    runtimeLock.assertWriting();

    isMeta = cls->isMetaClass();

    // Re-methodizing: check for more categories
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }

        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

我們看到這段程式碼的核心是呼叫了attachCategories(cls, cats, true /*flush caches*/);這個方法。這個方法中傳入了一個類cls和所有的分類cats。

8.我們點進attachCategories(cls, cats, true /*flush caches*/);這個方法。這個方法基本上就是核心方法了。

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;
    if (PrintReplacedMethods) printReplacements(cls, cats);

    bool isMeta = cls->isMetaClass();

    // fixme rearrange to remove these intermediate allocations
    //方法陣列
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
    //屬性陣列
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
    //協議陣列
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    int i = cats->count;
    bool fromBundle = NO;
    while (i--) {
        //取出某個分類
        auto& entry = cats->list[i];
//確定是物件方法還是類方法
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }
//得到類物件裡面的資料
    auto rw = cls->data();

    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    //將所有分類的物件方法，附加到類物件的方法串列中
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);
//將所有分類的協議，附加到類物件的協議串列中
    rw->properties.attachLists(proplists, propcount);
    free(proplists);

    rw->protocols.attachLists(protolists, protocount);
    free(protolists);
}

bool isMeta = cls->isMetaClass();判斷是類還是元類。
建立總的方法陣列，屬性陣列，協議陣列

//方法陣列
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
    //屬性陣列
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
    //協議陣列
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

這裡mlists，proplists，protolists都是用兩個修飾的，說明是申請了一個二維陣列。這三個二維陣列裡面的一級物件分別是方法串列，屬性串列，以及協議串列。由於每一個分類Category都有一個方法串列，一個屬性串列，一個協議串列，方法串列中裝著這個分類的方法，屬性串列中裝著這個分類的屬性。所以mlists也就是裝著所有分類的所有方法。

給前面建立的陣列賦值

while (i--) {
        //取出某個分類
        auto& entry = cats->list[i];
//確定是物件方法還是類方法
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }

這段程式碼就很清楚了，透過一個while迴圈遍歷所有的分類，然後獲取該分類的所有方法，賦值給前面建立的大陣列。

rw = cls->data();得到類物件裡面的所有資料。
rw->methods.attachLists(mlists, mcount);將所有分類的方法，附加到類的方法串列中。
9.我們點進這個方法裡面看看具體的實現：

void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return;

        if (hasArray()) {
            // many lists -> many lists
            uint32_t oldCount = array()->count;
            uint32_t newCount = oldCount + addedCount;
            setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
            array()->count = newCount;
            memmove(array()->lists + addedCount, array()->lists, 
                    oldCount * sizeof(array()->lists[0]));
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
        else if (!list  &&  addedCount == 1) {
            // 0 lists -> 1 list
            list = addedLists[0];
        } 
        else {
            // 1 list -> many lists
            List* oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount;
            setArray((array_t *)malloc(array_t::byteSize(newCount)));
            array()->count = newCount;
            if (oldList) array()->lists[addedCount] = oldList;
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
    }

傳進來的這個addedLists引數就是前面得到的這個類的所有分類的物件方法或者類方法，而addedCount就是addedLists這個陣列的個數。假設這個類有兩個分類，且每個分類有兩個方法，那麼addedLists的結構大概就應該是這樣的：

[
[method, method]
[method, method]
]
addedCount = 2
我們看一下這個類的方法串列之前的結構：

所以oldCount = 1

setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
array()->count = newCount;

這一句是重新分配記憶體，由於要把分類的方法合併進來，所以以前分配的記憶體就不夠了，重新分配後的記憶體：

memmove(array()->lists + addedCount, array()->lists, 
                    oldCount * sizeof(array()->lists[0]));

memmove這個函式是把第二個位置的物件移動到第一個位置。這裡也就是把這個類本來的方法串列移動到第三個位置。

memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));

memcpy這個函式是把第二個位置的物件複製到第一個位置，也就是把addedLists複製到第一個位置，複製之後的記憶體應該是這樣的：

至此就把分類中的方法串列合併到了類的方法串列中。

透過上面的合併過程我們也明白了，當分類和類中有同樣的方法時，類中的方法並沒有被改寫，只是分類的方法被放在了類的方法前面，導致先找到了分類的方法，所以分類的方法就被執行了。

四總結

1.透過runtime載入某個類的所有Category資料。
2.把所有Category的方法，屬性，協議資料合併到一個大陣列中，後面參與斌編譯的Category資料，會在陣列的前面。
3.將合併後的分類資料(方法，屬性，協議)，插入到類原來資料的前面。

●編號276，輸入編號直達本文

●輸入m獲取文章目錄

推薦↓↓↓

Web開發

更多推薦《18個技術類微信公眾號》

涵蓋：程式人生、演演算法與資料結構、駭客技術與網路安全、大資料技術、前端開發、Java、Python、Web開發、安卓開發、iOS開發、C/C++、.NET、Linux、資料庫、運維等。

雪山飛狐_91ae

贊賞

長按二維碼向我轉賬

受蘋果公司新規定影響，微信 iOS 版的贊賞功能被關閉，可透過二維碼轉賬支援公眾號。

閱讀原文

微信掃一掃
使用小程式

即將開啟”“小程式

取消
 開啟

Category的本質<一>

一寫在開頭

二底層結構

三利用runtime進行合併

四總結

相關推薦

熱門標籤

熱門文章

分享創造快樂

一 寫在開頭

二 底層結構

三 利用runtime進行合併

四 總結

相關推薦

熱門標籤

熱門文章

分享創造快樂

一寫在開頭

二底層結構

三利用runtime進行合併

四總結