博客链接 从源码理解关联属性
在类中，我们使用@property (nonatomic, copy) NSString *name生成一个属性。它干了三件事情：
- 声明一个
_name的变量； - 声明
setName:和getName方法； - setter和getter方法的默认实现；
但是在分类中写上述这样一个属性的，它只有setter和getter方法的声明，并不会生成成员变量和实现setter和getter方法，因此如果想要在分类中实现属性的话得使用关联对象的方式。
关联对象的使用
首先我们要明白为什么要使用关联对象？
在分类中@property并不会自动生成实例变量以及存取方法，另外在分类是不能声明成员变量的。从源码的角度去看，Category在编译时期生成的结构体中根本没有存放成员变量的数组。基于上面的原因，如果我们要实现类中属性那样的效果，就要使用关联对象。
关联对象的应用如下：
// .h
@interface FatherA : NSObject
@property (nonatomic, copy) NSString *name;
@end
// .m
@implementation FatherA
- (void)setName:(NSString *)name {
objc_setAssociatedObject(self,
@selector(name),
name,
OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)name {
return objc_getAssociatedObject(self, _cmd);
}
@end
关联对象的实现
这里使用objc4-750.1的源代码，你可以通过这里下载。我们常用的关于关联对象的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);
这三个方法的作用分别是：
- 以键值对形式添加关联对象
- 根据key获取关联对象
- 移除所有关联对象
关联对象的核心对象
在分析关联对象的API实现之前，先看一下关联对象的核心对象。
AssociationsManager
AssociationsManager的定义如下：
spinlock_t AssociationsManagerLock;
class AssociationsManager {
// associative references: object pointer -> PtrPtrHashMap.
static AssociationsHashMap *_map;
public:
AssociationsManager() { AssociationsManagerLock.lock(); }
~AssociationsManager() { AssociationsManagerLock.unlock(); }
AssociationsHashMap &associations() {
if (_map == NULL)
_map = new AssociationsHashMap();
return *_map;
}
};
AssociationsHashMap *AssociationsManager::_map = NULL;
AssociationsManager会维护一个AssociationsHashMap，在初始化的时候，调用AssociationsManagerLock.lock()，在析构时会调用AssociationsManagerLock.unlock()，而associations用于取得一个全局的AssociationsHashMap。
另外AssociationsManager通过一个自旋锁spinlock_t AssociationsManagerLock来确保对AssociationsHashMap的操作是线程安全的。
AssociationsHashMap
HashMap相当于OC中的NSDictionary。AssociationsHashMap的定义如下：
class AssociationsHashMap : public unordered_map<disguised_ptr_t, ObjectAssociationMap *, DisguisedPointerHash, DisguisedPointerEqual, AssociationsHashMapAllocator> {
public:
void *operator new(size_t n) { return ::malloc(n); }
void operator delete(void *ptr) { ::free(ptr); }
};
AssociationsHashMap继承自unordered_map，使用的是C++语法。它的作用就是保存从对象的disguised_ptr_t到ObjectAssociationMap的映射。 我们可以理解为AssociationsHashMap以key-value的形式存着若干个ObjectAssociationMap。
ObjectAssociationMap
ObjectAssociationMap的定义如下：
class ObjectAssociationMap : public std::map<void *, ObjcAssociation, ObjectPointerLess, ObjectAssociationMapAllocator> {
public:
void *operator new(size_t n) { return ::malloc(n); }
void operator delete(void *ptr) { ::free(ptr); }
};
ObjectAssociationMap保存了从key到ObjcAssociation的映射，我们可以理解为ObjectAssociationMap以key-value的形式存着若干个ObjcAssociation对象。这个数据结构保存了当前对象对应的所有关联对象：
ObjcAssociation
ObjcAssociation的定义如下：
class ObjcAssociation {
uintptr_t _policy;
id _value;
public:
ObjcAssociation(uintptr_t policy, id value) : _policy(policy), _value(value) {}
ObjcAssociation() : _policy(0), _value(nil) {}
uintptr_t policy() const { return _policy; }
id value() const { return _value; }
bool hasValue() { return _value != nil; }
};
ObjcAssociation对象保存了对象对应的关联对象，其中的_policy和_value字段存的便是我们使用objc_setAssociatedObject方法时传入的policy和value。
objc_setAssociatedObject
通过objc_setAssociatedObject函数，我们添加一个关联对象，其实现如下：
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) {
_object_set_associative_reference(object, (void *)key, value, policy);
}
接着看一下_object_set_associative_reference的实现：
void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
// retain the new value (if any) outside the lock.
// 创建一个ObjcAssociation局部变量，持有原有的关联对象和最后的释放
ObjcAssociation old_association(0, nil);
// 调用acquireValue对new_value进行retain或者copy
id new_value = value ? acquireValue(value, policy) : nil;
{
// 初始化一个AssociationsManager，并获取AssociationsHashMap
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
// disguised_ptr_t是AssociationsHashMap中的key，通过传入的object得到
disguised_ptr_t disguised_object = DISGUISE(object);
// new_value有值代表设置或者更新关联对象的值，否则表示删除一个关联对象
if (new_value) {
// break any existing association.
// 查找ObjectAssociationMap
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
// secondary table exists
// ObjectAssociationMap存在
// 判断key是否存在，key存在更新原有的关联对象，key不存在，则新增，并且新增的位置需要结合end()
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不存在
// 初始化一个ObjectAssociationMap，再实例化ObjcAssociation对象添加到Map中，并调用 setHasAssociatedObjects函数
// setHasAssociatedObjects标明当前类具有关联类
// 它会将isa结构体中的has_assoc标记为true
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.
// 查找ObjectAssociationMap
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
// ObjectAssociationMap存在
// 判断key是否存在，key存在则调用erase函数来删除ObjectAssociationMap中key对应的节点
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).
// 原来的关联对象有值，调用ReleaseValue函数释放关联对象的值
if (old_association.hasValue()) ReleaseValue()(old_association);
}
通过上面的源码以及注释可以知道objc_setAssociatedObject的流程，接着我们用一张图片来说明关联对象的原理：
objc_getAssociatedObject
在理解了objc_setAssociatedObject的实现之后，objc_getAssociatedObject就变得容易理解了，其实现如下：
id objc_getAssociatedObject(id object, const void *key) {
return _object_get_associative_reference(object, (void *)key);
}
接着看一下_object_get_associative_reference的实现：
id _object_get_associative_reference(id object, void *key) {
id value = nil;
uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
{
// 初始化一个AssociationsManager，并获取AssociationsHashMap
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
// 通过object获得disguised_ptr_t，用作在AssociationsHashMap的key
disguised_ptr_t disguised_object = DISGUISE(object);
// 查找ObjectAssociationMap的位置
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
// 查找ObjcAssociation对象
if (j != refs->end()) {
ObjcAssociation &entry = j->second;
value = entry.value();
policy = entry.policy();
// 说明是强类型，retain操作
if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
objc_retain(value);
}
}
}
}
if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
// autorelease
objc_autorelease(value);
}
return value;
}
objc_removeAssociatedObjects
objc_removeAssociatedObjects用来删除所有的关联对象，其实现：
void objc_removeAssociatedObjects(id object)
{
if (object && object->hasAssociatedObjects()) {
_object_remove_assocations(object);
}
}
通过hasAssociatedObjects函数判断是否含有关联对象，如果有则调用_object_remove_assocations。
在objc_setAssociatedObject的实现中有提到在添加关联对象的时候如果ObjectAssociationMap不存在，则会初始化一个ObjectAssociationMap，再实例化ObjcAssociation对象添加到Map中，并调用 setHasAssociatedObjects函数。setHasAssociatedObjects函数用来将isa结构体中的has_assoc标记为true，而hasAssociatedObjects函数则用来获取该该标志位的结果。
接着看一下_object_remove_assocations，其实现如下：
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_remove_assocations会将对象包含的所有关联对象加入到一个vector中，删除AssociationsHashMap中对应的节点，然后对所有的 ObjcAssociation对象调用 ReleaseValue()，释放不再被需要的值。
总结
关联对象的实现
- 关联对象的本质就是
ObjcAssociation对象； -
ObjectAssociationMap以key为健存储关联对象的数据结构（ObjcAssociation对象）； - 每一个对象都对应着一个
ObjectAssociationMap，对象中的has_assoc用来确定是否含有关联对象，而对象与ObjectAssociationMap之间的映射关系则存储在AssociationsHashMap中； -
AssociationsHashMap是全局唯一的，有AssociationsManager管理。
分类中能否实现属性
如果将属性看成是实例变量，那答案是不能，如果将属性看成是存取方法以及存储值的集合，那么分类是可以实现属性的，个人更倾向于前者。
weak类型的关联对象
关联对象里是没有weak类型的策略，而在开发过程中，真的几乎没有说要用弱类型的关联对象，除非是为了用而用。我是这么理解的，既然叫做关联对象，那肯定需要和自身生命周期有联系才谈得上关联，使用weak则代表对象和自身生命周期是没有联系，自身的释放不会影响关联对象。综上我认为weak类型的关联对象是没有意义的。
但是如果非要实现一个weak类型的关联对象也不是不可以，拿个中间对象包装一下即可。代码如下：
#pragma mark - Weak Associated Object
@interface _NNWeakAssociatedWrapper : NSObject
@property (nonatomic, weak) id associatedObject;
@end
@implementation _NNWeakAssociatedWrapper
@end
void nn_objc_setWeakAssociatedObject(id object, const void * key, id value) {
_NNWeakAssociatedWrapper *wrapper = objc_getAssociatedObject(object, key);
if (!wrapper) {
wrapper = [_NNWeakAssociatedWrapper new];
objc_setAssociatedObject(object, key, wrapper, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
wrapper.associatedObject = value;
}
id nn_objc_getWeakAssociatedObject(id object, const void * key) {
id wrapper = objc_getAssociatedObject(object, key);
id objc = wrapper && [wrapper isKindOfClass:_NNWeakAssociatedWrapper.class] ?
[(_NNWeakAssociatedWrapper *)wrapper associatedObject] :
nil;
return objc;
}
