谈Objective-C关联对象

#前言

前不久刚写了谈Objective-C类成员变量，分析了成员变量的实现原理以及不能动态添加的原因，在这篇文章里我们来根据 objc4-646.tar.gz版本源码来谈一下 Objective-C 关联对象的实现原理。

关联对象(Associated Objects)是 Objective-C 2.0运行时的一个特性，起始于OS X Snow Leopard和iOS 4。它允许开发者对已经存在的类在扩展中添加自定义的属性。相关参考可以查看 <objc/runtime.h> 中定义的三个允许你将任何键值在运行时关联到对象上的函数：

void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) 用于给对象添加关联属性，传入nil则移除已有的关联对象
id objc_getAssociatedObject(id object, const void *key) 用于获取关联属性
void objc_removeAssociatedObjects(id object) 移除一个对象所有的关联属性，但不建议手动调用这个函数，因为这可能会导致其它人对其添加的属性也被移除了。你可以调用objc_setAssociatedObject方法并传入nil来指定移除某个关联

下面分析一下 objc_setAssociatedObject 两个参数 key 和 policy

#key

通常来说该属性应该是常量、唯一的，在getter和setter方法中都可以访问到。这里有两种常见的添加方式：

第一种是添加 static char 类型的变量，当然更推荐是指针型的。

static char kAssociatedObjectKey;
- (void)setMenber:(NSString *)menber {
    objc_setAssociatedObject(self, &kAssociatedObjectKey, menber, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

当然更推荐的是使用更简单的方式实现：用 selector(getter方法)：

- (void)setMenber:(NSString *)menber {
    objc_setAssociatedObject(self, @selector(menber), menber, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

#关联策略 policy

关联策略跟属性修饰符的使用方法差不多，属性可以根据定义在 objc_AssociationPolicy 上的类型被关联到对象上：

关联策略	等价属性	说明
OBJC_ASSOCIATION_ASSIGN	@property (assign)或 @property (unsafe_unretained)	弱引用关联对象
OBJC_ASSOCIATION_RETAIN_NONATOMIC	@property (nonatomic, strong)	强引用关联对象，且为非原子操作
OBJC_ASSOCIATION_COPY_NONATOMIC	@property (nonatomic, copy)	复制关联对象，且为非原子操作
OBJC_ASSOCIATION_RETAIN	@property (atomic, strong)	强引用关联对象，且为原子操作
OBJC_ASSOCIATION_COPY	@property (atomic, copy)	复制关联对象，且为原子操作

#关联对象实现

下面让我们具体来分析一下这几个函数的具体实现吧！

分析objc_setAssociatedObject实现

在objc_setAssociatedObject的实现被定义在objc-auto.mm文件 467 行

GC_RESOLVER(objc_setAssociatedObject)

#define GC_RESOLVER(name)                                       \
    OBJC_EXPORT void *name##_resolver(void) __asm__("_" #name); \
    void *name##_resolver(void)                                 \
    {                                                           \
        __asm__(".symbol_resolver _" #name);                    \
        if (UseGC) return (void*)name##_gc;                     \
        else return (void*)name##_non_gc;                       \
    }

## 符号: 连接宏。举个例子：#define COMMAND(A, B) A##B ， int COMMAND(temp, Int) = 10 等同于 int tempInt = 10
UseGC 是否使用垃圾回收，在 iPhone 平台上被定义为 NO
所以这个宏展开来为下面的代码

   void GC_RESOLVER(name)                                 
   {                                                           
      return (void*)objc_setAssociatedObject_non_gc();                       
   }

objc_setAssociatedObject_non_gc的实现在objc-runtime.m文件，再经过一些跳转，可以发现 objc_setAssociatedObject 最终会调用 _object_set_associative_reference方法（objc-runtime.m 268行）

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (if any) outside the lock.
    ObjcAssociation old_association(0, nil);
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
            // break any existing association.
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
                // create the new association (first time).
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // setting the association to nil breaks the association.
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i !=  associations.end()) {
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    refs->erase(j);
                }
            }
        }
    }
    // release the old value (outside of the lock).
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

AssociationsManager manager;, 会创建一个AssociationsManager结构体的变量 manager，在调用它的构造函数时会上锁，调用析构函数时解锁。结构体内有一个静态变量 AssociationsHashMap, 懒加载该变量。
DISGUISE(object) 用来获取 object 的指针地址
AssociationsHashMap是一个无序的哈希表，维护了从对象地址到 ObjectAssociationMap 的映射
ObjectAssociationMap 是一个map，维护了从 key 到 ObjcAssociation 的映射
ObjcAssociation 是一个 C++ 类，主要包括两个成员变量：uintptr_t _policy(关联策略) id _value(关联对象的值)

简单的讲解上面那个函数的流程：

新建一个 AssociationsManager 实例 manager，同时上锁。通过 manager 得到 AssociationsHashMap 关联哈希表 associations，通过 DISGUISE()函数得到 object 的指针 disguised_object。在哈希表 associations 中根据 disguised_object 查找 ObjectAssociationMap，如果没有则新建一个 refs。

新建一个 ObjcAssociation 实例 new_association，存储在 refs 中

如果传入的value是nil，则在 refs 移除该映射关系

释放掉旧的 old_association

作用域结束释放掉 manager，解锁

添加关联对象流程图

分析objc_getAssociatedObject实现

按照上一节的流程，我们首先找到 objc_getAssociatedObject 的最终实现源码：

id _object_get_associative_reference(id object, void *key) {
    id value = nil;
    uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            ObjectAssociationMap *refs = i->second;
            ObjectAssociationMap::iterator j = refs->find(key);
            if (j != refs->end()) {
                ObjcAssociation &entry = j->second;
                value = entry.value();
                policy = entry.policy();
                if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) ((id(*)(id, SEL))objc_msgSend)(value, SEL_retain);
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        ((id(*)(id, SEL))objc_msgSend)(value, SEL_autorelease);
    }
    return value;
}

代码量比上一节少了还挺多哈，过程也类似，就不讲的很细了

先得到 AssociationsHashMap 实例 associations（静态变量）。根据 object 的指针地址，在 associations 得到映射的 ObjectAssociationMap refs。

在 refs 根据 key 得到映射的 ObjcAssociation 实例 entry，在 entry 中可以得到成员变量 _value，也就是我们所关联属性的值。

根据关联策略 policy 进行相应的操作(autorelease, retain)后返回 value

分析objc_removeAssociatedObjects实现

void _object_remove_assocations(id object) {
    vector< ObjcAssociation,ObjcAllocator<ObjcAssociation> > elements;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        if (associations.size() == 0) return;
        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            // copy all of the associations that need to be removed.
            ObjectAssociationMap *refs = i->second;
            for (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
                elements.push_back(j->second);
            }
            // remove the secondary table.
            delete refs;
            associations.erase(i);
        }
    }
    // the calls to releaseValue() happen outside of the lock.
    for_each(elements.begin(), elements.end(), ReleaseValue());
}

其实不看代码应该也能够猜出个大概了吧.

根据 object地址找到映射的 refs，遍历 refs，将保存着的 value 保存在 vector< ObjcAssociation,ObjcAllocator<ObjcAssociation> > elements

删除 refs，然后一个个的释放 elements 里面的值

#给类对象关联对象

看完源代码后，我们知道实例对象地址与 ObjectAssociationMap map是一一对应的。那么是否可以给类对象添加关联对象呢？
答案是可以，因为Class也是一个对象，我们完全可以用同样的方式给类对象添加关联对象，只不过我们一般情况下不会这样做，因为更多时候可以通过 static 变量来实现类级别的变量。

你可以通过下面的代码这样操作

@implementation NSObject (AssociatedObject)
+ (NSString *)associatedObject {
    return objc_getAssociatedObject(self, @selector(associatedObject));
}
+ (void)setAssociatedObject:(NSString *)associatedObject {
    objc_setAssociatedObject(self, @selector(associatedObject), associatedObject, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
@end

- (void) foo {
    NSObject.associatedObject = @"associatedObject";
}

#何时释放关联对象

在探究ARC下dealloc实现中我们研究过，当对象引用计数变为0时会调用 dealloc 方法，然后最终调用 objc_destructInstance 方法来执行释放所有__weak修饰的指向该对象的指针，释放关联对象，释放该对象成员变量的操作

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = !UseGC && obj->hasAssociatedObjects();
        bool dealloc = !UseGC;

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        if (dealloc) obj->clearDeallocating();
    }
    return obj;
}

void _object_remove_assocations(id object) {
    vector< ObjcAssociation,ObjcAllocator<ObjcAssociation> > elements;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        if (associations.size() == 0) return;
        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            // copy all of the associations that need to be removed.
            ObjectAssociationMap *refs = i->second;
            for (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
                elements.push_back(j->second);
            }
            // remove the secondary table.
            delete refs;
            associations.erase(i);
        }
    }
    // the calls to releaseValue() happen outside of the lock.
    for_each(elements.begin(), elements.end(), ReleaseValue());
}

是不是有点熟悉呢，在上上节中我们刚刚分析过这个方法。当对象 dealloc 时，会自动调用 objc_removeAssociatedObjects 方法来释放所有的关联对象。

#总结一下

类实例跟关联对象(关联的属性)并没有直接的存储关系，关联对象在创建时后存储在一个静态哈希表中，根据类实例的指针映射到该关联对象
当类实例 dealloc 后，会从哈希表中释放该实例的所有的关联对象
关联对象的关联策略跟属性的修饰符非常的相似，要合理使用避免 crash
比起其他解决问题的方法，关联对象应该被视为最后的选择

#引用

Associated Objects