這篇不打算再重複 KVO 的 API 怎麼寫,而是把焦點放在「它究竟如何做到」。閱讀過程中會不斷回到那些平時順手略過、卻其實很值得追問的細節。
我們每天寫 @property,也每天替 addObserver:forKeyPath: 傳入字串。那個 keyPath 對應的,是屬性名稱、實例變數,還是存取方法?
先看一個把 ivar 改名、getter 也重寫的例子:
#import "Person.h"
@interface Student : Person
@property (nonatomic, strong) NSString *mark;
@end
@implementation Student
@synthesize mark = abc;
- (void)setMark:(NSString *)newMark {
abc = newMark;
}
- (NSString *)mark {
return abc;
}
@end
int main() {
Student *stu = [Student new];
stu.mark = @"65";
StudentKvoObserver *observer =
[[StudentKvoObserver alloc] initWithStudent:stu];
[observer addObserverForKeyPath:@"mark"];
stu.mark = @"85";
}結果出乎意料:keyPath 傳 "mark" 時通知照樣收得到;一旦改成真正的實例變數 abc,反而完全靜默。
其實答案早就藏在日常寫法裡——不顯式指定時,編譯器等價於幫你補上 @synthesize mark = _mark;。也就是說,keyPath 指向的從來不是那塊真正存放資料的記憶體。
父類的屬性,甚至沒有在頭檔公開的屬性,子類能不能監聽?若剛好猜中 keyPath,能不能順手用 KVC 改它的值?把三種情況拆開看:繼承而來的公開屬性、繼承而來的內部屬性、以及子類重寫過 setter 的繼承屬性。
// Person
@interface Person : NSObject
@property (nonatomic, strong) NSString *firstName;
@property (nonatomic, strong) NSString *lastName;
@property (nonatomic, strong, readonly) NSString *fullName;
- (void)setNewInnerName:(NSString *)str;
@end
@interface Person ()
@property (nonatomic, strong) NSString *innerName; // 未對外暴露
@end
@implementation Person
- (void)setNewInnerName:(NSString *)str {
self.innerName = str; // 走 setter,觸發 KVO
// [self setValue:str forKey:@"innerName"]; // KVC 本質也是呼叫 setter
// _innerName = str; // 直接改 ivar,不觸發 KVO
}
@end
// Student 繼承 Person,並重寫 setter
@implementation Student
- (void)setFirstName:(NSString *)firstName {
NSLog(@"子類重寫的 setFirstName 被呼叫");
}
@end歸納出三點結論:
於是疑問來了:如果 KVO 靠的是「動態生類別 + 重寫 setter」,那子類自己已經重寫過了,為何監聽依然成立?
NSNotification 跨執行緒發送時,接收端常常收不到。KVO 在 GCD 環境下的表現又是如何?
dispatch_queue_t concurrentQueue =
dispatch_queue_create("my.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
__block Student *stu1 = nil;
dispatch_async(concurrentQueue, ^{
stu1 = [[Student alloc] init];
stu1.lastName = @"yyyyyyy";
});
__block StudentKvoObserver *observer1;
dispatch_async(concurrentQueue, ^{
sleep(2);
observer1 = [[StudentKvoObserver alloc] initWithStudent:stu1];
[observer1 addObserverForKeyPath:@"fullName"];
});
dispatch_barrier_async(concurrentQueue, ^{
stu1.lastName = @"zzzzzz";
});輸出顯示,fullName 的新舊值都被正確捕獲。結論很明確:觀察者與被觀察對象分別建立在不同執行緒,通知依然會送達。
順帶記一個 GCD 的坑:在自行建立的 concurrent queue 上,dispatch_barrier_async 能正常發揮屏障作用,保證第三個任務在兩個前驅之後執行;但把 barrier 套用到系統全域的 concurrent queue 上,它就失效了,順序不再有保證。
Foundation 中與 KVO 相關的宣告集中在 NSKeyValueObserving.h,主要透過 NSObject 的三個 category 提供:
以下以 - addObserver:forKeyPath:options:context: 為分析起點。
當某個物件第一次被 addObserver 時,Runtime 會為它的類動態產生一個帶 KVO 前綴的子類,在該子類中重寫相關 setter,同時把 -class 與 -superclass 改寫成回傳原始類,最後以 object_setClass 把實例的 isa 指向新子類。
具體來說:person 呼叫 addObserver 後,系統生出 KVOPerson;KVOPerson 重寫了所有需要監聽的 setter,並讓 [person class] 依然回傳 Person;接著 person 的 class 被替換成 KVOPerson。此後呼叫 [person setName:] 走的是 KVOPerson 的實作,而 setter 內部會在真正改值的前後分別呼叫 willChangeValueForKey: 與 didChangeValueForKey:,通知觀察者。
以下節錄自 GNUstep 的 Foundation,思路與 Apple 的實作相近,只是 API 版本較舊。
@implementation NSObject (NSKeyValueObserverRegistration)
- (void)addObserver:(NSObject *)anObserver
forKeyPath:(NSString *)aPath
options:(NSKeyValueObservingOptions)options
context:(void *)aContext {
// 1. 以當前類取得對應的 GSKVOReplacement
r = replacementForClass([self class]);
info = [self observationInfo];
if (info == nil) {
info = [[GSKVOInfo alloc] initWithInstance:self];
[self setObservationInfo:info];
// 2. 置換 isa
object_setClass(self, [r replacement]);
}
// 3. 重寫該 keyPath 對應的 setter
[r overrideSetterFor:aPath];
// 4. 把觀察關係登錄到全域表
[info addObserver:anObserver
forKeyPath:aPath
options:options
context:aContext];
}
@end忽略分支之後,主線就是這四步。
static GSKVOReplacement *replacementForClass(Class c) {
GSKVOReplacement *r;
setup();
[kvoLock lock];
r = NSMapGet(classTable, (void *)c);
if (r == nil) {
r = [[GSKVOReplacement alloc] initWithClass:c];
NSMapInsert(classTable, (void *)c, (void *)r);
}
[kvoLock unlock];
return r;
}
- (id)initWithClass:(Class)aClass {
original = aClass;
superName = NSStringFromClass(original);
name = [@"GSKVO" stringByAppendingString:superName];
// 動態配置並註冊 GSKVO 子類
template = GSObjCMakeClass(name, superName, nil);
GSObjCAddClasses([NSArray arrayWithObject:template]);
replacement = NSClassFromString(name);
// 掛上模板行為:改寫 class / superclass,
// 並在 setter 前後插入 willChange / didChange
GSObjCAddClassBehavior(replacement, baseClass);
keys = [NSMutableSet new];
return self;
}這裡用一張 classTable 搭配 kvoLock 做快取,保證同一個類只會產生一個 KVO 子類;命名規則就是在原名前面加上 GSKVO 前綴。
- (void)overrideSetterFor:(NSString *)aKey {
if ([keys member:aKey] == nil) {
// 以 keyPath 拼出 setXxx: 與 _setXxx: 兩個候選 selector
a[0] = [NSString stringWithFormat:@"set%@%@:", tmp, suffix];
a[1] = [NSString stringWithFormat:@"_set%@%@:", tmp, suffix];
for (i = 0; i != 2; i++) {
sel = NSSelectorFromString(a[i]);
sig = [original instanceMethodSignatureForSelector:sel];
type = [sig getArgumentTypeAtIndex:2]; // 傳入參數型別
switch (*type) {
case _C_CHR:
case _C_UCHR:
imp = [[GSKVOSetter class]
instanceMethodForSelector:@selector(setterChar:)];
break;
case _C_ID:
case _C_CLASS:
case _C_PTR:
imp = [[GSKVOSetter class]
instanceMethodForSelector:@selector(setter:)];
break;
default:
imp = 0;
break;
}
if (imp != 0) {
// 把「原 selector + 新 IMP」掛進子類
if (class_addMethod(replacement, sel, imp, [sig methodType])) {
found = YES;
}
}
}
if (found) {
[keys addObject:aKey];
}
}
}這一步的精神是:用 keyPath 拼出 setter 的 selector,取出方法簽名,依參數型別挑一個對應的通用 setter 實作,再掛進子類。如此一來,新子類對外表現與父類無異,加上前面的 class 置換,外部完全看不出差別。這也正好解釋了開頭的疑惑:keyPath 對應的其實是 setter 的方法名後綴,因為 @property 產生的預設 setter 恰好符合命名規範,我們才習慣把 keyPath 與 property 視為一體。
@implementation GSKVOSetter
- (void)setter:(void *)val {
NSString *key;
Class c = [self class];
void (*imp)(id, SEL, void *);
imp = (void (*)(id, SEL, void *))[c instanceMethodForSelector:_cmd];
key = newKey(_cmd);
if ([c automaticallyNotifiesObserversForKey:key] == YES) {
[self willChangeValueForKey:key];
(*imp)(self, _cmd, val);
[self didChangeValueForKey:key];
} else {
(*imp)(self, _cmd, val);
}
RELEASE(key);
}
@end這段程式碼被引用得很廣,但要完全讀通並不容易,特別是 IMP 的取得方式與原始 setter 之間的連結,建議對照不同版本的實作多看幾遍再下判斷。
所有 KVO 關係都由全域 infoTable 管理:以被觀察實例為 key、GSKVOInfo 為 value;每個 GSKVOInfo 內部再維護多組 keyPath,每個 keyPath 對應一組觀察者,並把實例與 options 一起打包成 GSKVOObservation。順帶一提,Notification 的實作也是類似套路,同樣靠全域表維護通知名與觀察者。

keyPath 是什麼?它是 setter 方法的關聯鍵。Runtime 拿它去拼 selector、找方法簽名,與真正存放資料的 ivar 或 property 名稱沒有必然關係。這就是為什麼一旦你把 setter 改名,KVO 與 KVC 都會失效,只能手動補上 willChangeValueForKey:。
繼承而來的公開屬性?繼承鏈 Father ← Son ← KVOSon 使得 Son 的實例在訊息查找時能一路找到父類的 setter,再把該 IMP 掛進 KVOSon。
繼承而來的內部屬性?overrideSetterFor 只認 selector 與方法簽名,跟有沒有在頭檔公開無關。
子類重寫了 setter?關鍵在於 KVO 監聽父類屬性並不依賴繼承,而是依賴 runtime 能找到該方法。子類重寫等同於在子類自己定義了一份,查找時第一步就命中,甚至不必往上走。想通這一點,就不必再糾結 setter 有沒有被重寫。
最後是執行緒安全。上面貼出的源碼為了聚焦主線,刪掉了大量加鎖細節;有興趣的人建議直接讀完整版本,其中遞迴鎖與惰性遞迴鎖的運用相當值得參考。