• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

iOS之深入解析KVO的底层原理

互联网 diligentman 6小时前 3次浏览

一、KVO 简介

① 概念
  • KVO 全称 Key Value Observing,是苹果提供的一套事件通知机制,允许对象监听另一个对象特定属性的改变,并在改变时接收到事件。
  • 由于 KVO 的实现机制,所以对属性才会发生作用,一般继承自 NSObject 的对象都默认支持 KVO。
  • KVO 和 NSNotificationCenter 都是 iOS 中观察者模式的一种实现,区别在于,相对于被观察者和观察者之间的关系,KVO 是一对一的,而 NSNotificationCenter 是一对多的,KVO 对被监听对象无侵入性,不需要修改其内部代码即可实现监听。
  • KVO 可以监听单个属性的变化,也可以监听集合对象的变化。通过 KVC 的 mutableArrayValueForKey: 等方法获得代理对象,当代理对象的内部对象发生改变时,会回调 KVO 监听的方法。
② 使用
  • 使用 KVO 分为三个步骤:
    • 通过 addObserver:forKeyPath:options:context: 方法注册观察者,观察者可以接收 keyPath 属性的变化事件;
    • 在观察者中实现 observeValueForKeyPath:ofObject:change:context: 方法,当 keyPath 属性发生改变后,KVO 会回调这个方法来通知观察者;
    • 当观察者不需要监听时,可以调用 removeObserver:forKeyPath: 方法将 KVO 移除。需要注意的是,调用 removeObserver 需要在观察者消失之前,否则会导致 Crash。
  • KVO 注册方法:
    • 在注册观察者时,可以传入 options 参数参数是一个枚举类型,如果传入 NSKeyValueObservingOptionNew 和 NSKeyValueObservingOptionOld 表示接收新值和旧值,默认为只接收新值;如果想在注册观察者后,立即接收一次回调,则可以加入 NSKeyValueObservingOptionInitial 枚举。
    • 还可以通过方法 context 传入任意类型的对象,在接收消息回调的代码中可以接收到这个对象,是 KVO 中的一种传值方式;
    • 在调用 addObserver 方法后,KVO 并不会对观察者进行强引用,所以需要注意观察者的生命周期,否则会导致观察者被释放带来的 Crash。
  • KVO 监听方法:
    • 观察者需要实现 observeValueForKeyPath:ofObject:change:context: 方法,当 KVO 事件到来时会调用这个方法,如果没有实现会导致 Crash。change 字典中存放 KVO 属性相关的值,根据 options 时传入的枚举来返回,枚举会对应相应 key 来从字典中取出值,例如:有 NSKeyValueChangeOldKey 字段,存储改变之前的旧值。
    • change 中还有 NSKeyValueChangeKindKey 字段,和 NSKeyValueChangeOldKey 是平级的关系,来提供本次更改的信息,对应 NSKeyValueChange 枚举类型的 value。例如:被观察属性发生改变时,字段为 NSKeyValueChangeSetting。
    • 如果被观察对象是集合对象,在 NSKeyValueChangeKindKey 字段中会包含 NSKeyValueChangeInsertion、NSKeyValueChangeRemoval、NSKeyValueChangeReplacement 的信息,表示集合对象的操作方式。
  • KVO 调用方式:
    • 调用 KVO 属性对象时,不仅可以通过点语法和 set 语法进行调用,KVO 兼容很多种调用方式:
	// 直接调用set方法,或者通过属性的点语法间接调用
	[person setName:@"dw"];
	 
	// 使用KVC的setValue:forKey:方法
	[person setValue:@"dw" forKey:@"name"];
	 
	// 使用KVC的setValue:forKeyPath:方法
	[document setValue:@"dw" forKeyPath:@"person.name"];
	
	// 通过mutableArrayValueForKey:方法获取到代理对象,并使用代理对象进行操作
	Transaction *newTransaction = <#Create a new transaction for the account#>;
	NSMutableArray *transactions = [account mutableArrayValueForKey:@"transactions"];
	[transactions addObject:newTransaction];
    • KVO 主要用来做键值观察操作,想要一个值发生改变后通知另一个对象,则用 KVO 实现最为合适。斯坦福大学的 iOS 教程中有一个很经典的案例,通过 KVO 在 Model 和 Controller 之间进行通信。如下图所示:

iOS之深入解析KVO的底层原理

    • KVO 的 addObserver 和 removeObserver 需要是成对的,如果重复 remove 则会导致 NSRangeException 类型的 Crash,如果忘记 remove 则会在观察者释放后再次接收到 KVO 回调时 Crash。
    • 苹果官方推荐的方式是,在 init 的时候进行 addObserver,在 dealloc 时 removeObserver,这样可以保证 add 和 remove 是成对出现的,是一种比较理想的使用方式。
  • 手动调用 KVO:
    • KVO 在属性发生改变时的调用是自动的,如果想要手动控制这个调用时机,或想自己实现 KVO 属性的调用,则可以通过 KVO 提供的方法进行调用。
	- (void)setAge:(double)theAge { 
	    if (theAge != _age) {
	        [self willChangeValueForKey:@"age"];
	        _age = theAge;
	        [self didChangeValueForKey:@"age"];
	    }
	}
    • 可以看到调用 KVO 主要依靠两个方法,在属性发生改变之前调用 willChangeValueForKey:方法,在发生改变之后调用 didChangeValueForKey:方法。
    • 如果想控制当前对象的自动调用过程,也就是由上面两个方法发起的 KVO 调用,则可以重写下面方法,方法返回 YES 则表示可以调用,如果返回 NO 则表示不可以调用。
	+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)theKey {
	    BOOL automatic = NO;
	    if ([theKey isEqualToString:@"age"]) {
	        automatic = NO;
	    }
	    else {
	        automatic = [super automaticallyNotifiesObserversForKey:theKey];
	    }
	    return automatic;
	}

二、KVO 的实现原理分析

① 实现原理
  • KVO 是通过 isa-swizzling 技术实现的。
  • 在运行时根据原类创建一个中间类,这个中间类是原类的子类,并动态修改当前对象的 isa 指向中间类,并且将 class 方法重写,返回原类的Class。
  • 所以苹果建议在开发中不应该依赖 isa 指针,而是通过 class 实例方法来获取对象类型。
② 实现方式
  • 定义以下调试代码:
	@interface YDWObject : NSObject
	@property (nonatomic, copy)   NSString *name;
	@property (nonatomic, assign) NSInteger age;
	@end

	#import "YDWObject.h"
	#import <objc/runtime.h>
	
	@implementation YDWObject
	
	- (NSString *)description {
	    NSLog(@"object address : %p n", self);
	    
	    IMP nameIMP = class_getMethodImplementation(object_getClass(self), @selector(setName:));
	    IMP ageIMP = class_getMethodImplementation(object_getClass(self), @selector(setAge:));
	    NSLog(@"object setName: IMP %p object setAge: IMP %p n", nameIMP, ageIMP);
	    
	    Class objectMethodClass = [self class];
	    Class objectRuntimeClass = object_getClass(self);
	    Class superClass = class_getSuperclass(objectRuntimeClass);
	    NSLog(@"objectMethodClass : %@, ObjectRuntimeClass : %@, superClass : %@ n", objectMethodClass, objectRuntimeClass, superClass);
	    
	    NSLog(@"object method list n");
	    unsigned int count;
	    Method *methodList = class_copyMethodList(objectRuntimeClass, &count);
	    for (NSInteger i = 0; i < count; i++) {
	        Method method = methodList[i];
	        NSString *methodName = NSStringFromSelector(method_getName(method));
	        NSLog(@"method Name = %@n", methodName);
	    }
	    
	    return @"";
	}
	
	@end
  • 调试调用:
	- (void)viewDidLoad {
	    [super viewDidLoad];
	    
	    self.object = [[YDWObject alloc] init];
	    self.object.name = @"ydw";
	    self.object.age = 10;
	    [self.object description];
	    
	    [self.object addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];
	    [self.object addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];
	    [self.object description];
	
	    self.object.name = @"dw";
	    self.object.age = 20;

		[self.object removeObserver:self forKeyPath:@"name"];
		[self.object removeObserver:self forKeyPath:@"age"];
	}
	
	- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
	    NSLog(@"监听到 %@ 的 %@ 改变 %@", object, keyPath, change);
	}
  • 打印结果如下:
	object address : 0x600003a59860
	object setName: IMP 0x101bea390 object setAge: IMP 0x101bea3f0
	objectMethodClass : YDWObject, ObjectRuntimeClass : YDWObject, superClass : NSObject
	object method list
	method Name = description
	method Name = name
	method Name = .cxx_destruct
	method Name = setName:
	method Name = setAge:
	method Name = age
	object address : 0x600003a59860
	object setName: IMP 0x7fff207bbb57 object setAge: IMP 0x7fff207bc799
	objectMethodClass : YDWObject, ObjectRuntimeClass : NSKVONotifying_YDWObject, superClass : YDWObject
	object method list
	method Name = setAge:
	method Name = setName:
	method Name = class
	method Name = dealloc
	method Name = _isKVOA
	object address : 0x600003a59860
	object setName: IMP 0x7fff207bbb57 object setAge: IMP 0x7fff207bc799
	objectMethodClass : YDWObject, ObjectRuntimeClass : NSKVONotifying_YDWObject, superClass : YDWObject
	object method list
	method Name = setAge:
	method Name = setName:
	method Name = class
	method Name = dealloc
	method Name = _isKVOA
	监听到  的 name 改变 {
    kind = 1;
    new = dw;
    old = ydw;
}
	object address : 0x600003a59860
	object setName: IMP 0x7fff207bbb57 object setAge: IMP 0x7fff207bc799
	objectMethodClass : YDWObject, ObjectRuntimeClass : NSKVONotifying_YDWObject, superClass : YDWObject
object method list
	method Name = setAge:	
	method Name = setName:
	method Name = class
	method Name = dealloc
	method Name = _isKVOA
	监听到  的 age 改变 {
    kind = 1;
    new = 20;
    old = 10;
}
  • 可以发现:一旦 YDWObject 的 name 和age 属性的值发生改变,就会通知到监听者,因此继续分析:
    • 对象被 KVO 后,其真正类型变为 NSKVONotifying_KVOObject 类,已经不是之前的类。
    • KVO 会在运行时动态创建一个新类,将对象的 isa 指向新创建的类,新类是原类的子类,命名规则是 NSKVONotifying_xxx 的格式。
    • KVO 为了使其更像之前的类,还会将对象的 class 实例方法重写,使其更像原类。
  • 在上面结果中还发现有一个 _isKVOA 方法,这个方法可以当做使用了 KVO 的一个标记,如果想判断当前类是否是 KVO 动态生成的类,就可以从方法列表中搜索这个方法。
  • 我们知道赋值操作都是调用 set 方法,可以重写 YDWObject 类中 age 的 set 方法,观察 KVO 是否是在 set 方法内部做了一些操作来通知监听者:
	- (void)setAge:(NSInteger)age {
	    NSLog(@"override setAge");
	    _age = age;
	}
  • 我们发现即使重写了 set 方法,age 除了调用 set 方法之外还会执行监听者的 observeValueForKeyPath 方法。KVO 会重写 keyPath 对应属性的 setter 方法,没有被 KVO 的属性则不会重写其 setter 方法,在重写的 setter 方法中,修改值之前会调用 willChangeValueForKey: 方法,修改值之后会调用 didChangeValueForKey: 方法,这两个方法最终都会被调用到 observeValueForKeyPath:ofObject:change:context: 方法中。
  • 根据上述调试推测:KVO 在运行时对对象进行了改动,使 object 对象在调用 setAge 方法时做了一些额外的操作,因此问题应该出在对象身上,两个对象可能本质上并不一样。
③ 实现分析
  • 如下所示,打上调试断点:

iOS之深入解析KVO的底层原理

  • 调试如下:
	(lldb) p object_getClassName(self.object)
	(const char * _Nonnull) $0 = 0x00000001061e64ab "YDWObject"

	(lldb) p object_getClassName(self.object)
(const char * _Nonnull) $1 = 0x0000600001bcd360 "NSKVONotifying_YDWObject"
  • 我们发现,object 对象的 isa 指针由之前的指向类对象 YDWObject 变成了指向类对象 NSKVONotifying_YDWObject。因此可以推测,object 对象的 isa 发生改变后,其执行的 setAge 也发生了改变。
  • 如果没有对 object 进行 addObserver,object 在调用 setAge 方法时,首先会通过 object 对象的 isa 指针找到 YDWObject 类对象,然后在类对象中找到 setAge 方法,最终找到方法对应的实现。
  • 但 object 对象的 isa 在添加 KVO 之后已经指向了 NSKVONotifying_YDWObject 类对象,NSKVONotifying_YDWObject 则是 object 的子类。NSKVONotifying_YDWObject 是 runtime 在运行时生成的,因此,object 对象在调用 setAge 方法时必然会根据 object 的 isa 找到 NSKVONotifying_YDWObject,并在 NSKVONotifying_YDWObject 中找到 setAge 方法及其实现。
  • 我们再通过 lldb 指令,去调试中间的变化过程,使用 watchpoint set variable object->_age 指令(watchpoint: 观察变量或者属性,非常有用,如果遇到某一个变量,不知道什么时候值被修改,就可以使用这个东西去定位),如下:(图LLDB)
  • NSKVONotifying_YDWObjct 中的 setAge 方法中其实调用了 Foundation 框架中 C 语言函数 _NSSetLongLongValueAndNotify,_NSSetLongLongValueAndNotify 内部的操作大致是:首先调用 willChangeValueForKey 方法,然后调用父类的 setAge 方法对成员变量赋值,最后调用 didChangeValueForKey 方法,didChangeValueForKey 方法中会调用监听者的监听方法,最终调用监听者的 observeValueForKeyPath 方法。
④ 原理验证
  • 我们已经通过断点打印类名的方式验证:object 对象在添加 KVO 后,其 isa 指针会指向一个通过 runtime 创建的 YDWObject 的子类 NSKVONotifying_YDWObjct。
  • 下面可以通过打印方法实现的地址来看一下 object 的 setAge 方法实现的地址在添加 KVO 前后有什么变化。
	NSLog(@"KVO之前:%p", [self.object methodForSelector:@selector(setAge:)]);
	
	self.object addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];
	
	NSLog(@"KVO之后:%p", [self.object methodForSelector:@selector(setAge:)]);


	// 打印如下
	KVO之前:0x107208300
	KVO之后:0x7fff207bc799
  • 可以发现:在添加 KVO 之前,object 的 setAge 方法实现的地址,在添加 KVO 之后发生了改变,通过打印方法实现可以证明,object 的 setAge 方法的实现由 YDWObject 类方法中的 setAge 方法转换成了 Foundation 框架中的 C 函数 _NSSetLongLongValueAndNotify。
⑤ 中间类内部结构
  • NSKVONotifying_YDWObjct 作为 YDWObjct 的子类,其 superclass 指针指向 YDWObjct 类,其内部对 setAge 方法做了单独的实现,那么 NSKVONotifying_YDWObjct 同 YDWObjct 类的差别可能就在于其内存储的对象方法及实现不同。
  • 我们可以通过 runtime 分别打印 YDWObjct 类对象和 NSKVONotifying_YDWObjct 类对象内存储的对象方法:
	[self printMethods:object_getClass(self.object)];
	
	- (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:@"n"];
	        [methodNames appendString:methodName];
	    }
	    NSLog(@"methodNames = %@", methodNames);
	    free(methods);
	}
  • 打印结果如下:
	methodNames == YDWObject - 
	description
	name
	.cxx_destruct
	setName:
	setAge:
	age

	methodNames == NSKVONotifying_YDWObject - 
	setAge:
	setName:
	class
	dealloc
	_isKVOA
  • 可以发现,NSKVONotifying_YDWObjct 中有 5 个对象方法,分别是:
	setAge:
	setName:
	class
	dealloc
	_isKVOA
  • NSKVONotifying_YDWObjct 重写 class 方法是为了隐藏 NSKVONotifying_YDWObjct 不被外界看到,我们在 self.object 添加 KVO 前后,分别打印 self.object 对象的 class,可以发现它们都返回 YDWObjct。
  • 验证 didChangeValueForKey: 内部调用 observeValueForKeyPath:ofObject:change:context: 方法,在 YDWObjct 类中重写 willChangeValueForKey: 和 didChangeValueForKey: 方法,模拟它们的实现:
	- (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: 方法内部调用了监听者的 observeValueForKeyPath:ofObject:change:context: 方法:
	willChangeValueForKey: - begin
	willChangeValueForKey: - end
	didChangeValueForKey: - begin
	监听到 <YDWObject: 0x6000010ed360> 的 name 改变 {
	    kind = 1;
	    new = dw;
	    old = ydw;
	}
	didChangeValueForKey: - end
	willChangeValueForKey: - begin
	willChangeValueForKey: - end
	override setAge
	didChangeValueForKey: - begin
	监听到 <YDWObject: 0x6000010ed360> 的 age 改变 {
	    kind = 1;
	    new = 20;
	    old = 10;
	}
	didChangeValueForKey: - end
  • 根据上述原理,可以通过调用 willChangeValueForKey: 和 didChangeValueForKey: 来手动触发 KVO。

三、KVO 性能分析

  • 根据上面 KVC 的实现原理,可以看出 KVC 的性能并不如直接访问属性快,虽然这个性能消耗是微乎其微的。因此在使用 KVC 的时候,建议最好不要手动设置属性的 setter、getter,否则会导致搜索步骤变长。
  • 尽量不要用 KVC 进行集合操作,例如 NSArray、NSSet 之类的,集合操作的性能消耗更大,而且还会创建不必要的对象。

四、KVO 使用示例

① 私有访问
  • KVC 本质上是操作方法列表以及在内存中查找实例变量,我们可以利用这个特性访问类的私有变量。例如,在 .m 中定义的私有成员变量和属性,都可以通过 KVC 的方式访问:
	TestObject.m
	
	@interface TestObject () {
	    NSObject *_objectOne;
	}
	@property (nonatomic, strong) NSObject *objectTwo;
	@end
  • 这个操作对 readonly 的属性,@protected 的成员变量,都可以正常访问,如果不想让外界访问类的成员变量,则可以将 accessInstanceVariablesDirectly 属性赋值为 NO。
  • KVC 在实践中也有很多用处,例如 UITabbar 或 UIPageControl 这样的控件,系统已经为我们封装好了,但是对于一些样式的改变并没有提供足够的 API,这种情况就需要用 KVC 进行操作。
② 安全性检查
  • KVC 存在一个问题,因为传入的 key 或 keyPath 是一个字符串,这样很容易写错或者属性自身修改后字符串忘记修改,这样会导致 Crash。
  • 可以利用 iOS 的反射机制来规避这个问题,通过 @selector() 获取到方法的 SEL,然后通过 NSStringFromSelector() 将 SEL 反射为字符串,这样在 @selector() 中传入方法名的过程中,编译器会有合法性检查,如果方法不存在或未实现会报黄色警告:
	[self valueForKey:NSStringFromSelector(@selector(object))];


程序员灯塔
转载请注明原文链接:iOS之深入解析KVO的底层原理
喜欢 (0)