IOS底层（三） KVO底层实现原理

@[TOC](IOS底层（三） KVO底层实现原理 )

一，KVO简述

KVO的全称 Key-Value Observing，俗称“键值监听”，可以用于监听某个对象属性值的改变。
带着问题探索：

  1. iOS用什么方式实现对一个对象的KVO？（KVO的本质是什么？）
答. 当一个对象使用了KVO监听，iOS系统会修改这个对象的isa指针，
改为指向一个全新的通过Runtime动态创建的子类，子类拥有自己的set方法实现，
set方法实现内部会顺序调用willChangeValueForKey方法、原来的setter方法实现、
didChangeValueForKey方法，而didChangeValueForKey方法内部
又会调用监听器的observeValueForKeyPath:ofObject:change:context:监听方法。
  1. 如何手动触发KVO
答. 被监听的属性的值被修改时，就会自动触发KVO。
如果想要手动触发KVO，则需要我们自己调用willChangeValueForKey和
didChangeValueForKey方法即可在不改变属性值的情况下手动触发KVO
，并且这两个方法缺一不可。
  1. KVO 底层实现是什么?
  2. 修改成员变量的值会出发 KVO 吗?
  3. KVC 赋值会出发 KVO 吗?

二，KVC 简述

1. KVC定义

KVC: Key-value coding is a mechanism for indirectly accessing anobject’s attributes and relationships using string identifiers.

所谓键值编码，并不是访问器方法的启动和实例变量的访问这种直接的方式，而是使用表示属性的字符串来间接访问对象属性值的一种结构。

只要存在访问器方法、声明属性或实例变量，就可以将其名字指定为字符串来访问。

之所以说键值编码的访问是接的：

  1. 可以在运行中确定作为键的字符串

  2. 使用者无法知道实际访问属性的方法

键值编码必需的方法在非正式协议NSKeyValueCoding中声明（头文件Foundation/NSKeyValueCoding.h）。默认在NSObject中实现。

2. 方法调用

下面就以下两个方法的调用进行说明：

  •  (id)  valueForKey: (NSString *) key

返回表示属性的键字符串所对应的值。如果不能取得值，则将引起接收器调用方法valueForUndefinedKey:。

  •  (void)setValue: (id) value  forKey: (NSString*) key

将键字符串key所对应的属性的值设置为value。不能设定属性时，将引起接收器调用方法setValue:ForUndefinedKey:。

执行时，有访问器的属性会使用访问器，没有访问器的属性也可以设定值和访问。因为上面两个方法均为实例方法，可以在方法体内访问实例变量。

访问过程如下：

  1. 接收器中如果有key访问器（或getKey、isKey、_key、_getKey、setKey）则使用它。

  2. 没有访问器时，使用接收器的类方法accessInstanceVariablesDirectly来查询。返回YES时，如果存在实例变量key（或_key、isKey、_isKey等）则返回或设置其值。使用引用计数管理方式时，实例变量如果为对象，则旧值会被自动释放，新值被保存并代入。

  • (BOOL)accessInstanceVariablesDirectly

    通常定义为返回YES，可以在子类中改变。该类方法返回YES时，使用键值编码可以访问该类的实例变量。返回NO时不可以访问。只要该方法返回YES，实例变量的可视属性即使有@private修饰，也可以访问。

  1. 既没有访问器也没有实例变量时，将引起接收器调用方法valueForUndefinedKey:或setValue:forUndefinedKey:。
  •   (id) valueForUndefinedKey: (NSStirng *) key

不能取得键字符串对应的值时，从方法valueForKey：中调用该方法。默认情况下，该方法的执行会触发NSUndefinedKeyException。不过，通过在子类中修改定义，就可以返回其他对象。

  •   (void) setValue: (id) value  forUndefinedKey: (NSString *) key

不能设置键字符串key对应的属性值时，从方法setValue:forKey中调用该方法。默认情况下，该方法的执行会触发异常NSUndefinedKeyException。不过，通过在子类中修改定义，可以返回其他对象。

  1. 如果该返回值不是对象，则返回被适当的对象包装的值；设置值时也应先包装成相应的对象。

属性为对象时，该对象还可能持有属性。这时候可以用“.”连接表示键的字符串，这种表示方式称为键路径。只要能找到对象，点和键多长都没有关系。

  •  (id) valueForKeyPath:(NSString *) keyPath

以点切分键路径，并使用第一个键向接收器发送valueForKey：方法。然后，再使用键路径的下一个键，向得到的对象发送valueForKey：方法，如此反复操作，返回最后获得的对象。

  •  (void)setValue: (id) value  forKeyPath:(NSString *) keyPath

与valueForKeyPath：方法一样取出对象，这里只对路径中的最后一个键调用setValue：forKey：方法，并设定属性值为value。

3. KVC准则

  1. 随访问器方法而改变。

  2. 使用setValue：forKey：和键进行改变。此时也可能不经由访问器。

  3. 使用setValue：forKeyPath：和键路径进行改变。此时也可能不经由访问器。不仅仅是最终的监视对象的属性，当路径中的属性发生变化时，也会被通知。

三，KVO实现原理探索

  1. 首先需要了解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底层原理

在这里插入图片描述
  1. 首先创建一个 Person 类 内部有个 name 属性,然后 创建p1 和 p2两个实例对象,其中p1添加了kvo监听,p2没有添加 kvo 监听,然后重写了 observeValueForKeyPath 方法 监听Person.name 属性发生改变时候的通知.
在这里插入图片描述

从本质上来看 Person 给name赋值的时候 调用的是 setName 方法 ,无论 p1还是p2 调用的 setter 方法都是一样的,为什么 p1改变 name 属性值就能有通知, p2确没有,调用的 都是同一个 setName:(NSString *)name 方法,区别怎么那么大?

  1. 接下来打印下p1和p2的内存地址 看看p1和p2内存地址能不能一探究竟.
在这里插入图片描述

  1. 从 p1和 p2内存地址上也看不出来什么东东.接着打印 p1和 p2 的 class 信息


    在这里插入图片描述

  2. 打印 object_getClass 试试看，我们都知道object_getClass(id) 才会返回这个实例对象的真实 class 类型


    在这里插入图片描述

  3. 打印 setName 方法实现IMP指针有没有发生改变,我们知道同一个方法的实现 IMP 地址是不变的.


    在这里插入图片描述

  4. 这里连 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 的值也发生了改变?

  1. 接下来我们准备对刚才 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 监听方法.

  1. 继续探究 NSKVONotifying_Person 子类 重写 setName 都做了什么?
    其实 setName 方法内部 是调用了 Foundation 的 _NSSetObjectValueAndNotify 函数 ,在 _NSSetObjectValueAndNotify 内部：
    1. 首先会调用 willChangeValueForKey
    1. 然后给 name 属性赋值
    1. 最后调用 didChangeValueForKey
    1. 最后调用 observer 的 observeValueForKeyPath 去告诉监听器属性值发生了改变 .
在这里插入图片描述

  1. 由于苹果 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监听

  1. 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
  1. 定义两个类
  • 定义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
  1. 定义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

  1. 运行打印结果：


    在这里插入图片描述

2. 通过 runtime 动态创建子类方式去实现

  1. 动态创建一个 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;
}
  1. 动态的给这个子类 动态添加方法 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);
  1. 重写 class 方法实现

/**
 自实现 class 方法

 @param self 当前类实现
 @param _cmd  class
 @return  返回父类 Class 外界不会知道 NSKVONotifying_子类存在
 */
static Class kvo_class(id self,SEL _cmd) {
    return class_getSuperclass(object_getClass(self));
}
  1. 重写 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];

};
  1. 重写 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];

}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,793评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,567评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,342评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,825评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,814评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,680评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,033评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,687评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,175评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,668评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,775评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,419评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,020评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,206评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,092评论 2赞 351
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,510评论 2赞 343

推荐阅读更多精彩内容

  • iOS底层原理汇 - 探索KVO本质
    问题 iOS用什么方式实现对一个对象的KVO？（KVO的本质是什么？） 如何手动触发KVO ？ 首先需要了解KVO...
    hjltony阅读 574评论 0赞 2
  • iOS底层原理总结 - 探寻KVO本质
    对小码哥底层班视频学习的总结与记录。面试题部分，通过对面试题的分析探索问题的本质内容。 问题iOS用什么方式实现对...
    xx_cc阅读 10,754评论 26赞 65
  • iOS进阶之KVO底层原理
    前言 KVO作为iOS一个设计模式，监听对象属性变化。通过属性变化来做出一些处理。那么KVO底层原理是什么？相信大...
    枫叶无处漂泊阅读 798评论 0赞 2
  • 探寻KVO本质
    面试问题： · iOS用什么方式实现对一个对象的KVO？ · 如何手动触发KVO？ 我们通过以下几个点来寻找这两个...
    高思阳阅读 239评论 0赞 1
  • 泡面也可以很治愈
    泡面，以其食用便捷性、价格平价性和味道的丰富性，自出世以来，便广受欢迎。现今，更是众多宅男宅女月末吃土的最佳选择。...
    Log君阅读 617评论 0赞 1