关联对象

前言

之前我们大致分析了类的加载和分类的加载，清楚了主类和分类在懒加载和非懒加载的不同情况下，分类方法绑定到主类方法列表的时机问题。
那分类中能添加属性吗？相信大家都知道这个问题的答案，虽然声明了属性，但是系统底层只会生成set&get方法，并没有成员变量，那有其它方式可以实现吗？这就是我们今天要研究的问题：关联对象。

设置关联对象objc_setAssociatedObject

void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    SetAssocHook.get()(object, key, value, policy);
}

有四个参数：

参数1：要关联的对象，即给谁添加关联属性
参数2：标识符，方便下次查找
参数3：value
参数4：属性的策略，即nonatomic、atomic、assign等，

再看SetAssocHook定义如下

static ChainedHookFunction SetAssocHook{_base_objc_setAssociatedObject};

那么SetAssocHook.get()(object, key, value, policy); ==> _base_objc_setAssociatedObject(object, key, value, policy)

static void
_base_objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
  _object_set_associative_reference(object, key, value, policy);
}

最终我们来到了_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));

    DisguisedPtr disguised{(objc_object *)object};

    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();

    {
        AssociationsManager manager;
        
        AssociationsHashMap &associations(manager.get());

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            if (refs_result.second) {
                /* it's the first association we make */
                object->setHasAssociatedObjects();
            }

            /* establish or replace the association */
            auto &refs = refs_result.first->second;
            auto result = refs.try_emplace(key, std::move(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();
}

先细看，其中调用了AssociationsHashMap的try_emplace方法 find方法和erase方法，也调用了ObjcAssociation的swap方法，还有setHasAssociatedObjects，先具体看看这些方法的大致作用：

1. try_emplace

2. find

3.erase

4.swap

5.setHasAssociatedObjects

再回头来看_object_set_associative_reference流程，就比较明朗了

关联对象: 设值流程
1: 创建一个 AssociationsManager 管理类 2: 获取唯一的全局静态哈希Map
3: 判断是否插入的关联值是否存在:
3.1: 存在走第4步
3.2: 不存在就走 : 关联对象插入空流程
4: 创建一个空的 ObjectAssociationMap 去取查询的键值对
5: 如果发现没有这个 key 就插入一个空的 BucketT进去返回
6: 标记对象存在关联对象
7: 用当前修饰策略和值组成了一个 ObjcAssociation 替换原来 BucketT 中的空
8: 标记一下 ObjectAssociationMap 的第一次为 false
关联对象插入空流程
1: 根据 DisguisedPtr 找到 AssociationsHashMap 中的 iterator 迭代查询器
2: 清理迭代器
3: 其实如果插入空置相当于清除

进一步看看AssociationsManager和AssociationsHashMap

6.AssociationsManager

class AssociationsManager {
    using Storage = ExplicitInitDenseMap, ObjectAssociationMap>;
    static Storage _mapStorage;

public:
    AssociationsManager()   { AssociationsManagerLock.lock(); }
    ~AssociationsManager()  { AssociationsManagerLock.unlock(); }

    AssociationsHashMap &get() {
        return _mapStorage.get();
    }

    static void init() {
        _mapStorage.init();
    }
};

从其构造函数可知，AssociationsManager manager;这句代码会开启一个锁AssociationsManagerLock.lock();，保证当前只有一个线程进入操作关联对象的设置流程，同时，manager并不是单例对象，不具备唯一性。

7.AssociationsHashMap

typedef DenseMap ObjectAssociationMap;
typedef DenseMap, ObjectAssociationMap> AssociationsHashMap;

其中DenseMapPair内部结构

然后回到_object_set_associative_reference的这句代码AssociationsHashMap &associations(manager.get());

manager.get()-->_mapStorage.get();，而_mapStorage定义是static Storage _mapStorage;是一个static静态变量
&associations(manager.get())其实就是获取了_mapStorage的地址，所以它是唯一的全局静态变量

综上，AssociationsHashMap ObjectAssociationMap和BucketT的关系图

断点追踪关联对象设置流程

接下来我们示例，再断点追踪下设值流程：

NS_ASSUME_NONNULL_BEGIN

@interface LGPerson (LG)

@property (nonatomic, copy) NSString *cate_name;

@end

NS_ASSUME_NONNULL_END
@implementation LGPerson (LG)

- (void)setCate_name:(NSString *)cate_name {
    objc_setAssociatedObject(self, @"cate_name", cate_name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

- (NSString *)kc_name {
    return objc_getAssociatedObject(self, @"cate_name");
}

@end

调用设置关联对象方法代码

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        LGPerson *person = [LGPerson alloc];
        person.cate_name = @"KC";
        NSLog(@"%p",person);
    }
    return 0;
}

设置断点，run

上图即refs_result，一个std::pair迭代器与bool的键值对结构

//pair -- 表示有键值对
(std::__1::pair<
 objc::DenseMapIterator,
 
 objc::DenseMap, objc::DenseMapInfo, objc::detail::DenseMapPair >,
 
 objc::DenseMapValueInfo, objc::DenseMapInfo, objc::detail::DenseMapPair > >,
 
 objc::DenseMapInfo >,
 
 objc::detail::DenseMapPair, objc::DenseMap, objc::DenseMapInfo, objc::detail::DenseMapPair > >,
 
 false>,
 
 bool>)

//可以简写为

(std::__1::pair<
 
 objc
 
bool>)

接着往下走

上图的refs是iterator的第二个子结构体

(objc::DenseMap,
objc::DenseMapInfo, 
objc::detail::DenseMapPair >)

接着断点进入try_emplace
查看Args入参，即ObjectAssociationMap{}

再查看TheBucket结构

(objc::detail::DenseMapPair, objc::DenseMap, objc::DenseMapInfo, objc::detail::DenseMapPair > > *)

那么我们发现，refs_result refs Args 和 TheBucket的结构关系如下图

objc_getAssociatedObject大致流程

id
objc_getAssociatedObject(id object, const void *key)
{
    return _object_get_associative_reference(object, key);
}

id
_object_get_associative_reference(id object, const void *key)
{
    ObjcAssociation association{};

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            ObjectAssociationMap &refs = i->second;
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                association = j->second;
                association.retainReturnedValue();
            }
        }
    }

    return association.autoreleaseReturnedValue();
}

分析完set流程，再来看get流程，更简单了!

取值大致分为以下几步：
1: 创建一个 AssociationsManager 管理类
2: 获取唯一的全局静态哈希Map
3: 根据 DisguisedPtr 找到 AssociationsHashMap 中的 iterator 迭代查询器
4: 如果这个迭代查询器不是最后一个获取 : ObjectAssociationMap (这里有策略和value)
5: 找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
6: 返回_value

总结

根据以上的分析，其实我们可以发现，不论是设值还是取值的流程，都是在哈希map中进行迭代遍历查询。

这个哈希map是个二维的结构-->AssociationsHashMap<*, ObjectAssociationMap>，我们可以把它理解为一个二维数组。
迭代器iterator，是DenseMapIterator结构 --> DenseMapIterator ，其中BucketT中包含了策略policy和关联值value。