Objective-C通过联合存储为类增加属性及原理解析

作者：wangzz

原文地址：http://blog.csdn.net/wzzvictory_tjsd/article/details/9347981

转载请注明出处

如果觉得文章对你有所帮助，请通过留言或关注微信公众帐号wangzzstrive来支持我，谢谢！

动态语言的最大好处，就是灵活性，对于Objective-C来说，能在运行时动态地为类增加方法和实例变量是很多其它语言羡慕不已的能力。现在说说为类增加实例变量用到的技术：联合存储。

一、联合存储的实现方式

下面这段代码实现了为Duck类增加color属性：

Duck+associative.h文件

[cpp] view plain copy

1. #import "Duck.h"  
2.   
3. @interface Duck (associative)  
4.   
5. @property (nonatomic, retain) NSString *color;  
6.   
7. @end  

Duck+associative.m文件

[cpp] view plain copy

1. #import "Duck+associative.h"  
2. #import <objc/runtime.h>  
3.   
4. @implementation Duck (associative)  
5.   
6. static char colorKey = NULL;  
7.   
8. - (NSString *)color {  
9.     return objc_getAssociatedObject(self, &colorKey);  
10. }  
11.   
12. - (void)setColor:(NSString *)aColor {  
13.     objc_setAssociatedObject(self, &colorKey,  
14.                              aColor,  
15.                              OBJC_ASSOCIATION_RETAIN);  
16. }  

调用举例：

[cpp] view plain copy

1. Duck    *smallDuck = [[Duck alloc] init];  
2. smallDuck.color = @"red color";  
3. NSLog(@"duck color:%@",smallDuck.color);  
4. [smallDuck release];  

输出结果：

[cpp] view plain copy

1. 2013-07-18 19:09:26.578 ObjcRunTime[429:403] duck color:red color  

至此，我们已经成功的为Duck类增加了一个color属性。

二、为类动态增加属性用到的技术

主要用到了三种设计模式：

1、访问器（accessor）

访问器模式是Cocoa设计模式中很重要的一个，使用它的目的是通过少量的方法（通常时get和set方法）来访问类中每个实例的引用。通过该技术，尽管Duck类没有color实例变量，但是通过联合存储，依然可以实现同访问实例变量完全一样的效果。这些对于类的使用者来说，屏蔽了实现细节。

可以说，访问器模式是通过联合存储实现为类增加属性的必要前提。

2、类别（category）

类别可以在运行时为类动态的增加方法，这是可以利用访问器模式实现为类增加属性的基础。

3、联合存储（associative storage）

通过类别和访问器，再结合联合存储技术，我们完成了为类增加属性的功能。这一切让用户觉得好像真的增加新的实例变量了，但是实际上我们只是通过访问器模拟出来了一个，而不是真正的增加了。

三、联合存储的实现原理

从上面的例子可以看出，为类增加属性看起来是so easy的事情，主要是调了objc_setAssociatedObject和objc_getAssociatedObject两个方法。我的疑问是为类增加的属性对应的对象值存储在哪了呢？下面通过这两个方法的实现部分来寻找答案：

1、objc_setAssociatedObject方法的实现部分：

[cpp] view plain copy

1. void objc_setAssociatedObject(id object, void *key, id value, objc_AssociationPolicy policy) {  
2.     if (UseGC) {  
3.         //这部分是有垃圾回收机制的实现，我们不用管  
4.         if ((policy & OBJC_ASSOCIATION_COPY_NONATOMIC) == OBJC_ASSOCIATION_COPY_NONATOMIC) {  
5.             value = objc_msgSend(value, @selector(copy));  
6.         }  
7.         auto_zone_set_associative_ref(gc_zone, object, key, value);  
8.     } else {  
9.         //这是引用计数机制部分的实现  
10.         // Note, creates a retained reference in non-GC.  
11.         _object_set_associative_reference(object, key, value, policy);  
12.     }  
13. }  

从上述方法中可以看出， objc_setAssociatedObject实际上调用的是：

2、_object_set_associative_reference方法的实现部分：

[cpp] view plain copy

1. __private_extern__ void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {  
2.     // retain the new value (if any) outside the lock.  
3.     uintptr_t old_policy = 0;  
4.     // NOTE:  old_policy is always assigned to when old_value is non-nil.  
5.     id new_value = value ? acquireValue(value, policy) : nil, old_value = nil;  
6.     {  
7.         AssociationsManager manager;  
8.         AssociationsHashMap &associations(manager.associations());  
9.         if (new_value) {  
10.             //如果new_value不为空，开始遍历associations指向的map，查找object对象是否存在保存联合存储数据的ObjectAssociationMap对象  
11.             // break any existing association.  
12.             AssociationsHashMap::iterator i = associations.find(object);  
13.             if (i != associations.end()) {  
14.                 //object对象在associations指向的map中存在一个ObjectAssociationMap对象refs  
15.                 //检查refs中是否使用key保存过value  
16.                 // secondary table exists  
17.                 ObjectAssociationMap *refs = i->second;  
18.                 ObjectAssociationMap::iterator j = refs->find(key);  
19.                 if (j != refs->end()) {  
20.                     //使用过该key保存value，用新的value和policy替换掉原来的值  
21.                     ObjcAssociation &old_entry = j->second;  
22.                     old_policy = old_entry.policy;  
23.                     old_value = old_entry.value;  
24.                     old_entry.policy = policy;  
25.                     old_entry.value = new_value;  
26.                 } else {  
27.                     //没用使用过该key保存value，将value和policy保存到key映射的map中  
28.                     (*refs)[key] = ObjcAssociation(policy, new_value);  
29.                 }  
30.             } else {  
31.                 // object对象在associations指向的map中不存在一个ObjectAssociationMap对象  
32.                 // 则新建一个ObjectAssociationMap对象，并将new_value通过key的地址映射到该map中保存  
33.                 // create the new association (first time).  
34.                 ObjectAssociationMap *refs = new ObjectAssociationMap;  
35.                 associations[object] = refs;  
36.                 (*refs)[key] = ObjcAssociation(policy, new_value);  
37.                 _class_assertInstancesHaveAssociatedObjects(object->isa);//通知object对象，绑定了一个新的值  
38.             }  
39.         } else {  
40.             //new_value为空，如果使用过该key保存过value，则解除使用该key保存的value值  
41.             // setting the association to nil breaks the association.  
42.             AssociationsHashMap::iterator i = associations.find(object);  
43.             if (i != associations.end()) {  
44.                 ObjectAssociationMap *refs = i->second;  
45.                 ObjectAssociationMap::iterator j = refs->find(key);  
46.                 if (j != refs->end()) {  
47.                     ObjcAssociation &old_entry = j->second;  
48.                     old_policy = old_entry.policy;  
49.                     old_value = (id) old_entry.value;  
50.                     refs->erase(j);  
51.                 }  
52.             }  
53.         }  
54.     }  
55.     // release the old value (outside of the lock).  
56.     if (old_value) releaseValue(old_value, old_policy);  
57. }  

3、通过这个方法的实现部分可以清楚的看出，在runtime系统中：
① 有一个单例的AssociationsHashMap实例

该实例的生成方式如下：

[cpp] view plain copy

1. AssociationsHashMap &associations() {  
2.         if (_map == NULL)  
3.             _map = new(::_malloc_internal(sizeof(AssociationsHashMap))) AssociationsHashMap();  
4.         return *_map;  
5.     }  

②AssociationsHashMap实例用于保存一个个的ObjectAssociationMap对象

③每个类都拥有一个ObjectAssociationMap实例，每个类通过联合存储模式保存的键值对也都保存在ObjectAssociationMap实例中。

④Key对应的值无所谓，我们需要的是key的地址，因此定义key时通常的写法是：

[cpp] view plain copy

1. static char colorKey = NULL;  

也就是说，说有的数据其实还是保存在AssociationsHashMap实例中， 现在似乎一切都豁然开朗了！

四、联合存储的优缺点

1、优点

联合存储的最大的优点，在于它能通过灵活的方式实现为类增加属性。

2、缺点

效率低， 使用单条机器指令就可以访问真正的实例变量，但是访问存储在映射表中的值需要多个函数调用，效率问题还是需要注意的。

事实上，目前许多Cocoa类，像NSAttributedString、NSFileManager、NSNotification、NSProcessInfo等都广泛地使用了联合存储。