深入理解Category

1、category简介

category的主要作用是为已经存在的类添加方法。除此之外，apple还推荐了category的另外两个使用场景

可以把类的实现分开在几个不同的文件里面。

减少单个文件的体积
把不同的功能组织到不同的category里
可以由多个开发者共同完成一个类。

声明私有方法

不过除了apple推荐的使用场景，广大开发者脑洞大开，还衍生出了category的其他几个使用场景：

模拟多继承
把framework的私有方法公开

2、category和extension

extension看起来很像一个匿名的category，但是extension和有名字的category几乎完全是两个东西。 extension在编译期决议，它就是类的一部分，在编译期和头文件里的@interface以及实现文件里的@implement一起形成一个完整的类，它伴随类的产生而产生，亦随之一起消亡。extension一般用来隐藏类的私有信息，你必须有一个类的源码才能为一个类添加extension，所以你无法为系统的类比如NSString添加extension。

但是category则完全不一样，它是在运行期决议的。
就category和extension的区别来看，我们可以推导出一个明显的事实，extension可以添加实例变量，而category是无法添加实例变量的（成员变量是存放在实例对象中的，并且编译的那一刻就已经决定好了 . 所以在运行期，对象的内存布局已经确定，如果添加实例变量就会破坏类的内部布局，这对编译型语言来说是灾难性的）。

3、category真面目

我们知道，所有的OC类和对象，在runtime层都是用struct表示的，category也不例外，在runtime层，category用结构体category_t（在objc-runtime-new.h中可以找到此定义），它包含了

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; // 属性列表// Fields below this point are not always present on disk.struct property_list_t *_classProperties; // 类的属性列表// 判断了是否是元类,// 如果是元类返回classMethods类方法列表,非元类,返回instanceMethods对象方法列表method_list_t *methodsForMeta(bool isMeta) {if (isMeta) return classMethods;else return instanceMethods;}property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};

从category的定义也可以看出category的可为（可以添加实例方法，类方法，可以实现协议，添加属性）和不可为（无法添加实例变量）。
ok，我们先去写一个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到底会变成什么：

clang -rewrite-objc MyClass.m

好吧，我们得到了一个3M大小，10w多行的.cpp文件（这绝对是Apple值得吐槽的一点），我们忽略掉所有和我们无关的东西，在文件的最后，我们找到了如下代码片段：

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$_CATEGORYMyClass$_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动态加载的。
对于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();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(images这里代表模块)的时候发生的，在new-ABI的标准下，_objc_init里面的调用的map_images最终会调用objc-runtime-new.mm里面的_read_images方法，而在_read_images方法的结尾，有以下的代码片段：

// Discover categories. 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);}}}}

从上述代码中我们可以知道这段代码是用来查找有没有分类的。通过_getObjc2CategoryList函数获取到分类列表之后(一个主类的分类可能有很多,所以用了一个数组)，进行遍历，获取其中的方法，协议，属性等。

这段代码有2个比较重要的地方：
1)、把category的实例方法、协议以及属性添加到类上 ,
2)、把category的类方法和协议添加到类的metaclass上 ,

值得注意的是，在代码中有一小段注释 / || cat->classProperties /，看来苹果有过给类添加属性的计划啊。
ok，我们接着往里看，category的各种列表是怎么最终添加到类上的，就拿实例方法列表来说吧：
在上述的代码片段里，addUnattachedCategoryForClass只是把类和category做一个关联映射，而remethodizeClass才是真正去处理添加事宜的功臣。

static void remethodizeClass(Class cls)
{category_list *cats;bool isMeta;runtimeLock.assertWriting();isMeta = cls->isMetaClass();// Re-methodizing: check for more categoriesif ((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，如我们一开始写的代码所示，一个类可以有多个分类。之前我们说到分类信息存储在category_t结构体中，那么多个分类则保存在category_list中。

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 allocationsmethod_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 firstint mcount = 0;int propcount = 0;int protocount = 0;int i = cats->count;bool fromBundle = NO;// 这里是倒序遍历category,// 比如load的顺序是类别1,类别2,类别3 , 由于是倒序遍历 , 加入数组后就是 类别3,类别2,类别1 // 这么做 , 保证了后添加的类别方法"覆盖"前面的类别方法 , // 比如类别1,类别2,类别3都有test方法, 类别3最后编译,那么调用test方法就会是类别3的,因为类别3的test方法被最优先查找到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);if (proplist) {proplists[propcount++] = proplist;}protocol_list_t *protolist = entry.cat->protocols;if (protolist) {protolists[protocount++] = protolist;}}// 拿到了主类的原始数据,class_rw_tauto 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);
}

上述源码中可以看出，首先根据方法列表，属性列表，协议列表，malloc分配内存，根据多少个分类以及每一块方法需要多少内存来分配相应的内存地址。之后从分类数组里面往三个数组里面存放分类数组里面存放的分类方法，属性以及协议放入对应mlist、proplists、protolosts数组中，这三个数组放着所有分类的方法，属性和协议。
之后通过类对象的data()方法，拿到类对象的class_rw_t结构体rw，在class结构中我们介绍过，class_rw_t中存放着类对象的方法，属性和协议等数据，rw结构体通过类对象的data方法获取，所以rw里面存放这类对象里面的数据。
之后分别通过rw调用方法列表、属性列表、协议列表的attachList函数，将所有的分类的方法、属性、协议列表数组传进去，我们大致可以猜想到在attachList方法内部将分类和本类相应的对象方法，属性，和协议进行了合并。

我们来看一下attachLists函数内部.

void attachLists(List* const * addedLists, uint32_t addedCount) {if (addedCount == 0) return;if (hasArray()) {// 本来是一个数组,新加入的也是一个数组 -> 新加入的数组 + 旧数组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) {// 本来是空白,新加入一个元素 -> 直接把新加入的元素放到空白位置list = addedLists[0];} else {// 1 list -> many lists// 本来只有一个元素或没有元素,新加入一个数组 ->  新加入数组 + 原来的一个/原来的0List* 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]));}
}

上述源代码中有两个重要的数组
array()->lists：类对象原来的方法列表，属性列表，协议列表。
addedLists：传入的所有分类的方法列表，属性列表，协议列表。

无论是属性,协议,方法,都是category的在前面 .

那么为什么要将分类方法的列表追加到本来的对象方法前面呢，这样做的目的是为了保证分类方法优先调用，我们知道当分类重写本类的方法时，会覆盖本类的方法。
其实经过上面的分析我们知道本质上并不是覆盖，而是优先调用。本类的方法依然在内存中的。运行时在查找方法的时候是顺着方法列表的顺序查找的，它只要一找到对应名字的方法，就会罢休^_^，殊不知后面可能还有一样名字的方法。

看看这两个方法为memmove内存移动和memcpy内存拷贝。用了这样的方法, 就把category中的方法,属性,协议insetAt最开始的位置

// memmove ：内存移动。
/*  __dst : 移动内存的目的地
*   __src : 被移动的内存首地址
*   __len : 被移动的内存长度
*   将__src的内存移动__len块内存到__dst中
*/
void    *memmove(void *__dst, const void *__src, size_t __len);// memcpy ：内存拷贝。
/*  __dst : 拷贝内存的拷贝目的地
*   __src : 被拷贝的内存首地址
*   __n : 被移动的内存长度
*   将__src的内存移动__n块内存到__dst中
*/
void    *memcpy(void *__dst, const void *__src, size_t __n);

5、category和关联对象

category 具体是如何存储关联对象 : https://blog.csdn.net/u014600626/article/details/51435943

总结

Category的实现原理，分类加载过程？

分类的实现原理是将category中的方法，属性，协议数据放在category_t结构体中，然后将结构体内的方法列表拷贝到类对象的方法列表中。

Runtime初始化的时候会加载主类所有分类数据
把分类的方法、协议,属性合并到对应的3个大数组中
后编译的分类数组会在数组前面
合并后分类数据插入主类原来数据的前面

Category为什么只能加方法不能加属性?
Category可以添加属性，但是并不会自动生成成员变量及set/get方法。因为category_t结构体中并不存在成员变量。通过之前对对象的分析我们知道成员变量是存放在实例对象中的，并且编译的那一刻就已经决定好了。而分类是在运行时才去加载的。那么我们就无法再程序运行时将分类的成员变量中添加到实例对象的结构体中。因此分类中不可以添加成员变量。

在类的+load方法调用的时候，我们可以调用category中声明的方法么？

可以调用，因为附加category到类的工作会先于+load方法的执行 ,

具体看 iOS 程序 main 函数之前发生了什么 http://blog.sunnyxx.com/2014/08/30/objc-pre-main/

怎么调用到原来类中被category覆盖掉的方法？

为什么会有这么奇怪的需求??? 对于这个问题，我们已经知道category其实并不是完全替换掉原来类的同名方法，只是category在方法列表的前面而已，所以我们只要倒序查找方法列表找到第一个一个对应名字的方法，就可以调用原来类的方法 . 具体代码不粘贴了,可以看 https://tech.meituan.com/DiveIntoCategory.html

参考了2篇文章:

https://www.jianshu.com/p/fa66c8be42a2
https://tech.meituan.com/DiveIntoCategory.html