ios 底层 类扩展及关联对象

舜爸
180 阅读5分钟

一、类拓展

1.类拓展的定义

类拓展和分类很相似，但是前提是你拥有原始类的源码，并且是在编译时被附加到类上的。

@interface ClassName ()

@end

2.类拓展确定时间

我们验证下

// Person.h
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@end

NS_ASSUME_NONNULL_END

// Person.m
#import "Person.h"
#import "Person+Extension.h"

@interface Person ()
@property (nonatomic, copy) NSString *mName;
- (void)extM_method;
@end
@implementation Person
+ (void)load{
   NSLog(@"%s",__func__);
}
- (void)extM_method{
   NSLog(@"%s",__func__);
}
- (void)extH_method{
   NSLog(@"%s",__func__);
}
@end
// Person+Extension.h
#import <AppKit/AppKit.h>
#import "Person.h"

NS_ASSUME_NONNULL_BEGIN
@interface Person ()
@property (nonatomic, copy) NSString *ext_name;
@property (nonatomic, copy) NSString *ext_subject;
- (void)extH_method;
@end
NS_ASSUME_NONNULL_END

接着我们在 main.m 中来测试一下：

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "Person.h"

int main(int argc, const char * argv[]) {
   @autoreleasepool {
       Person *p = [Person alloc];
       NSLog(@"%@ - %p", p, p);
   }
   return 0;
}

我们在 Person 实例化对象 p 这一行打上断点，然后运行项目。接着在控制台进行 LLDB 打印: 我们的目标是看类拓展的方法是否在类结构中的ro里面，如果有，那么就是在编译的时候加入的。

通过 x/4gx 命令打印出 LGPerson 类对象的内存地址，以 16 进制方式打印，打印 4 段
因为类对象的内存地址起始为 isa，紧接着是 superclass，然后是 cache_t。我们前面已经分析过，在默认的 arm64 处理器架构下，isa 占 8 个字节，superclass 占 8 个字节，而 cache_t 的三个属性加起来是 8 + 4 + 4 = 16 个字节，所以要想拿到 bits 需要进行 8 + 8 + 16 = 32 字节的内存平移，但是这里是 16 进制，所以需要移动 0x20 个内存地址，也就是 0x100002420 + 0x20 = 0x100002440
因为类对象的 data() 属性会返回 bits.data()，所以这里直接打印刚才取到的 bits 的 data() 属性，而 bits 的 data() 属性其实返回的是 rw。

struct objc_class : objc_object {
    class_rw_t *data() { 
        return bits.data();
    }
}
    
struct class_data_bits_t {
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
}

接着打印 rw 的属性 ro，然后我们先尝试读取 baseMethodList 属性，该属性存储的是编译时确定的类的所有的方法。
因为 baseMethodList 属性是一个 List 类型的容器，我们直接使用 get(index) 来获取其 index 处的值，结果我们所要寻找的 extH_method 和 extM_method 出现了，不过还没结束，我们还没验证类拓展中声明的两个属性，让我们打印一下 ro 的 baseProperties
我们很清楚的看到，mName，ext_name 和 ext_subject 都被找到了，那么是不是就是说类拓展就是编译时确定的了呢？我们还漏掉了这三个属性的 getter 和 setter 了，让我们回过头再去 baseMethodList 中查找一下
我们类拓展定义的属性的 getter 和 setter 方法也生成了，至此，我们就完全确定了类拓展在编译时就会被加载到类的 ro 中。

3.类拓展和分类的区别

研究对象 加载时间 操作对象 能否通过@propoerty生成getter和setter方法
分类(实现了load方法) 运行时 rw 不能，需要借助关联对象来实现
分类(没有实现load方法) 编译时 ro 不能，需要借助关联对象来实现
类拓展 编译时 ro 可以

二、关联对象

1. 关联对象使用方法

分类通过 @property 的方式来声明属性却不能生成 getter 和 setter 方法。而其实 iOS 中有一种方式可以为分为增加具有 getter 和 setter 的属性，那就是 - 关联对象 Associated Objects 。

// 设置关联对象
objc_setAssociatedObject()

// 获取关联对象
objc_getAssociatedObject()

我们如果要给一个分类中的属性设置关联对象，需要重写属性的 setter 方法，然后使用 objc_setAssociatedObject：

- (void)setXXX:(关联值数据类型)关联值
    objc_setAssociatedObject(self, 关联的key, 关联值, 关联对象内存管理策略);
}

然后还需要重写 getter 方法，然后使用 objc_getAssociatedObject：

- (关联值数据类型)关联值{
    return objc_getAssociatedObject(self, 关联的key);
}

2. 关联对象的底层原理

我们看下源码

void _object_set_associative_reference(id object, 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;
    
    assert(object);
    
    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));
    
    // retain the new value (if any) outside the lock.
    // 在锁之外保留新值（如果有）。
    ObjcAssociation old_association(0, nil);
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        // 关联对象的管理类
        AssociationsManager manager;
        // 获取关联的 HashMap -> 存储当前关联对象
        AssociationsHashMap &associations(manager.associations());
        // 对当前的对象的地址做按位去反操作 - 就是 HashMap 的key (哈希函数)
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
            // break any existing association.
            // 获取 AssociationsHashMap 的迭代器 - (对象的) 进行遍历
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                ObjectAssociationMap *refs = i->second;
                // 根据key去获取关联属性的迭代器
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    // 替换设置新值
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    // 到最后了 - 直接设置新值
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
                // create the new association (first time).
                // 如果AssociationsHashMap从没有对象的关联信息表，
                // 那么就创建一个map并通过传入的key把value存进去
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // setting the association to nil breaks the association.
            // 如果传入的value是nil，并且之前使用相同的key存储过关联对象，
            // 那么就把这个关联的value移除（这也是为什么传入nil对象能够把对象的关联value移除）
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i !=  associations.end()) {
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    refs->erase(j);
                }
            }
        }
    }
    // release the old value (outside of the lock).
    // 最后把之前使用传入的这个key存储的关联的value释放（OBJC_ASSOCIATION_SETTER_RETAIN策略存储的）
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

2A83DB40-1A91-40DD-ABCA-4621BC50C491.png

三、总结

  • 类拓展是一种匿名的分类，加载时机为编译时
  • 类拓展可以添加属性和方法以及实例变量，分类只能添加方法，属性，但是需要借助关联对象来生成 getter 和 setter，而且分类不能声明实例变量
  • 关联对象在底层其实是 ObjcAssociation 对象的结构
  • 全局有一个 AssociationsManager 管理类存储了一个静态的哈希表 AssociationsHashMap，这个哈希表存储的是以对象指针为键，以该对象所有的关联对象为值，而对象所有的关联对象又是以 ObjectAssociationMap 来存储的
  • ObjectAssociationMap 存储结构为 key 为键，ObjcAssociation 为值
  • 快速判断一个对象是否存在关联对象，可以直接取对象 isa 的 has_assoc
avatar
文章
阅读
粉丝