前言
关于Category的详细介绍推荐阅读深入理解Objective-C：Category，这篇文章是我个人感觉对Category的解释说的最清楚的一篇。以下关于源码部分的解读都是参考自这篇文章，只是这篇文章比较老了，里面的源码部分苹果也做了更新，所以个人做了一点稍微的修改和整理。但我个人感觉已经没有什么好多说的了，下面也只是做为个人笔记的一个整理，不推荐阅读。
介绍
Category其实是OC里面一个很重要的特性，几乎在我们日常的开发中随处可见。它可以扩展我们已有类的方法，我们在开发中最常用的就是扩展一些系统类的方法。比如这里有一份我早几年收集的一些Category：DSCategories，都是一些对系统类的扩展，当然这个库我早已没维护了，这里只是拿出来做一个简单的示例。
当然扩展已有类的方法是Category的一个基本应用，它还有一些其他的应用，比如减少单个文件的体积，把不同的功能组织到不同的category中等。
所以如果只是使用Category的话其实很简单，没有什么好说的，很多初学者刚开始应该就是接触的Category，也基本上马上就会使用了。因此我们本篇文章主要讲解一下Category的一些底层原理和问题。
Category的优缺点：
优点：改动小，耦合性小，仅对本category有效，不会影响其他类与原有类的关系。
缺点：分类里的方法跟原有类的方法相同，同一个类的不同分类里面有方法冲突，这些都会发生一些奇怪的问题，互相覆盖之类的。类别里的方法优先级高于原有类的方法。
抛出问题
在开始了解底层之前，我们先抛出几个问题，然后通过底层源码来对这几个问题进行解读。
- Category可以添加属性吗？
- Category是如何附加到主类上面的？
- Category的方法和主类上面的方法同名了会先调用哪个？
Category的结构
我们在Runtime源码地址里下载最新的Runtime源码objc4-723.tar.gz。
然后我们在objc-runtime-new.h文件中看到Category的结构体如下定义：
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;
method_list_t *methodsForMeta(bool isMeta) {
if (isMeta) return classMethods;
else return instanceMethods;
}
property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};
- name是指class_name而不是category_name
- cls是要扩展的类对象，编译期间是不会定义的，而是在Runtime阶段通过name对应到对应的类对象
- instanceMethods表示实例方法列表
- classMethods表示类方法列表
- protocols表示实现的所有协议的列表
- instanceProperties表示Category里所有的properties。
给Category添加属性
这里我们回答上面抛出的第一个问题：Category可以添加属性吗？答案是不可以，但是可以利用关联对象来实现属性的功能。
我们先来确定一下什么是属性，属性在Objective-C中是一个重要的概念，我们在声明属性的时候，其实系统默认会帮我们生成getter和setter方法，并生产对应的成员变量(一般为_propertyName)。
我们看上面的结构体能看到Categor里面是包含有属性的列表，所以是可以存储属性的，但是它没有成员变量列表，所以创建的这个属性并没有对应的成员变量。
而且编译器也不会给Category自动生成getter和setter方法。但是结构体中是有实例方法列表的（instanceMethods），所以 getter和setter可以自己写。
那现在如果要实现属性的功能就差一个成员变量了，这里我们可以用关联对象(Associated Objects)来实现成员变量。
Runtime Associate
Runtime Associate其实就算用来Category关联对象用的。它有如下几个对应的方法：
objc_setAssociatedObject
objc_getAssociatedObject
objc_removeAssociatedObjects
OBJC_EXPORT id objc_getAssociatedObject(id object, const void *key)
__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_1);
OBJC_EXPORT void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_1);
我们发现上面这两个方法都需要一个key，这个key其实就是一个唯一常量，用来标识对应的关联对象用的。
我们在Category中添加关联对象使用Key一般有如下几种：
- 第一种：固定地址
static char studentNameKey;
@implementation NSObject (Student)
- (NSString *)name{
return objc_getAssociatedObject(self, &studentNameKey);
}
- (void)setName:(NSString *)name{
objc_setAssociatedObject(self, &studentNameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- 第二种：固定地址
static const void *studentNameKey = &studentNameKey;
@implementation NSObject (Student)
- (NSString *)name{
return objc_getAssociatedObject(self, studentNameKey);
}
- (void)setName:(NSString *)name{
objc_setAssociatedObject(self, studentNameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- 第三种：使用getter的方法名作为key
@implementation NSObject (Student)
- (NSString *)name{
return objc_getAssociatedObject(self, @selector(name));
}
- (void)setName:(NSString *)name{
objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
说完了objc_setAssociatedObject和objc_getAssociatedObject方法，那objc_removeAssociatedObjects又是用来干嘛的呢？其实我们一看名字就知道是用来移除关联对象用的。这个方法一般我们不会直接去使用它，都是系统在对象释放的时候调用的。
那关联对象是什么时候被释放的呢？
我们先来看看对象的销毁流程：
- 调用objc_release
- 因为对象的引用计数为0，所以执行dealloc
- 在dealloc中，调用了_objc_rootDealloc函数
- 在_objc_rootDealloc中，调用了object_dispose函数
- 调用objc_destructInstance
- 最后调用clearDeallocating
在runtime源码的objc-runtime-new.mm文件中我们看到objc_destructInstance的定义如下，可以看到里面有个_object_remove_assocations执行了移除关联对象的操作：
void *objc_destructInstance(id obj)
{
if (obj) {
// Read all of the flags at once for performance.
bool cxx = obj->hasCxxDtor();
bool assoc = !UseGC && obj->hasAssociatedObjects();
bool dealloc = !UseGC;
// This order is important.
if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_assocations(obj);
if (dealloc) obj->clearDeallocating();
}
return obj;
}
个人认为这个关联对象有点像类的weak对象，他们都会有一个专门的hash表来维护，当对象释放的时候，系统通过对应的方法找到hash表并一一清除。
Category如何加载
对于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方法的结尾，有以下的代码片段：
// 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);
}
}
}
}
首先，我们拿到的catlist就是编译器为我们准备的category_t数组，关于是如何加载catlist本身的，我们暂且不表，这和category本身的关系也不大，有兴趣的同学可以去研究以下Apple的二进制格式和load机制。
略去PrintConnecting这个用于log的东西，这段代码很容易理解：
1)、把category的实例方法、协议以及属性添加到类上
2)、把category的类方法和协议添加到类的metaclass上
值得注意的是，在代码中有一小段注释 /* || cat->classProperties */，看来苹果有过给类添加属性的计划啊。
我们接着往里看，category的各种列表是怎么最终添加到类上的，就拿实例方法列表来说吧：
在上述的代码片段里，addUnattachedCategoryForClass把类和category做一个关联映射，remethodizeClass去处理添加Category。
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这里真正的处理Categories的方法、属性、协议到类上面：
// 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);
}
我们这里能看到方法是从cats数组中倒序取出方法添加到方法数组中的，最后得到一个Category所有方法的数组，然后再调用prepareMethodLists函数把得到的Category方法数组插入到类的方法列表前面。
static void
prepareMethodLists(Class cls, method_list_t **addedLists, int addedCount,
bool baseMethods, bool methodsFromBundle)
{
runtimeLock.assertWriting();
if (addedCount == 0) return;
// Don't scan redundantly
bool scanForCustomRR = !cls->hasCustomRR();
bool scanForCustomAWZ = !cls->hasCustomAWZ();
// There exist RR/AWZ special cases for some class's base methods.
// But this code should never need to scan base methods for RR/AWZ:
// default RR/AWZ cannot be set before setInitialized().
// Therefore we need not handle any special cases here.
if (baseMethods) {
assert(!scanForCustomRR && !scanForCustomAWZ);
}
// Add method lists to array.
// Reallocate un-fixed method lists.
// The new methods are PREPENDED to the method list array.
for (int i = 0; i < addedCount; i++) {
method_list_t *mlist = addedLists[i];
assert(mlist);
// Fixup selectors if necessary
if (!mlist->isFixedUp()) {
fixupMethodList(mlist, methodsFromBundle, true/*sort*/);
}
// Scan for method implementations tracked by the class's flags
if (scanForCustomRR && methodListImplementsRR(mlist)) {
cls->setHasCustomRR();
scanForCustomRR = false;
}
if (scanForCustomAWZ && methodListImplementsAWZ(mlist)) {
cls->setHasCustomAWZ();
scanForCustomAWZ = false;
}
}
}
所以最后总结Category和主类方法的执行顺序如下：
编译的时候系统应该是把类对应的所有
category方法都找到并前序添加到method list中，也就是说后编译的category的方法在method list的最前面。比如先编译的category1的方法列表为d，后编译的方法列表为c。那么插入之后的方法列表将会是c，d。最后把这个分类的
method list前序添加到类的method list中,如果原来类的方法列表是a，b，Category的方法列表是c，d。那么插入之后的方法列表将会是c，d，a，b。所有说覆盖方法的优先级是：后编译的Category的方法>先编译的Category方法>类的方法。注意：+(void)load;方法的执行顺序是先类，然后是先编译的
Category，最后是后编译的Category。
示例
@implementation Person
- (void)myName{
NSLog(@"person");
}
@end
#import "Person+Chinese.h"
@implementation Person (Chinese)
- (void)myName{
NSLog(@"person chinese");
}
@end
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
Class currentClass = [Person class];
Person *my = [[Person alloc] init];
if (currentClass) {
unsigned int methodCount;
Method *methodList = class_copyMethodList([Person class], &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];
lastImp = method_getImplementation(method);
lastSel = method_getName(method);
typedef void (*fn)(id,SEL);
fn f = (fn)lastImp;
f(my,lastSel);
NSLog(@"%@ %p %p",methodName, lastSel ,lastImp);
}
free(methodList);
}
return YES;
}
输出结果（可以看到分类的方法先执行）：
2018-09-14 21:01:10.992143+0800 test[81215:5981234] person chinese
2018-09-14 21:01:10.992302+0800 test[81215:5981234] myName 0x10d7b0a34 0x10d7b0460
2018-09-14 21:01:10.992732+0800 test[81215:5981234] person
2018-09-14 21:01:10.992986+0800 test[81215:5981234] myName 0x10d7b0a34 0x10d7b0520
参考
深入理解Objective-C：Category
objc - Category中调回主类的同名原方法