Extension 类扩展与关联对象探索

Extension与Category区别

Category

• 专门给类添加新的方法
• 原则上不能给类添加成员属性，但可用过runtime进行属性关联，重写setter和getter方法
• 分类中用@property 定义变量，只会生成变量的setter、getter方法的声明，不能生成方法实现 和 带下划线的成员变量

Extension

• 特殊的分类（匿名分类）
• 可以给类添加成员属性（私有变量）
• 可以给类添加方法（私有方法）

Extension底层探索

类扩展

#import "SLAnimal.h"

@interface SLAnimal()
@property(nonatomic,copy) NSString * ext_name;
-(void)ext_instanceMethod;
+(void)ext_classMethod;
@end

@implementation SLAnimal
-(void)ext_instanceMethod{}
+(void)ext_classMethod{}
@end

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc SLAnimal.m -o SLAnimal.cpp

 Extension的方法，在编译时就直接添加到本类methodlist了

总结 

• Extension在编译时会和类一起编译，并作为类的一部分。
• Extension没.m文件，只有.h，依赖于主类

分类关联对象 底层原理探索

关联对象 主要分为

设值objc_setAssociatedObject

取值objc_getAssociatedObject

@interface SLAnimal (SL)
@property(nonatomic, copy)NSString *cate_name;
@end

@implementation SLAnimal (SL)

- (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");
}

@end

设值 

objc_setAssociatedObject源码，该设计模式属于接口模式，对外的接口不变，内部逻辑变化不影响外部的调用。

 进入_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/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是否存在，存在则继续下一步，不存在就走 : 关联对象-插入空流程
4. 通过try_emplace并创建一个空的 ObjectAssociationMap 去取查询的键值对：如果发现没有这个 key 就插入一个 空的 BucketT进去并返回true
5. 通过setHasAssociatedObjects方法标记对象存在关联对象即置isa指针的has_assoc属性为true
6. 用当前 policy 和 value 组成了一个 ObjcAssociation 替换原来 BucketT 中的空
7. 标记一下 ObjectAssociationMap 的第一次为 false

取值

id
objc_getAssociatedObject(id object, const void *key)
{
    return _object_get_associative_reference(object, key);
}

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

总结

关联对象的底层调用流程如下图所示，（图片转载自Style_月月，感谢🙏）