iOS底层原理 15 :类的加载(下)

上一篇中，我们介绍了类是如何从mach-o中加载到内存的，分析了read_images方法，readClass方法, realizeClassWithoutSwift方法，methodizeClass以及attachLists方法

接下来我们探索分类的加载，在探索之前我们需要知道分类的结构

category_t结构

1、探索category_t的底层结构

• 首先我们在mian.m函数里面去定义一个分类

@interface NSObject (LGB)
@property (nonatomic,strong) NSString * cate_name;

- (void)cate_instanceMethod1;
- (void)cate_instanceMethod2;
- (void)cate_instanceMethod3;
- (void)cate_instanceMethod4;
+ (void)cate_instanceMethod;
@end

@implementation NSObject (LGB)
- (void)cate_instanceMethod1{
    NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod2{
    NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod3{
    NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod4{
    NSLog(@"%s",__func__);
}
+ (void)cate_instanceMethod{
    NSLog(@"%s",__func__);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSObject *obj = [[NSObject alloc]init];
        
        LGPerson *person = [[LGPerson alloc] init];
        
        NSLog(@"%ld - %ld",sizeof(person),class_getInstanceSize(person.class));
    }
    return 0;
}

• 使用 clang rewrite-objc main.m -o mian.cpp 终端命令去编译mian.m得到mian.cpp文件

• 在mian.cpp里面,我们得到了分类的底层结构, instance_methods表示实例方法列表，class_methods表示类方法列表

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

• 其中instance_methods表示实例方法列表，class_methods表示类方法列表
  
• 我们发现了一个问题：查看看_prop_list_t，明明分类中定义了属性，但是在底层编译中并没有看到属性，如下图所示，这是因为分类中定义的属性没有相应的set、get方法，我们可以通过关联对象来设置

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_NSObject_$_LGB __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"cate_name","T@\"NSString\",&,N"}}
};

当然我们通过objc源码搜索 category_t，我们也能得到分类category_t的结构：

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);
    
    protocol_list_t *protocolsForMeta(bool isMeta) {
        if (isMeta) return nullptr;
        else return protocols;
    }
};

2、分类与类拓展的区别

category : 分类，类别

• 专门用来给类添加新的方法
• 不能给类添加成员变量
• 可以添加属性， 但是只会生成变量的 getter setter 方法的声明，不会生成方法的实现和带下划线的成员变量

extension : 类拓展

• 可以说是特殊的分类，也称为匿名分类
• 可以给类添加成员变量和属性，但是是私有变量
• 可以给类添加方法，但也是私有方法

3、关联对象

如果想要给分类有效的添加属性，需要在重写的 getter setter方法里面去关联对象

#import <Foundation/Foundation.h>
@interface NSObject (LGA)
@property (nonatomic,strong) NSString * lga_name;
@end

#import "NSObject+LGA.h"
#import <objc/runtime.h>
@implementation NSObject (LGA)
- (void)setLga_name:(NSString *)lga_name{
    objc_setAssociatedObject(self, "lga_name", lga_name, OBJC_ASSOCIATION_RETAIN);
}

- (NSString *)lga_name{
    return  objc_getAssociatedObject(self, "lga_name");
}
@end

分类的加载

准备： 创建LGPerson的两个分类：LGA LGB

在分析realizeClassWithoutSwift时，realizeClassWithoutSwift -> methodizeClass -> attachToClass -> load_categories_nolock -> extAlloc ->attachCategories中提及了rwe的加载，中分析了分类的data数据 是如何 加载到类中的，且分类的加载顺序是：LGA -> LGB的顺序加载到类中，即越晚加进来，越在前面

其中查看methodizeClass的源码实现，可以发现类的数据和 分类的数据是分开处理的，主要是因为类在编译阶段，就已经确定好了方法的归属位置（即实例方法存储在类中，类方法存储在元类中），而分类是后面才加进来的

其中分类需要通过attatchToClass添加到类，然后才能在外界进行使用，在此过程，我们已经知道了分类加载三步骤的后面两个步骤，分类的加载主要分为3步：

• 【第一步】分类数据加载时机：根据类和分类是否实现load方法来区分不同的时机
• 【第二步】attachCategories准备分类数据
• 【第三步】attachLists将分类数据添加到主类中

【第一步】分类加载的时机

以主类LGPerson + 分类LGA、LGB 均实现+load方法为例

• load_images
• loadAllCategories
• load_categories_nolock
• attachCategories

拓展:只要有一个分类是非懒加载分类，那么所有的分类都会被标记位非懒加载分类

分类与类的搭配下的加载时机

【情况1】非懒加载类 + 非懒加载分类

• 类的数据加载是通过_getObjc2NonlazyClassList加载，即ro、rw的操作，对rwe赋值初始化，是在extAlloc方法中
• 分类的数据加载是通过load_images加载到类中的

其调用路径为：

• 非懒加载类路径：map_images -> map_images_nolock -> _read_images -> readClass -> _getObjc2NonlazyClassList -> realizeClassWithoutSwift -> methodizeClass -> attachToClass ,此时的mlists是一维数组，然后走到load_images部分

• 非懒加载分类路径：load_images --> loadAllCategories -> load_categories_nolock -> load_categories_nolock -> attachCategories -> attachLists，此时的mlists是二维数组

【情况2】非懒加载类 + 懒加载分类
非懒加载类 与 懒加载分类的数据加载，有如下结论：

• 类 和 分类的加载是在read_images就加载数据了
• 其中data数据在编译时期就已经完成了

【情况3】懒加载类 + 懒加载分类
懒加载类 与 懒加载分类的数据加载是在消息第一次调用时加载的

【情况4】懒加载类 + 非懒加载分类
只要分类实现了load，会迫使主类提前加载,即 主类 强行转换为 非懒加载类样式， 加载流程就和情况1是一致的

分类与类的搭配下的加载时机.png

关联对象的原理

关联对象设置值流程

首先我们先来了解一下objc_setAssociatedObject方法的四个参数：

• 参数1：要关联的对象，即给谁添加关联属性
• 参数2：标识符，方便下次查找
• 参数3：value

• 参数4：属性的策略，即retain，copy，

  
  

objc_setAssociatedObject源码实现：
SetAssocHook.get()是一种接口模式的设计思想，对外的接口不变，内部的逻辑变化不影响外部的调用

进入SetAssocHook，其底层实现是_base_objc_setAssociatedObject，类型是ChainedHookFunction

所以可以理解为SetAssocHook.get()等价于_base_objc_setAssociatedObject

void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    SetAssocHook.get()(object, key, value, policy);//接口模式，对外接口始终不变
}

👇等价于

void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    _base_objc_setAssociatedObject(object, key, value, policy);//接口模式，对外接口始终不变
}

进入_base_objc_setAssociatedObject源码实现：_base_objc_setAssociatedObject -> _object_set_associative_reference
进入_object_set_associative_reference源码实现

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    // This code used to work when nil was passed for object and key. Some code
    // probably relies on that to not crash. Check and handle it explicitly.
    // rdar://problem/44094390
    if (!object && !value) return;

    if (object->getIsa()->forbidsAssociatedObjects())
        _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
    //object封装成一个数组结构类型，类型为DisguisedPtr
    DisguisedPtr<objc_object> disguised{(objc_object *)object};//相当于包装了一下 对象object,便于使用
    // 包装一下 policy - value
    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();//根据策略类型进行处理
    //局部作用域空间
    {
        //初始化manager变量，相当于自动调用AssociationsManager的析构函数进行初始化
        AssociationsManager manager;//并不是全场唯一，构造函数中加锁只是为了避免重复创建，在这里是可以初始化多个AssociationsManager变量的
    
        AssociationsHashMap &associations(manager.get());//AssociationsHashMap 全场唯一

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});//返回的结果是一个类对
            if (refs_result.second) {//判断第二个存不存在，即bool值是否为true
                /* it's the first association we make 第一次建立关联*/
                object->setHasAssociatedObjects();//nonpointerIsa ，标记位true
            }

            /* establish or replace the association 建立或者替换关联*/
            auto &refs = refs_result.first->second; //得到一个空的桶子，找到引用对象类型,即第一个元素的second值
            auto result = refs.try_emplace(key, std::move(association));//查找当前的key是否有association关联对象
            if (!result.second) {//如果结果不存在
                association.swap(result.first->second);
            }
        } else {//如果传的是空值，则移除关联，相当于移除
            auto refs_it = associations.find(disguised);
            if (refs_it != associations.end()) {
                auto &refs = refs_it->second;
                auto it = refs.find(key);
                if (it != refs.end()) {
                    association.swap(it->second);
                    refs.erase(it);
                    if (refs.size() == 0) {
                        associations.erase(refs_it);

                    }
                }
            }
        }
    }

    // release the old value (outside of the lock).
    association.releaseHeldValue();//释放
}

通过源码可知，我们总结一下关联对象的设置流程：

• 1.创建一个 AssociationsManager 管理类
• 2.获取唯一的全局静态哈希Map：AssociationsHashMap
• 3.判断是否插入的关联值value是否存在
  - 3.1 如果存在走第4步
  - 3.2 如果不存在，关联对象 -插入空 的流程
• 4.通过try_emplace方法，并创建一个空的 ObjectAssociationMap 去取查询的键值对
• 5.如果发现没有这个 key 就插入一个 空的 BucketT进去并返回true
• 6.通过setHasAssociatedObjects方法标记对象存在关联对象即置isa指针的has_assoc属性为true
• 7.用当前 policy 和 value 组成了一个 ObjcAssociation 替换原来 BucketT 中的空
• 8.标记一下 ObjectAssociationMap 的第一次为 false

关联对象取值流程

我们通过源码 objc_getAssociatedObject() --> _object_get_ associative_reference(object,key)

_object_get_associative_reference的源码实现:

id
_object_get_associative_reference(id object, const void *key)
{
    ObjcAssociation association{};//创建空的关联对象

    {
        AssociationsManager manager;//创建一个AssociationsManager管理类
        AssociationsHashMap &associations(manager.get());//获取全局唯一的静态哈希map
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);//找到迭代器，即获取buckets
        if (i != associations.end()) {//如果这个迭代查询器不是最后一个 获取
            ObjectAssociationMap &refs = i->second; //找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
            ObjectAssociationMap::iterator j = refs.find(key);//根据key查找ObjectAssociationMap，即获取bucket
            if (j != refs.end()) {
                association = j->second;//获取ObjcAssociation
                association.retainReturnedValue();
            }
        }
    }

    return association.autoreleaseReturnedValue();//返回value
}

通过源码可知，主要分为以下部分：

• 创建一个 AssociationManager管理类
• 获取唯一的全局静态哈希Map：AssociationMap
• 通过find方法根据 DisguisedPtr找到 AssociationsHashMap 中的 iterator 迭代查询器
• 如果这个迭代查询器不是最后一个 获取 : ObjectAssociationMap (policy和value)
• 通过find方法找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
• 返回value

关联对象涉及的哈希Map结构

• AssociationHashMap里面存放的是ObjectAssociationMap
• ObjectAssociationMap存放的是ObjectAssociation
• ObjectAssociation是一种类似字典一样结构，存放{policy ,value}结构

load_images

load_image的源码分析：

• 1.首先找到所有懒加载类的load方法:prepare_load_methods()
• 2.然后进行调用:call_load_methods()

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    if (!didInitialAttachCategories && didCallDyldNotifyRegister) {
        didInitialAttachCategories = true;
        loadAllCategories();
    }

    // Return without taking locks if there are no +load methods here.
    if (!hasLoadMethods((const headerType *)mh)) return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods
    {
        mutex_locker_t lock2(runtimeLock);
        //
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}

prepare_load_methods()源码分析：

• 获取非懒加载类，以及继承链上实现了load方法的类
• 获取非懒加载分类上实现了load方法的类

void prepare_load_methods(const headerType *mhdr)
{
    size_t count, i;

    runtimeLock.assertLocked();

    //_getObjc2NonlazyClassList 获取非懒加载类的列表
    classref_t const *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        // 递归获取继承链上的类
        schedule_class_load(remapClass(classlist[i]));
    }

    // 获取非懒加载分类上的list
    category_t * const *categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
    for (i = 0; i < count; i++) {
        category_t *cat = categorylist[i];
        Class cls = remapClass(cat->cls);
        if (!cls) continue;  // category for ignored weak-linked class
        if (cls->isSwiftStable()) {
            _objc_fatal("Swift class extensions and categories on Swift "
                        "classes are not allowed to have +load methods");
        }
        realizeClassWithoutSwift(cls, nil);
        ASSERT(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

call_load_methods()源码分析：

• call_class_loads() 执行类的load方法
• call_category_loads() 执行分类的load方法

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

load_images流程分析图：