,❓思考一下:分类中能否添加属性?能否添加成员变量?
直接上代码验证一下:创建一个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:
第一步
_object_set_associative_reference:
第二步
AssociationManager:
第三步
AssociationHashMap:
第四步
ObjcAssociationMap:
第五步
找到目标ObjcAssociation:
第六步
关联对象这种技术,主要基于4个对象实现的:
AssociationsManagerAssociationsHashMapObjectAssociationMap-
ObjcAssociation
通过上面的6步真图,总结出他们的关系如下:
关系图
解释:map就相当于 OC 中的 字典,AssociationsManager存放一个AssociationsHashMap,结构如下:
{
person1 : ObjectAssociationMap;
}
ObjectAssociationMap结构如下:
{
city : ObjectAssociation;
}
ObjcAssociation 结构如下:
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);
}
值得注意的是,当传递进来的关联对象的值value为 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,相当于移除对象.
