本文是 『Crash 防護系統』系列 第二篇。通過本文，您將瞭解到：
- KVO Crash 的主要原因
- KVO 防止 Crash 的常見方案
- 我的 KVO 防護實現
- 測試 KVO 防護效果
文中示例代碼在： bujige / YSC-Avoid-Crash
1. KVO Crash 的常見原因
KVO（Key Value Observing） 翻譯過來就是鍵值對觀察，是 iOS 觀察者模式的一種實現。KVO 允許一個對象監聽另一個對象特定屬性的改變，並在改變時接收到事件。但是 KVO API 的設計，我個人覺得不是很合理。被觀察者需要做的工作太多，日常使用時稍不注意就會導致崩潰。
KVO 日常使用造成崩潰的原因通常有以下幾個：
- KVO 添加次數和移除次數不匹配：
- 移除了未註冊的觀察者，導致崩潰。
- 重複移除多次，移除次數多於添加次數，導致崩潰。
- 重複添加多次，雖然不會崩潰，但是發生改變時，也同時會被觀察多次。
- 被觀察者提前被釋放，被觀察者在 dealloc 時仍然註冊着 KVO，導致崩潰。
例如：被觀察者是局部變量的情況（iOS 10 及之前會崩潰）。- 添加了觀察者，但未實現
observeValueForKeyPath:ofObject:change:context:方法，導致崩潰。- 添加或者移除時
keypath == nil，導致崩潰。
2. KVO 防止 Crash 常見方案
爲了避免上面提到的使用 KVO 造成崩潰的問題，於是出現了很多關於 KVO 的第三方庫，比如最出名的就是 FaceBook 開源的第三方庫 facebook / KVOController。
FBKVOController 對 KVO 機制進行了額外的一層封裝，框架不但可以自動幫我們移除觀察者，還提供了 block 或者 selector 的方式供我們進行觀察處理。不可否認的是，FBKVOController 爲我們的開發提供了很大的便利性。但是相對而言，這種方式對項目代碼的侵入性比較大，必須依靠編碼規範來強制約束團隊人員使用這種方式。
那麼有沒有一種對項目代碼侵入性小，同時還能有效防護 KVO 崩潰的防護機制呢？
網上有很多類似的方案可以參考一下。
- 首先爲 NSObject 建立一個分類，利用 Method Swizzling，實現自定義的
BMP_addObserver:forKeyPath:options:context:、BMP_removeObserver:forKeyPath:、BMP_removeObserver:forKeyPath:context:、BMPKVO_dealloc方法，用來替換系統原生的添加移除觀察者方法的實現。 - 然後在觀察者和被觀察者之間建立一個
KVODelegate 對象，兩者之間通過KVODelegate 對象建立聯繫。然後在添加和移除操作時，將 KVO 的相關信息例如observer、keyPath、options、context保存爲KVOInfo 對象，並添加到KVODelegate 對象中對應 的關係哈希表中，對應原有的添加觀察者。
關係哈希表的數據結構：{keypath : [KVOInfo 對象1, KVOInfo 對象2, ... ]} - 在添加和移除操作的時候，利用
KVODelegate 對象做轉發，把真正的觀察者變爲KVODelegate 對象，而當被觀察者的特定屬性發生了改變，再由KVODelegate 對象分發到原有的觀察者上。
那麼，BayMax 系統是如何避免 KVO 崩潰的呢?
- 添加觀察者時：通過關係哈希表判斷是否重複添加，只添加一次。
- 移除觀察者時：通過關係哈希表是否已經進行過移除操作，避免多次移除。
- 觀察鍵值改變時：同樣通過關係哈希表判斷，將改變操作分發到原有的觀察者上。
另外，爲了避免被觀察者提前被釋放，被觀察者在 dealloc 時仍然註冊着 KVO 導致崩潰。BayMax 系統還利用 Method Swizzling 實現了自定義的 dealloc，在系統 dealloc 調用之前，將多餘的觀察者移除掉。
方案二： ValiantCat / XXShield（第三方框架）
XXShield 實現方案和 BayMax 系統類似。也是利用一個 Proxy 對象用來做轉發， 真正的觀察者是 Proxy，被觀察者出現了通知信息，由 Proxy 做分發。不過不同點是 Proxy 裏面保存的內容沒有前者多。只保存了 _observed（被觀察者） 和關係哈希表，這個關係哈希表中只維護了 keyPath 和 observer 的關係。
關係哈希表的數據結構：{keypath : [observer1, observer2 , ...](NSHashTable)} 。
XXShield 在 dealloc 中也做了類似將多餘觀察者移除掉的操作，是通過關係數據結構和 _observed ，然後調用原生移除觀察者操作實現的。
方案三： JackLee18 / JKCrashProtect（第三方框架）
JKCrashProtect 相對於前兩個方案來講，看上去更加的簡潔明瞭。他的不同點在於沒有使用 delegate。而是直接在分類中建立了一個關係哈希表，用來保存 {keypath : [observer1, observer2 , ...](NSHashTable)} 的關係。
添加的時候，如果關係哈希表中與 keyPath 對應的已經有了相關的觀察者，就不再進行添加。同樣移除觀察者的時候，也在哈希表中進行查找，如果存在 observer、keyPath 的信息，就移除掉，否則就不進行移除操作。
不過，這個框架並沒有對被觀察者在 dealloc 時仍然註冊着 KVO ，造成崩潰的情況進行處理。
3. 我的 KVO 防護實現
參考了這幾個方法的實現後，分別實現了一下之後，最終還是選擇了 方案一、方案二 這兩種方案的實現思路。
- 我使用了
YSCKVOProxy 對象，在YSCKVOProxy 對象中使用{keypath : [observer1, observer2 , ...](NSHashTable)}結構的關係哈希表進行observer、keyPath之間的維護。 - 然後利用
YSCKVOProxy 對象對添加、移除、觀察方法進行分發處理。 - 在分類中自定義了
dealloc的實現，移除了多餘的觀察者。
- 代碼如下所示：
#import "NSObject+KVODefender.h"
#import "NSObject+MethodSwizzling.h"
#import <objc/runtime.h>
// 判斷是否是系統類
static inline BOOL IsSystemClass(Class cls){
BOOL isSystem = NO;
NSString *className = NSStringFromClass(cls);
if ([className hasPrefix:@"NS"] || [className hasPrefix:@"__NS"] || [className hasPrefix:@"OS_xpc"]) {
isSystem = YES;
return isSystem;
}
NSBundle *mainBundle = [NSBundle bundleForClass:cls];
if (mainBundle == [NSBundle mainBundle]) {
isSystem = NO;
}else{
isSystem = YES;
}
return isSystem;
}
#pragma mark - YSCKVOProxy 相關
@interface YSCKVOProxy : NSObject
// 獲取所有被觀察的 keyPaths
- (NSArray *)getAllKeyPaths;
@end
@implementation YSCKVOProxy
{
// 關係數據表結構：{keypath : [observer1, observer2 , ...](NSHashTable)}
@private
NSMutableDictionary<NSString *, NSHashTable<NSObject *> *> *_kvoInfoMap;
}
- (instancetype)init {
self = [super init];
if (self) {
_kvoInfoMap = [NSMutableDictionary dictionary];
}
return self;
}
// 添加 KVO 信息操作, 添加成功返回 YES
- (BOOL)addInfoToMapWithObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
options:(NSKeyValueObservingOptions)options
context:(void *)context {
@synchronized (self) {
if (!observer || !keyPath ||
([keyPath isKindOfClass:[NSString class]] && keyPath.length <= 0)) {
return NO;
}
NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];
if (info.count == 0) {
info = [[NSHashTable alloc] initWithOptions:(NSPointerFunctionsWeakMemory) capacity:0];
[info addObject:observer];
_kvoInfoMap[keyPath] = info;
return YES;
}
if (![info containsObject:observer]) {
[info addObject:observer];
}
return NO;
}
}
// 移除 KVO 信息操作, 添加成功返回 YES
- (BOOL)removeInfoInMapWithObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath {
@synchronized (self) {
if (!observer || !keyPath ||
([keyPath isKindOfClass:[NSString class]] && keyPath.length <= 0)) {
return NO;
}
NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];
if (info.count == 0) {
return NO;
}
[info removeObject:observer];
if (info.count == 0) {
[_kvoInfoMap removeObjectForKey:keyPath];
return YES;
}
return NO;
}
}
// 添加 KVO 信息操作, 添加成功返回 YES
- (BOOL)removeInfoInMapWithObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
context:(void *)context {
@synchronized (self) {
if (!observer || !keyPath ||
([keyPath isKindOfClass:[NSString class]] && keyPath.length <= 0)) {
return NO;
}
NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];
if (info.count == 0) {
return NO;
}
[info removeObject:observer];
if (info.count == 0) {
[_kvoInfoMap removeObjectForKey:keyPath];
return YES;
}
return NO;
}
}
// 實際觀察者 yscKVOProxy 進行監聽，並分發
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary<NSKeyValueChangeKey,id> *)change
context:(void *)context {
NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];
for (NSObject *observer in info) {
@try {
[observer observeValueForKeyPath:keyPath ofObject:object change:change context:context];
} @catch (NSException *exception) {
NSString *reason = [NSString stringWithFormat:@"KVO Warning : %@",[exception description]];
NSLog(@"%@",reason);
}
}
}
// 獲取所有被觀察的 keyPaths
- (NSArray *)getAllKeyPaths {
NSArray <NSString *>*keyPaths = _kvoInfoMap.allKeys;
return keyPaths;
}
@end
#pragma mark - NSObject+KVODefender 分類
@implementation NSObject (KVODefender)
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 攔截 `addObserver:forKeyPath:options:context:` 方法，替換自定義實現
[NSObject yscDefenderSwizzlingInstanceMethod: @selector(addObserver:forKeyPath:options:context:)
withMethod: @selector(ysc_addObserver:forKeyPath:options:context:)
withClass: [NSObject class]];
// 攔截 `removeObserver:forKeyPath:` 方法，替換自定義實現
[NSObject yscDefenderSwizzlingInstanceMethod: @selector(removeObserver:forKeyPath:)
withMethod: @selector(ysc_removeObserver:forKeyPath:)
withClass: [NSObject class]];
// 攔截 `removeObserver:forKeyPath:context:` 方法，替換自定義實現
[NSObject yscDefenderSwizzlingInstanceMethod: @selector(removeObserver:forKeyPath:context:)
withMethod: @selector(ysc_removeObserver:forKeyPath:context:)
withClass: [NSObject class]];
// 攔截 `dealloc` 方法，替換自定義實現
[NSObject yscDefenderSwizzlingInstanceMethod: NSSelectorFromString(@"dealloc")
withMethod: @selector(ysc_kvodealloc)
withClass: [NSObject class]];
});
}
static void *YSCKVOProxyKey = &YSCKVOProxyKey;
static NSString *const KVODefenderValue = @"YSC_KVODefender";
static void *KVODefenderKey = &KVODefenderKey;
// YSCKVOProxy setter 方法
- (void)setYscKVOProxy:(YSCKVOProxy *)yscKVOProxy {
objc_setAssociatedObject(self, YSCKVOProxyKey, yscKVOProxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
// YSCKVOProxy getter 方法
- (YSCKVOProxy *)yscKVOProxy {
id yscKVOProxy = objc_getAssociatedObject(self, YSCKVOProxyKey);
if (yscKVOProxy == nil) {
yscKVOProxy = [[YSCKVOProxy alloc] init];
self.yscKVOProxy = yscKVOProxy;
}
return yscKVOProxy;
}
// 自定義 addObserver:forKeyPath:options:context: 實現方法
- (void)ysc_addObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
options:(NSKeyValueObservingOptions)options
context:(void *)context {
if (!IsSystemClass(self.class)) {
objc_setAssociatedObject(self, KVODefenderKey, KVODefenderValue, OBJC_ASSOCIATION_RETAIN);
if ([self.yscKVOProxy addInfoToMapWithObserver:observer forKeyPath:keyPath options:options context:context]) {
// 如果添加 KVO 信息操作成功，則調用系統添加方法
[self ysc_addObserver:self.yscKVOProxy forKeyPath:keyPath options:options context:context];
} else {
// 添加 KVO 信息操作失敗：重複添加
NSString *className = (NSStringFromClass(self.class) == nil) ? @"" : NSStringFromClass(self.class);
NSString *reason = [NSString stringWithFormat:@"KVO Warning : Repeated additions to the observer:%@ for the key path:'%@' from %@",
observer, keyPath, className];
NSLog(@"%@",reason);
}
} else {
[self ysc_addObserver:observer forKeyPath:keyPath options:options context:context];
}
}
// 自定義 removeObserver:forKeyPath:context: 實現方法
- (void)ysc_removeObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
context:(void *)context {
if (!IsSystemClass(self.class)) {
if ([self.yscKVOProxy removeInfoInMapWithObserver:observer forKeyPath:keyPath context:context]) {
// 如果移除 KVO 信息操作成功，則調用系統移除方法
[self ysc_removeObserver:self.yscKVOProxy forKeyPath:keyPath context:context];
} else {
// 移除 KVO 信息操作失敗：移除了未註冊的觀察者
NSString *className = NSStringFromClass(self.class) == nil ? @"" : NSStringFromClass(self.class);
NSString *reason = [NSString stringWithFormat:@"KVO Warning : Cannot remove an observer %@ for the key path '%@' from %@ , because it is not registered as an observer", observer, keyPath, className];
NSLog(@"%@",reason);
}
} else {
[self ysc_removeObserver:observer forKeyPath:keyPath context:context];
}
}
// 自定義 removeObserver:forKeyPath: 實現方法
- (void)ysc_removeObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath {
if (!IsSystemClass(self.class)) {
if ([self.yscKVOProxy removeInfoInMapWithObserver:observer forKeyPath:keyPath]) {
// 如果移除 KVO 信息操作成功，則調用系統移除方法
[self ysc_removeObserver:self.yscKVOProxy forKeyPath:keyPath];
} else {
// 移除 KVO 信息操作失敗：移除了未註冊的觀察者
NSString *className = NSStringFromClass(self.class) == nil ? @"" : NSStringFromClass(self.class);
NSString *reason = [NSString stringWithFormat:@"KVO Warning : Cannot remove an observer %@ for the key path '%@' from %@ , because it is not registered as an observer", observer, keyPath, className];
NSLog(@"%@",reason);
}
} else {
[self ysc_removeObserver:observer forKeyPath:keyPath];
}
}
// 自定義 dealloc 實現方法
- (void)ysc_kvodealloc {
@autoreleasepool {
if (!IsSystemClass(self.class)) {
NSString *value = (NSString *)objc_getAssociatedObject(self, KVODefenderKey);
if ([value isEqualToString:KVODefenderValue]) {
NSArray *keyPaths = [self.yscKVOProxy getAllKeyPaths];
// 被觀察者在 dealloc 時仍然註冊着 KVO
if (keyPaths.count > 0) {
NSString *reason = [NSString stringWithFormat:@"KVO Warning : An instance %@ was deallocated while key value observers were still registered with it. The Keypaths is:'%@'", self, [keyPaths componentsJoinedByString:@","]];
NSLog(@"%@",reason);
}
// 移除多餘的觀察者
for (NSString *keyPath in keyPaths) {
[self ysc_removeObserver:self.yscKVOProxy forKeyPath:keyPath];
}
}
}
}
[self ysc_kvodealloc];
}
@end
4. 測試 KVO 防護效果
這裏提供一下相關崩潰的測試代碼：
/********************* KVOCrashObject.h 文件 *********************/
#import <Foundation/Foundation.h>
@interface KVOCrashObject : NSObject
@property (nonatomic, copy) NSString *name;
@end
/********************* KVOCrashObject.m 文件 *********************/
#import "KVOCrashObject.h"
@implementation KVOCrashObject
@end
/********************* ViewController.m 文件 *********************/
#import "ViewController.h"
#import "KVOCrashObject.h"
@interface ViewController ()
@property (nonatomic, strong) KVOCrashObject *objc;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
self.objc = [[KVOCrashObject alloc] init];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
// 1.1 移除了未註冊的觀察者，導致崩潰
[self testKVOCrash11];
// 1.2 重複移除多次，移除次數多於添加次數，導致崩潰
// [self testKVOCrash12];
// 1.3 重複添加多次，雖然不會崩潰，但是發生改變時，也同時會被觀察多次。
// [self testKVOCrash13];
// 2. 被觀察者 dealloc 時仍然註冊着 KVO，導致崩潰
// [self testKVOCrash2];
// 3. 觀察者沒有實現 -observeValueForKeyPath:ofObject:change:context:導致崩潰
// [self testKVOCrash3];
// 4. 添加或者移除時 keypath == nil，導致崩潰。
// [self testKVOCrash4];
}
/**
1.1 移除了未註冊的觀察者，導致崩潰
*/
- (void)testKVOCrash11 {
// 崩潰日誌：Cannot remove an observer XXX for the key path "xxx" from XXX because it is not registered as an observer.
[self.objc removeObserver:self forKeyPath:@"name"];
}
/**
1.2 重複移除多次，移除次數多於添加次數，導致崩潰
*/
- (void)testKVOCrash12 {
// 崩潰日誌：Cannot remove an observer XXX for the key path "xxx" from XXX because it is not registered as an observer.
[self.objc addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
self.objc.name = @"0";
[self.objc removeObserver:self forKeyPath:@"name"];
[self.objc removeObserver:self forKeyPath:@"name"];
}
/**
1.3 重複添加多次，雖然不會崩潰，但是發生改變時，也同時會被觀察多次。
*/
- (void)testKVOCrash13 {
[self.objc addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
[self.objc addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
self.objc.name = @"0";
}
/**
2. 被觀察者 dealloc 時仍然註冊着 KVO，導致崩潰
*/
- (void)testKVOCrash2 {
// 崩潰日誌：An instance xxx of class xxx was deallocated while key value observers were still registered with it.
// iOS 10 及以下會導致崩潰，iOS 11 之後就不會崩潰了
KVOCrashObject *obj = [[KVOCrashObject alloc] init];
[obj addObserver: self
forKeyPath: @"name"
options: NSKeyValueObservingOptionNew
context: nil];
}
/**
3. 觀察者沒有實現 -observeValueForKeyPath:ofObject:change:context:導致崩潰
*/
- (void)testKVOCrash3 {
// 崩潰日誌：An -observeValueForKeyPath:ofObject:change:context: message was received but not handled.
KVOCrashObject *obj = [[KVOCrashObject alloc] init];
[self addObserver: obj
forKeyPath: @"title"
options: NSKeyValueObservingOptionNew
context: nil];
self.title = @"111";
}
/**
4. 添加或者移除時 keypath == nil，導致崩潰。
*/
- (void)testKVOCrash4 {
// 崩潰日誌： -[__NSCFConstantString characterAtIndex:]: Range or index out of bounds
KVOCrashObject *obj = [[KVOCrashObject alloc] init];
[self addObserver: obj
forKeyPath: @""
options: NSKeyValueObservingOptionNew
context: nil];
// [self removeObserver:obj forKeyPath:@""];
}
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary*)change context:(void *)context {
NSLog(@"object = %@, keyPath = %@", object, keyPath);
}
@end
可以將示例項目 NSObject+KVODefender.m 中的 + (void)load; 方法註釋掉或打開進行防護前後的測試。
經測試可以發現，成功的攔截了這幾種因爲 KVO 使用不當導致的崩潰。