MJiOS底層筆記--Cateogry

本文屬筆記性質，主要針對本身理解不太透徹的地方進行記錄。

推薦系統直接學習小碼哥iOS底層原理班---MJ老師的課確實不錯，強推一波。

---

伸手黨乾貨

Category的加載處理過程

經過Runtime加載某個類的全部Category數據

把全部Category的方法、屬性、協議數據，合併到一個大數組中 後面參與編譯的Category數據，會在數組的前面

將合併後的分類數據（方法、屬性、協議），插入到類原來數據的前面

---

編譯階段

編譯階段，分類文件內的信息會被編譯成一個個結構體

_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; //屬性列表
};
複製代碼

對於一個具體的分類MJPerson+Test

將會依次對應的傳入參數並生成一個_category_t類型的結構體對象_OBJC_$_CATEGORY_MJPerson_$_Test

static struct _category_t _OBJC_$_CATEGORY_MJPerson_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
    //主類名
	"MJPerson", 
	0, // &OBJC_CLASS_$_MJPerson,
	//對象方法列表
	(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_MJPerson_$_Test,
	//類方法列表
	(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_MJPerson_$_Test,
	//協議列表--未實現
	0,
	//屬性列表--未實現
	0,
};
複製代碼

---

運行階段

運行階段，以前編譯好的分類結構體會被追加進主類/元類對象中。

加載類

在加載每個類時會調用此方法，將其分類也提取出來進行下一步處理

/***********************************************************************
* remethodizeClass
* Attach outstanding categories to an existing class.
* Fixes up cls's method list, protocol list, and property list. * Updates method caches for cls and its subclasses. * Locking: runtimeLock must be held by the caller **********************************************************************/ 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); } } 複製代碼

讀取分類信息

按照加載順序逆序的方式，將每一個分類的(方法，屬性，協議)信息分別添加到單獨的二維數組內備用。

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;
        // i--，後加載的分類會被放在前面。也就是"覆蓋"效果
        while (i--) {
        
        //取出單個分類
        auto& entry = cats->list[i];
        
        //取出分類中的方法
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            
            //將信息添加進二維數組
            //mlists[0] = cat0.mlist ,mlists[1] = cat1.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;
        }
    }
    
    // class_rw_t 結構體(存放類中的可讀寫信息)
    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);
}
複製代碼

將分類(單個)信息列表，附加給主類

對類本來的信息列表進行擴容

將本來的信息放到列表末尾

將分類的信息附加到列表前端

/**
 將分類(單個)信息列表，附加給主類

 @param addedLists mlists[0] = cat0.mlist ,mlists[1] = cat1.mlist
 @param addedCount mlists.count
 */
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;
        
        //將原有的方法列表array = [原方法列表] 從新分配內存
        //變成 array = [原方法列表,0,0,0];
        setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
        array()->count = newCount;
        
        //內存移動
        //array = [原方法列表,0,0,0];
        //變成array = [0,0,0,原方法列表];
        memmove(array()->lists + addedCount, array()->lists, 
                oldCount * sizeof(array()->lists[0]));
        
        //數組copy
        //array = [0,0,0,原方法列表];
        //變成array = [分類1方法列表,分類2方法列表,分類3方法列表,原方法列表];
        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]));
    }
}
複製代碼

---

類方法列表實際上是一個二維數組

綜上所述吧，看一遍上面的就懂了。

長這個樣子，因此纔會覆蓋本來的方法。

methodlist = [加載的第3個分類的方法列表,加載的第2個分類的方法列表,加載的第1個分類的方法列表,原方法列表];

---

後加載的分類，方法會被調用

cats是按照加載順序的，i--就會將其逆序

while (i--) {
        
        //取出單個分類
        auto& entry = cats->list[i]
}
複製代碼

---

Cateogry 與 Extension

Class Extension在編譯的時候，它的數據就已經包含在類信息中

Category是在運行時，纔會將數據合併到類信息中

---

關聯對象

由一個manager(AssociationsManager)經過二維map(AssociationsHashMap)統一管理

實現原理

1. AssociationsHashMap以object做爲key，另外一個map(ObjectAssociationMap)做爲value。
2. ObjectAssociationMap以key做爲key，具體的value和policy做爲value。

因此實際上objc_setAssociatedObject關聯對象並不會改變類的狀態以及實例的分佈。

參數

void objc_setAssociatedObject(id object, const void * key,
                              id value, 
			     objc_AssociationPolicy policy)
複製代碼

key要求爲指針，內部會使用其地址進行操做。