本文的主要目的是针对类的加载的一个扩展，主要讲讲类扩展和分类的底层实现原理
1. 类扩展底层原理探索
1.1 类扩展的创建方式
1、 直接在类中书写：永远在声明之后，在实现之前（需要在.m文件中书写）
2、 通过 command+N 新建 -> Objective-C File -> 选择Extension
1.2 类扩展的本质
1.2.1 通过clang底层编译
step1:
- 创建一个
LBHPerson类，声明一个属性和一个实例方法，方法只声明不实现
//.h
@interface LBHPerson : NSObject
@property (nonatomic, copy) NSString *name;
- (void)instanceMethod;
@end
//.m
@implementation LBHPerson
@end
- 创建一个基于
LBHPerson的类扩展LBHPerson+EXT，并声明一个属性和一个实例方法
@interface LBHPerson ()
@property (nonatomic, copy) NSString *ext_name;
- (void)ext_instanceMethod;
@end
step2: cd到main.m所在的文件夹，通过clang -rewrite-objc main.m -o main.cpp命令生成cpp文件，打开cpp文件，搜索ext_name属性
在编译阶段，分类的属性已经添加到本类里面
step3:查看方法列表
这里只有根据属性自动生成的setter、gettter方法，声明的方法并没有出现在这里
问题：声明的方法在方法列表中找不到，怎么办？
解答:
方法列表中存储的都是方法的实现，想要出现方法列表中，必须要有方法实现。
1.2.2 通过源码调试探索
step1: 创建LBHPerson+EXT.h即类的扩展，并声明两个方法
step2: 在LBHPerson.m 中实现这两个方法
step3: 在objc4源码中找到readClass函数，
step4: 在readClass函数打上断点，运行程序，
step5: 查看所有方法 p kc_ro->baseMethodList
总结
类扩展 在编译阶段 会作为类的一部分，和类一起编译进来类的扩展只是声明，依赖于当前的主类，没有.m文件，可以理解为一个·h文件
2. 分类关联对象底层原理探索
其底层的实现主要为两部分:
* 通过objc_setAssociatedObject设值流程
* 通过objc_getAssociatedObject取值流程
2.1 关联对象-设值流程
step1: 创建一个分类LBHPerson+Category，
//.h 声明两个属性
@interface LBHPerson (Category)
@property (nonatomic, copy) NSString *cate_name;
@property (nonatomic, assign) int cate_age;
@end
//.m
@implementation LBHPerson (Category)
@end
step2: 重写属性cate_name的set、get方法，通过runtime的属性关联方法实现
- (void)setCate_name:(NSString *)cate_name
{
/**
1: 对象
2: 标识符
3: value
4: 策略
*/
objc_setAssociatedObject(self, "cate_name", cate_name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)cate_name
{
return objc_getAssociatedObject(self, @"cate_name");
}
其中
objc_setAssociatedObject方法有四个参数，分别表示：
参数1：要关联的对象，即给谁添加关联属性
参数2：标识符，方便下次查找
参数3：value
参数4：属性的策略，即nonatomic、atomic、assign等，如下所示
step3: 进入objc_setAssociatedObject源码
这种设计模式属于是接口模式，对外的接口不变，内部的逻辑变化不影响外部的调用， 类似于set方法的底层源码实现
step4: 进入get方法实现，其中 ChainedHookFunction是一个函数指针
step5: 返回上一步，进入SetAssocHook，其底层实现是_base_objc_setAssociatedObject，类型是ChainedHookFunction
static void
_base_objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
_object_set_associative_reference(object, key, value, policy);
}
static ChainedHookFunction<objc_hook_setAssociatedObject> SetAssocHook{_base_objc_setAssociatedObject};
所以可以理解为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);//接口模式，对外接口始终不变
}
step6: 进入_base_objc_setAssociatedObject源码实现：_base_objc_setAssociatedObject -> _object_set_associative_reference，通过断点调试，确实会来到这里
_object_set_associative_reference 方法
进入_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.
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：获取唯一的
全局静态哈希Map：AssociationsHashMap - 3：判断是否插入的
关联值value是否存在- 3.1：存在走第4步
- 3.2：不存在就走 :
关联对象-插入空流程
- 4：通过
try_emplace方法，并创建一个空的ObjectAssociationMap去取查询的键值对： - 5：如果发现
没有这个 key就插入一个空的 BucketT进去并返回true - 6：通过
setHasAssociatedObjects方法标记对象存在关联对象即置isa指针的has_assoc属性为true - 7：用当前
policy和value组成了一个ObjcAssociation替换原来BucketT中的空 - 8：标记一下
ObjectAssociationMap的第一次为false
