为什么想弄明白category呢？因为以前对category一直停留在表面的用法和作用，直到我知道了，category不能添加的是实例变量，可以添加属性。
1.category是个什么鬼？
总的来说，category就是类的扩展，可以在不入侵原类代码的基础上扩充类的方法和属性。举个例子：
@interface ClassA (Some)
- (void)test2: (NSString *)str;
@end
@implementation ClassA (Some)
- (void)test2: (NSString *)str {
NSLog(@"category_some_%@", NSStringFromSelector(_cmd));
}
@end
2.category相比于inherit(继承)的优缺点？
优点：
1.category可以修改原类的基础上扩展类的方法，可以实现私有类的 方法扩展以及一些不能修改源码类的扩展，也就是说不会入侵原类的代码结构，比继承更为轻量级。
2.category可以将类的实现分散到多个文件。
3.category可以创建私有方法的前向引用：在类别里提供一个类的私有方法的声明(不需要提供实现)，当实例调用的时候，编译器不会报错，运行时会调用类的私有方法，继承不能继承私有方法的实现。
4.category可以向类添加非正式协议：因为Object-C里面所有类都是NSObject的子类，所以NSObject的类别里定义的函数，所有对象都能使用。
缺点：
1.category里面不能添加实例变量。
2.category定义的方法如果和类里面的方法同名，则会覆盖原来类定义的方法。
3.如果一个类有多个category，每个category定义了同一个方法，则类调用的方法是哪个category的是不确定的。
3.category不能添加实例变量，但是可以添加属性
我们来看一下经典的UIView+Addition：
@interface UIView (Addition)
@property (nonatomic) CGFloat left;
@property (nonatomic) CGFloat top;
@end
@implementation UIView (Addition)
- (CGFloat)left {
return self.frame.origin.x;
}
- (void)setLeft:(CGFloat)x {
CGRect frame = self.frame;
frame.origin.x = x;
self.frame = frame;
}
- (CGFloat)top {
return self.frame.origin.y;
}
- (void)setTop:(CGFloat)y {
CGRect frame = self.frame;
frame.origin.y = y;
self.frame = frame;
}
@end
上面新定义了left和top属性，并实现了它们的getter和setter方法，所以可以使用点语法调用，并且，getter和setter方法里面并没有使用实例变量，很巧妙地使用元类有的属性类作为参考，进行一系列的运算。但是，如果我想在category里添加新的属性，并且和原来类的属性，实例变量没有关系，怎么办？别急，Object-C是动态语言，我们可以利用runtime机制为在category为原类添加属性变量，如下：
@interface ClassA (Addition)
@property (nonatomic, strong) NSString *name;
@end
@implementation ClassA (Addition)
- (NSString *)studentNumber {
return objc_getAssociatedObject(self, @selector(studentNumber));
}
- (void)setStudentNumber:(NSString *)studentNumber {
objc_setAssociatedObject(self, @selector(studentNumber), studentNumber, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
@end
设置关联属性的key，必须保证key是不可变的，唯一的和并且只在当前的类使用，我们可以使用static char key或者static void *key等等，但是更好的是使用getter的selector，因为SEL保证是不可变和唯一的。这只是添加属性，并没有为该属性添加对应的实例变量。
3.category为什么不能添加实例变量？
在这之前我们看来了解一些基础知识：
我们先看一段代码：
@interface ClassA (Some)
@end
@implementation ClassA (Some)
@end
反编译成C++文件，如下：
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;
};
我们可以看到category的结构体里就没有包括实例变量列表ivars，所以，category不能添加实例变量。runtime有一个可以动态添加实例变量的方法，class_addIvar()，文档明确提到：
This function may only be called after objc_allocateClassPair and before objc_registerClassPair.
Adding an instance variable to an existing class is not supported.
添加成员变量必须在class分配内存还没有注册的时候添加，因为这时候类的内存大小还没有最终定下来，在runtime注册这个类之前还是可以改变的，一旦类已经注册，那么类所占内存大小就不能改变，也就不能再添加实例变量，因为实例变量会改变类的内存结构，比如说，classA和classB分配的内存是挨在一起的，如果classA的内存变大了，势必会影响classB，所以类一旦定下来了就不能添加成员变量，可以添加方法和属性，因为方法和属性并不会影响类的内存结构，仅需要保存一个指针。
4.category实现的原理
runtime的源码可以直接在苹果官网上下载，这里看的是最新版objc4-709，在objc-runtime-new.mm先找到_read_images函数：
//这里只贴出加载category的源代码
void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses) {
...
// Discover categories.
for (EACH_HEADER) {
category_t **catlist =
_getObjc2CategoryList(hi, &count);
bool hasClassProperties = hi->info()->hasCategoryClassProperties();
for (i = 0; i < count; i++) {
category_t *cat = catlist[i];
Class cls = remapClass(cat->cls);
if (!cls) {
// Category's target class is missing (probably weak-linked).
// Disavow any knowledge of this category.
catlist[i] = nil;
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 (cls->isRealized()) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
cls->nameForLogging(), cat->name,
classExists ? "on existing class" : "");
}
}
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
cls->nameForLogging(), cat->name);
}
}
}
}
...
}
上面代码提到了比较重要的函数有两个：
1. addUnattachedCategoryForClass()
2. remethodizeClass()
- addUnattachedCategoryForClass作用
/***********************************************************************
* addUnattachedCategoryForClass
* Records an unattached category.
* Locking: runtimeLock must be held by the caller.
**********************************************************************/
static void addUnattachedCategoryForClass(category_t *cat, Class cls,
header_info *catHeader)
{
runtimeLock.assertWriting();
// DO NOT use cat->cls! cls may be cat->cls->isa instead
NXMapTable *cats = unattachedCategories();
category_list *list;
list = (category_list *)NXMapGet(cats, cls);
if (!list) {
list = (category_list *)
calloc(sizeof(*list) + sizeof(list->list[0]), 1);
} else {
list = (category_list *)
realloc(list, sizeof(*list) + sizeof(list->list[0]) * (list->count + 1));
}
list->list[list->count++] = (locstamped_category_t){cat, catHeader};
NXMapInsert(cats, cls, list);
}
addUnattachedCategoryForClass()主要是构建class和category的哈希表，如果不存在则生成，如果存在则重新构建，主要是class到category的一个映射关系。
- remethodizeClass作用
/***********************************************************************
* 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);
}
}
// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order,
// oldest categories first.
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);
}
remethodizeClass调用了attachCategories方法，这个方法里面把category里的方法，属性和协议列表都添加到相应的类里面，从本质来说，调用类的方法和分类的方法都是一样的。
结合上面亮点，加载category的时候做了两件事：
1.构建类(元类)与category的哈希表。
2.将category的实例方法，属性和协议添加到类里面，而类方法，类属性和协议添加到元类里面。
为什么category方法可以覆盖原类的方法？而同为category方法的调用顺序却是不确定的？
在attachCategories方法里，我们可以看到，最后调用了attachLists方法，把category里面的方法，属性和协议添加到原类相应的列表里，那么我们看一下attachLists这个函数的实现：
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]));
}
}
第一个条件语句里，使用了memmove(des, src, size)和memcpy(des, src, size)这两个C函数，memmove函数将array() -> lists中长度为oldCount * sizeof(array() -> lists[0])移动到array() -> lists + addedCount，然后通过memcpy函数将addedLists中长度为addedCount * sizeof(array() -> lists[0])复制到array() -> lists里，简单点来说就是，先把旧的函数数组移动到后面，然后将新的函数数组添加到旧的函数数组位置。第二个条件语句里，如果list没有值，那么直接将新增的addedLists赋值给list。第三个条件语句里，将新的addedLists添加在list前面，然后将旧的list往后移。综上所述，category里新增的函数都是被添加在原类函数列表的前面，也就是说，其实并不是覆盖，只是category的函数会先被调用，如果想要调用原类的函数，只需要遍历整个函数列表，然后调用最后面的函数实现就行。
category里面的同名方法调用顺序和category加载顺序有关，在_read_images函数里，所有的category都存在catlist里，而catlist和header_info有关，header_info是加载头文件的信息，也就是说，category加载顺序靠前的，调用通名方法时就是先被调到。
总结
category是一项很强大技术，可以把一个庞大的类分成若干个文件，方便管理，并且不需要知道原类的实现。但是注意不要轻易覆写原类的方法，这会覆盖原类的方法。
参考：
iOS Category中添加属性和成员变量的区别
Objective-C Category 的实现原理
Overriding methods using categories in Objective-C
Guides and Sample Code
Associated Objects
Objective-C Associated Objects
深入理解Objective-C：Category
Objective-C类成员变量深度剖析
