OC基础 - 类添加成员变量
属性 = ivar + setter(声明，实现) + getter（声明，实现）
类扩展
属性= 没有成员变量 + setter(声明) + getter（声明）
因为类扩展没有成员变量，所以属性也用不到，因为不能对其进行setter以及getter方法，所以想办法给类扩展属性增加一个成员变量
方法1 （肯定不可行啦）
增加一个全局变量
#import "MJPerson+Test.h"
int ages_;
@implementation MJPerson (Test)
- (void)setAge:(int)age
{
ages_ = age;
}
- (int)age
{
return ages_;
}
@end
这个时候存在的问题如下所示
MJPerson * p1 = [[MJPerson alloc]init];
p1.name = @"James";
p1.age = 23;
MJPerson * p2 = [[MJPerson alloc]init];
p2.name = @"Durant";
p2.age = 7;
MJPerson * p3 = [[MJPerson alloc]init];
p2.name = @"Harden";
p2.age = 13;
NSLog(@"p2.name = %@,age = %d",p2.name,p2.age);
NSLog(@"p1.name = %@,age = %d",p1.name,p1.age);
NSLog(@"p3.name = %@,age = %d",p3.name,p3.age);
打印输出
2021-03-05 11:03:53.319031+0800 CategoryAssociate[40891:1338125] p2.name = Harden,age = 13
2021-03-05 11:03:53.319529+0800 CategoryAssociate[40891:1338125] p1.name = James,age = 13
2021-03-05 11:03:53.319587+0800 CategoryAssociate[40891:1338125] p3.name = (null),age = 13
原因分析：后面传进来的age的值会将全局变量ages_进行覆盖，所以导致之前所有的值都是最后一个传进来的值
方法2（方法也会欠缺）
（NSMutableDictionary） 通过键值对，每一个person有对应的自己的age,一对一关系所以为字典
在load方法里给字典初始化，因为load方法只会被调用一次
+(void)load
{
//在load里面给NSMutableDictionary *ages_;赋值，load只调用一次
ages_ = [NSMutableDictionary new];
}
然后通过字典里的key取出value，这边用伪代码(思路)表示先，这样就可以暂时获取到所谓的成员变量，这个时候再写setter和getter方法
- (void)setAge:(int)age
{
//通过字典里的key取出字典里的value
//伪代码
ages_[self] = @(age);
}
- (int)age
{
return [ages_[self] intValue];
}
替换掉伪代码，则整个代码如下所示
主要是字典里的key一般都是NSString类型(用当前person类的内存地址做为key)，所以self 替换成 NSString *ages = [NSString stringWithFormat:@"%p",self];
并将其设置为一个宏，因为多处会用到
#import "MJPerson+Test.h"
#define MJKey [NSString stringWithFormat:@"%p",self]
NSMutableDictionary *ages_;
@implementation MJPerson (Test)
+(void)load
{
//在load里面给NSMutableDictionary *ages_;赋值，load只调用一次
ages_ = [NSMutableDictionary new];
}
- (void)setAge:(int)age
{
//通过字典里的key取出字典里的value
//伪代码
ages_[MJKey] = @(age);
}
- (int)age
{
return [ages_[MJKey] intValue];
}
@end
调用
MJPerson * p1 = [[MJPerson alloc]init];
p1.name = @"James";
p1.age = 23;
MJPerson * p2 = [[MJPerson alloc]init];
p2.name = @"Durant";
p2.age = 7;
/**
struct MJPerson_IMPl{
class isa;
NSString *_name;
}
*/
MJPerson * p3 = [[MJPerson alloc]init];
p3.name = @"Harden"; // @"Harden"是存储在person对象的内部 ，@"Harden" 是赋值给_name的
p3.age = 13; 13不是存在于person内部，13是存在于全局的字典对象里面，但是对外界来讲是没有什么区别的
NSLog(@"p3.name = %@,age = %d",p3.name,p3.age);
NSLog(@"p2.name = %@,age = %d",p2.name,p2.age);
NSLog(@"p1.name = %@,age = %d",p1.name,p1.age);
打印结果
2021-03-05 11:29:18.562053+0800 CategoryAssociate[41418:1361256] p3.name = Harden,age = 13
2021-03-05 11:29:18.562517+0800 CategoryAssociate[41418:1361256] p2.name = Durant,age = 7
2021-03-05 11:29:18.562579+0800 CategoryAssociate[41418:1361256] p1.name = James,age = 23
方法二总结：问题：1.线程安全（每一个person的set方法都会访问全局的字典，不同person对象，在不同线程同时访问这个字典就会造成线程安全问题），
2.内存泄漏（因为是全局变量，而却一直在内存中）
3.如果增加多个属性，那么就会存在多个这样的字典，就要增加其对应的setter和getter方法
方法三：利用runtime 关联对象在category里面添加属性（重点）
添加关联属性
objc_setAssociatedObject(<#id _Nonnull object#>, <#const void * _Nonnull key#>, <#id _Nullable value#>, <#objc_AssociationPolicy policy#>);
关联对象就是将属性（age）和类(person)关联起来
关联策略
objc_AssociationPolicy 对应的修饰符
OBJC_ASSOCIATION_ASSIGN assign
OBJC_ASSOCIATION_RETAIN_NONATOMIC strong, nonatomic
OBJC_ASSOCIATION_COPY_NONATOMIC copy, nonatomic
OBJC_ASSOCIATION_RETAIN strong, atomic
OBJC_ASSOCIATION_COPY copy, atomic
key值传自己的地址（遵从唯一不为空性）
获得关联属性
objc_getAssociatedObject(<#id _Nonnull object#>, <#const void * _Nonnull key#>)
移除关联属性
objc_removeAssociatedObjects(<#id _Nonnull object#>)
设置对象为nil,person.height = nil;移除单个的关联对象
id object：被关联的对象
const void *key：关联的key，要求唯一
id value：关联的对象
objc_AssociationPolicy policy：内存管理的策略
上代码
person类
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface MJPerson : NSObject
@property (nonatomic,assign)int age;
@end
NS_ASSUME_NONNULL_END
Person分类
#import "MJPerson.h"
NS_ASSUME_NONNULL_BEGIN
@interface MJPerson (Test)
@property (nonatomic,copy)NSString *name;
@property (nonatomic,assign)int height;
@end
#import "MJPerson+Test.h"
#import <objc/runtime.h>
@implementation MJPerson (Test)
const void * MJNameKey = &MJNameKey;
const void * MJHeightKey = &MJHeightKey;
- (void)setName:(NSString *)name
{
objc_setAssociatedObject(self, MJNameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)name
{
return objc_getAssociatedObject(self, MJNameKey);
}
- (void)setHeight:(int)height{
objc_setAssociatedObject(self, MJHeightKey, @(height), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (int)height
{
return [objc_getAssociatedObject(self, MJHeightKey) intValue];
}
@end
调用以及打印
MJPerson * p1 = [[MJPerson alloc]init];
p1.name = @"James";
p1.age = 23;
p1.height = 203;
MJPerson * p2 = [[MJPerson alloc]init];
p2.name = @"Durant";
p2.age = 7;
p2.height = 211;
MJPerson * p3 = [[MJPerson alloc]init];
p3.name = @"Harden";
p3.age = 13;
p3.height = 196;
NSLog(@"p3.name = %@,age = %d,height = %d",p3.name,p3.age,p3.height);
NSLog(@"p2.name = %@,age = %d,height = %d",p2.name,p2.age,p2.height);
NSLog(@"p1.name = %@,age = %d,height = %d",p1.name,p1.age,p1.height);
//打印输出
2021-03-05 12:06:33.275907+0800 CategoryAssociate[42088:1396908] p3.name = Harden,age = 13,height = 196
2021-03-05 12:06:33.276356+0800 CategoryAssociate[42088:1396908] p2.name = Durant,age = 7,height = 211
2021-03-05 12:06:33.276407+0800 CategoryAssociate[42088:1396908] p1.name = James,age = 23,height = 203
总结：有缺陷，外部可以访问到里面的全局变量（MJNameKey，MJHeightKey）的值，就可以去改这个值
在外部直接 extern const void * MJNameKey 就可以直接访问到这个值
（在方法三的基础上）
优化1：
static const void * MJNameKey = &MJNameKey;(指针变量占8个字节)
static const void * MJHeightKey = &MJHeightKey;
优化2：
static const char * MJNameKey;(char只占一个字节)
static const char * MJHeightKey;
使用时候 &MJNameKey,&MJHeightKey,
优化3：
直接使用的时候
objc_setAssociatedObject(self, @“name”, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
return objc_getAssociatedObject(self, @“name”);
set 和get 的“name”是同一个地址（因为 “name”是放在常量区是不变的）
所以定义一个宏
define MJNameKey @“name”
objc_setAssociatedObject(self, MJNameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
return objc_getAssociatedObject(self, MJNameKey);
优化4：
objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);
return objc_getAssociatedObject(self, @selector(name));
优化5：
get方法里(只有get方法)
_cmd = @selector(name);
隐式参数
return objc_getAssociatedObject(self, _cmd);
接下来就是 关联对象的原理
其实runtime是生成一个AssociationsManager类用来管理分类的关联对象，让分类能正常使用成员变量，有点类似于前面说到的用字典去保存的原理。通过查看源码，我们可以知道AssociationsManager类有一个AssociationsHashMap属性，这个属性是相当于一个字典，用来存储对象-关联对象的，也就是它的key是我们关联对象时传的self，也就是这个Person分类，以这个为key，然后value是一个ObjectAssociationMap，ObjectAssociationMap对象也相当于是一个字典，这个字典的key是我们关联对象时传进去的那个key，value是ObjcAssociation，ObjcAssociation对象里面有两个属性_value和_policy，这两个就是我们关联对象的值和关联策略了。
简单说AssociationsHashMap存储的是项目中所有分类的关联对象，里面应该是长这样{Person分类: AssociationsHashMap,Student分类: AssociationsHashMap}，我们项目中有几个分类有关联对象，那AssociationsHashMap里面就有多少个元素。而AssociationsHashMap里面存放的就是关联对象的key和ObjcAssociation，里面应该长这样{@selector(weight):@(weight),@selector(name):name}，一个分类里面有多少个关联对象AssociationsHashMap里面就有多少个元素。最后ObjcAssociation就是保存着关联对象的值和关联策略了。ObjcAssociation{unitptr_t _policy= OBJC_ASSOCIATION_RETAIN_NONATOMIC; id _value=@(weight)}。
person对象如果被销毁了，那对应的map会被移除
以下图很好的展示了其中的原理。
本文部分内容来自链接：https://www.jianshu.com/p/841a02ca8468
