平时我们应该会比较常用分类，今天我们直接分析Category的本质原理，分析过后应该对于分类的大部分问题都能有一个自信的答案。
Category本质
我们已经OC中类的本质都是结构体，分类也不例外，也是结构体，直接上源码结构
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);
};
这里就是Category的真正结构，我们会发现它只有属性列表，没有成员变量。那么分类他的实现原理是什么呢？我们看下它编译之后的样子。
先创建这样一个分类
//Person+AddCategory.h
@interface Person (AddCategory)<NSCopying>
@property(nonatomic, assign)int age;
- (void)eat;
- (void)run;
+ (void)live;
@end
//Person+AddCategory.m
@implementation Person (AddCategory)
- (void)eat{
NSLog(@"category-eat");
}
- (void)run{
NSLog(@"category-run");
}
+ (void)live{
NSLog(@"category-live");
}
@end
我们通过clang编译一下这个.m文件
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+AddCategory.m
在生产的.cpp文件中，我们可以找到这些代码
和源码中看到类似的结构体，这里只有主要的方法、协议、属性列表等信息
image.png
再向下看_method_list_t类型的结构体，下面={}中的结构和上面的定义结构一致，并且可以在里面看到我们在Category里面实现的对象方法。
image.png
还有一个_method_list_t，这里是类方法
image.png
下面是协议列表：
image.png
然后是属性列表：
image.png
后面是对一个新的_category_t类型的
_OBJC_$_CATEGORY_Person_$_AddCategory结构体赋值，与_category_t结构体结构一致
image.png
最后，编译器在'__DATA'段下的
__objc_catlist section里保存了一个大小为1的category_t的数组L_OBJC_LABEL_CATEGORY$（如果有多个category，会生成对应长度的数组），用于运行期category的加载。后面我们分析Category在运行时的加载。
image.png
Category加载
为了了解清楚分类在runtime到底是怎么加载的，我们直接看runtime源码，runtime初始化入口
image.png
方法调用顺序：进入map_images-->map_images_nolock-->_read_images
在_read_images方法里看到注释有 // Discover categories.
这里代码太长，不好截图（其实就是懒）
// 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);
}
}
}
}
ts.log("IMAGE TIMES: discover categories");
在这段代码中可以看到有获取分类列表catList,然后遍历里面的分类category_t *cat,然后关键位置，对象方法remethodizeClass(cls);类方法remethodizeClass(cls->ISA());
都是remethodizeClass()方法，我们再看这里的实现
image.png
再看attachCategories方法
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--) {//注意这里是倒叙遍历cat
auto& entry = cats->list[i];
//这里是给类中添加分类的对象方法还是元类中添加分类的类方法，都是走这里，我们暂时认为是给类中添加对象方法
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
//把分类中的对象方法列表放到mlists中
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= entry.hi->isBundle();
}
//把分类中的属性列表放到proplist中
property_list_t *proplist =
entry.cat->propertiesForMeta(isMeta, entry.hi);
if (proplist) {
proplists[propcount++] = proplist;
}
//把分类中的协议列表放到protolist中
protocol_list_t *protolist = entry.cat->protocols;
if (protolist) {
protolists[protocount++] = protolist;
}
}
//之前分析类结构的时候的class_rw_t结构体。
auto rw = cls->data();
//把mlists附加到class_rw_t中的methods上，attachLists(mlists, mcount)方法
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
rw->methods.attachLists(mlists, mcount);
free(mlists);
if (flush_caches && mcount > 0) flushCaches(cls);
//把proplists附加到class_rw_t中的properties上，attachLists(proplists, propcount)方法
rw->properties.attachLists(proplists, propcount);
free(proplists);
//把protolists附加到class_rw_t中的protocols上，attachLists(protolists, protocount)方法
rw->protocols.attachLists(protolists, protocount);
free(protolists);
}
这里总结：就是获取分类列表，然后倒叙遍历取出分类，然后将所有分类中的方法列表、属性列表、协议列表放到一个数组（二维数组：mlist、proplists、protolosts）中。
然后通过再通过对应结构的.attachLists方法附加到原来的类里的class_rw_t结构体的对应列表中。
这里还有比较关键的一点，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;
//关键,内存移动，将原数组array()->lists（内存起始位置）这块内存（大小是oldCount * sizeof(array()->lists[0])）移动到array()->lists + addedCount这个位置。
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
//关键，内存拷贝，将分类添加的列表数组addedLists（大小是addedCount * sizeof(array()->lists[0])）copy到array()->lists这个位置。
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(array()->lists + addedCount, array()->lists, oldCount * sizeof(array()->lists[0]));
- memcpy(array()->lists, addedLists, addedCount * sizeof(array()->lists[0]));
array()->lists是原列表数组，addedLists是分类添加的列表数组。首先是根据addedLists扩容，然后把原列表移动到列表最后，然后将addedLists添加到列表开头位置。
- 这也就是为什么同样的方法名，分类的方法会覆盖原来类的方法（PS:并不是真正的覆盖，只是分类方法在原来类的方法列表的前面，在查找方法时，先查找到分类的方法就调用了，原来类的方法就不会被调用了）。
- 那么问题又来了，多个分类分同样方法先调用谁的？我们注意一下分类在编译的时候编译完成就加入到catList中了，但是之前在遍历分类的时候是倒叙遍历的，所以也就是说后编译的分类最后attachCategories中组装的时候会在最前面，这也就可以解答这个问题。
- 最后，编译顺序是什么样的呢？就是我们那在build Phases 中compile Source文件从上到下的顺序。
本来是有面试题的，后来发现了解这些后面试题就显得比较简单，有其他问题大家再一起讨论吧。有不对的请指出，一起学习，共勉！
文章编写参考MJ课程和iOS底层原理总结 - Category的本质
