前言
对于干活而言，针对Category的运用，只要知道怎么用，有些需要注意的地方能够注意到（比如，Category里定义的方法与主类相同时，这个方法调用时实际上是Category里的）就可以了。另外，对于一些地方的运用，可以知道如何给Category加属性基本上也就够了。
但实际上，有的时候，还是会碰到有人问你一句Category是怎么实现的。从我个人的理解，其实就是希望你从其实现原理上来回答那几个需要注意的地方，也就是当Category中定义了一个与主类相同的方法时，会调用Category的，而不是主类的。
当然了，也可能会碰到再有人问你如果就要调用主类的呢？
总之，林林总总就是这样的。你能做多少事，跟你能说多少事，这之间的差距就是你资（zhuang）深（bi）的程度了。当然了，如果能从原理的角度上，加深对于Category的认识也是很好的事情，所以，让我们开始资（zhuang）深（bi）吧～
Category的实现
先让我们来看看Category的数据结构
typedef 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;
} category_t;
上面这个就是Category的结构体，我们可以看到，Category从结构上来讲，可以存储实例方法(instanceMethods)、类方法(classMethods)、委托(protocols)以及属性(instanceProperties).
但在这里我们要看到，结构体中虽然有属性，但并没有实例变量（ivar）的存储，这就回答了我们一个问题——为什么Category加属性需要自己使用objc_getAssociatedObject的方式来实现，实际上就是因为category里不能存储实例变量。
比如我们可以在Category中写一个属性，具体如下：
@interface NSObject (IndieBandName)
@property (nonatomic, copy) NSString *indieBandName;
@end
通常来讲，我们这么写是不会有问题的，编译也过得去。但只要你一使用，就会报错：错误的内容大概是告诉你找不到setIndieBandName方法这类的。所以，我们还要实现它的getter,setter方法
- (void)setIndieBandName:(NSString *)indieBandName
{
_indieBandName = [indieBandName copy];
}
写到这里发现问题了吧，_indieBandName这个实例变量在Category中根本就没生成！结合category的结构体也可以理解，因为category_t里，也没地方保存！所以，我们才使用objc_getAssociatedObject来保存对象，用来充当getter／setter方法中负责返回和保存的实例变量。
好了让我们继续下去，我们知道了Category的结构体后，就要看看Category里定义的方法是怎么加载的了。
看过OC对象内存布局的人都知道，OC的类对象和元类对象中有methodList来分别保存实例方法和类方法。那么Category的方法到底是怎么保存在类对象里的呢？这就要从Category的加载聊起。
Category的加载
我们知道，Objective-C的运行是依赖OC的runtime的，而OC的runtime和其他系统库一样，是OS X和iOS通过dyld动态加载的。具体的入口函数大概是这个样子：
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();
lock_init();
exception_init();
// Register for unmap first, in case some +load unmaps something
_dyld_register_func_for_remove_image(&unmap_image);
dyld_register_image_state_change_handler(dyld_image_state_bound,
1/*batch*/, &map_images);
dyld_register_image_state_change_handler(
dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}
写这些东西就是为了说明category被附加到类上面是在map_images的时候发生的，我们截取在_read_images方法的结尾，它大概是这个样子的：
for (EACH_HEADER) {
category_t **catlist =
_getObjc2CategoryList(hi, &count);
for (i = 0; i < count; i++) {
category_t *cat = catlist[i];
class_t *cls = remapClass(cat->cls);
if (!cls) {
// Category's target class is missing (probably weak-linked).
// Disavow any knowledge of this category.
catlist[i] = NULL;
if (PrintConnecting) {
_objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
"missing weak-linked target class",
cat->name, cat);
}
continue;
}
// Process this category.
// First, register the category with its target class.
// Then, rebuild the class's method lists (etc) if
// the class is realized.
BOOL classExists = NO;
if (cat->instanceMethods || cat->protocols
|| cat->instanceProperties)
{
addUnattachedCategoryForClass(cat, cls, hi);
if (isRealized(cls)) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
getName(cls), cat->name,
classExists ? "on existing class" : "");
}
}
if (cat->classMethods || cat->protocols
/* || cat->classProperties */)
{
addUnattachedCategoryForClass(cat, cls->isa, hi);
if (isRealized(cls->isa)) {
remethodizeClass(cls->isa);
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
getName(cls), cat->name);
}
}
}
}
从这个代码中，我们可以看到，首先，系统获取了Category的列表（catlist），之后就开始遍历，遍历时拿到每一个Category(category_t *cat = catlist[i])，同时获取Category所附着的类（class_t *cls = remapClass(cat->cls)）。然后就开始干活了，具体步骤如下：
- 如果cat结构体中，instanceMethods，protocols，instanceProperties三个之中，只要有值，就会通过addUnattachedCategoryForClass(cat,cls,hi)方法，把Category和类先关联起来，但这时还没有针对Category的方法做操作。
- 如果cat结构体中，classMethods，protocols两个当中，只要有值，就睡通过addUnattachedCategoryForClass(cat,cls->isa,hi)方法，将Category和元类对象关联起来。
PS. cls->isa指向的就是元类对象，这块大家应该知道哈～ 另外，我们发现上面与元类对象关联的代码中有一小段注释掉的cat->classProperties。仔细想想，哎呦我靠，看来当初苹果还想弄个类属性出来哈～
至此，我们已经将Category有关实例方法、委托以及实例属性关联到类对象上，而类方法等关联到元类对象上，后面就是要重新构建类对象和元类对象的methodList了。
实际上，真正处理Category中方法的实现，是一个叫做remethodizeClass的静态方法，它大概是长这个样子：
static void remethodizeClass(class_t *cls)
{
category_list *cats;
BOOL isMeta;
rwlock_assert_writing(&runtimeLock);
isMeta = isMetaClass(cls);
// Re-methodizing: check for more categories
if ((cats = unattachedCategoriesForClass(cls))) {
chained_property_list *newproperties;
const protocol_list_t **newprotos;
if (PrintConnecting) {
_objc_inform("CLASS: attaching categories to class '%s' %s",
getName(cls), isMeta ? "(meta)" : "");
}
// Update methods, properties, protocols
BOOL vtableAffected = NO;
attachCategoryMethods(cls, cats, &vtableAffected);
newproperties = buildPropertyList(NULL, cats, isMeta);
if (newproperties) {
newproperties->next = cls->data()->properties;
cls->data()->properties = newproperties;
}
newprotos = buildProtocolList(cats, NULL, cls->data()->protocols);
if (cls->data()->protocols && cls->data()->protocols != newprotos) {
_free_internal(cls->data()->protocols);
}
cls->data()->protocols = newprotos;
_free_internal(cats);
// Update method caches and vtables
flushCaches(cls);
if (vtableAffected) flushVtables(cls);
}
}
这段代码中，我们看到声明了新的属性列表(newproperties)和委托列表(newprotos)，之后，又调用了attachCategoryMethods方法，实际上，这个方法就是将指定的类对象中的methodList与Category中methodList进行整合的地方。
不管怎么样，attach后，newproperties和newprotos都获得了新的数据，并把这些数据赋值给了cls。整体的融合也就完成了。
好了，看来attachCategoryMethods方法是其中的核心，让我们来看看它都干了啥
static void
attachCategoryMethods(class_t *cls, category_list *cats,
BOOL *inoutVtablesAffected)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
BOOL isMeta = isMetaClass(cls);
method_list_t **mlists = (method_list_t **)
_malloc_internal(cats->count * sizeof(*mlists));
// Count backwards through cats to get newest categories first
int mcount = 0;
int i = cats->count;
BOOL fromBundle = NO;
while (i--) {
method_list_t *mlist = cat_method_list(cats->list[i].cat, isMeta);
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= cats->list[i].fromBundle;
}
}
attachMethodLists(cls, mlists, mcount, NO, fromBundle, inoutVtablesAffected);
_free_internal(mlists);
}
这段代码主要的目的就是把所有的Category都拿出来遍历一次，然后用新的方法列表mlists来填装，填装完成后，就把它连同类对象扔给了attachMethodLists方法了。
好吧，我们需要看一下attachMethodLists又都干了啥...... GFY
for (uint32_t m = 0;
(scanForCustomRR || scanForCustomAWZ) && m < mlist->count;
m++)
{
SEL sel = method_list_nth(mlist, m)->name;
if (scanForCustomRR && isRRSelector(sel)) {
cls->setHasCustomRR();
scanForCustomRR = false;
}
else if (scanForCustomAWZ && isAWZSelector(sel)) {
cls->setHasCustomAWZ();
scanForCustomAWZ = false;
}
}
// Fill method list array
newLists[newCount++] = mlist;
.
.
.
// Copy old methods to the method list array
for (i = 0; i < oldCount; i++) {
newLists[newCount++] = oldLists[i];
}
整体来说，就是又有了一个新的数组，这数组首先是把所有的Category的方法都保存了下来，之后，又把所谓的老方法列表追加到了数组中，这里的oldList实际上就是你类对象中原有的方法列表。换句话说，在重组的新方法列表中，Category方法都是排在前面的，而来方法都追加到了后面，这时，如果发生Category和主类中都有相同的方法，那么Category的方法在前面而主类的方法在后面。
到这里，我们又能明确一件事情了，那就是为什么当Category和主类拥有相同方法时，实际被执行的是Category的方法。因为它在最前面嘛！ 同时，我们也能够发现，主类的方法并没有被覆盖，而只是排在了后面。因此，如果我们想的话，只需要获取当前对象的方法列表，倒序找到第一个或者正向找到最后一个同名方法，那就是主类的方法了。
多个Category重名方法调用
紧接着问题又来了，如果一个类上有多个Category，且都有相同的重名方法呢？
首先，根据上面的分析，肯定还是不会有主类方法什么事儿了。另外，也不可能两个Category里的重名方法都被执行，剩下的就是Category1和Category2两个里面谁会被执行了。
如果做实验你会发现，其顺序与CompileSources里的文件顺序直接相关，假设两个Category分别为C1和C2。那么在CompileSources里的顺序也是C1在前C2在后，其最终被执行的实际上是C2中的方法，如果反过来，C2在前，C1在后，那么执行的就是C1了。
现在我们知道了，其执行顺序是文件加载的倒序顺序哈。但这是否有根据呢？实际上，我们前面有一段代码，如果仔细看看，就会发现端倪。代码段如下：
static void
attachCategoryMethods(class_t *cls, category_list *cats,
BOOL *inoutVtablesAffected)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
BOOL isMeta = isMetaClass(cls);
method_list_t **mlists = (method_list_t **)
_malloc_internal(cats->count * sizeof(*mlists));
// Count backwards through cats to get newest categories first
int mcount = 0;
int i = cats->count;
BOOL fromBundle = NO;
while (i--) {
method_list_t *mlist = cat_method_list(cats->list[i].cat, isMeta);
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= cats->list[i].fromBundle;
}
}
attachMethodLists(cls, mlists, mcount, NO, fromBundle, inoutVtablesAffected);
_free_internal(mlists);
}
请注意，这段代码中间while循环是倒序的，而不是从i=0开始的。实际的情况我们就可以假设一下。实际在编译时，肯定是按照CompileSources的顺序读取文件的。因此attachCategoryMethods中的cats数组内，其顺序也是C1在前C2在后（假定这就是CompileSources的顺序），但由于i是降序开始的，因此，首先被加载到mlists方法列表里的实际上就是C2了。所以才会有实验中的结果，即执行的方法是多个Category在CompileSources中排列最后的那个文件。
＋load方法
现在，我们知道了Category中的方法发生重名时，并不是覆盖关系，且Category的方法先于主类的方法被执行。那么+load方法呢？如果主类和Category中都写了+load方法会怎样？
通过模拟这种情况，我们就会发现实际上的顺序。这里就直接说结论了：先执行主类的+load方法，之后再执行category的+load方法。这两个方法都可以被执行到。另外，如果你在主类里用了category的方法也没有问题，因为category的加载是先于+load方法执行之前就完成的。
调用主类方法
前面提到了，如果主类与Category有同名方法时，被调用的是Category的方法，但如果我们就是想调用主类的方法呢？当然是有办法的，毕竟我们从前面的结论中得知，Category并不是覆盖同名方法，只是排的比较靠前而已。因此，我们还是可以通过获取方法列表，并找到最后一个同名方法就可以执行了。（当然，我想说，你TM别重名不是更好.....）
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);
}
AssociatedObject的存储
前面已经说过，由于Category中不能存有成员变量，因此，我们就需要使用AssociatedObject来存储变量，用来充当成员变量。但AssociatedObject里保存的变量到底在什么地方？我们后面就直接说结论吧，就不粘源代码了
AssociatedObject中的变量实际上是在一个全局的AssociationsHashMap中管理的，这相当于把所有对象的关联对象都存在一个全局map里面。而map的的key是这个对象的指针地址（任意两个不同对象的指针地址一定是不同的），而这个map的value又是另外一个AssociationsHashMap，里面保存了关联对象的kv对。
当一个对象销毁时，系统会调用如下代码：
void *objc_destructInstance(id obj)
{
if (obj) {
Class isa_gen = _object_getClass(obj);
class_t *isa = newcls(isa_gen);
// Read all of the flags at once for performance.
bool cxx = hasCxxStructors(isa);
bool assoc = !UseGC && _class_instancesHaveAssociatedObjects(isa_gen);
// This order is important.
if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_assocations(obj);
if (!UseGC) objc_clear_deallocating(obj);
}
return obj;
}
在这个方法中，可以看到assoc变量是标识，这个对象是否存在关联对象，如果是的话，就会调用_object_remove_assocations(obj)方法，将指定的obj的关联对象全部干掉。
总结
上面说了那么多，实际上也就结合一些源码，总结和加强记忆一下东西
- Categroy的实现，运行时先把Category中的方法遍历出来，形成一个新的方法数组，之后再将主类上原有的方法追加上去，从而变成Category方法在前，主类方法在后的一个新的methodList。
- 在主类和Category中，同名方法可以同时存在，且不不是覆盖关系。运行时，当调用到同名方法，被调用的是在方法列表中排在前面的Category方法。
- Category中，同名方法不是覆盖关系，因此还是可以想办法调用主类方法的。其途径就是获取当前对象的方法列表，从列表中找出最后一个同名方法，就是主类的方法。
- 在主类的+load方法中可以调用Category的方法，因为Category的加载是在load方法之前就完成的。对于主类和Category中都有+load的方法的时候，顺序是先主类后Category。
- associatedObject保存变量是保存在一个全局的HashMap中，对象的地址是Key，value是另一个HashMap，这个HashMap里保存Key-Value对。
