@[TOC](IOS底层（三） KVO底层实现原理 )
一，KVO简述
KVO的全称 Key-Value Observing，俗称“键值监听”，可以用于监听某个对象属性值的改变。
带着问题探索：
- iOS用什么方式实现对一个对象的KVO？（KVO的本质是什么？）
答. 当一个对象使用了KVO监听，iOS系统会修改这个对象的isa指针，
改为指向一个全新的通过Runtime动态创建的子类，子类拥有自己的set方法实现，
set方法实现内部会顺序调用willChangeValueForKey方法、原来的setter方法实现、
didChangeValueForKey方法，而didChangeValueForKey方法内部
又会调用监听器的observeValueForKeyPath:ofObject:change:context:监听方法。
- 如何手动触发KVO
答. 被监听的属性的值被修改时，就会自动触发KVO。
如果想要手动触发KVO，则需要我们自己调用willChangeValueForKey和
didChangeValueForKey方法即可在不改变属性值的情况下手动触发KVO
，并且这两个方法缺一不可。
- KVO 底层实现是什么?
- 修改成员变量的值会出发 KVO 吗?
- KVC 赋值会出发 KVO 吗?
二，KVC 简述
1. KVC定义
KVC: Key-value coding is a mechanism for indirectly accessing anobject’s attributes and relationships using string identifiers.
所谓键值编码，并不是访问器方法的启动和实例变量的访问这种直接的方式，而是使用表示属性的字符串来间接访问对象属性值的一种结构。
只要存在访问器方法、声明属性或实例变量，就可以将其名字指定为字符串来访问。
之所以说键值编码的访问是接的：
-
可以在运行中确定作为键的字符串
-
使用者无法知道实际访问属性的方法
键值编码必需的方法在非正式协议NSKeyValueCoding中声明（头文件Foundation/NSKeyValueCoding.h）。默认在NSObject中实现。
2. 方法调用
下面就以下两个方法的调用进行说明：
(id) valueForKey: (NSString *) key
返回表示属性的键字符串所对应的值。如果不能取得值，则将引起接收器调用方法valueForUndefinedKey:。
(void)setValue: (id) value forKey: (NSString*) key
将键字符串key所对应的属性的值设置为value。不能设定属性时，将引起接收器调用方法setValue:ForUndefinedKey:。
执行时，有访问器的属性会使用访问器，没有访问器的属性也可以设定值和访问。因为上面两个方法均为实例方法，可以在方法体内访问实例变量。
访问过程如下：
-
接收器中如果有key访问器（或getKey、isKey、_key、_getKey、setKey）则使用它。
-
没有访问器时，使用接收器的类方法accessInstanceVariablesDirectly来查询。返回YES时，如果存在实例变量key（或_key、isKey、_isKey等）则返回或设置其值。使用引用计数管理方式时，实例变量如果为对象，则旧值会被自动释放，新值被保存并代入。
-
(BOOL)accessInstanceVariablesDirectly
通常定义为返回YES，可以在子类中改变。该类方法返回YES时，使用键值编码可以访问该类的实例变量。返回NO时不可以访问。只要该方法返回YES，实例变量的可视属性即使有@private修饰，也可以访问。
- 既没有访问器也没有实例变量时，将引起接收器调用方法valueForUndefinedKey:或setValue:forUndefinedKey:。
(id) valueForUndefinedKey: (NSStirng *) key
不能取得键字符串对应的值时，从方法valueForKey：中调用该方法。默认情况下，该方法的执行会触发NSUndefinedKeyException。不过，通过在子类中修改定义，就可以返回其他对象。
(void) setValue: (id) value forUndefinedKey: (NSString *) key
不能设置键字符串key对应的属性值时，从方法setValue:forKey中调用该方法。默认情况下，该方法的执行会触发异常NSUndefinedKeyException。不过，通过在子类中修改定义，可以返回其他对象。
- 如果该返回值不是对象，则返回被适当的对象包装的值；设置值时也应先包装成相应的对象。
属性为对象时，该对象还可能持有属性。这时候可以用“.”连接表示键的字符串，这种表示方式称为键路径。只要能找到对象，点和键多长都没有关系。
(id) valueForKeyPath:(NSString *) keyPath
以点切分键路径，并使用第一个键向接收器发送valueForKey：方法。然后，再使用键路径的下一个键，向得到的对象发送valueForKey：方法，如此反复操作，返回最后获得的对象。
(void)setValue: (id) value forKeyPath:(NSString *) keyPath
与valueForKeyPath：方法一样取出对象，这里只对路径中的最后一个键调用setValue：forKey：方法，并设定属性值为value。
3. KVC准则
-
随访问器方法而改变。
-
使用setValue：forKey：和键进行改变。此时也可能不经由访问器。
-
使用setValue：forKeyPath：和键路径进行改变。此时也可能不经由访问器。不仅仅是最终的监视对象的属性，当路径中的属性发生变化时，也会被通知。
三，KVO实现原理探索
- 首先需要了解KVO基本使用，KVO的全称 Key-Value Observing，俗称“键值监听”，可以用于监听某个对象属性值的改变。KVO：key-value observing,是在KVC基础上实现的，当某个对象的属性发生改变时，通知其它对象的机制。仅仅在以KVC准则来访问访问器或实例变量的情况下，才可以监视属性的变化。在方法内直接改变实例变量的值时，就不能监视了。
- (void)viewDidLoad {
[super viewDidLoad];
Person *p1 = [[Person alloc] init];
Person *p2 = [[Person alloc] init];
p1.age = 1;
p1.age = 2;
p2.age = 2;
// self 监听 p1的 age属性
NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
[p1 addObserver:self forKeyPath:@"age" options:options context:nil];
p1.age = 10;
[p1 removeObserver:self forKeyPath:@"age"];
}
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
{
NSLog(@"监听到%@的%@改变了%@", object, keyPath,change);
}
// 打印内容
监听到<Person: 0x604000205460>的age改变了{
kind = 1;
new = 10;
old = 2;
}
上述代码中可以看出，在添加监听之后，age属性的值在发生改变时，就会通知到监听者，执行监听者的observeValueForKeyPath方法。
1. 探寻KVO底层实现原理
通过上述代码我们发现，一旦age属性的值发生改变时，就会通知到监听者，并且我们知道赋值操作都是调用 set方法，我们可以来到Person类中重写age的set方法，观察是否是KVO在set方法内部做了一些操作来通知监听者。
我们发现即使重写了set方法，p1对象和p2对象调用同样的set方法，但是我们发现p1除了调用set方法之外还会另外执行监听器的observeValueForKeyPath方法。
说明KVO在运行时获取对p1对象做了一些改变。相当于在程序运行过程中，对p1对象做了一些变化，使得p1对象在调用setage方法的时候可能做了一些额外的操作，所以问题出在对象身上，两个对象在内存中肯定不一样，两个对象可能本质上并不一样。接下来来探索KVO内部是怎么实现的。
2. KVO底层实现分析
- 首先我们对上述代码中添加监听的地方打断点，看观察一下，addObserver方法对p1对象做了什么处理？也就是说p1对象在经过addObserver方法之后发生了什么改变，我们通过打印isa指针如下图所示
addObserver对p1对象的处理
通过上图我们发现，p1对象执行过addObserver操作之后，p1对象的isa指针由之前的指向类对象Person变为指向NSKVONotifyin_Person类对象，而p2对象没有任何改变。也就是说一旦p1对象添加了KVO监听以后，其isa指针就会发生变化，因此set方法的执行效果就不一样了。
那么我们先来观察p2对象在内容中是如何存储的，然后对比p2来观察p1。
首先我们知道，p2在调用setage方法的时候，首先会通过p2对象中的isa指针找到Person类对象，然后在类对象中找到setage方法。然后找到方法对应的实现。如下图所示
未使用KVO监听的对象放大实现路径
但是刚才我们发现p1对象的isa指针在经过KVO监听之后已经指向了NSKVONotifyin_Person类对象，NSKVONotifyin_Person其实是Person的子类，那么也就是说其superclass指针是指向Person类对象的，NSKVONotifyin_Person是runtime在运行时生成的。那么p1对象在调用setage方法的时候，肯定会根据p1的isa找到NSKVONotifyin_Person，在NSKVONotifyin_Person中找setage的方法及实现。
经过查阅资料我们可以了解到。
NSKVONotifyin_Person中的setage方法中其实调用了 Fundation框架中C语言函数 _NSsetIntValueAndNotify，_NSsetIntValueAndNotify内部做的操作相当于，首先调用willChangeValueForKey 将要改变方法，之后调用父类的setage方法对成员变量赋值，最后调用didChangeValueForKey已经改变方法。didChangeValueForKey中会调用监听器的监听方法，最终来到监听者的observeValueForKeyPath方法中。
- 那么如何验证KVO真的如上面所讲的方式实现？
首先经过之前打断点打印isa指针，我们已经验证了，在执行添加监听的方法时，会将isa指针指向一个通过runtime创建的Person的子类NSKVONotifyin_Person。
另外我们可以通过打印方法实现的地址来看一下p1和p2的setage的方法实现的地址在添加KVO前后有什么变化。
// 通过methodForSelector找到方法实现的地址
NSLog(@"添加KVO监听之前 - p1 = %p, p2 = %p", [p1 methodForSelector: @selector(setAge:)],[p2 methodForSelector: @selector(setAge:)]);
NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
[p1 addObserver:self forKeyPath:@"age" options:options context:nil];
NSLog(@"添加KVO监听之后 - p1 = %p, p2 = %p", [p1 methodForSelector: @selector(setAge:)],[p2 methodForSelector: @selector(setAge:)]);
setage的方法实现的地址在添加KVO前后的变化
我们发现在添加KVO监听之前，p1和p2的setAge方法实现的地址相同，而经过KVO监听之后，p1的setAge方法实现的地址发生了变化，我们通过打印方法实现来看一下前后的变化发现，确实如我们上面所讲的一样，p1的setAge方法的实现由Person类方法中的setAge方法转换为了C语言的Foundation框架的_NSsetIntValueAndNotify函数。
Foundation框架中会根据属性的类型，调用不同的方法。例如我们之前定义的int类型的age属性，那么我们看到Foundation框架中调用的_NSsetIntValueAndNotify函数。那么我们把age的属性类型变为double重新打印一遍
_NSSetDoubleValueAndNotify函数
我们发现调用的函数变为了_NSSetDoubleValueAndNotify，那么这说明Foundation框架中有许多此类型的函数，通过属性的不同类型调用不同的函数。
那么我们可以推测Foundation框架中还有很多例如_NSSetBoolValueAndNotify、_NSSetCharValueAndNotify、_NSSetFloatValueAndNotify、_NSSetLongValueAndNotify等等函数。
我们可以找到Foundation框架文件，通过命令行查询关键字找到相关函数
相关函数
- NSKVONotifyin_Person内部结构是怎样的？
首先我们知道，NSKVONotifyin_Person作为Person的子类，其superclass指针指向Person类，并且NSKVONotifyin_Person内部一定对setAge方法做了单独的实现，那么NSKVONotifyin_Person同Person类的差别可能就在于其内存储的对象方法及实现不同。
我们通过runtime分别打印Person类对象和NSKVONotifyin_Person类对象内存储的对象方法
- (void)viewDidLoad {
[super viewDidLoad];
Person *p1 = [[Person alloc] init];
p1.age = 1.0;
Person *p2 = [[Person alloc] init];
p1.age = 2.0;
// self 监听 p1的 age属性
NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
[p1 addObserver:self forKeyPath:@"age" options:options context:nil];
[self printMethods: object_getClass(p2)];
[self printMethods: object_getClass(p1)];
[p1 removeObserver:self forKeyPath:@"age"];
}
- (void) printMethods:(Class)cls
{
unsigned int count ;
Method *methods = class_copyMethodList(cls, &count);
NSMutableString *methodNames = [NSMutableString string];
[methodNames appendFormat:@"%@ - ", cls];
for (int i = 0 ; i < count; i++) {
Method method = methods[I];
NSString *methodName = NSStringFromSelector(method_getName(method));
[methodNames appendString: methodName];
[methodNames appendString:@" "];
}
NSLog(@"%@",methodNames);
free(methods);
}
上述打印内容如下:
NSKVONotifyin_Person内存储的对象方法
通过上述代码我们发现NSKVONotifyin_Person中有4个对象方法。分别为setAge: class dealloc _isKVOA，那么至此我们可以画出NSKVONotifyin_Person的内存结构以及方法调用顺序。
NSKVONotifyin_Person的内存结构以及方法调用顺序
这里NSKVONotifyin_Person重写class方法是为了隐藏NSKVONotifyin_Person。不被外界所看到。我们在p1添加过KVO监听之后，分别打印p1和p2对象的class可以发现他们都返回Person。
NSLog(@"%@,%@",[p1 class],[p2 class]);
// 打印结果 Person,Person
如果NSKVONotifyin_Person不重写class方法，那么当对象要调用class对象方法的时候就会一直向上找来到nsobject，而nsobect的class的实现大致为返回自己isa指向的类，返回p1的isa指向的类那么打印出来的类就是NSKVONotifyin_Person，但是apple不希望将NSKVONotifyin_Person类暴露出来，并且不希望我们知道NSKVONotifyin_Person内部实现，所以在内部重写了class类，直接返回Person类，所以外界在调用p1的class对象方法时，是Person类。这样p1给外界的感觉p1还是Person类，并不知道NSKVONotifyin_Person子类的存在。
那么我们可以猜测NSKVONotifyin_Person内重写的class内部实现大致为:
- (Class) class {
// 得到类对象，在找到类对象父类
return class_getSuperclass(object_getClass(self));
}
- 验证didChangeValueForKey:内部会调用observer的observeValueForKeyPath:ofObject:change:context:方法.
我们在Person类中重写willChangeValueForKey:和didChangeValueForKey:方法，模拟他们的实现。
- (void)setAge:(int)age
{
NSLog(@"setAge:");
_age = age;
}
- (void)willChangeValueForKey:(NSString *)key
{
NSLog(@"willChangeValueForKey: - begin");
[super willChangeValueForKey:key];
NSLog(@"willChangeValueForKey: - end");
}
- (void)didChangeValueForKey:(NSString *)key
{
NSLog(@"didChangeValueForKey: - begin");
[super didChangeValueForKey:key];
NSLog(@"didChangeValueForKey: - end");
}
再次运行来查看didChangeValueForKey的方法内运行过程，通过打印内容可以看到，确实在didChangeValueForKey方法内部已经调用了observer的observeValueForKeyPath:ofObject:change:context:方法。
didChangeValueForKey内运行顺序
四，KVO底层原理
在这里插入图片描述
- 首先创建一个 Person 类 内部有个 name 属性,然后 创建p1 和 p2两个实例对象,其中p1添加了kvo监听,p2没有添加 kvo 监听,然后重写了 observeValueForKeyPath 方法 监听Person.name 属性发生改变时候的通知.
在这里插入图片描述
从本质上来看 Person 给name赋值的时候 调用的是 setName 方法 ,无论 p1还是p2 调用的 setter 方法都是一样的,为什么 p1改变 name 属性值就能有通知, p2确没有,调用的 都是同一个 setName:(NSString *)name 方法,区别怎么那么大?
- 接下来打印下p1和p2的内存地址 看看p1和p2内存地址能不能一探究竟.
在这里插入图片描述
-
从 p1和 p2内存地址上也看不出来什么东东.接着打印 p1和 p2 的 class 信息
在这里插入图片描述
-
打印 object_getClass 试试看，我们都知道object_getClass(id) 才会返回这个实例对象的真实 class 类型
在这里插入图片描述
-
打印 setName 方法实现IMP指针有没有发生改变,我们知道同一个方法的实现 IMP 地址是不变的.
在这里插入图片描述
-
这里连 setName方法都不一样了 , 为了一探究竟 对上边的 NSKVONotifying_Person 和 添加 KVO 之后的 imp 指针进行进一步研究.
-
首先 在 lldb 上输入 imp1和 imp2
在这里插入图片描述
发生了 imp1 方法实现在 Foundation 框架里的 _NSSetObjectValueAndNotify 函数中 ,而 imp2 则调用了 Person setName 方法
在这里插入图片描述
也就是说添加了 KVO 之后 p1 修改 name 值之后 不再调用 Person 的 setName方法 ,而 p2没有添加 kvo 监听 依然正常调用 setName:方法 ,由此可以得出 p1 添加完 KVO 监听后 系统修改了默认方法实现,那么既然没有调用 setName: 方法 为什么 p1.name 的值也发生了改变?
-
接下来我们准备对刚才 NSKVONotifying_Person 类进行下一步研究, NSKVONotifying_Person 和 Person 有没有内在的联系呢? 研究一下NSKVONotifying_Person和 Person 之间的联系时什么？
在这里插入图片描述
通过打印 NSKVONotifying_Person 的 superclass 和 Person 的 superclass 可以得出, NSKVONotifying_Person是一个 Person 子类,那么为什么苹果会动态创建这么一个 子类呢? NSKVONotifying_Person 这个子类 跟 Person 内部有哪些不同呢 ?
这个时候 我们去输出下 Person 和 NSKVONotifying_Person 内部的方法列表 和 属性列表 ,看看NSKVONotifying_Person 子类都添加了那些方法和属性.
- (void)viewDidLoad {
[super viewDidLoad];
Person *p1 = [[Person alloc] init];
Person *p2 = [[Person alloc] init];
id cls1 = object_getClass(p1);
id cls2 = object_getClass(p2);
NSLog(@"添加 KVO 之前: cls1 = %@ cls2 = %@ ",cls1,cls2);
[p1 addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
cls1 = object_getClass(p1);
cls2 = object_getClass(p2);
NSString *methodList1 = [self printPersonMethods:cls1];
NSString *methodList2 = [self printPersonMethods:cls2];
NSLog(@"%@",methodList1);
NSLog(@"%@",methodList2);
// NSLog(@"添加 KVO 之后: cls1 = %@ cls2 = %@ ",cls1,cls2);
// id super_cls1 = class_getSuperclass(cls1);
// id super_cls2 = class_getSuperclass(cls2);
//
// NSLog(@"super_cls1 = %@ ,super_cls2 = %@",super_cls1,super_cls2);
//
// p1.name = @"dzb";
// p2.name = @"123";
}
- (NSString *) printPersonMethods:(id)obj {
unsigned int count = 0;
Method *methods = class_copyMethodList([obj class],&count);
NSMutableString *methodList = [NSMutableString string];
[methodList appendString:@"[\n"];
for (int i = 0; i<count; i++) {
Method method = methods[I];
SEL sel = method_getName(method);
[methodList appendFormat:@"%@",NSStringFromSelector(sel)];
[methodList appendString:@"\n"];
}
[methodList appendFormat:@"]"];
free(methods);
return methodList;
}
输出结果如下：
在这里插入图片描述
从输出结果可以看出来 NSKVONotifying_Person 内部也有一个 setName:方法 还重写了 class 和 dealloc 方法 , _isKVOA, 那么我们可以大致的得出, p1添加 kVO 后 runtime 动态的生成了一个 NSKVONotifying_Person子类 并重写了 setName 方法 ,那么 setName 内部一定是做了一些事情,才会触发 observeValueForKeyPath 监听方法.
- 继续探究 NSKVONotifying_Person 子类 重写 setName 都做了什么?
其实 setName 方法内部 是调用了 Foundation 的 _NSSetObjectValueAndNotify 函数 ,在 _NSSetObjectValueAndNotify 内部：
- 首先会调用 willChangeValueForKey
- 然后给 name 属性赋值
- 最后调用 didChangeValueForKey
- 最后调用 observer 的 observeValueForKeyPath 去告诉监听器属性值发生了改变 .
在这里插入图片描述
-
由于苹果 Foundation 框架是不开源的 ,所以我们依然可以通过重写Person 的 willChangeValueForKey 和 didChangeValueForKey 验证我们的猜想 .
在这里插入图片描述
首先当我们改变p1.name 的值时 并不是首先执行的 setName: 这个方法 ,而是先调用了 willChangeValueForKey 其次 调用父类的 setter 方法 对属性赋值 ,然后再调用 didChangeValueForKey 方法 ,并在 didChangeValueForKey 内部 调用监听器的 observeValueForKeyPath方法 告诉外界 属性值发生了改变.
在这里插入图片描述
在这里插入图片描述
至于重写了 dealloc 和 class 方法 是为了做一些 KVO 释放内存 和 隐藏外界对于 NSKVONotifying_Person 子类的存在
在这里插入图片描述
10.这就是我们调用 [p1 class] 和 [p2 class]结果都显示 Person 类 ,让我们误以为 Person 没有发生变化
- KVC 对属性赋值时候 是会在这个类里边 去查找 _age isAge setAge setIsAge 等方法的 ,最终会调用属性的 setter 方法 ,那么如果添加了 KVO 还是会被触发的 .
相反 设置成员变量 _age 由于不会触发 setter 方法 ,因此不会去触发 KVO 相关的代码 .
五，KVO底层实现代码
1. 通过代码来自己实现KVO监听
- ViewController调用实现
#import "ViewController.h"
#import "Person.h"
#import "NSObject+KCKVO.h"
#import "Dog.h"
@interface ViewController ()
@property (nonatomic, strong) Person *p;
@end
// 分类
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
self.p = [[Person alloc] init];
[self.p lg_addObserver:self forKeyPath:@"name"];
self.p.name = @"kongyulu";
}
#pragma mark - value 回调
- (void)lg_observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object newValue:(id)newValue{
NSLog(@"lg_observeValueForKeyPath - %@",newValue);
}
#pragma mark - dealloc
- (void)dealloc{
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
self.p.name = [NSString stringWithFormat:@"%@+",self.p.name];
}
@end
- 定义两个类
- 定义Person类
#import <Foundation/Foundation.h>
@interface Person : NSObject{
@public
NSString *girl;
}
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
@property (nonatomic, strong) NSMutableArray *mArray;
+ (instancetype)shared;
@end
#import "Person.h"
@implementation Person
- (void)setName:(NSString *)name{
NSLog(@"设置方法 ");
}
- (void)dealloc{
NSLog(@"父走了");
}
@end
- 定义Dog类
#import <Foundation/Foundation.h>
#import "Person.h"
@interface Dog : Person
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
@end
#import "Dog.h"
@implementation Dog
- (void)dealloc{
NSLog(@"儿子走了");
}
@end
- 定义NSObject的一个实现KVO监听的分类NSObject+KCKVO
- 头文件
#import <Foundation/Foundation.h>
typedef void(^KCKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);
@interface NSObject (KCKVO)
- (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;
- (void)lg_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;
@end
- 实现类
#import "NSObject+KCKVO.h"
#import <objc/message.h>
static NSString *const kKCKVOPrefix = @"KCKVO_";
static NSString *const kKCKVOAssiociateKey = @"kKCKVO_AssiociateKey";
@implementation NSObject (KCKVO)
- (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath{
// 1: 是否有setter方法
// id superClassName = object_getClassName(self); // person
// setName
NSString *setterMethodName = setterForGetter(keyPath); // setName:
SEL setterSel = NSSelectorFromString(setterMethodName);
// method
Method method = class_getInstanceMethod([self class], setterSel);// runtime 1900009931
if (!method) {
@throw [[NSException alloc] initWithName:NSExtensionItemAttachmentsKey reason:@"没有setter方法" userInfo:nil];
}
//2: 动态生成子类
Class childClass = [self creatChildClassWithKeypath:keyPath];
if (!childClass) {
NSLog(@"创建失败");
}
// 3.0 消息转发
// observer
// 关联对象
objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kKCKVOAssiociateKey), observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
#pragma mark - 动态创建子类
- (Class)creatChildClassWithKeypath:(NSString *)keyPath{
NSString *oldClassName = NSStringFromClass([self class]);//person
NSString *childClassName = [NSString stringWithFormat:@"%@%@",kKCKVOPrefix,oldClassName];
//2: 动态生成子类
//2.1 申请类
Class childClass = objc_allocateClassPair([self class], childClassName.UTF8String, 0);
//2.2 注册类
objc_registerClassPair(childClass);
//2.3 添class
SEL classSel = NSSelectorFromString(@"class");
Method classMethod = class_getClassMethod([self class], classSel);
const char *classType = method_getTypeEncoding(classMethod);
class_addMethod(childClass, classSel, (IMP)lg_Class, classType);
//2.4 setter : setName:
SEL setterSel = NSSelectorFromString(setterForGetter(keyPath));
Method setterMethod = class_getClassMethod([self class], setterSel);
const char *setterType = method_getTypeEncoding(setterMethod);
class_addMethod(childClass, setterSel, (IMP)lg_setter, setterType);
//2.5 isa 指向
object_setClass(self, childClass);
return childClass;
}
/**
判断是否存在该方法
*/
- (BOOL)hasSeletor:(SEL)selector{
Class observedClass = object_getClass(self);
unsigned int methodCount = 0;
//得到一堆方法的名字列表 //class_copyIvarList 实例变量 //class_copyPropertyList 得到所有属性名字
Method *methodList = class_copyMethodList(observedClass, &methodCount);
for (int i = 0; i<methodCount; i++) {
SEL sel = method_getName(methodList[I]);
if (selector == sel) {
free(methodList);
return YES;
}
}
free(methodList);
return NO;
}
#pragma mark - 函数区域
static Class lg_Class(id self,SEL _cmd){
return class_getSuperclass(object_getClass(self));
}
static void lg_setter(id self,SEL _cmd,id value){
NSLog(@"lg_setter - %@",value);
id observer = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kKCKVOAssiociateKey));
SEL handlSEL = @selector(lg_observeValueForKeyPath: ofObject:newValue:);
NSString *keypath = getterForSetter(NSStringFromSelector(_cmd));
objc_msgSend(observer,handlSEL,keypath,self,value);
// [observer performSelector:@selector(lg_observeValueForKeyPath: ofObject:newValue:) withObject:self afterDelay:0];
}
#pragma mark - 从get方法获取set方法的名称 name ===>>> setName:
static NSString * setterForGetter(NSString *getter){
if (getter.length <= 0) { return nil; }
NSString *firstString = [[getter substringToIndex:1] uppercaseString];
NSString *leaveString = [getter substringFromIndex:1];
return [NSString stringWithFormat:@"set%@%@:",firstString,leaveString];
}
#pragma mark - 从set方法获取getter方法的名称 setName:===> name
static NSString * getterForSetter(NSString *setter){
if (setter.length <= 0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) { return nil;}
NSRange range = NSMakeRange(3, setter.length-4);
NSString *getter = [setter substringWithRange:range];
NSString *firstString = [[getter substringToIndex:1] lowercaseString];
getter = [getter stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:firstString];
return getter;
}
@end
-
运行打印结果：
在这里插入图片描述
2. 通过 runtime 动态创建子类方式去实现
- 动态创建一个 NSKVONotifying_Person 子类
/**
运行时动态的创建子类
@param super_cls 父类
@return 返回子类
*/
- (Class) registerSubClassWithSuperClass:(Class)super_cls {
///动态的创建 子类
NSString *clsName = [NSString stringWithFormat:@"NSKVONotifying_%@",super_cls];
///一个 NSObject 默认分配16个字节内存
Class sub_cls = objc_allocateClassPair(super_cls,clsName.UTF8String,16);
///注册一个子类
objc_registerClassPair(sub_cls);
///将父类 isa 指针指向 子类
object_setClass(self, sub_cls);
return sub_cls;
}
- 动态的给这个子类 动态添加方法 setter 方法 didChangeValueForKey方法 class 方法实现
///动态创建子类 NSKVONotifying_xxx
Class sub_cls = [self registerSubClassWithSuperClass:super_cls];
///给子类动态的添加 class setter didChangeValueForKey 实现
Method class_method = class_getInstanceMethod(super_cls, @selector(class));
Method changeValue_method = class_getInstanceMethod(super_cls, @selector(didChangeValueForKey:));
class_addMethod(sub_cls, @selector(class), (IMP)kvo_class,method_getTypeEncoding(class_method));
///给子类动态的添加 didChangeValueForKey
class_addMethod(sub_cls, @selector(didChangeValueForKey:), (IMP)didChangeValue,method_getTypeEncoding(changeValue_method));
///动态的给子类添加 setter 方法
class_addMethod(sub_cls, setterSel, (IMP)kvo_setter,method_getTypeEncoding(method));
///将观察者对象跟当前实例 self 关联起来
objc_setAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedObservers), observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
- 重写 class 方法实现
/**
自实现 class 方法
@param self 当前类实现
@param _cmd class
@return 返回父类 Class 外界不会知道 NSKVONotifying_子类存在
*/
static Class kvo_class(id self,SEL _cmd) {
return class_getSuperclass(object_getClass(self));
}
- 重写 setter 方法实现
/**
自实现 setter 方法
@param self 当前类实现
@param _cmd setter
@param newValue 赋值
*/
static void kvo_setter(id self,SEL _cmd,id newValue) {
NSString *setterName = NSStringFromSelector(_cmd);
NSString *getterName = getterForSetter(setterName);
///将要改变属性的值
[self willChangeValueForKey:getterName];
///调用 super setter 方法
struct objc_super suer_cls = {
.receiver = self,
.super_class = class_getSuperclass(object_getClass(self))
};
///存储旧值
objc_setAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedOldValue),[self valueForKey:getterName], OBJC_ASSOCIATION_RETAIN_NONATOMIC);
///调用父类 setter 方法 设置新值
objc_msgSendSuper(&suer_cls,_cmd,newValue);
///改变监听属性值后 调用 didChangeValueForKey 并在内部 调用
[self didChangeValueForKey:getterName];
};
- 重写 didChangeValueForKey 方法实现
/**
didChangeValueForkey 实现方法 , 当根据 SEL (didChangeValueForkey:) 会找到方法 IMP 实现
*/
static void didChangeValue(id self,SEL _cmd,NSString *key) {
id newValue = [self valueForKey:key];
id observer = objc_getAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedObservers));
id oldValue = objc_getAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedOldValue));
NSMutableDictionary *change = [NSMutableDictionary dictionary];
if (oldValue) {
change[@"oldValue"] = oldValue;
} else {
change[@"oldValue"] = [NSNull null];
}
if (newValue) {
change[@"newValue"] = newValue;
} else {
change[@"newValue"] = newValue;
}
[observer observeValueForKeyPath:key ofObject:self change:change context:NULL];
}
网友评论