iOS Category分类底层探究

一、Category的实现原理

我们先看一个简单Demo
创建Person类以及它的两个分类Person+Test、Person+Eat，并在Person、Person+Test、Person+Eat 中都实现方法- (void)run、+ (void)test
代码如下

@implementation Person
- (void)run {
    NSLog(@"Person 实例方法 Run");
}
+ (void)test {
    NSLog(@"Person 类方法 test");
}

@implementation Person (Test)
- (void)run {
    NSLog(@"Person+Test 实例方法 Run");
}

+ (void)test {
    NSLog(@"Person+Test 类方法 test");
}

@implementation Person (Eat)
- (void)run {
    NSLog(@"Person+Eat 实例方法 Run");
}

+ (void)test {
    NSLog(@"Person+Eat 类方法 test");
}

// 执行以下代码
    [[Person new] run];
    [Person test];

控制台会有如下打印

2021-09-18 13:53:31.545587+0800 CategoryTest[6366:147547] Person+Eat 实例方法 Run
2021-09-18 13:53:31.545686+0800 CategoryTest[6366:147547] Person+Eat 类方法 test

想想为什么是执行分类里的方法？？？

我们都知道
一个类的类对象只有一个，存储着实例方法，元类对象也只有一个，存储着类方法
实例方法的调用轨迹是实例对象通过isa指针找到类对象，在类对象的方法列表中查找该方法，如果找不到，就通过superclass指针继续向上查找
类方法的调用轨迹是类对象通过isa指针找到元类对象，在元类对象的方法列表中查找该方法，如果找不到，就通过superclass指针继续向上查找（如果不理解可以看下 iOS 深入理解isa指针和superclass指针）

那也就是说，Person的类对象的实例方法列表中存在分类的方法，Person的元类对象的类方法列表中也存在分类的方法

那么我们验证下，打印下类对象元类对象的方法列表

代码如下

- (void)printMethodNamesOfClass:(Class)cls
{
    unsigned int count;
    // 获得方法数组
    Method *methodList = class_copyMethodList(cls, &count);
    
    // 存储方法名
    NSMutableString *methodNames = [NSMutableString string];
    
    // 遍历所有的方法
    for (int i = 0; i < count; i++) {
        // 获得方法
        Method method = methodList[I];
        // 获得方法名
        NSString *methodName = NSStringFromSelector(method_getName(method));
        // 拼接方法名
        [methodNames appendString:methodName];
        [methodNames appendString:@", "];
    }
    
    // 释放
    free(methodList);
    
    // 打印方法名
    NSLog(@"%@ %@", cls, methodNames);
}

// 执行以下代码
    [self printMethodNamesOfClass:[Person class]];
    [self printMethodNamesOfClass:object_getClass([Person class])];

控制台结果如下

2021-09-18 13:53:31.545803+0800 CategoryTest[6366:147547] Person run, run, run,
2021-09-18 13:53:31.545906+0800 CategoryTest[6366:147547] Person test, test, test,

我们不难发现
分类的实例方法是被加载到类对象中，分类的类方法也是被加载到元类对象中

那么新问题又来了，分类方法是什么时候加载到类对象、元类对象中的？
是在编译时，还是runtime动态加载

我们把分类编译成C++代码，看看源码

 xcrun  -sdk  iphoneos  clang  -arch  arm64  -rewrite-objc  Person+Test.m  -o  Person+Test.cpp

在Person+Test.cpp文件中，我们会看到以下代码

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

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_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"run", "v16@0:8", (void *)_I_Person_Test_run}}
};

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"test", "v16@0:8", (void *)_C_Person_Test_test}}
};

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_t结构体，_category_t结构体存储着分类的实例方法列表、类方法列表、协议、属性。
分类实例方法、类方法不是在编译时，加载到类对象、元类对象中

那我们看看是不是runtime动态加载的

在苹果开源代码里下载objc4-824源码
objc-os.mm 是runtime入口
阅读源码的顺序如下

objc-os.mm 
    _objc_init
    _dyld_objc_notify_register(&map_images, load_images, unmap_image)
objc-runtime-new.m
     map_images
objc-os.mm    
    map_images_nolock
objc-runtime-new.m
    _read_images
    load_categories_nolock
    attachCategories
    attachLists

核心代码 attachLists

 for (int i = oldCount - 1; i >= 0; I--)
     newArray->lists[i + addedCount] = array()->lists[I];
 for (unsigned i = 0; i < addedCount; I++)
     newArray->lists[i] = addedLists[I];

在苹果源码中，我们不难理解到，分类的数据是通过runtime动态加载到类信息中（类对象、元类对象中）

Runtime加载某个类的所有Category数据是按照编译顺序加载的，
先编译的分类会先加载到原来数据的前面，最后加载的分类的数据会在最前面

我们可以试下，在Build Phases - Compile Sources中调整下编译顺序，结果会不一样

综上

Category编译之后的底层结构是struct category_t，里面存储着分类的对象方法、类方法、属性、协议信息
在程序运行的时候，runtime会将Category的数据，合并到类信息中（类对象、元类对象中

二、load方法是什么时候调用的？调用顺序？

load方法在runtime加载类、分类的时候调用
先看Demo, Student类继承于Person类，Student类有两个分类Student+Test1、Student+Test2,Person类有两个分类Person+Test1、Person+Test2。所有类都实现了Load方法

@implementation Person
+ (void)load
{
    NSLog(@"Person +load");
}

@implementation Student
+ (void)load
{
    NSLog(@"Student +load");
}

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

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

@implementation Student (Test1)
+ (void)load
{
    NSLog(@"Student (Test1) +load");
}

@implementation Student (Test2)
+ (void)load
{
    NSLog(@"Student (Test2) +load");
}

控制台运行结果如下

2021-09-21 10:40:38.360286+0800 CategoryTest[1255:34564] Person +load
2021-09-21 10:40:38.360735+0800 CategoryTest[1255:34564] Student +load
2021-09-21 10:40:38.360819+0800 CategoryTest[1255:34564] Student (Test1) +load
2021-09-21 10:40:38.360899+0800 CategoryTest[1255:34564] Person (Test1) +load
2021-09-21 10:40:38.360969+0800 CategoryTest[1255:34564] Person (Test2) +load
2021-09-21 10:40:38.361038+0800 CategoryTest[1255:34564] Student (Test2) +load

调整编译顺序发现，每次都是先执行父类Person的load方法，再执行子类Student的load 方法，分类的load方法执行顺序和编译顺序一致。

我们看下源码
阅读源码的顺序如下

objc-os.mm 
    _objc_init
    _dyld_objc_notify_register(&map_images, load_images, unmap_image)
objc-runtime-new.mm
    load_images
    prepare_load_methods
    schedule_class_load
    call_load_methods
objc-loadmethod.m
    call_class_loads
    call_category_loads

核心代码
方法schedule_class_load

schedule_class_load(cls->getSuperclass());

方法call_load_methods

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

load方法调用轨迹

1. 先调用类的load
先编译的类，优先调用load
调用子类的load之前，会先调用父类的load
2. 再调用分类的load
先编译的分类，优先调用load

核心代码：

call_class_loads
        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));

call_category_loads

        Category cat = cats[i].cat;
        load_method_t load_method = (load_method_t)cats[i].method;
        Class cls;
        if (!cat) continue;

        cls = _category_getClass(cat);
        if (cls  &&  cls->isLoadable()) {
            if (PrintLoading) {
                _objc_inform("LOAD: +[%s(%s) load]\n", 
                             cls->nameForLogging(), 
                             _category_getName(cat));
            }
            (*load_method)(cls, @selector(load));
            cats[i].cat = nil;
        }

load 方法都是通过(*load_method)(cls, @selector(load))调用的，是通过函数直接调用，因而每个类的load方法都会调用

综上：
1. load方法在runtime加载类、分类的时候调用
2.load是根据函数地址直接调用
3.调用顺序
(a). 先调用类的load
* 先编译的类，优先调用load
* 调用子类的load之前，会先调用父类的load
(b)再调用分类的load
* 先编译的分类，优先调用load

三、initialize方法的调用时机和调用顺序？？？

initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）

代码如下：

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

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

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

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

@implementation Student (Test1)
+ (void)initialize
{
    NSLog(@"Student (Test1) +initialize");
}

@implementation Student (Test2)
+ (void)initialize
{
    NSLog(@"Student (Test2) +initialize");
}

执行代码

    [Student alloc];

运行结果

2021-09-22 14:46:58.924985+0800 CategoryTest[22678:280860] Person (Test2) +initialize
2021-09-22 14:46:58.925091+0800 CategoryTest[22678:280860] Student (Test2) +initialize

如果注释掉Student类及其分类的initialize方法，执行代码

    [Person alloc];
    [Student alloc];

运行结果

2021-09-22 14:50:29.884029+0800 CategoryTest[22763:284676] Person (Test2) +initialize
2021-09-22 14:50:29.884128+0800 CategoryTest[22763:284676] Person (Test2) +initialize

当类第一次收到消息时，是执行分类的initialize方法，因而我们推测initialize方法的调用是基于消息机制的，也就是通过 objc_msgSend调用

看下源码
阅读源码的顺序如下：

 objc-msg-arm64.s
       objc_msgSend
 objc-runtime-new.m
       lookUpImpOrForward
       realizeAndInitializeIfNeeded_locked
       initializeAndLeaveLocked
      initializeAndMaybeRelock
      initializeNonMetaClass
objc-initialize.m
      callInitialize

核心代码
initializeNonMetaClass

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

先调用父类的+initialize，再调用子类的+initialize

callInitialize

((void(*)(Class, SEL))objc_msgSend)(cls, @selector(initialize));

initialize是通过objc_msgSend调用

综上

1. initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）
2.initialize是通过objc_msgSend调用
3.调用顺序
(a)先初始化父类
(b)再初始化子类（可能最终调用的是父类的initialize方法）

四、关联成员变量

默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中。但可以通过关联对象来间接实现

关联对象提供了以下API
添加关联对象
void objc_setAssociatedObject(id object, const void * key,
id value, objc_AssociationPolicy policy)

获得关联对象
id objc_getAssociatedObject(id object, const void * key)

移除所有的关联对象
void objc_removeAssociatedObjects(id object)

4.1 key的常见用法

static void *MyKey = &MyKey;
objc_setAssociatedObject(obj, MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, MyKey)

static char MyKey;
objc_setAssociatedObject(obj, &MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, &MyKey)

使用属性名作为key
objc_setAssociatedObject(obj, @"property", value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
objc_getAssociatedObject(obj, @"property");

使用get方法的@selecor作为key
objc_setAssociatedObject(obj, @selector(getter), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, @selector(getter))

4.2 objc_AssociationPolicy

截屏2021-09-22 下午3.27.48.png

4.3 关联对象的原理

实现关联对象技术的核心对象有

AssociationsManager
AssociationsHashMap
ObjectAssociationMap
ObjcAssociation

截屏2021-09-15 下午4.46.40.png