iOS底层探索之类的加载(四):类的关联对象AssociatedObject

1. 回顾

在前面的几篇博客中，主要讲了类的加载、包括分类的加载底层探索，本次就类的扩展和关联对象进行分析。

iOS底层探索之类的加载(三): attachCategories分析

2. 扩展

2.1 什么是分类和扩展

首先我们来看看什么是分类和扩展

category: 类别/分类

专门用来给类添加新的方法

不能给类添加成员属性，添加了成员变量，也无法取到

注意:其实可以通过runtime给分类添加属性

分类中用@property定义变量，只会生成变量的 getter,setter方法的声明，不能生成方法实现和带下划线的成员变量。

extension:类扩展

可以说成是特殊的分类，也称作匿名分类

可以给类添加成员属性，但是是私有变量

可以给类添加方法，也是私有方法

分类我们已经很熟悉了，这里就不必过多赘述了，下面介绍下扩展 extension

2.2 扩展

类扩展，我们平时用的是非常多的，如下

what ? 什么，这就是扩展吗？天天用居然不知道！
是的，这就是扩展，平时用的是非常之多，但是很多人都不知道。

注意：类扩展要放在声明之后，实现之前，否则会报错。

给扩展加点属性、方法，下面我们看看底层C++是什么样子的。

从底层C++代码可以发现，类的扩展属性会添加到成员变量列表，方法也会放在方法列表里面。

思考：那么扩展是否也会像分类一样，影响主类的加载呢？

建立一个单独的扩展文件
LGPerson.m 导入#import "LGPerson+Ext.h"头文件，实现扩展里面的方法

- (void)ext_sayHello {NSLog(@"%s",__func__);
}
+ (void)ext_classMehod{NSLog(@"%s",__func__);
}

在objc 源码里面，把断点断在realizeClassWithoutSwift处
lldb打印ro方法列表

(lldb) p ro.baseMethods()
(method_list_t *) $0 = 0x0000000100004190Fix-it applied, fixed expression was: ro->baseMethods()
(lldb) p *$0
(method_list_t) $1 = {entsize_list_tt<method_t, method_list_t, 4294901763, method_t::pointer_modifier> = (entsizeAndFlags = 24, count = 8)
}
(lldb) p $1.get(0).big()
(method_t::big) $2 = {name = "saySomething"types = 0x0000000100003e09 "v16@0:8"imp = 0x00000001000039f0 (ObjcBuild`-[LGPerson(LGA) saySomething])
}
(lldb) p $1.get(1).big()
(method_t::big) $3 = {name = "cateA_instanceMethod1"types = 0x0000000100003e09 "v16@0:8"imp = 0x0000000100003a20 (ObjcBuild`-[LGPerson(LGA) cateA_instanceMethod1])
}
(lldb) p $1.get(2).big()
(method_t::big) $4 = {name = "cateA_instanceMethod2"types = 0x0000000100003e09 "v16@0:8"imp = 0x0000000100003a50 (ObjcBuild`-[LGPerson(LGA) cateA_instanceMethod2])
}
(lldb) p $1.get(3).big()
(method_t::big) $5 = {name = "saySomething"types = 0x0000000100003e09 "v16@0:8"imp = 0x00000001000038a0 (ObjcBuild`-[LGPerson saySomething])
}
(lldb) p $1.get(4).big()
(method_t::big) $6 = {name = "sayHello1"types = 0x0000000100003e09 "v16@0:8"imp = 0x00000001000038d0 (ObjcBuild`-[LGPerson sayHello1])
}
(lldb) p $1.get(5).big()
(method_t::big) $7 = {name = "ext_sayHello"types = 0x0000000100003e09 "v16@0:8"imp = 0x0000000100003900 (ObjcBuild`-[LGPerson ext_sayHello])
}
(lldb) p $1.get(6).big()
(method_t::big) $8 = {name = "name"types = 0x0000000100003de3 "@16@0:8"imp = 0x0000000100003930 (ObjcBuild`-[LGPerson name])
}
(lldb)

从调式信息可以看到，在$1.get(5).big()打印了扩展的ext_sayHello方法，这也就证明了，类的扩展信息，也会作为类一部分加载到类里面。

3. 关联对象

在分类里面是不可以直接添加成员变量的，但是我们可以间接的添加，这就涉及到关联对象的知识了。

// 获取关联对象
id
objc_getAssociatedObject(id object, const void *key)
{return _object_get_associative_reference(object, key);
}// 设置关联对象
void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{_object_set_associative_reference(object, key, value, policy);
}// 移除关联对象
void objc_removeAssociatedObjects(id object)
{if (object && object->hasAssociatedObjects()) {_object_remove_assocations(object, /*deallocating*/false);}
}

objc_getAssociatedObject 获取关联对象
objc_setAssociatedObject 设置关联对象
objc_removeAssociatedObjects 移除关联对象

3.1 设值流程

我们来看看下objc_setAssociatedObject设置关联对象方法的里面调用了_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/44094390if (!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<objc_object> disguised{(objc_object *)object};ObjcAssociation association{policy, value};// retain the new value (if any) outside the lock.association.acquireValue();bool isFirstAssociation = false;{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 */isFirstAssociation = true;}/* 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);}}}}}// Call setHasAssociatedObjects outside the lock, since this// will call the object's _noteAssociatedObjects method if it// has one, and this may trigger +initialize which might do// arbitrary stuff, including setting more associated objects.if (isFirstAssociation)object->setHasAssociatedObjects();// release the old value (outside of the lock).association.releaseHeldValue();
}

四个主要的参数是：

objc: 要关联的对象，即给谁添加关联属性
key: 标识符，方便下次查找
value: 要存的值
policy: 关联策略

DisguisedPtr方法是一种包装策略，就像快递一样，打包成一个个包裹，方便存储和查找

class DisguisedPtr {uintptr_t value;static uintptr_t disguise(T* ptr) {return -(uintptr_t)ptr;}static T* undisguise(uintptr_t val) {return (T*)-val;}

对ptr进行了处理，也就是value的处理，也就是对object包装了一下，包装成统一的数据结构。

AssociationsManager

class AssociationsManager {using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;static Storage _mapStorage;public:AssociationsManager()   { AssociationsManagerLock.lock(); }~AssociationsManager()  { AssociationsManagerLock.unlock(); }AssociationsHashMap &get() {return _mapStorage.get();}static void init() {_mapStorage.init();}
};AssociationsManager::Storage AssociationsManager::_mapStorage;}

很多人第一次看到AssociationsManager肯定以为是单例，但是这并不是一个单例，而是通过构造函数加锁、析构函数解锁，以此来达到线程安全。
AssociationsManager只是用来调用AssociationsHashMap方法的作用，但是AssociationsHashMap是一个单例，因为它通过_mapStorage.get()获取，_mapStorage是一个全局静态变量，放在任何地方都是唯一的。

新建一个分类，里面写几个属性和方法进行验证

@interface LGPerson (LGA)@property (nonatomic, copy) NSString *cate_name;
@property (nonatomic, copy) NSString *cate_age;- (void)saySomething;- (void)cateA_instanceMethod1;
- (void)cateA_instanceMethod2;+ (void)cateA_classMethod1;
+ (void)cateA_classMethod2;@end- (void)setCate_name:(NSString *)cate_name{objc_setAssociatedObject(self, "cate_name", cate_name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}- (NSString *)cate_name{return  objc_getAssociatedObject(self, "cate_name");
}- (void)setCate_age:(NSString *)cate_age{objc_setAssociatedObject(self, "cate_age", cate_age, OBJC_ASSOCIATION_COPY_NONATOMIC);
}- (NSString *)cate_age{return objc_getAssociatedObject(self, "cate_age");
}

然后再属性赋值，断点提示

LGPerson * person = [LGPerson alloc];person.cate_name  = @"jp";person.cate_age   = @"20";[person saySomething];

可以看到associations的结构和refs_result结构，这样看可能不太清楚，那么再lldb看看

纳尼？什么鬼啊！refs_result这是个什么玩意啊！

靓仔，不用慌，淡定，请看看下面这个取值

if (refs_result.second) {/* it's the first association we make */isFirstAssociation = true;
}

虽然refs_result很长，很变态，前面那么长只是类型，相当于NSObject、LGPerson这种，但是真正的内容只是后面几个，而这里只是用到了second，其他的压根就不用关心，这一波是不是就很舒服了，哈哈