iOS底层原理 - 探寻KVO本质

·  阅读 2180

KVO全称KeyValueObserving,俗称键值监听,是苹果提供的一套事件通知机制。允许对象监听另一个对象特定属性的改变,并在改变时接收到事件。由于KVO的实现机制,所以对属性才会发生作用,一般继承自NSObject的对象都默认支持KVO。KVO可以监听单个属性的变化,也可以监听集合对象的变化。通过KVC的mutableArrayValueForKey:等方法获得代理对象,当代理对象的内部对象发生改变时,会回调KVO监听的方法。

1. KVO基本使用

先简单的回顾一下 KVO的代码实现以及基本使用

定义一个 PWPerson 类 继承自 NSObject ,定义一个 age 属性

// PWPerson.h 文件

#import <Foundation/Foundation.h>

@interface PWPerson : NSObject
@property (nonatomic, assign) int age;
@end



///> ViewController.m 文件

#import "ViewController.h"
#import "PWPerson.h"
@interface ViewController ()
@property (nonatomic, strong) PWPerson *person1;
@property (nonatomic, strong) PWPerson *person2;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    self.person1 = [[PWPerson alloc]init];
    self.person1.age = 1;
    
    self.person2 = [[PWPerson alloc]init];
    self.person2.age = 2;
    
    // self 监听 p1的 age属性
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [self.person1 addObserver:self forKeyPath:@"age" options:options context:nil];
    
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    self.person1.age = 20;
    self.person2.age = 30;
}

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

- (void)dealloc{
    ///> 使用结束后记得移除
    [self.person1 removeObserver:self forKeyPath:@"age"];
}

@end

输出结果:
监听到了<PWPerson: 0x6000033d4e40>的age属性发生了改变- {
kind = 1;
new = 20;
old = 1;
}

///>  因为我们只监听了person1  所以只会输出person1的改变。

复制代码

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

2. KVO存在的疑问

PWPerson 中使用 @property 声名一个属性的时候会自动生成声名属性的set和get方法。如下代码:

///> PWPerson.h文件
#import <Foundation/Foundation.h>
@interface PWPerson : NSObject
@property (nonatomic, assign) int age;
@end


///> PWPerson.m文件

#import "PWPerson.h"

@implementation PWPerson

- (void)setAge:(int)age{
    _age = age;
}

@end

复制代码

我们在 touchesBegan:withEvent: 的方法中使用 setAge: 方法去改变成员变量的值。

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    // self.person1.age = 20;
    [self.person1 setAge:20]; ///> 等同于self.person1.age = 20;
    
    //self.person2.age = 30;
    [self.person2 setAge:30];///> 等同于self.person2.age = 30;
}
复制代码

既然 person1person2 的本质都是在调用 set 方法,一定都会走 PWPerson 类中的 setAge: 这个方法。

那么问题来了,同样走的是 PWPerson 类中的 setAge: 方法,为什么 person1 就会走到

- (void)observeValueForKeyPath:(nullable NSString *)keyPath ofObject:(nullable id)object change:(nullable NSDictionary<NSKeyValueChangeKey, id> *)change context:(nullable void *)context;
复制代码

方法中而 person2 就不会呢?

3.KVO底层实现原理

接下来我们探究一下两个对象的本质,首先需要将 person1person2isa 打印出来,查看一下他们的实例对象isa指向的类对象是什么?

(lldb) po self.person1->isa
NSKVONotifying_PWPerson

(lldb) po self.person2->isa
PWPerson
复制代码

通过控制台打印我们会发现 person1isa 指针打印出的是: NSKVONotifying_PWPerson

person2isa 指针打印出来的是: PWPerson

person1person2 都是实例对象 所以 person1person2isa 指针指向的都是类对象,通过打印这两个对象指向的类是不一样的。说明 KVO 在运行时获取对p1对象做了一些改变。相当于在程序运行过程中,对 person1 对象做了一些变化,使得 person1 对象在调用 setAge: 方法的时候可能做了一些额外的操作,两个对象在内存中肯定不一样,两个对象可能本质上并不一样。接下来来探索KVO内部是怎么实现的。

4. KVO底层实现分析

对上述代码中添加监听的地方打断点,看观察一下,addObserver 方法对 person1 对象做了什么处理?也就是说 person1 对象在经过 addObserver 方法之后发生了什么改变,通过打印 isa 指针如下:

(lldb) po self.person1->isa
NSKVONotifying_PWPerson

(lldb) po self.person2->isa
PWPerson
复制代码

通过上面的控制台打印的信息我们发现,person1 对象执行过 addObserver 操作之后,person1 对象的 isa 指针由之前的指向类对象 PWPerson 变为指向 NSKVONotifyin_PWPerson 类对象,而 person2 对象没有任何改变。也就是说一旦 person1 对象添加了 KVO 监听以后,其 isa 指针就会发生变化,因此 set 方法的执行效果就不一样了。

person1 对象的 isa 指针在经过 KVO 监听之后已经指向了 NSKVONotifyin_PWPerson 类对象,NSKVONotifyin_PWPerson 其实是 PWPerson 的子类,那么也就是说其 super class 指针是指向 PWPerson 类对象的,NSKVONotifyin_PWPerson 是runtime在运行时生成的。那么 person1 对象在调用 setAge: 方法的时候,肯定会根据 person1isa 找到NSKVONotifyin_PWPerson,在 NSKVONotifyin_PWPerson 中找 setAge: 的方法及实现。

首先经过之前打断点打印isa指针,我们已经验证了,在执行添加监听的方法时,会将 isa 指针指向一个通过 runtime 创建的 Person 的子类 NSKVONotifyin_PWPerson。 另外我们可以通过打印方法实现的地址来看一下 person1person2setAge: 的方法实现的地址在添加KVO前后有什么变化。

// 通过methodForSelector找到方法实现的地址
NSLog(@"添加KVO监听之前 - person1 = %p, person2 = %p", [person1 methodForSelector: @selector(setAge:)],[person2 methodForSelector: @selector(setAge:)]);
    
NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
[person1 addObserver:self forKeyPath:@"age" options:options context:nil];

NSLog(@"添加KVO监听之后 - person1 = %p, person2 = %p", [person1 methodForSelector: @selector(setAge:)],[person2 methodForSelector: @selector(setAge:)]);
复制代码

控制台打印结果

添加KVO监听之前 - person1 = 0x101c1b4a0, person2 = 0x101c1b4a0
添加KVO监听之后 - person1 = 0x7fff207a6cb3, person2 = 0x101c1b4a0
复制代码

我们发现在添加 KVO 监听之前,person1person2setAge 方法实现的地址相同,而经过 KVO 监听之后,person1setAge: 方法实现的地址发生了变化。

NSKVONotifyin_PWPerson内部结构是怎样的?

首先我们知道,NSKVONotifyin_PWPerson 作为 PWPerson 的子类,其 super class 指针指向 PWPerson 类,并且 NSKVONotifyin_PWPerson 内部一定对 setAge 方法做了单独的实现,那么NSKVONotifyin_PWPersonPWPerson 类的差别可能就在于其内存储的对象方法及实现不同。 我们通过 runtime 分别打印 PWPerson 类对象和 NSKVONotifyin_PWPerson 类对象内存储的对象方法

- (void)viewDidLoad {
    [super viewDidLoad];

    PWPerson *person1 = [[PWPerson alloc] init];
    person1.age = 1.0;
    PWPerson *person2 = [[PWPerson alloc] init];
    person2.age = 2.0;
    // self 监听 person1 的 age属性
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [person1 addObserver:self forKeyPath:@"age" options:options context:nil];

    [self printMethodNamesOfClass: object_getClass(person2)];
    [self printMethodNamesOfClass: object_getClass(person1)];
}

- (**void**)printMethodNamesOfClass:(Class)cls

{

    unsigned int count;
    // 获得方法数组
    Method *methodList = class_copyMethodList(cls, &count);
    // 存储方法名
    NSMutableString *methodNames = [NSMutableString string];
    // 遍历所有的方法
    for (int i = 0; i < count; i++) {
        // 获得方法
        Method method = methodList[i];
        // 获得方法名
        NSString *methodName = NSStringFromSelector(method_getName(method));
        // 拼接方法名
        [methodNames appendString:methodName];
        [methodNames appendString:@", "];
    }
    // 释放
    free(methodList);
    // 打印方法名
    NSLog(@"%@ %@", cls, methodNames);

}
复制代码

上述打印内容如下

NSKVONotifying_PWPerson setAge:, class, dealloc, _isKVOA,

PWPerson age, setAge:,
复制代码

通过上述代码我们发现 NSKVONotifyin_Person 中有4个对象方法。分别为 setAge: class ,dealloc, _isKVOA, 而 PWPerson 只有一个方法:setAge:

这里 NSKVONotifyin_Person 重写 class 方法是为了隐藏 NSKVONotifyin_Person。不被外界所看到。我们在 person1 添加过 KVO 监听之后,分别打印 person1 和 person2 对象的 class 可以发现他们都返回PWPerson。

NSLog(@"%@,%@",[p1 class],[p2 class]);
// 打印结果 PWPerson,PWPerson
复制代码

如果 NSKVONotifyin_PWPerson 不重写 class 方法,那么当对象要调用class对象方法的时候就会一直向上找来到nsobject,而nsobect的class的实现大致为返回自己isa指向的类,返回 person1 的 isa 指向的类那么打印出来的类就是 NSKVONotifyin_Person,但是 apple 不希望将NSKVONotifyin_Person 类暴露出来,并且不希望我们知道 NSKVONotifyin_Person 内部实现,所以在内部重写了 class 类,直接返回 PWPerson 类,所以外界在调用 person1 的class对象方法时,是PWPerson类。这样person1给外界的感觉person1还是PWPerson类,并不知道NSKVONotifyin_PWPerson子类的存在。

那么我们可以猜测NSKVONotifyin_Person内重写的class内部实现大致为

- (Class) class {
     // 得到类对象,在找到类对象父类
     return class_getSuperclass(object_getClass(self));
}
复制代码

验证didChangeValueForKey:内部会调用observerobserveValueForKeyPath:ofObject:change:context:方法

我们在PWPerson类中重写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 方法内部已经调用了 observerobserveValueForKeyPath:ofObject:change:context: 方法。

willChangeValueForKey
setAge:
didChangeValueForKey - begin
监听到<PWPerson: 0x6000035486d0>的age属性值改变了 - {
kind = 1;
new = 21;
old = 1;
}
didChangeValueForKey - end
复制代码

5. 面试题答案

  1. iOS用什么方式实现对一个对象的KVO?(KVO的本质是什么?)

     利用RuntimeAPI动态生成一个子类,并且让instance对象的isa指向这个全新的子类
     当修改instance对象的属性时,会调用Foundation_NSSetXXXValueAndNotify函数
     willChangeValueForKey:
     父类原来的setter
     didChangeValueForKey:
     内部会触发监听器(Oberser)的监听方法(observeValueForKeyPath:ofObject:change:context:)
    复制代码
  2. 如何手动触发KVO?

     手动调用willChangeValueForKey:和didChangeValueForKey:
    复制代码
  3. 直接修改成员变量会触发KVO么?

     不会触发KVO,因为直接修改成员变量并没有走set方法。
    复制代码

6.注意点

需要注意的是,我们已经移除了监听,如果再次移除的话,就会crash

例如

- (void)viewDidLoad {
    [super viewDidLoad];
    self.person1 = [[PWPerson alloc]init];
    self.person1.age = 1;
    
    self.person2 = [[PWPerson alloc]init];
    self.person2.age = 2;
    
    // self 监听 p1的 age属性
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [self.person1 addObserver:self forKeyPath:@"age" options:options context:nil];
    
}

- (void)dealloc{
     // 移除监听
    [self.person1 removeObserver:self forKeyPath:@"age"];
    // 再次移除
    [self.person1 removeObserver:self forKeyPath:@"age"];
}


复制代码

移除多次会报错

KVOdemo[9261:2171323] *** Terminating app due to uncaught exception 'NSRangeException', 
reason: 'Cannot remove an observer <ViewController 0x139e07220> for the key path "name" 
from <PWPerson 0x281322f20> because it is not registered as an observer.'

复制代码

如果忘记移除的话,有可能下次收到这个属性的变化的时候,会carsh

所以,我们要保证 add 和 remove 是成对出现的

注意点:如果使用 [self.person1 class] 无法获取真实的类

例如我们在添加KVO监听之后,这样来获取类对象

 NSLog(@"person1添加KVO监听之后 - %@ %@",[self.person1 class],[self.person2 class]);
复制代码

那么打印结果为

person1添加KVO监听之后 - PWPerson PWPerson
复制代码

这是因为,苹果为我们生成了中间类 NSKVONotifying_PWPerson 但是,他并不想让我们知道有这个类的存在,重写了这个 NSKVONotifying_PWPerson 的class方法,所以,我们获取的结果是不准确的。

分类:
iOS
标签:
分类:
iOS
标签:
收藏成功!
已添加到「」, 点击更改