iOS之深入決議KVO的底層原理-有解無憂

一、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 之間進行通信，如下圖所示：

在這里插入圖片描述

- 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 方法時做了一些額外的操作，因此問題應該出在物件身上，兩個物件可能本質上并不一樣，

③ 實作分析

如下所示，打上除錯斷點：

在這里插入圖片描述

除錯如下：

	(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))];

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/286357.html

標籤：其他

上一篇：android 仿微信小demo（實作移動端，服務端）

下一篇：鴻蒙App開發（2）---Button組件