14、关联对象的分析

一、 先说说类的扩展 与 分类

category /分类：
不能给类添加成员属性，专门用来给类添加新的方法
注：可以通过runtime 给分类添加属性，即属性关联，在分类中用@property 定义变量，只会生成变量的setter/getter方法的声明，不能生成方法实现 和带下划线的成员变量

extension类扩展
可以说成特殊的分类，可以添加成员变量、属性、方法，但都是私有的

1、类的扩展

创建一个类的扩展

image.png

通过 clang -rewrite-objc main.mm -o main.cpp 命令生成cpp文件，再打开cpp文件，搜索一下 ext_name 属性

image.png

查看LGTeacher 类扩展的方法，在编译过程中，方法就直接添加到 methodlist中，作为类的一部分，编译时期直接添加到本类里面

image.png

总结：
类的扩展 在编译器 会作为类的一部分，和类一起编译进来。
类的扩展 只是声明，依赖于当前的主类，没有.m文件，可以理解为一个.h文件

二、分类关联对象的探索

底层原理的实现，主要通过：
objc_setAssociatedObject 设置流程
objc_getAssociatedObject 取值流程

关联对象-设值流程

在分类LG中重写属性cate_name的set、get方法，通过runtime的属性关联方法实现：

image.png

例：objc_setAssociatedObject(self, &OperationKey, block, OBJC_ASSOCIATION_RETAIN);
其中objc_setAssociatedObject 方法有四个参数，分别表示：
参数1:要关联的对象，即给谁添加关联属性
参数2: 标识符，方便下次查找
参数3: value
参数4: 属性的策略，即retain、copy等，如下图：

image.png

进入objc_setAssociatedObject 源码实现：
这是一种接口模式，对外的接口不变，内部的逻辑变化不影响外部的调用，类似于set方法的底层源码

image.png

进入get方法实现，其中ChainedHookFuncation是一个函数指针

image.png

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

image.png

可以理解为** 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_associtative_reference方法分析**

进入_object_set_associative_reference 源码实现，关于关联对象 底层原理的探索 主要看**value**存到了哪里，以及如何**取出value**，

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、 创建一个 AssociationManager 管理类
2、获取唯一的全局静态哈希Map：AssicationsHashMap
3、判断是否插入的关联值value是否存在，若存在就继续，若不存在，关联对象-插入空流程
4、通过try_emplace 方法，并创建一个空的 ObjectAssociationMap 去取查询的键值对
5、如果发现没有这个key就插入一个空的Bucket进去并返回true
6、通过setHasAssociatedObjects方法 标记对象存在关联对象 即置 isa指针的has_assoc 属性为true
7、用当前policy 和 value 组成一个 objcAssociation 替换原来的 bucketT 中的空
8、标记一下 ObjectAssociationMap 的第一次为 false

进入 try_emplace 方法的源码实现

有两个返回，都是通过std::make_pair生成相应的键值对
通过LookupBucketFor 方法查找桶子，如果map中已经存在，则直接返回，其中make_pair 的 第二个参数 bool值为false
如果没有找到，则通过InsertIntoBucket 插入map，其中make_pair的第二个参数bool值为true

image.png

进入LookupBucketFor 源码，有两个同名方法，其中第二个方法属于重载函数，区别于第一个的是第二个参数没有const修饰，通过调试可知，外部的调用是调用的第二个重载函数，而第二个LookupBucketFor方法，内部的实现是调用第一个lookupBucketFor方法

image.png 第一个lookupBucketFor方法.png 第二个LookupBucketFor方法.png

总结一下：

关联对象的设值.png 哈希map结构.png

AssociationsManager 可以有多个，通过AssociationsManagerLock锁 可以得到一个 AssociationsHashMap 类型的 map

map中有很多的关联对象map，类型是ObjectAssociationMap，其中key为DisguisedPtr<objc_object>, 例如LGperson会对应一个objectAssociationMap，LGTeacher会对应一个objectAssociationMap，

typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;

ObjectAssociationMap哈希表中有很多key-value键值对，其中key的类型为const void *，value的类型为ObjcAssociation

typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;

其中ObjcAssociation是用于包装policy和value的一个类

image.png

关联对象-取值流程

截屏2020-10-2418.20.38.png

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
}

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

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

调取流程：

接着上一步调试，进入_objct_get_associative_reference源码实现：
进入find方法：根据关联对象迭代查找AssociationHashMap，即buckets

image.png

p i
p i->second

image.png

再次通过find方法，在buckets中查找与key配对的bucket

find方法执行之前，j的打印，此时的value为nil

find方法查询之后，j的打印，此时的value为KC

image.png

总结：

image.png