KVO 到底在干什么？

一、KVO 的基本使用

首先我们来看一下 KVO 的基本使用，KVO 的全称 Key-Value Observing，俗称“键值监听”，可以用于监听某个对象属性值的改变。

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *p1 = [[Person alloc] init];
    Person *p2 = [[Person alloc] init];
    p1.age = 10;
    p2.age = 20;
    // self 监听 p1 的 age 属性
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [p1 addObserver:self forKeyPath:@"age" options:options context:nil];
    p1.age = 30;
    p2.age = 40;
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
{
    NSLog(@"监听到%@的%@改变了%@", object, keyPath,change);
}

// 打印内容
监听到<Person: 0x600000108640>的age改变了{
    kind = 1;
    new = 30;
    old = 10;
}

从上述代码中可以看出，在添加监听之后，age 属性的值在发生改变时，就会通知到监听者，执行监听者的 observeValueForKeyPath 方法。

二、探寻 KVO 原理

通过上述代码我们发现，一旦 age 属性的值发生改变时，就会通知到监听者，并且我们知道赋值操作都是调用属性的 set 方法，我们可以来到 Person 类中重写 age 的 set 方法，观察是否是 KVO 在 set 方法内部做了一些操作来通知监听者。
我们发现即使重写了 set 方法，p1 对象和 p2 对象调用同样的 set 方法，但是我们发现 p1除了调用 set 方法之外还会另外执行监听器的 observeValueForKeyPath:ofObject:change:context: 方法。
这说明 KVO 在运行时获取对 p1 对象做了一些改变。相当于在程序运行过程中，对 p1 对象做了一些变化，使得 p1 对象在调用 setAge: 方法的时候可能做了一些额外的操作，所以问题出在对象身上，两个对象在内存中肯定不一样，两个对象本质上也不一样。

三、KVO 底层实现分析

首先我们来看一下 p1 和 p2 在 addObserver 方法前后的 isa 分别是什么

通过上图我们发现，p1 对象执行过 addObserver 操作之后，p1 对象的 isa 指针由之前的指向类对象 Person 变为指向 NSKVONotifyin_Person 类对象，而 p2 对象没有任何改变。也就是说一旦 p1 对象添加了 KVO 监听以后，其 isa 指针就会发生变化，因此 set 方法的执行效果就不一样了。
那么我们先来观察 p2 对象在内容中是如何存储的，然后对比 p2 来观察 p1 。
首先我们知道，p2 在调用 setAge: 方法的时候，首先会通过 p2 对象中的 isa 指针找到 Person 类对象，然后在类对象中找到 setAge: 方法。然后找到方法对应的实现。如下图所示
但是刚才我们发现 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:ofObject:change:context: 方法中

四、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 = 10;
    Person *p2 = [[Person alloc] init];
    p2.age = 20;
    // 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 (NSInteger i = 0 ; i < count; i++) {
        Method method = methods[i];
        NSString *methodName  = NSStringFromSelector(method_getName(method));

        [methodNames appendString: methodName];
        [methodNames appendString:@" "];
    }
    NSLog(@"%@",methodNames);
    free(methods);
}

// 打印内容
Person - setAge: age
NSKVONotifying_Person - setAge: class dealloc _isKVOA

通过上述代码我们发现 NSKVONotifyin_Person 中有 4 个对象方法。分别为 setAge: class dealloc _isKVOA，那么至此我们可以知道 NSKVONotifyin_Person 的内存结构以及方法调用顺序。

这里 NSKVONotifyin_Person 重写 class 方法是为了隐藏 NSKVONotifyin_Person，使其不被外界所看到。我们在 p1 添加过KVO监听之后，分别打印 p1 和 p2 对象的 class 可以发现他们都返回 Person。
1
2
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 内部实现大致为
1
2
3
4
5
- (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");
}
// 打印内容
setAge:
setAge:
willChangeValueForKey: - begin
willChangeValueForKey: - end
setAge:
didChangeValueForKey: - begin
监听到<Person: 0x6000032f4260>的age改变了{
    kind = 1;
    new = 30;
    old = 10;
}
didChangeValueForKey: - end
setAge:

通过上面的打印内容，我们知道 didChangeValueForKey: 内部确实会调用 observer 的 observeValueForKeyPath:ofObject:change:context: 方法，验证了之前的观点。

六、总结（KVO的本质是什么？）

利用 RuntimeAPI 动态生成一个子类，并且让 instance 对象的 isa 指向这个全新的子类（NSKVONotifying_XXX）
当修改 instance 对象的属性时，会调用 Foundation 的 _NSSetXXXValueAndNotify 函数
子类拥有自己的set方法实现，内部会调用
- willChangeValueForKey:
- 原来的 setter 方法
- didChangeValueForKey: 这个方法内部又会调用监听器(observe)的监听方法（observeValueForKeyPath:ofObject:change:context:）