空白诗007

这个屌丝很懒，什么也没留下！

热门标签

【iOS】—— 分类，扩展和关联对象_ios 分类

作者：空白诗007 | 2024-08-29 08:57:50

踩

ios 分类

分类，扩展和关联对象

在上周中学习JSONModel源码的过程中，源码里用到了许多关联对象的知识，之前在学小蓝书的时候对这一部分内容学习并不完整，在这作以补充：

分类和扩展

分类概念

Category是Objective-C 2.0之后添加的语言特性，分类、类别其实都是指的Category。
Category的主要作用是为已经存在的类添加方法。也可以说是将庞大的类代码按逻辑划入几个分区。
分类的特性是可以在运行时阶段动态的为已有的类添加新行为。
Objective-C 中Category 就是对装饰模式的一种具体实现。它的主要作用是在不改变原有类的前提下，动态地给这个类添加一些方法。
分类也可以把framework私有方法公开化
比如我们假如我有一个类里有一个私有方法A 外界是调用不到的但是我给这个类写了个category 在里里面申明了一个方法（也叫A，只申明，不实现）现在我import这个category 调用这个A 的情况是怎么样的呢？实际上这时候就会调用私有方法这个A，我们通过分类将私有方法公开化了。

扩展概念

扩展(Extension)有时候被称为匿名分类。但是两者实质上不是一个内容。
扩展是在编译阶段与该类同时编译的，是类的一部分。扩展中声明的方法只能在该类的@implementation中实现。所以这也就意味着我们无法对系统的类使用扩展。
同时与分类不同，扩展不但可以声明方法，还可以声明成员变量，这是分类所做不到的。

两者区别

1.分类原则上只能增加方法，但是也可以通过关联属性增加属性
2.拓展可以增加方法和属性，都是私有的。
3.扩展只能在自身类中使用，而不是子类或者其他地方。
4.类扩展是在编译阶段添加到类中，而分类是在运行时添加到类中

分类的实质

typedef struct category_t *Category;
struct category_t {
    const char *name;
    classref_t cls;
    struct method_list_t *instanceMethods;  //实例方法
    struct method_list_t *classMethods; //类方法
    struct protocol_list_t *protocols;  //协议
    struct property_list_t *instanceProperties; //实例属性
    // Fields below this point are not always present on disk.
    struct property_list_t *_classProperties;   //类属性

    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }

    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};

从结构体可以知道，有属性列表,所以分类可以声明属性，但是分类只会生成该属性对应的get和set的声明，没有去实现该方法。
结构体没有成员变量列表，所以不能声明成员变量。
方法可以运行时改变，结构体不能运行时改变，要想改变原结构体，增加一个属性，只能用关联变量的方式，而关联本质是在类的定义之外为类增加额外的存储空间，是一层映射关系

关联对象

通过关联对象给分类添加属性

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface NSObject (testCategory)
@property (nonatomic, strong) id associatedObject;
@end

NS_ASSUME_NONNULL_END

首先在分类的.h文件里声明一个属性，然后在main中给属性赋值：

#import <Foundation/Foundation.h>
#import "NSObject+testCategory.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSObject *obj = [[NSObject alloc] init];
        obj.associatedObject = @"1";
        NSLog(@"%@",obj.associatedObject);
        [obj setAssociatedObject:@"2"];
        NSLog(@"%@",obj.associatedObject);
    }
    return 0;
}

我们发现在编译中并没有报错，然而在运行的时候出现崩溃：
在这里插入图片描述

添加的属性系统并没有自动生成成员变量，也没有实现set和get方法，只是生成了set和get方法的声明。这就是为什么在分类中扩展了属性，在外部并没有办法调用。
在外部调用点语法设值和取值，本质其实就是调用属性的set和get方法，现在系统并没有实现这两个方法，所以外部就没法调用分类中扩展的属性。

关联对象的用处

运行时给cagetory添加getter和setter。因为category中添加的property不会生成带下划线"_"的成员变量以及getter和setter的实现。所以可以通过关联对象实现getter和setter。
有时需要在对象中存储一些额外的信息，我们通常会从对象所属的类中继承一个子类。然后给这个子类添加额外的属性，改用这个子类。然而并非所有的情况都能这么做，有时候类的实例可能是由某种机制创建的，而开发者无法另这种机制创建出自己所写的子类实例。此时可以使用“关联对象”。
有时只是给某个类添加一个额外的属性，完全没有必要继承出来一个子类。此时可以使用“关联对象”。
delegate回调的方法中使用关联对象。有时候在一些delegate回调的方法中需要处理一些回调任务。比如发起网络请求和在delegate回调的方法中做UI的更新。这样一来，发起网络请求和在回调中更新UI的代码被分散到了两个地方，不利于管理和阅读。此时可以使用“关联对象”。

关联对象的API

添加关联对象
void objc_setAssociatedObject(id object, const void * key, id value, objc AssociationPolicy policy)

获得关联对象
id objc_getAssociatedObject(id object, const void * key)

移除所有的关联对象
void objic_removeAssociatedObjects(id object)

set方法的参数：

参数一：id object : 给哪个对象添加属性。
参数二：const void *key : 关联对象中属性值存取过程中对应唯一标识，根据key来设置和取值。
参数三：id value : 关联的值，也就是set方法传入的值给属性去保存。
参数四：objc AssociationPolicy policy : 策略，属性以什么形式保存。

参数二：

	给key设值有三种比较好的的方法
	因为key值类型为const void*,任何类型的值，其实就是给个唯一的标识
	
	1.我们针对每个属性，定义-个全局的key名， 然后取其地址，这一定是唯一的加上static,只在文件内部有效
	static const void *NameKey = &NameKey;
	static const void *WeightKey = &WeightKey;
	
	2.针对每个属性，因为类中的属性名是唯一的，直接拿属性名作为key
	#define NameKey = @"name";
	#define WeightKey = @"weight";
	
	3.使用@selector作为key
	直接用属性名对应的get方法的selector,有提示不容易写错
	并且get方法隐藏参数cmd 可以直接用，看上去就会更加简洁
	以下实例代码就是用的第三种方式

参数四枚举类型：

typedef OBJC ENUM(uintptr_t, objc_AssociationPolicy) {
	OBJC_ ASSOCIATION_ASSIGN = 0, //指定个弱引用相关联的对象
	OBJC_ ASSOCIATION_RETAIN_NONATOMIC = 1; //指定相关对象的强引用， 非原子性
	OBJC_ ASSOCIATION_COPY_NONATOMIC = 3; //指定相关的对象被复制， 非原子性
	OBJC_ ASSOCIATION_RETAIN = 01401; //指定相关对象的强引用，原子性
	OBJC_ ASSOCIATION_COPY = 01403; //指定相关的对象被复制， 原子性
};

给声明的属性添加setter，getter方法

#import "NSObject+testCategory.h"
#import <objc/runtime.h> // 关联对象相关api在runtime库中
@implementation NSObject (testCategory)
- (void)setAssociatedObject:(id)object {

    objc_setAssociatedObject(self, @selector(associatedObject), object, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

}

- (id)associatedObject {

    return objc_getAssociatedObject(self, _cmd);

}

@end

这时候运行main代码：
在这里插入图片描述

在get方法中我们看到了_cmd参数，这是个什么东西呢？

_cmd 是隐藏的参数，表示当前方法的selector，他和self表示当前方法调用的对象实例。
获取当前被调用方法： NSStringFromSelector(_cmd)
在运行时时使用：在某个分类方法里为对象动态添加属性，由于_cmd是在编译时候（compile - time）就可以确定的值，因此可以直接使用

关联对象底层源码

实现关联对象的核心对象有

AssociationsManager
AssociationsHashMap
ObjectAssociationMap
ObjcAssociation

objc_setAssociatedObject(self, @selector(associatedObject), object, OBJC_ASSOCIATION_RETAIN_NONATOMIC);实际调用下面的方法：

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.
    //isa有一位信息为禁止关联对象，如果设置了，直接报错
    if (!object && !value) return;
    // 判断runtime版本是否支持关联对象
    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};
    // // 将 policy和value 封装成ObjcAssociation，目的是方便底层统一处理
    ObjcAssociation association{policy, value};
    // (如果有新值)保留锁外的新值。
    // retain the new value (if any) outside the lock.
    // 根据传入的缓存策略，创建一个新的value对象
    association.acquireValue();

    bool isFirstAssociation = false;
    {
    //调用构造函数，构造函数内加锁操作
        AssociationsManager manager; 
        // 创建一个管理对象管理单例，类AssociationsManager管理一个锁/哈希表单例对。分配一个实例将获得锁
        // 并不是全场唯一，构造函数中加锁只是为了避免重复创建，在这里是可以初始化多个AssociationsManager变量的
        
        //获取全局的HasMap
        // 全场唯一
        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 */
                // 这是我们建立的第一个关联
                //说明是第一次设置关联对象，把是否关联对象设置为YES
                isFirstAssociation = true;
            }
            // 建立或替换关联
            /* establish or replace the association */
            // 获取ObjectAssociationMap中存储值的地址
            auto &refs = refs_result.first->second;
            // 移除之前的关联，根据key
            // 将需要存储的值存放在关联表中存储值的地址中
            // 同时会根据key去查找，如果查找到`result.second` = false ，如果找不到就创建`result.second` = true
            // 创建association时，当（association的个数+1）超过3/4，就会进行两倍扩容
            auto result = refs.try_emplace(key, std::move(association));
            if (!result.second) {
                // 交换association和查询到的`association`
                // 其实可以理解为更新查询到的`association`数据，新值替换旧值
                association.swap(result.first->second);
            }
        } else {
            // 这里相当于传入的nil，移除之前的关联
            // 到AssociationsHashMap找到ObjectAssociationMap，将传入key对应的值变为空。
            // 查找disguised 对应的ObjectAssociationMap
            auto refs_it = associations.find(disguised);
            // 如果找到对应的 ObjectAssociationMap 对象关联表
            if (refs_it != associations.end()) {
                // 获取 refs_it->second 里面存放了association类型数据
                auto &refs = refs_it->second;
                // 根据key查询对应的association
                auto it = refs.find(key);
                if (it != refs.end()) {
                    // 如果找到，更新旧的association里面的值
                    association.swap(it->second);
                    refs.erase(it);
                    if (refs.size() == 0) {
                        // 如果该对象关联表中所有的关联属性数据被清空，那么该对象关联表会被释放
                        associations.erase(refs_it);

                    }
                }
            }
        }
    }
    // 在锁外面调用setHasAssociatedObjects，因为如果对象有一个，这个//将调用对象的noteAssociatedObjects方法，这可能会触发initialize，这可能会做任意的事情，包括设置更多的关联对象。
    if (isFirstAssociation)
        object->setHasAssociatedObjects();

    // release the old value (outside of the lock).
    // 释放旧的值(在锁外部)
    association.releaseHeldValue();
}

objc_getAssociatedObject(self, _cmd)实际是调用下面的方法：

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
}

最后来看void objic_removeAssociatedObjects(id object)：

// Unlike setting/getting an associated reference,
// this function is performance sensitive because of
// raw isa objects (such as OS Objects) that can't track
// whether they have associated objects.
// 与设置/获取关联引用不同，此函数对性能敏感，因为原始isa对象（如OS对象）不能跟踪它们是否有关联对象。
void
_object_remove_assocations(id object, bool deallocating)
{
    ObjectAssociationMap refs{};

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            refs.swap(i->second);

            // If we are not deallocating, then SYSTEM_OBJECT associations are preserved.
            //如果我们没有回收，那么SYSTEM_OBJECT关联会被保留。
            bool didReInsert = false;
            if (!deallocating) {
                for (auto &ref: refs) {
                    if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
                        i->second.insert(ref);
                        didReInsert = true;
                    }
                }
            }
            if (!didReInsert)
                associations.erase(i);
        }
    }

    // Associations to be released after the normal ones.
    // 在正常关联之后释放关联。
    SmallVector<ObjcAssociation *, 4> laterRefs;

    // release everything (outside of the lock).
    // 释放锁外的所有内容。
    for (auto &i: refs) {
        if (i.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
            // If we are not deallocating, then RELEASE_LATER associations don't get released.
            //如果我们不是在释放，那么RELEASE_LATER关联不会被释放
            if (deallocating)
                laterRefs.append(&i.second);
        } else {
            i.second.releaseHeldValue();
        }
    }
    for (auto *later: laterRefs) {
        later->releaseHeldValue();
    }
}

总结

设值流程

创建一个AssociationsManager 管理类
获取唯一全局静态哈希Map
判断是否存在关联对象值
存在 :
创建一个空的 ObjectAssociationMap 去取查询的键值对
如果发现没有这个 key 就先插入一个空的 BucketT
标记对象存在关联对象
用当前策略 policy 和值 value 组成了一个 ObjcAssociation 替换之前空的BucketT
标记 ObjectAssociationMap 为第二次
不存在 :
根据DisguisedPtr 找到 AssociationsHashMap 中的 iterator 迭代查询器
清理迭代器

取值流程

创建一个 AssociationsManager 管理类
获取唯一的全局静态哈希Map
根据 DisguisedPtr 找到 AssociationsHashMap 中的 iterator 迭代查询器
如果这个迭代查询器 != associations.end(), 即不是最后一个, 那么获取 : ObjectAssociationMap (这里有策略 policy 和值 value)
ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
返回value

销毁流程

对象销毁dealloc时，销毁相关的关联对象。
调用流程：dealloc --> _objc_rootDealloc --> rootDealloc --> object_dispose --> objc_destructInstance --> _object_remove_assocations。

除此之外还看了一些分类的运行期之类的东西，但是没太看懂，后面再补充。

4月4日补充：

分类在运行期做了什么

_objc_init这个函数是runtime的初始化函数，我们从_objc_init开始入手

_objc_init

/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Called by libSystem BEFORE library initialization time
**********************************************************************/

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;
    
    // fixme defer initialization until an objc-using image is found?
    environ_init();
    static_init();
    runtime_init();
    exception_init();
    cache_t::init();

    _imp_implementationWithBlock_init();

    _dyld_objc_callbacks_v1 callbacks = {
        1, // version
        &map_images,
        load_images,
        unmap_image,
        _objc_patch_root_of_class
    };
    _dyld_objc_register_callbacks((_dyld_objc_callbacks*)&callbacks);

    didCallDyldNotifyRegister = true;
}

map_images读取资源（images代表资源模块），我们点进去看看：

void
map_images(unsigned count, const char * const paths[],
           const struct mach_header * const mhdrs[])
{
    bool takeEnforcementDisableFault;

    {
        mutex_locker_t lock(runtimeLock);
        map_images_nolock(count, paths, mhdrs, &takeEnforcementDisableFault);
    }

    if (takeEnforcementDisableFault) {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
        bool objcModeNoFaults = DisableFaults
            || DisableClassROFaults
            || getpid() == 1
            || is_root_ramdisk()
            || !os_variant_has_internal_diagnostics("com.apple.obj-c");
        if (!objcModeNoFaults) {
            os_fault_with_payload(OS_REASON_LIBSYSTEM,
                                  OS_REASON_LIBSYSTEM_CODE_FAULT,
                                  NULL, 0,
                                  "class_ro_t enforcement disabled",
                                  0);
        }
#endif
    }
}

然后再点进去map_images_nolock方法：
这个方法实现太长了，就不放出来了，咱们重点看的是这个方法里面的_read_images方法：
这个方法也很长，就放出分类相关这一部分代码：

_read_images

// Discover categories. 
    for (EACH_HEADER) {
        category_t **catlist = 
            _getObjc2CategoryList(hi, &count);
        bool hasClassProperties = hi->info()->hasCategoryClassProperties();

        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls);

            if (!cls) {
                catlist[i] = nil;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class", 
                                 cat->name, cat);
                }
                continue;
            }
            bool classExists = NO;
            if (cat->instanceMethods ||  cat->protocols  
                ||  cat->instanceProperties) 
            {
                addUnattachedCategoryForClass(cat, cls, hi);
                if (cls->isRealized()) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s", 
                                 cls->nameForLogging(), cat->name, 
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols  
                ||  (hasClassProperties && cat->_classProperties)) 
            {
                addUnattachedCategoryForClass(cat, cls->ISA(), hi);
                if (cls->ISA()->isRealized()) {
                    remethodizeClass(cls->ISA());
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)", 
                                 cls->nameForLogging(), cat->name);
                }
            }
        }
    }

我们来看看这个方法都干了什么：

获取category列表list
遍历category list中的每一个category
获取category的对应的主类cls，如果没有cls就跳过（continue）这个继续获取下一个
如果其有对应的主类，并其有实例方法、协议、属性，则调用addUnattachedCategoryForClass，同时如果cls中有实现的话，进一步调用remethodizeClass方法
如果其有对应的主类，并其有类方法、协议，则调用addUnattachedCategoryForClass，同时如果cls的元类有实现的话，就进一步调用remethodizeClass方法

4、5主要是分类对应的主类是元类对象还是类对象

然后我们来看看上面方法中用到的addUnattachedCategoryForClass方法：

addUnattachedCategoryForClass

static void addUnattachedCategoryForClass(category_t *cat, Class cls, 
                                          header_info *catHeader)
{
    runtimeLock.assertWriting();

    // DO NOT use cat->cls! cls may be cat->cls->isa instead
    NXMapTable *cats = unattachedCategories();
    category_list *list;

    list = (category_list *)NXMapGet(cats, cls);
    if (!list) {
        list = (category_list *)
            calloc(sizeof(*list) + sizeof(list->list[0]), 1);
    } else {
        list = (category_list *)
            realloc(list, sizeof(*list) + sizeof(list->list[0]) * (list->count + 1));
    }
    list->list[list->count++] = (locstamped_category_t){cat, catHeader};
    NXMapInsert(cats, cls, list);
}
static NXMapTable *unattachedCategories(void)
{
    runtimeLock.assertWriting();
    //全局对象
    static NXMapTable *category_map = nil;
    if (category_map) return category_map;
    // fixme initial map size
    category_map = NXCreateMapTable(NXPtrValueMapPrototype, 16);
    return category_map;
}