自實現 KVO

基本概念

KVO (Key-Value Observing) 是Cocoa提供的一種基于KVC的機制，允許一個對象去監聽另一個對象的某個屬性，當該屬性改變時系統會去通知監聽的對象。

添加方法：

- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)opions context:(nullable void *)context;

接收方法：

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

移除方法：

- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(nullable void *)context
或者
- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;

本文相關 Demo

自動 KVO

調用上面三個方法實現即自動 KVO，不細說。

手動 KVO

以 Demo 中的 Boy 類為例，Boy 有 name 和 age 兩個屬性，要實現手動發送 KVO 得先禁用 KVO 的自動發送機制，再在需要發送的地方手動發送。

1.在 Boy 類中重寫以下方法：

/**
 *  重寫此方法，設置對該 key 不自動發送通知
 */
+ (BOOL) automaticallyNotifiesObserversForKey:(NSString *)key {
    if ([key isEqualToString:@"name"]) {
        return NO;
    }else if ([key isEqualToString:@"age"]) {
        return NO;
    }
    return [super automaticallyNotifiesObserversForKey:key];
}

2.手動發送 KVO

/**
 *  手動發送通知
 */
- (void)setName:(NSString *)name {
    if (_name != name) {
        [self willChangeValueForKey:@"name"];
        _name = name;
        [self didChangeValueForKey:@"name"];
    }
}
- (void)setAge:(int)age {
    if (_age != age) {
        [self willChangeValueForKey:@"age"];
        _age = age;
        [self didChangeValueForKey:@"age"];
    }
}

KVO 注冊依賴鍵

有一些屬性的值取決于一個或者多個其他對象的屬性值，一旦某個被依賴的屬性值變了，依賴它的屬性的變化也需要被通知。

To-one 依賴鍵

以 Demo 中的 Person 類為例，其 information 屬性同時依賴 name 和 age 屬性：

/**
 *  依賴鍵 information 依賴 name 和 age
 */
- (NSString *)information {
    return [NSString stringWithFormat:@"%@-%d",_name,_age];
}

這樣的話修改 name 和 age 都會改變 information 的值，此時想實現對 information 的 KVO，需要重新確認依賴關系，這里有兩種方法。

1.實現+ (NSSet *)keyPathsForValuesAffecting<Key>:(NSString *)key

+ (NSSet *)keyPathsForValuesAffectingInformation {
    NSSet * keyPaths = [NSSet setWithObjects:@"age", @"name", nil];
    return keyPaths;
}

2.重寫+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key

+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key {
    NSSet *keyPaths = [super keyPathsForValuesAffectingValueForKey:key];

    if ([key isEqualToString:@"information"]) {
        keyPaths = [keyPaths setByAddingObjectsFromArray:@[@"name", @"age"]];
    }
    return keyPaths;
}

To-many 依賴鍵

以 Demo 中的 Person 類為例，其 totalAges 屬性依賴 girls 這個集合屬性，totalAges的值為girls數組里所有Girl對象的 age 之和。
那么為實現對totalAges的 KVO，需要在 Person 類里監聽 girls 屬性，然后每次更新totalAges的值：

- (instancetype)init {
    self = [super init];
    if (self) {
        [self addObserver:self forKeyPath:@"girls" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:totalAgesContext];
    }
    return self;
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
    if (context == totalAgesContext) {
        NSLog(@"totalAgesContext:%@,%@",change[@"new"],change[@"old"]);
        [self updateTotalAges];
    }else {
        // Any unrecognized context must belong to super
        [super observeValueForKeyPath:keyPath
                             ofObject:object
                               change:change
                              context:context];
    }
}

- (void)updateTotalAges {
    NSString *sum = (NSString *)[self valueForKeyPath:@"girls.@sum.age"];
    [self setTotalAges:sum.intValue];
}

KVO 原理

先來看看蘋果怎么說

Key-Value Observing Implementation Details

Automatic key-value observing is implemented using a technique called isa-swizzling.

The isa pointer, as the name suggests, points to the object's class which maintains a dispatch table. This dispatch table essentially contains pointers to the methods the class implements, among other data.

When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class. As a result the value of the isa pointer does not necessarily reflect the actual class of the instance.

You should never rely on the isa pointer to determine class membership. Instead, you should use the class method to determine the class of an object instance.

可見蘋果是實現了一種叫 isa-swizzling 的機制，那么具體怎么做呢，大概有這么幾步：

  • 1.在運行期動態地創建被觀察類的派生類（類名就是在該類的前面加上NSKVONotifying_ 前綴）

  • 2.在這個派生類中重寫基類中被觀察屬性的 setter 方法

  • 3.將 isa 指向這個新建的派生類(欺騙外部調用者它就是起初的那個類)

注意這里是在派生類里被重寫的 setter 方法里實現真正的通知機制，在對象上對 setter 的調用就會調用重寫的 setter，從而激活 KVO。

自實現 KVO

根據上面的原理，來自實現一個 KVO 機制，首先創建一個 NSObject 的分類:

#import <Foundation/Foundation.h>

typedef void(^PDObservingBlock)(id observedObject, NSString *observedKey, id oldValue, id newValue);

@interface NSObject (PDKVO)

- (void)pd_addObserver:(NSObject *)observer
                forKey:(NSString *)key
             withBlock:(PDObservingBlock)block;

- (void)pd_removeObserver:(NSObject *)observer forKey:(NSString *)key;

@end

ObservationInfo

添加對 block 的支持，block info 如下：

@interface PDObservationInfo : NSObject

@property (nonatomic, weak) NSObject *observer;
@property (nonatomic, copy) NSString *key;
@property (nonatomic, copy) PDObservingBlock block;

@end

@implementation PDObservationInfo

- (instancetype)initWithObserver:(NSObject *)observer
                             Key:(NSString *)key
                           block:(PDObservingBlock)block {
    self = [super init];
    if (self) {
        _observer = observer;
        _key = key;
        _block = block;
    }
    return self;
}
@end

addObserver

在 addObserver 方法里首先得檢查對象是否存在該屬性的setter方法，若沒有則拋出異常：

SEL setterSelector = NSSelectorFromString(setterForGetter(key));
Method setterMethod = class_getInstanceMethod([self class], setterSelector);
if (!setterMethod) {
    NSString *reason = [NSString stringWithFormat:@"Object %@ does not have a setter for key %@", self, key];
    @throw [NSException exceptionWithName:NSInvalidArgumentException
                                   reason:reason
                                 userInfo:nil];
    return;
}

然后檢查自身(類)是否是 KVO 類，如果不是，新建一個繼承原來類的子類，并把 isa 指向這個新建的子類：

Class clazz = object_getClass(self);
NSString *clazzName = NSStringFromClass(clazz);
if (![clazzName hasPrefix:kPDKVOClassPrefix]) {
    clazz = [self createKvoClassWithOriginalClassName:clazzName];
    // 改變 isa 指向剛創建的 clazz 類
    object_setClass(self, clazz);
}

再添加重寫的 setter 方法，并將 block 信息加到數組中：

if (![self hasSelector:setterSelector]) {
    const char *types = method_getTypeEncoding(setterMethod);
    class_addMethod(clazz, setterSelector, (IMP)kvo_setter, types);
}

// 創建觀察者的信息
PDObservationInfo *info = [[PDObservationInfo alloc] initWithObserver:observer Key:key block:block];

@synchronized (info) {
    NSMutableArray *observers = objc_getAssociatedObject(self, (__bridge const void *)(kPDKVOAssociatedObservers));
    if (!observers) {
        observers = [NSMutableArray array];
        objc_setAssociatedObject(self, (__bridge const void *)(kPDKVOAssociatedObservers), observers, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }
    [observers addObject:info];
}

需要注意的是這里 @synchronized() 傳入的是 info 而不是 self，這是因為 synchronized 中傳入的 object 的內存地址，被用作 key，通過hash map對應的一個系統維護的遞歸鎖。所以不管是傳入什么類型的object，只要是有內存地址，就能啟動同步代碼塊的效果。因此避免傳入 self，以免導致死鎖，例如：

//class A
@synchronized (self) {
    [_sharedLock lock];
    NSLog(@"code in class A");
    [_sharedLock unlock];
}

//class B
[_sharedLock lock];
@synchronized (objectA) {
    NSLog(@"code in class B");
}
[_sharedLock unlock];

原因是因為self很可能會被外部對象訪問，被用作key來生成一鎖，類似上述代碼中的@synchronized (objectA)。兩個公共鎖交替使用的場景就容易出現死鎖。

所以正確的做法是傳入一個類內部維護的NSObject對象，而且這個對象是對外不可見的。

調用

一句代碼就搞定，不用再到 - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context 方法里去嵌套 if else

[self.message pd_addObserver:self forKey:@"info" withBlock:^(id observedObject, NSString *observedKey, id oldValue, id newValue) {
        self.label.text = newValue;
}];

具體實現可見 Demo 的 NSObject+PDKVO 類。

Reference

如何自己動手實現 KVO

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容