OC关联对象

作者: 小心韩国人 | 来源:发表于2019-11-27 21:50 被阅读0次

,❓思考一下:分类中能否添加属性?能否添加成员变量?
直接上代码验证一下:创建一个Person类和它的分类Person + Test1,然后在Person + Test1中添加属性@property (nonatomic,assign)NSString *name;.运行一下发现直接崩溃:

找不到 setter 方法
会发现找不到setName方法,我们给一个类添加属性,实际上是做了3个事情:
1: 添加 _name成员变量;
2: 添加setter,getter方法声明;
3: 添加setter,getter方法实现;
但是我们给一个类的分类添加属性,其实只做了一步:
只添加了setter,getter方法的声明
我们我们试着手动给属性name添加成员变量和setter,getter方法实现,然后运行,发现连编译都不成功:

添加 _name 报错
由此我们得出结论,分类中不能直接添加成员变量
那我们怎么往分类中添加成员变量呢,这就要用到associated关联对象了.
关联对象会用到两个api:

objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key, id _Nullable value, objc_AssociationPolicy policy)

objc_setAssociatedObject
objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)

objc_getAssociatedObject

我们在name的setter和getter方法中这样使用:

那这个key我们怎么写呢?这个key就是用来往字典里面取值用的,所以只要保证这个key有值且唯一就可以了.

key的第一种写法: -指针变量
objc_setAssociatedObjectAPI中的key的类型是:const void * _Nonnull key,我们也可以创建这种类型的指针变量:

const void *nameKey = &nameKey;
const void *cityKey = &cityKey;

----------------------------------------

- (void)setName:(NSString *)name{
    objc_setAssociatedObject(self, nameKey, name, OBJC_ASSOCIATION_COPY);
}

- (NSString *)name{
    return objc_getAssociatedObject(self, nameKey);
}

- (void)setCity:(NSString *)city{
    objc_setAssociatedObject(self, cityKey, city, OBJC_ASSOCIATION_COPY);
}

- (NSString *)city{
    return objc_getAssociatedObject(self, cityKey);
}

----------------------------------------

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *person = [[Person alloc]init];
    person.age = 10;
    person.name = @"Jack";
    person.city = @"武汉";
    
    Person *person2 = [[Person alloc]init];
    person2.name = @"July";
    person2.city = @"杭州";
    
    NSLog(@"name is %@  city is %@",person.name,person.city);
    NSLog(@"name is %@  city is %@",person2.name,person2.city);
}

----------------------------------------打印结果----------------------------------------
2019-11-27 16:13:43.022586+0800 关联属性[2095:890346] name is Jack  city is 武汉
2019-11-27 16:13:43.022734+0800 关联属性[2095:890346] name is July  city is 杭州

可以达到我们的目的,的确能常常使用name 和 city这两个属性,但是这样做会有个问题:如果在外部修改了这个指针变量,我们就无法正常访问属性了,我们用代码验证一下:

我们用static关键字修饰指针变量,就可以解决这种问题,static修饰全局变量,就意味着全局变量的作用域仅在当前文件.

key的第二种写法: - 使用变量地址
既然key的类型是void *类型,也就是说key可以是任何类型的指针对象,所以我们可以声明char nameKey , char cityKey变量,然后再取出变量的地址(之所以是char类型是因为char类型只占2个字节,当然也可以是int类型)

static const int nameKey;
static const int cityKey;
//第二种
- (void)setName:(NSString *)name{
    objc_setAssociatedObject(self, &nameKey, name, OBJC_ASSOCIATION_COPY);
}

- (NSString *)name{
    return objc_getAssociatedObject(self, &nameKey);
}

- (void)setCity:(NSString *)city{
    objc_setAssociatedObject(self, &cityKey, city, OBJC_ASSOCIATION_COPY);
}

- (NSString *)city{
    return objc_getAssociatedObject(self, &cityKey);
}

//打印结果
2019-11-27 16:52:10.862235+0800 关联属性[2236:1141645] name is Jack  city is 武汉
2019-11-27 16:52:10.862386+0800 关联属性[2236:1141645] name is July  city is 杭州

key的第三种写法: - 直接使用字符串

- (void)setName:(NSString *)name{
    objc_setAssociatedObject(self, @"name", name, OBJC_ASSOCIATION_COPY);
}

- (NSString *)name{
    return objc_getAssociatedObject(self, @"name");
}

- (void)setCity:(NSString *)city{
    objc_setAssociatedObject(self, @"city", city, OBJC_ASSOCIATION_COPY);
}

- (NSString *)city{
    return objc_getAssociatedObject(self, @"city");
}

为什么字符串在这里也可以呢?因为字符串存储在内存中的常量区,在内存中只存储一份,他的地址始终是一样的.我们平常写的NSString *str = @"name",实际上就是把@"name"的地址赋值给str.所以这里直接写@"name",也相当于写地址.

key的第四种写法: - @selector

//第四种
- (void)setName:(NSString *)name{
    objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY);
}

- (NSString *)name{
    return objc_getAssociatedObject(self, @selector(name));
}

- (void)setCity:(NSString *)city{
    objc_setAssociatedObject(self, @selector(city), city, OBJC_ASSOCIATION_COPY);
}

- (NSString *)city{
    return objc_getAssociatedObject(self, @selector(city));
}

@selector同一个方法在内存中的地址都是一样的,并且@selector拼写的时候还有提示,毫无疑问这种写法是最好的.

那么现在我们就实现了间接的往类中添加成员变量了,那么这些成员变量添加到哪里了呢?是不是也添加到类的内存中去了?我们从源码中一探究竟.
打开runtime源码,搜索objc_setAssociatedObject进入_object_set_associative_reference:

第一步
进入AssociationsManager:

第二步
进入AssociationsHashMap:

第三步
进入ObjectAssociationMap:

第四步
进入ObjcAssociation:

第五步
找到目标:

第六步

关联对象这种技术,主要基于4个对象实现的:

AssociationsManager
AssociationsHashMap
ObjectAssociationMap
ObjcAssociation
通过上面的6步真图,总结出他们的关系如下:
关系图
解释:map就相当于 OC 中的字典,AssociationsManager存放一个AssociationsHashMap,结构如下:

{
  person1 : ObjectAssociationMap;
}

ObjectAssociationMap结构如下:

{
city : ObjectAssociation;
}

ObjectAssociationMap 结构如下:

    class ObjcAssociation {
        uintptr_t _policy;
        id _value;
}

现在我们就明白了,通过关联对象技术,间接的给类添加成员变量时,并不会添加到类本身的空间,而是通过一个类似全局字典的东西在存储,我们结合一下源码配上注释再看看:

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (if any) outside the lock.
    ObjcAssociation old_association(0, nil);
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
        //从 manager 中获取 AssociationsHashMap类型的 associations
        AssociationsHashMap &associations(manager.associations());
        //通过传入的 objc 通过位移 生成key : disguised_object
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
            // break any existing association.
            // 把 disguised_object 当做 key ,从 associations 中得到 AssociationsHashMap类型的 i
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                // 通过 i 找到 ObjectAssociationMap 类型的 refs
                ObjectAssociationMap *refs = i->second;
                // 根据传进来的 key ,从 refs 中找到 ObjectAssociationMap 类型的 j
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    // 把传递传递进来的 policy ,new_value 保存到 j 中
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
                // create the new association (first time).
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // 当传入的 value 为 nil 时
            // setting the association to nil breaks the association.
            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).
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

值得注意的是,当传递进来的关联对象为 nil时,源码中有一个移除的操作,相当于删除关联对象.

objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)的源码也是按照类似取值的:

id _object_get_associative_reference(id object, void *key) {
    id value = nil;
    uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
    {
        AssociationsManager manager;
        //从 manager 中 取出 AssociationsHashMap 类型的 associations
        AssociationsHashMap &associations(manager.associations());
        //把传递进来的被关联对象 通过 位移,得到一个 disguised_object 作为 key
        disguised_ptr_t disguised_object = DISGUISE(object);
        // 把 作为 key ,从 associations 中 得到 AssociationsHashMap i
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            // 从 遍历器 i 中 得到 ObjectAssociationMap 类型的 refs
            ObjectAssociationMap *refs = i->second;
            // 从 ObjectAssociationMap 中 得到 ObjectAssociationMap 类型的 j
            ObjectAssociationMap::iterator j = refs->find(key);
            if (j != refs->end()) {
                // 从 ObjectAssociationMap 中取值
                ObjcAssociation &entry = j->second;
                value = entry.value();
                policy = entry.policy();
                if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
                    objc_retain(value);
                }
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        objc_autorelease(value);
    }
    return value;
}

最后补充一个移除被关联对象所有关联对象的api: void objc_removeAssociatedObjects(id object):传入一个对象进去,把这个对象所有的关联对象移除

大总结:

分类中可以添加属性,但是系统只会给这个属性添加setter,getter方法的声明,不会添加成员变量和setter,getter的实现.
如果直接在分类中添加成员变量会报错,我们可以通过 关联对象这种技术,间接的给分类添加成员变量.
通过关联对象间接给分类添加的成员变量,并没有添加到类本身的内存结构中,而是由runtime生成了一个类似全局变量的字典来管理,也就是AssociationsManager.
设置关联对象为nil,相当于移除对象.

OC关联对象

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读