iOS底层系列：Category

前言

Category是我们平常用到的比较多的一种技术，比方说给某个类添加方法，增加成员变量，或者者用Category优化代码结构。

我们通过下面这几个问题作为切入点，结合runtime的源码，探索一下Category的底层原理。

我们在Category中，可以直接增加方法，而且我们也都知道，增加的方法会合并到本类当中，同时我们也可以公告属性，但是此时的属性没有功能，也就是不能存值，这就相似于Swift中的计算属性，假如我们想让这个属性可以储存值，就要用runtime的方式，动态的增加。

探索

1. Category为什么能增加方法不能增加成员变量

首先我们先创立一个Person类，而后创立一个Person+Run的Category，并在Person+Run中实现-run方法。

我们可以使用命令行对Person+Run.m进行编译

xcrun -sdk iphonesimulator clang -rewrite-objc Person+Run.m

得到一个Person+Run.cpp文件，在文件的底部，可以找到这样一个结构体

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都会编译而后存储在一个_category_t类型的变量中

static struct _category_t _OBJC_$_CATEGORY_Person_$_Run __attribute__ ((used, section ("__DATA,__objc_const"))) = {    "Person",    0, // &OBJC_CLASS_$_Person,    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Run,    0,    0,    0,};

由于我们的Person+Run里面只有一个实例方法，从上述代码中来看，也只有对应的位置传值了。

通过这个_category_t的结构结构我们也可以看出，属性存储在_prop_list_t，这里并没有类中的objc_ivar_list结构体，所以Category的_category_t结构体中根本没有储存ivar的地方，所以不能增加成员变量。

假如我们在分类中手动为成员变量增加了set和get方法之后，也可以调用，但实际上是没有内存来储值的，这就如同Swift中的计算属性，只起到了计算的作用，就相当于是两个方法（set和get），但是并不能拥有真用的内存来存储值。

举个例子

@property (copy, nonatomic) NSString * name;

下面这个公告假如实在类中，系统会默认帮我们公告一个成员变量_name, 在.h中公告setName和name两个方法，并提供setName和name方法的默认实现。

假如是在Category中，只相当于公告setName和name两个方法，没有实现也没有_name。

2. Category的方法是何时合并到类中的

大家都知道Category分类一定是我们的应用启动是，通过运行时特性加载的，但是这个加载过程具体的细节就要结合runtime的源码来分析了。

runtime源码太多了，我们先通过大概浏览代码来定位实现功能的相关位置。

我从objc-runtime-new.mm中找到了下面这个方法。

/************************************************************************ methodizeClass* Fixes up cls's method list, protocol list, and property list.* Attaches any outstanding categories.* Locking: runtimeLock must be held by the caller**********************************************************************/static void methodizeClass(Class cls, Class previously)

而且他的注释少量的很清楚，修复类的方法，协议和变量列表，关联还未关联的分类。

而后我们继续找，就找到了我们需要的这个方法。

 void attachLists(List* const * addedLists, uint32_t addedCount)

我们从其中摘出一段代码来分析即可以处理我们的问题了。

 // 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]));

在调用此方法之前我们所有的分类会被方法一个list里面（每一个分类都是一个元素），而后再调用attachLists方法，我们可以看到，在realloc的时候传进一个newCount，这是由于要添加分类中的方法，所以需要对之前的数组扩容，在扩容结束后先调用了memmove方法，在调用memcopy，大家可以上网查一下这两个方法具体的区别，这里简单一说，其实完成的效果都是把后面的内存的内容拷贝到前面内存中去，但是memmove可以解决内存重叠的问题。

其实也就是首先将原来数组中的每个元素先往后移动（我们要增加几个元素，就移动几位），由于移动后的位置，其实也是数组自己的内存空间，所以存在重叠问题，直接移动会导致元素丢失的问题，所以用memmove（会检测能否有内存重叠）。

移动完之后，把我们储存分类中方法的list中的元素移动到数组前面位置。

过程就是这样子了，其实我们第三个问题就顺便处理完了。

3. Category方法和类中方法的执行顺序

上面其实说到了，类中原来的方法是要往后面移动的，分类的方法增加到前面的位置，而且调用方法的时候是在list中遍历查找，所以我们调用方法的时候，一定会先调用到Category中的方法，但是这并不是覆盖，由于我们的原方法还在，只是这中机制保证了假如分类中有重写类的方法，会被优先查找到。

4. +load和+initialize的区别

对于这个问题我们从两个角度出发分析，调用方式和调用时刻。

+load

简单的举一个例子，我们创立一个Person类，而后重写+load方法，而后为Person新建两个Category，都分别实现+load。

@implementation Person+ (void)load {    NSLog(@"Person - load");}@end@implementation Person (Test1)+ (void)load {    NSLog(@"Person Test1 - load");}@end@implementation Person (Test2)+ (void)load {    NSLog(@"Person Test2 - load");}@end

当我们进行项目的时候，会得到下面的打印结果。

2020-09-14 09:34:41.900161+0800 Category[4533:53426] Person - load2020-09-14 09:34:41.900629+0800 Category[4533:53426] Person Test1 - load2020-09-14 09:34:41.900700+0800 Category[4533:53426] Person Test2 - load

我们并没有使用这个Person类和他的Category，所以应该是项目运行后，runtime在加载类和分类的时候，就会调用+load方法。

我们从源码中找到下面这个方法
void load_images(const char *path __unused, const struct mach_header *mh)

方法中的最后一行调用了call_load_methods()，这个call_load_methods()中就是实现了+load的调用方式。

下面是call_load_methods()函数的实现 ，大家简单浏览一遍

void call_load_methods(void){    static bool loading = NO;    bool more_categories;    loadMethodLock.assertLocked();    // Re-entrant calls do nothing; the outermost call will finish the job.    if (loading) return;    loading = YES;    void *pool = objc_autoreleasePoolPush();    do {        // 1. Repeatedly call class +loads until there aren't any more        while (loadable_classes_used > 0) {            call_class_loads();        }        // 2. Call category +loads ONCE        more_categories = call_category_loads();        // 3. Run more +loads if there are classes OR more untried categories    } while (loadable_classes_used > 0  ||  more_categories);    objc_autoreleasePoolPop(pool);    loading = NO;}

从源码中很清楚的可以看到， 先调用call_class_loads()， 再调用call_category_loads()，这就说明了在调用所有的+load方法时，实现调用了所有类的+load方法，再去调用分类中的+load方法。

而后我们在进入到call_class_loads()函数中

static void call_class_loads(void){    int i;        // Detach current loadable list.    struct loadable_class *classes = loadable_classes;    int used = loadable_classes_used;    loadable_classes = nil;    loadable_classes_allocated = 0;    loadable_classes_used = 0;        // Call all +loads for the detached list.    for (i = 0; i < used; i++) {        Class cls = classes[i].cls;        load_method_t load_method = (load_method_t)classes[i].method;        if (!cls) continue;         if (PrintLoading) {            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());        }        (*load_method)(cls, @selector(load));    }        // Destroy the detached list.    if (classes) free(classes);}

从中间的循环中可以看出，是取到了每个类的+load函数的指针，直接通过指针调用了这个函数。 call_category_loads()函数中表现出来的Category的+load方法的调用，也是同理。

同时这也解答了我们的另一个疑惑，那就是为什么总是先调用类的+load，在调用Category的+load。

思考：假如存在继承的情况，+load又会是怎么的调用顺序呢？

从上面call_class_loads()函数中可以看到有一个list：loadable_classes，我们猜测这里面应该就是存放着我们所有的类，由于下面的循环是从0开始循环，所以我们要研究所有的类的+load方法的执行顺序，就要看这个list中的类的顺序是怎样样的。

我们从个源码中可以找到这样一个方法，prepare_load_methods，在其实现中调用了schedule_class_load方法，我们看一下schedule_class_load的源码

static void schedule_class_load(Class cls){    if (!cls) return;    ASSERT(cls->isRealized());  // _read_images should realize    if (cls->data()->flags & RW_LOADED) return;    // Ensure superclass-first ordering    schedule_class_load(cls->superclass);    add_class_to_loadable_list(cls);    cls->setInfo(RW_LOADED); }

从源码中schedule_class_load(cls->superclass);这一句中可以看出，递归调用自己本身，并且传入自己的父类，结果递归之后，才调用add_class_to_loadable_list，这就说明父类总是在子类前面加入到list当中，所有在调用一个类的+load方法之前，一定要先调用其父类的+load方法。

那假如是其余没有继承关系的类呢，这就跟编译顺序有关系了，大家可以自己尝实验证一下。

小结：

+load方法会在runtime加载类和分类时调用
每个类和分类的+load方法之后调用一次
调用顺序：
先调用类的+load

• 按照编译顺序调用
• 调用子类+load之前，先调用父类的+load
  再调用分类的+load
• 按照编译顺序调用

小结中假如有我没提到的，大家可以自行验证。

+initialize

+initialize的调用是不同的，假如某一个类我们没有使用过，他的+initialize方法是不会调用的，到我们使用这个类（调用了类的某个方法）的时候，才会触发+initialize方法的调用。

@implementation Person+ (void)initialize {    NSLog(@"Person - initialize");}@end@implementation Person (Test1)+ (void)initialize {    NSLog(@"Person Test1 - initialize");}@end@implementation Person (Test2)+ (void)initialize {    NSLog(@"Person Test2 - initialize");}@end

当我们执行[Person alloc];的时候，才会走+initialize方法，而且执行的Category中的+initialize：

2020-09-14 10:40:23.579623+0800 Category[9134:94173] Person Test2 - initialize

这个我们之前已经说过了，Category的方法会增加list的前面，所以会先被找到并且执行，所以我们猜测+initialize的执行是走的正常的消息机制，objc_msgSend。

因为objc_msgSend实现并没有完全开源，都是汇编代码，所以我们需要换一个思路来研究源码。

objc_msgSend本质是什么？以调用实例方法为例，其实就是通过isa指针找到该类，而后寻觅方法，找到之后调用。假如没有找到则通过superClass找到父类，继续查找方法。上面的例子中，我们仅仅是调用了一个alloc方法，但是也执行了+initialize方法，所以我们猜测+initialize会在查找方法的时候调用到。通过这个思路，我们定位到了class_getInstanceMethod()函数（class_getInstanceMethod函数就是在类中查找某个sel时候调用的），在这个函数中，又调用了IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)

在该函数中我们可以找到下面这段代码

if ((behavior & LOOKUP_INITIALIZE)  &&  !cls->isInitialized()) {    initializeNonMetaClass (_class_getNonMetaClass(cls, inst));}

可以看出假如类还没有执行+initialize 就会先执行，我们再看一下if语句中的initializeNonMetaClass函数，他会先拿到superClass，执行superClass的+initialize

supercls = cls->superclass;if (supercls  &&  !supercls->isInitialized()) {    initializeNonMetaClass(supercls);}

这就是存在继承的情况，为什么会先执行父类的+initialize。

大总结

1. 调用方式

   load是根据函数地址直接调用
   initialize是通过消息机制objc_msgSend调用

2. 调用时刻

   load是在runtime加载类和分类时调用（只会调用一次）
   initialize是在类第一次收到消息时调用个，默认没有继承的情况下每个类只会initialize一次（父类的initialize可能会被执行屡次）

3. 调用顺序

   • load
     先调用类的load：先编译的类先调用，子类调用之前，先调用父类的
     在调用Category的load：先编译的先调用

   • initialize
     先初始化父类
     在初始化子类（初始化子类可能调用父类的initialize）

补充

上面总结的时候说到父类的initialize会被执行屡次，什么情况下会被执行屡次，为什么？举个例子：

@implementation Person+ (void)initialize {    NSLog(@"Person - initialize");}@end@implementation Student@end

Student类继承Person类，并且只有父类Person中实现了+initialize，Student类中并没有实现

此时我们调用[Student alloc];， 会得到如下的打印。

2020-09-14 11:31:55.377569+0800 Category[11483:125034] Person - initialize2020-09-14 11:31:55.377659+0800 Category[11483:125034] Person - initialize

Person的+initialize被执行了两次，但这两个意义是不同的，第一次执行是由于在调用子类的+initialize方法之前必需先执行父类的了+initialize，所以会打印一次。当要执行子类的+initialize时，通过消息机制，student类中并没有找到实现的+initialize的实现，所以要通过superClass指针去到父类中继续查找，由于父类中实现了+initialize，所以才会有了第二次的打印。

结尾

本文的篇幅略长，笔者按照自己的思路和想法写完了此文，陈述过程不肯定那么调理和完善，大家在阅读过程中发现问题，可以留言交流。

感谢阅读。