1.category 是什么？
首先，新建一个NcFood类，并添加两个分类
#import <Foundation/Foundation.h>
@interface NcFood : NSObject
- (void)color;
@end
@interface NcFood (Apple)
@property(nonatomic,strong)NSString *name;
@end
@interface NcFood (Mango)
@property(nonatomic,strong)NSString *name;
@property(nonatomic,assign)int amount;
@end
#import "NcFood.h"
@implementation NcFood
- (void)color {
NSLog(@"color");
}
@end
@implementation NcFood (Apple)
- (void)color {
NSLog(@"pink");
}
@end
@implementation NcFood (Mango)
- (void)color {
NSLog(@"golden yellow");
}
@end
用Clang编译成c++文件
终端输入：
clang -rewrite-objc Ncfood.m
忽略不用的信息，先查看编译后的category的结构
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;
};
再看编译后的分类Apple与Mango
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_NcFood_$_Apple __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"color", "v16@0:8", (void *)_I_NcFood_Apple_color}}
};
// 属性列表
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_NcFood_$_Apple __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
1,
{{"name","T@\"NSString\",&,N"}}
};
// 分类结构体
static struct _category_t _OBJC_$_CATEGORY_NcFood_$_Apple __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"NcFood",
0, // &OBJC_CLASS_$_NcFood,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_NcFood_$_Apple,
0,
0,
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_NcFood_$_Apple,
};
// 此处将_NcFood类的地址赋给Apple分类结构体中的cls
static void OBJC_CATEGORY_SETUP_$_NcFood_$_Apple(void ) {
_OBJC_$_CATEGORY_NcFood_$_Apple.cls = &OBJC_CLASS_$_NcFood;
}
Mango：
// 实例方法列表
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_NcFood_$_Mango __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"color", "v16@0:8", (void *)_I_NcFood_Mango_color}}
};
// 属性列表
static struct /*_prop_list_t*/ {
unsigned int entsize; // sizeof(struct _prop_t)
unsigned int count_of_properties;
struct _prop_t prop_list[2];
} _OBJC_$_PROP_LIST_NcFood_$_Mango __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
2,
{{"name","T@\"NSString\",&,N"},
{"amount","Ti,N"}}
};
// 分类结构体
static struct _category_t _OBJC_$_CATEGORY_NcFood_$_Mango __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"NcFood",
0, // &OBJC_CLASS_$_NcFood,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_NcFood_$_Mango,
0,
0,
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_NcFood_$_Mango,
};
// 此处将_NcFood类的地址赋给Mango分类结构体中的cls
static void OBJC_CATEGORY_SETUP_$_NcFood_$_Mango(void ) {
_OBJC_$_CATEGORY_NcFood_$_Mango.cls = &OBJC_CLASS_$_NcFood;
}
另外还有一点需要关注的
static struct _category_t *L_OBJC_LABEL_CATEGORY_$ [2] __attribute__((used, section ("__DATA, __objc_catlist,regular,no_dead_strip")))= {
&_OBJC_$_CATEGORY_NcFood_$_Apple,
&_OBJC_$_CATEGORY_NcFood_$_Mango,
};
所有的分类都会被保存在这个表里，在程序启动运行的时候会遍历这个列表，将其中的category与它所属的类关联。
编译后的category就是这个样子了
关于category的属性
以上两个分类（Apple与Mango）都有自己的属性，但在实例方法列表中并没有看到相应的set与get方法，分类的结构体中也没有用来存储成员变量的地方，所以分类中的属性没有实现set与get方法，也没有自动生成成员变量。
用点语法访问分类的属性会导致程序崩溃。（点语法本质就是调用set、get方法）
NcFood *food = [[NcFood alloc] init];
NSLog(@"---%@",food.name); // 此处崩溃
2018-11-20 17:10:45.419760+0800 Nunca[39382:6373286] -[NcFood name]: unrecognized selector sent to instance 0x600000008860
2. category的加载
category的加载发生在程序启动后调用的map_images函数中（objc-runtime-new.mm类中）
在map_images里面，在加载category之前还会先加载好Class、_Protocol。
以下是其中加载分类的代码
// Discover categories.
for (EACH_HEADER) {
//取出编译时生成的一个包含程序中所有category的list
category_t **catlist =
_getObjc2CategoryList(hi, &count);
bool hasClassProperties = hi->info()->hasCategoryClassProperties();
for (i = 0; i < count; i++) { // 遍历每一个category
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)
{
// 在此方法中将分类存到类对应的其分类的list（类与类的分类可能是一对多的）
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);
}
}
}
}
主要需要关注两个方法
addUnattachedCategoryForClass ：将新遍历到的category添加至还未与类进行关联的对应的category_list
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
//cats是一个以cls为key、以category_list为value的map
NXMapTable *cats = unattachedCategories();
category_list *list;
// 根据cls获取还未进行关联的分类列表
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);
}
remethodizeClass ：将分类中的各种方法整合至类的方法列表
static void remethodizeClass(Class cls)
{
category_list *cats;
bool isMeta;
runtimeLock.assertWriting();
isMeta = cls->isMetaClass();
// Re-methodizing: check for more categories
// unattachedCategoriesForClass里面会返回类对应的分类列表，并将其从map中移除
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);
}
}
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--) {
// 倒序遍历，编译越后的category，在list中越靠前
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，下面摘录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]));
}
}
关于分类的调用顺序
可以看到，新添加的分类的方法会在类的方法的最前部。
越后编译的分类的方法在类的方法列表中位置越靠前，因此，如果一个类与它的分类中存在相同的方法，在调用此方法时，会从它的类的方法列表去查找，最后被编译的在列表的最前面，因此被调用的也是最后被编译的那个分类中的那个方法（即使此分类的头文件未被导入至方法调用的类）。
（编译的顺序往往是我们不太关心确定的，因此最好不要在同一个类的多个分类中写同名的方法）
主要参考：
深入理解Objective-C：Category
