問題
- Category的實現原理，以及Category為什么只能加方法不能加屬性。
- Category中有load方法嗎？load方法是什么時候調用的？load 方法能繼承嗎？
- load、initialize的區別，以及它們在category重寫的時候的調用的次序。
- Catagory_t存儲的方法，屬性，協議等是如何加載到類對象中的？
1、Category簡介
category是Objective-C 2.0之后添加的語言特性，category的主要作用是為已經存在的類添加方法。除此之外，apple還推薦了category的另外兩個使用場景
- 可以把類的實現分開在幾個不同的文件里面。這樣做有幾個顯而易見的好處，
a)可以減少單個文件的體積
b)可以把不同的功能組織到不同的category里
c)可以由多個開發者共同完成一個類
d)可以按需加載想要的category 等等。 - 聲明私有方法
不過除了apple推薦的使用場景，廣大開發者腦洞大開，還衍生出了category的其他幾個使用場景：
- 模擬多繼承
- 把framework的私有方法公開
Objective-C的這個語言特性對于純動態語言來說可能不算什么，比如javascript，你可以隨時為一個“類”或者對象添加任意方法和實例變量。但是對于不是那么“動態”的語言而言，這確實是一個了不起的特性。
2、連類比事-category和extension
extension看起來很像一個匿名的category，但是extension和有名字的category幾乎完全是兩個東西。 extension在編譯期決議，它就是類的一部分，在編譯期和頭文件里的@interface以及實現文件里的@implement一起形成一個完整的類，它伴隨類的產生而產生，亦隨之一起消亡。extension一般用來隱藏類的私有信息，你必須有一個類的源碼才能為一個類添加extension，所以你無法為系統的類比如NSString添加extension。（詳見2）
但是category則完全不一樣，它是在運行期決議的。 就category和extension的區別來看，我們可以推導出一個明顯的事實，extension可以添加實例變量，而category是無法添加實例變量的（因為在運行期，對象的內存布局已經確定，如果添加實例變量就會破壞類的內部布局，這對編譯型語言來說是災難性的）。
3、挑燈細覽-category真面目
我們知道，所有的OC類和對象，在runtime層都是用struct表示的，category也不例外，在runtime層，category用結構體category_t（在objc-runtime-new.h中可以找到此定義），iOS上關于Runtime的源碼其實就是objc4，我們在objc4源碼上能看到最新版本為objc-750，它包含了：
- 1)、類的名字（name）
- 2)、類（cls）
- 3)、category中所有給類添加的實例方法的列表（instanceMethods）
- 4)、category中所有添加的類方法的列表（classMethods）
- 5)、category實現的所有協議的列表（protocols）
- 6)、category中添加的所有屬性（instanceProperties）
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;
method_list_t *methodsForMeta(bool isMeta) {
if (isMeta) return classMethods;
else return instanceMethods;
}
property_list_t *propertiesForMeta(bool isMeta) {
if (isMeta) return nil; // classProperties;
else return instanceProperties;
}
};
從category的定義也可以看出category的可為（可以添加實例方法，類方法，甚至可以實現協議，添加屬性）和不可為（無法添加實例變量）。
我們先去寫一個category看一下category到底為何物：
MyClass.h：
#import <Foundation/Foundation.h>
@interface MyClass : NSObject
- (void)printName;
@end
@interface MyClass(MyAddition)
@property(nonatomic, copy) NSString *name;
- (void)printName;
@end
MyClass.m：
#import "MyClass.h"
@implementation MyClass
- (void)printName
{
NSLog(@"%@",@"MyClass");
}
@end
@implementation MyClass(MyAddition)
- (void)printName
{
NSLog(@"%@",@"MyAddition");
}
@end
我們使用clang的命令去看看category到底會變成什么：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc MyClass.m
好吧，我們得到了一個1.6M大小，3w多行的.cpp文件，我們忽略掉所有和我們無關的東西，在文件的最后，我們找到了如下代碼片段
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_MyClass_$_MyAddition __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"printName", "v16@0:8", (void *)_I_MyClass_MyAddition_printName}}
};
static struct /*_prop_list_t*/ {
unsigned int entsize; // sizeof(struct _prop_t)
unsigned int count_of_properties;
struct _prop_t prop_list[1];
} _OBJC_$_PROP_LIST_MyClass_$_MyAddition __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
1,
{{"name","T@\"NSString\",C,N"}}
};
extern "C" __declspec(dllexport) struct _class_t OBJC_CLASS_$_MyClass;
static struct _category_t _OBJC_$_CATEGORY_MyClass_$_MyAddition __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"MyClass",
0, // &OBJC_CLASS_$_MyClass,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_MyClass_$_MyAddition,
0,
0,
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_MyClass_$_MyAddition,
};
static void OBJC_CATEGORY_SETUP_$_MyClass_$_MyAddition(void ) {
_OBJC_$_CATEGORY_MyClass_$_MyAddition.cls = &OBJC_CLASS_$_MyClass;
}
#pragma section(".objc_inithooks$B", long, read, write)
__declspec(allocate(".objc_inithooks$B")) static void *OBJC_CATEGORY_SETUP[] = {
(void *)&OBJC_CATEGORY_SETUP_$_MyClass_$_MyAddition,
};
static struct _class_t *L_OBJC_LABEL_CLASS_$ [1] __attribute__((used, section ("__DATA, __objc_classlist,regular,no_dead_strip")))= {
&OBJC_CLASS_$_MyClass,
};
static struct _class_t *_OBJC_LABEL_NONLAZY_CLASS_$[] = {
&OBJC_CLASS_$_MyClass,
};
static struct _category_t *L_OBJC_LABEL_CATEGORY_$ [1] __attribute__((used, section ("__DATA, __objc_catlist,regular,no_dead_strip")))= {
&_OBJC_$_CATEGORY_MyClass_$_MyAddition,
};
我們可以看到，
1)、首先編譯器生成了實例方法列表OBJC$_CATEGORY_INSTANCE_METHODS_MyClass$_MyAddition和屬性列表OBJC$_PROP_LIST_MyClass$_MyAddition，兩者的命名都遵循了公共前綴+類名+category名字的命名方式，而且實例方法列表里面填充的正是我們在MyAddition這個category里面寫的方法printName，而屬性列表里面填充的也正是我們在MyAddition里添加的name屬性。還有一個需要注意到的事實就是category的名字用來給各種列表以及后面的category結構體本身命名，而且有static來修飾，所以在同一個編譯單元里我們的category名不能重復，否則會出現編譯錯誤。
2)、其次，編譯器生成了category本身OBJC$_CATEGORY_MyClass$_MyAddition，并用前面生成的列表來初始化category本身。
3)、最后，編譯器在DATA段下的objc_catlist section里保存了一個大小為1的category_t的數組L_OBJC_LABELCATEGORY$（當然，如果有多個category，會生成對應長度的數組_），用于運行期category的加載。
到這里，編譯器的工作就接近尾聲了，對于category在運行期怎么加載，我們下節揭曉。
4、追本溯源-category如何加載
我們知道，Objective-C的運行是依賴OC的runtime的，而OC的runtime和其他系統庫一樣，是OS X和iOS通過dyld動態加載的。
想了解更多dyld地同學可以移步這里（3）。
對于OC運行時，入口方法如下（在objc-os.mm文件中）：
void _objc_init(void)
{
static bool initialized = false;
if (initialized) return;
initialized = true;
// fixme defer initialization until an objc-using image is found?
environ_init();
tls_init();
static_init();
lock_init();
exception_init();
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
category被附加到類上面是在map_images的時候發生的，在new-ABI的標準下，_objc_init里面的調用的map_images最終會調用objc-runtime-new.mm里面的_read_images方法，而在_read_images方法的結尾，有以下的代碼片段：
// Realize newly-resolved future classes, in case CF manipulates them
if (resolvedFutureClasses) {
for (i = 0; i < resolvedFutureClassCount; i++) {
realizeClass(resolvedFutureClasses[i]);
resolvedFutureClasses[i]->setInstancesRequireRawIsa(false/*inherited*/);
}
free(resolvedFutureClasses);
}
ts.log("IMAGE TIMES: realize future classes");
進入核心函數 realizeClass
static Class realizeClass(Class cls)
{
runtimeLock.assertLocked();
const class_ro_t *ro;
class_rw_t *rw;
Class supercls;
Class metacls;
bool isMeta;
if (!cls) return nil;
if (cls->isRealized()) return cls;
assert(cls == remapClass(cls));
// fixme verify class is not in an un-dlopened part of the shared cache?
ro = (const class_ro_t *)cls->data(); //?????? class_rw_t 強制轉換為 class_ro_t 指針
if (ro->flags & RO_FUTURE) {
// This was a future class. rw data is already allocated.
rw = cls->data(); //??????如果rw已經分配了內存，則rw指向cls->data()，然后將rw的ro指針指向之前最開始的ro
ro = cls->data()->ro;
cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
} else {
// Normal class. Allocate writeable class data. //??????如果rw還沒有分配內存
rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1); //??????給rw分配內存
rw->ro = ro;
rw->flags = RW_REALIZED|RW_REALIZING;
cls->setData(rw); //??????調整類的data()
}
isMeta = ro->flags & RO_META;
...
...
// Attach categories
methodizeClass(cls); //????????????附加
return cls;
}
在加載 ObjC 運行時的過程中在 realizeClass 方法中：
- 從 class_data_bits_t 調用 data 方法，將結果從 class_rw_t 強制轉換為 class_ro_t 指針
- 初始化一個 class_rw_t 結構體
- 設置結構體 ro 的值以及 flag
- 最后設置正確的 data。
但是，在這段代碼運行之后 class_rw_t 中的方法，屬性以及協議列表均為空。這時需要realizeClass 調用 methodizeClass 方法來將類自己實現的方法（包括分類）、屬性和遵循的協議加載到 methods、 properties 和 protocols 列表中，我們去看下methodizeClass：
static void methodizeClass(Class cls)
{
runtimeLock.assertLocked();
bool isMeta = cls->isMetaClass();
auto rw = cls->data();
auto ro = rw->ro;
// Methodizing for the first time
if (PrintConnecting) {
_objc_inform("CLASS: methodizing class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
// Install methods and properties that the class implements itself.
//????????????rw找到ro取出里面的baseMethods、baseProperties、baseProtocols，
//????????????添加到rw對應的methods、properties、protocols中
method_list_t *list = ro->baseMethods();
if (list) {
prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
rw->methods.attachLists(&list, 1);
}
property_list_t *proplist = ro->baseProperties;
if (proplist) {
rw->properties.attachLists(&proplist, 1);
}
protocol_list_t *protolist = ro->baseProtocols;
if (protolist) {
rw->protocols.attachLists(&protolist, 1);
}
// Attach categories. //????????????取出未添加過的分類內容添加進來
category_list *cats = unattachedCategoriesForClass(cls, true /*realizing*/);
attachCategories(cls, cats, false /*don't flush caches*/);
...
...
}
從上述源碼中可以看出，從rw找到ro取出里面的baseMethods、baseProperties、baseProtocols，添加到rw對應的methods、properties、protocols中。最后取出未添加過的分類內容添加進來。關于怎么將分類方法添加進來的，即 attachCategories 函數的具體實現，
// ????????????獲取到Category的Protocol list、Property list、Method list，
//????????????然后通過attachLists函數添加到所屬的類中
static void
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
//????????????按照Category個數，分配對應的內存空間
// 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;
//???????????? 循環查找出Protocol list、Property list、Method list
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);
}
attachLists 函數的具體實現
上述源代碼中有兩個重要的數組
array()->lists： 類對象原來的方法列表，屬性列表，協議列表。
addedLists：傳入所有分類的方法列表，屬性列表，協議列表。
attachLists函數中最重要的兩個方法為 memmove 內存移動和 memcpy 內存拷貝。
經過memmove和memcpy方法之后，分類的方法，屬性，協議列表被放在了類對象中原本存儲的方法，屬性，協議列表前面。
需要注意的有兩點：
1)、category的方法沒有“完全替換掉”原來類已經有的方法，也就是說如果category和原來類都有methodA，那么category附加完成之后，類的方法列表里會有兩個methodA
2)、category的方法被放到了新方法列表的前面，而原來類的方法被放到了新方法列表的后面，這也就是我們平常所說的category的方法會“覆蓋”掉原來類的同名方法，這是因為運行時在查找方法的時候是順著方法列表的順序查找的，它只要一找到對應名字的方法，就會罷休_，殊不知后面可能還有一樣名字的方法。
5、旁枝末葉-category和+load方法
我們知道，在類和category中都可以有+load方法，那么有兩個問題：
1)、在類的+load方法調用的時候，我們可以調用category中聲明的方法么？
2)、這么些個+load方法，調用順序是咋樣的呢？ 鑒于上述幾節我們看的代碼太多了，對于這兩個問題我們先來看一點直觀的：
我們的代碼里有MyClass和MyClass的兩個category （Category1和Category2），MyClass和兩個category都添加了+load方法，并且Category1和Category2都寫了MyClass的printName方法。 在Xcode中點擊Edit Scheme，添加如下兩個環境變量（可以在執行load方法以及加載category的時候打印log信息，更多的環境變量選項可參見objc-private.h）:
運行項目，我們會看到控制臺打印很多東西出來，我們只找到我們想要的信息，順序如下：
objc[1187]: REPLACED: -[MyClass printName] by category Category1
objc[1187]: REPLACED: -[MyClass printName] by category Category2 . . .
objc[1187]: LOAD: class ‘MyClass’ scheduled for +load
objc[1187]: LOAD: category ‘MyClass(Category1)’ scheduled for +load
objc[1187]: LOAD: category ‘MyClass(Category2)’ scheduled for +load
objc[1187]: LOAD: +[MyClass load] . . .
objc[1187]: LOAD: +[MyClass(Category1) load] . . .
objc[1187]: LOAD: +[MyClass(Category2) load]
所以，對于上面兩個問題，答案是很明顯的：
1)、可以調用，因為附加category到類的工作會先于+load方法的執行
2)、+load的執行順序是先類，后category，而category的+load執行順序是根據編譯順序決定的。 目前的編譯順序是這樣的：
我們調整一個Category1和Category2的編譯順序，run。我們可以看到控制臺的輸出順序變了：
objc[1187]: REPLACED: -[MyClass printName] by category Category2
objc[1187]: REPLACED: -[MyClass printName] by category Category1 . . .
objc[1187]: LOAD: class ‘MyClass’ scheduled for +load
objc[1187]: LOAD: category ‘MyClass(Category2)’ scheduled for +load
objc[1187]: LOAD: category ‘MyClass(Category1)’ scheduled for +load
objc[1187]: LOAD: +[MyClass load] . . .
objc[1187]: LOAD: +[MyClass(Category2) load] . . .
objc[1187]: LOAD: +[MyClass(Category1) load]
雖然對于+load的執行順序是這樣，但是對于“覆蓋”掉的方法，則會先找到最后一個編譯的category里的對應方法。 這一節我們只是用很直觀的方式得到了問題的答案，有興趣的同學可以繼續去研究一下OC的運行時代碼。
問：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調用。
6、觸類旁通-category和方法覆蓋
鑒于上面幾節我們已經把原理都講了，這一節只有一個問題：
怎么調用到原來類中被category覆蓋掉的方法？ 對于這個問題，我們已經知道category其實并不是完全替換掉原來類的同名方法，只是category在方法列表的前面而已，所以我們只要順著方法列表找到最后一個對應名字的方法，就可以調用原來類的方法：
Class currentClass = [MyClass class];
MyClass *my = [[MyClass alloc] init];
if (currentClass) {
unsigned int methodCount;
Method *methodList = class_copyMethodList(currentClass, &methodCount);
IMP lastImp = NULL;
SEL lastSel = NULL;
for (NSInteger i = 0; i < methodCount; i++) {
Method method = methodList[i];
NSString *methodName = [NSString stringWithCString:sel_getName(method_getName(method))
encoding:NSUTF8StringEncoding];
if ([@"printName" isEqualToString:methodName]) {
lastImp = method_getImplementation(method);
lastSel = method_getName(method);
}
}
typedef void (*fn)(id,SEL);
if (lastImp != NULL) {
fn f = (fn)lastImp;
f(my,lastSel);
}
free(methodList);
}
7、更上一層-category和關聯對象
如上所見，我們知道在category里面是無法為category添加實例變量的。但是我們很多時候需要在category中添加和對象關聯的值，這個時候可以求助關聯對象來實現。
但是關聯對象又是存在什么地方呢？ 如何存儲？ 對象銷毀時候如何處理關聯對象呢？
而在對象的銷毀邏輯里面，見objc-runtime-new.mm:
/***********************************************************************
* objc_destructInstance
* Destroys an instance without freeing memory.
* Calls C++ destructors.
* Calls ARC ivar cleanup.
* Removes associative references.
* Returns `obj`. Does nothing if `obj` is nil.
**********************************************************************/
void *objc_destructInstance(id obj)
{
if (obj) {
// Read all of the flags at once for performance.
bool cxx = obj->hasCxxDtor();
bool assoc = obj->hasAssociatedObjects();
// This order is important.
if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_assocations(obj);
obj->clearDeallocating();
}
return obj;
}
嗯，runtime的銷毀對象函數objc_destructInstance里面會判斷這個對象有沒有關聯對象，如果有，會調用_object_remove_assocations做關聯對象的清理工作。
后記
正如侯捷先生所講-“源碼面前，了無秘密”，Apple的Cocoa Touch框架雖然并不開源，但是Objective-C的runtime和Core Foundation卻是完全開放源碼的可以下載到全部的開源代碼
