本文主要是针对类的加载的扩展，探索下分类的底层实现原理。
1. 类扩展和分类介绍
1.1 category 类别、分类
- 专门用来给类添加新的方法
- 不能给类添加成员变量
- 可以利用
runtime实现关联属性，重写setter、getter方法 - 分类中用
@property定义的属性，只有setter、getter方法的声明，不能生成方法实现和带下划线的成员变量
1.2 extension 类扩展
- 可以说成时特殊的分类，也可称作匿名分类
- 可以给类添加成员属性，但是是私有变量
- 可以给类添加方法，也是私有方法
2. 类扩展底层探索
类的扩展有两种创建方式：
- 直接在类中书写：永远在声明之后，在实现之前(写在
.m文件中) - 通过
command + N 新建->Objective-C File-> 选择Extension
image.jpeg
2.1 通过clang 底层编译
-
写一个类扩展
image.jpeg -
通过
clang -rewrite-objc main.mm -o main.cpp命令生成cpp文件，打开cpp文件，搜索ext_name属性：
image.jpeg -
查看
LGTeacher类扩展的方法，在编译过程中，方法就直接添加到了methodlist中，作为类的一部分，即编译时期直接添加到本类里面
image.jpeg
2.2 总结
- 类的扩展在编译期会作为类的一部分，和类一起编译进来
- 类的扩展只是声明，依赖于当前的主类，没有
.m文件，可以理解为一个.h文件
3. 分类关联对象底层探索
其底层原理的实现，主要分为两个部分：
- 通过
objc_setAssociatedObject设值流程 - 通过
objc_getAssociatedObject取值流程
3.1 关联对象 - 设值流程
-
在分类 LG 中重写
cate_name的setter、getter方法，通过runtime的属性关联方法实现
image.jpeg -
运行程序，断点端在
main中cate_name赋值处
image.jpeg -
继续往下运行，断在
setCate_name方法中：
image.jpeg
其中objc_setAssociatedObject方法有四个参数，分别表示：
参数 1：要关联的对象，即给谁添加关联属性
参数 2：标识符，方便取值
参数 3：
value-
参数 4：属性的
策略，即nonatomic、atomic、assign等，如下所示：
image.jpeg -
进入
objc_setAssociatedObject源码实现
这种设计模式是接口模式，对外的接口不变，内部的逻辑变化不影响外部的调用，类似于set方法的底层源码实现：
image.jpeg -
进入
SetAssocHook.get()方法实现，其中ChainedHookFunction是一个函数指针
image.jpeg -
进入
SetAssocHook，其底层实现是_base_objc_setAssociatedObject，类型是ChainedHookFunction
image.jpeg 所以可以理解为
SetAssocHook.get()等价于_base_objc_setAssociatedObject
void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
SetAssocHook.get()(object, key, value, policy);//接口模式，对外接口始终不变
}
👇等价于
void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
_base_objc_setAssociatedObject(object, key, value, policy);//接口模式，对外接口始终不变
}
-
进入
_base_objc_setAssociatedObject，通过断点调试，确实会来到这里：
image.jpeg 进入
_object_set_associative_reference方法
关键的方法，关于关联对象底层原理的探索，主要是看value存到了哪里，以及如何取出value，下面是源码：
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));
//object封装一层，类型为DisguisedPtr
DisguisedPtr<objc_object> disguised{(objc_object *)object};//相当于包装了一下 对象object,便于使用
// 包装一下 policy - value
ObjcAssociation association{policy, value};
// retain the new value (if any) outside the lock.
// 根据策略类型对value进行处理
association.acquireValue();//根据策略类型进行处理
//局部作用域空间
{
//初始化manager变量，相当于自动调用AssociationsManager的析构函数进行初始化
AssociationsManager manager;//并不是全场唯一，构造函数中加锁只是为了避免重复创建，在这里是可以初始化多个AssociationsManager变量的
AssociationsHashMap &associations(manager.get());//AssociationsHashMap 全场唯一
if (value) {
auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});//返回的结果是一个类对
if (refs_result.second) {//判断第二个存不存在，即bool值是否为true
/* it's the first association we make 第一次建立关联*/
object->setHasAssociatedObjects();//nonpointerIsa ，标记位true
}
/* establish or replace the association 建立或者替换关联*/
auto &refs = refs_result.first->second; //得到一个空的桶子，找到引用对象类型,即第一个元素的second值
auto result = refs.try_emplace(key, std::move(association));//查找当前的key是否有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();//释放
}
通过源码可以知道，主要分为以下几部分：
1.创建一个 AssociationsManager 管理类
2.获取唯一的全局静态哈希表：AssociationsHashMap
3.判断插入的关联值 value 是否存在
. 3.1 存在则继续向下走
. 3.2 不存在就走：关联对象-插入空流程，也就是移除关联对象流程
4.通过try_emplace方法，并创建一个空的ObjectAssociationMap去取查询的键值对
5.如果发现没有这个key，就插入一个空的BuckeT 进去并返回 true
6.通过setHasAssociatedObjects方法标记对象存在关联对象即置isa指针的has_assoc属性为true
7.用当前policy 和value 组成了一个ObjcAssociation 替换原来 BucketT 中的空
8.标记一下ObjectAssociationMap的第一次为 false
下面进行源码调试：
定义
AssociationsManager类型的变量，相当于自动调用AssociationsManager的构造函数进行初始化
加锁lock，并不代表唯一，只是为了避免多线程重复创建，其实在外面是可以定义多个AssociationsManager manager;的-
定义
AssociationsHashMap类型的HashMap，这个是唯一的，从哪里可以体现呢？
通过_mapStorage.get()生成HashMap，其中_mapStorage是一个静态变量，所以永远是唯一的
image.jpeg
可以看到这个 hashMap 的key 是前面对于 object的封装：DisguisedPtr<objc_object>，value 是ObjectAssociationMap类型。
-
经过调试，可以查看当前的数据结构：
p disguised: 其中的 value 是来自 object 还原出来的
p association
p manager
p associations: 目前的associations为0x0，表示还没有查找到相应的递归查找域中
image.jpeg -
走到局部作用域的
if判断，此时value是有值的，为KC
image.jpeg -
如果传入的
value是空值，则会走到else流程，通过源码得知，相当于解除关联
image.jpeg -
继续往下执行，查看
refs_result，通过p refs_result，其中的类型很多，可以进行拆解查看
associations调用try_emplace方法，传入一个对象disguised和一个空的关联map:ObjectAssociationMap{}
image.jpeg
//pair -- 表示有键值对
(std::__1::pair<
objc::DenseMapIterator<DisguisedPtr<objc_object>,
objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> >,
objc::DenseMapValueInfo<objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > >,
objc::DenseMapInfo<DisguisedPtr<objc_object> >,
objc::detail::DenseMapPair<DisguisedPtr<objc_object>, objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > >,
false>,
bool>)
//可以简写为
(std::__1::pair<
objc
bool>)
- 进入
try_emplace方法的源码实现
有两个返回值，都是通过std::make_pair生成相应的键值对；
通过LookupBucketFor方法查找桶子，如果map中已经存在，则直接返回，其中make_pair的第二个参数bool值为false；
如果没有找到，则通过InsertIntoBucket插入map，其中make_pair的第二个参数bool值为true
std:: make_pair主要作用是将两个数据合成一个数据，然后通过返回值的.first和.second进行使用
-
进入
LookupBucketFor源码，有两个同名方法，其中第二个方法属于重载函数，区别于第一个的是第二个参数没有const修饰，通过调试可知，外部的调用是调用的第二个重载函数，而第二个LookupBucketFor方法，内部的实现是调用第一个LookupBucketFor方法：
image.jpeg -
第一个
LookupBucketFor方法实现：
image.jpeg -
断点运行值
try_emplace方法中，获取bucket部分TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);:
然后p TheBucket
image.jpeg
其中 TheBucket 的类型与refs_result中属性的类型是一致的：
-
进入
if(refs_result.second)的流程，通过setHasAssociatedObjects将nonpointerIsa的has_assoc标记为true:
image.jpeg -
继续往下执行，查看
refs
p refs，执行try_emplace前查看
p refs，执行try_emplace后查看
image.jpeg
第一次执行try_emplace插入的是一个空桶，还没有值，第二次执行 try_emplace才插入值，即往空桶中插入ObjectAssociationMap（value，policy），返回true，可以通过调试验证：
p result.second，返回的true，到此就将属性和 value 关联上了：
3.1.1 全部流程
所以，关联对象的设值流程，有点类似于cache_t中的insert方法插入sel-imp的逻辑，如下图所示:
属性关联涉及的hashMap 结构：
-
AssociationsManager可以有多个，通过AssociationsManagerLock锁可以得到一个AssociationsHashMap类型的map
-map中有很多关联对象 map，类型是ObjectAssociationMap，其中 key 为DisguisedPtr<objc_object>
typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;
-
ObjectAssociationMap哈希表中有很多key-value键值对，其中key的类型为const void *，这个key也就是我们关联属性时设置的字符串，value的类型为ObjcAssociation：
typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;
-
其中ObjcAssociation是用于包装policy和value的一个类
image.jpeg
3.1.2 对象插入空流程
根据源码可知，主要是局部作用域中的else流程，其实这个流程可以通俗的理解为当传入的value为nil时，则移除关联，主要分为以下几步：
- 根据
DisguisedPtr找到AssociationsHashMap中的iterator迭代查询器 - 清理迭代器
- 其实如果插入空值，相当于清除
3.2 关联对象-取值流程
-
main中 打印
person.cate_name的值，断点来到分类中重写的属性get方法
image.jpeg -
进入
objc_getAssociatedObject源码实现
image.jpeg _object_get_associative_reference源码如下：
id
_object_get_associative_reference(id object, const void *key)
{
ObjcAssociation association{};//创建空的关联对象
{
AssociationsManager manager;//创建一个AssociationsManager管理类
AssociationsHashMap &associations(manager.get());//获取全局唯一的静态哈希map
AssociationsHashMap::iterator i = associations.find((objc_object *)object);//找到迭代器，即获取buckets
if (i != associations.end()) {//如果这个迭代查询器不是最后一个 获取
ObjectAssociationMap &refs = i->second; //找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
ObjectAssociationMap::iterator j = refs.find(key);//根据key查找ObjectAssociationMap，即获取bucket
if (j != refs.end()) {
association = j->second;//获取ObjcAssociation
association.retainReturnedValue();
}
}
}
return association.autoreleaseReturnedValue();//返回value
}
通过源码可知，主要分为以下几部分：
1.创建一个AssociationsManager 管理类
2.获取唯一的全局静态哈希Map：AssociationsHashMap
3.通过find方法根据 DisguisedPtr 找到 AssociationsHashMap中的 iterator 迭代查询器
4.如果这个迭代查询器不是最后一个 获取 :ObjectAssociationMap(policy和value)
5.通过find方法找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
6.返回 value
3.2.1 调试取值流程
- 接着上一步调试，进入
_object_get_associative_reference源码实现
进入find方法：根据关联对象迭代查找AssociationsHashMap，即buckets：
image.jpeg
- 再次通过
find方法，在buckets中查找与key配对的bucket
find方法执行之前，j的打印，此时的value为nil
image.jpeg
find方法查询之后，j的打印，此时的value为KC
3.3 总结
所以，综上所述，所以关联对象的底层调用流程如下图所示
总的来说，关联对象主要就是两层哈希map的处理，即存取时都是两层处理。
4. 关联对象的释放
上面介绍了关联对象的取值流程和设值流程，那么关联对象是在什么时候释放的呢？
我们知道对象的销毁会调用dealloc方法，先来看下这个方法：
// Replaced by NSZombies
- (void)dealloc {
_objc_rootDealloc(self);
}
其中调用了_objc_rootDealloc方法，源码如下：
void
_objc_rootDealloc(id obj)
{
ASSERT(obj);
obj->rootDealloc();
}
继续调用了obj->rootDealloc()，源码如下：
inline void
objc_object::rootDealloc()
{
if (isTaggedPointer()) return; // fixme necessary?
if (fastpath(isa.nonpointer &&
!isa.weakly_referenced &&
!isa.has_assoc &&
!isa.has_cxx_dtor &&
!isa.has_sidetable_rc))
{
assert(!sidetable_present());
free(this);
}
else {
object_dispose((id)this);
}
}
这里发现了一个关键点：isa.hass_assoc，我们在设值流程中，就是给 isa.hass_assoc进行赋值了，标志这个对象有关联的属性，所以这里会走else 流程，也就是object_dispose((id)this);，这个方法源码如下：
id
object_dispose(id obj)
{
if (!obj) return nil;
objc_destructInstance(obj);
free(obj);
return nil;
}
free(obj)是释放对象，那么关联对象的移除就是在objc_destructInstance(obj);里面了，我们看下objc_destructInstance这个方法，源码如下：
void *objc_destructInstance(id obj)
{
if (obj) {
// Read all of the flags at once for performance.
bool cxx = obj->hasCxxDtor();
bool assoc = obj->hasAssociatedObjects();
// This order is important.
if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_assocations(obj);
obj->clearDeallocating();
}
return obj;
}
这个方法中发现if (assoc) _object_remove_assocations(obj);是移除关联属性的方法，我们继续探索_object_remove_assocations方法，源码如下：
void
_object_remove_assocations(id object)
{
ObjectAssociationMap refs{};
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.get());
AssociationsHashMap::iterator i = associations.find((objc_object *)object);
if (i != associations.end()) {
refs.swap(i->second);
associations.erase(i);
}
}
// release everything (outside of the lock).
for (auto &i: refs) {
i.second.releaseHeldValue();
}
}
可以看到这里是将对象 object 关联的表全部移除了，从全局的 HashMap 找到object 的迭代器，将对象关联的ObjectAssociationMap全部移除。
调用链为：dealloc -> _objc_rootDealloc -> object_dispose() ->
objc_destructInstance() -> _object_remove_assocations。
