Category的本質<二>load，initialize方法
Category的本質<三>關聯對象
一 寫在開頭
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(&map_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_header * const mhdrs[])這個函數非常長，我們直接拉到這個函數最下面，找到_read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);這個函數，點擊進去。 - 6.
void _read_images(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.將合并后的分類數據(方法，屬性，協議)，插入到類原來數據的前面。
Category的本質<二>load，initialize方法
