KVO简析 | MrHook的时光机

KVO是一种键值观察机制，是Cocoa Binding的基础。通过它，一个对象能在当另一个对象的属性被修改时得到通知。现在让我们来探究一下这个神奇的KVO。

KVO的实现机制

KVO是通过runtime来实现的。当首次观察一个对象时，KVO会在runtime时创建一个新的继承原先类的子类。在这个新的子类中，它重写了所有被观察键的set方法。同时它转换了这个对象的isa指针，是它成为这个新子类的实例。最后通过这个重写的set方法，通知观察者值的改变。
但是苹果不想把这个实现机制暴露出来，它企图通过重写-class方法，欺骗我们这个类没有改变，就是原先的类。其实通过深挖，可以发现其中的奥妙。

-----------TestClass.h--------------
#import <Foundation/Foundation.h>

@interface TestClass : NSObject
@property (nonatomic, assign) NSInteger x;
@property (nonatomic, assign) NSInteger y;
@property (nonatomic, assign) NSInteger z;

@end

-----------TestClass.m--------------
#import "TestClass.h"

@implementation TestClass

@end

-----------main.m--------------
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import "TestClass.h"
#import <objc/runtime.h>

static NSArray *ClassMethodNames(Class c) {
    NSMutableArray *array = [NSMutableArray array];
    
    unsigned int methodCount = 0;
    Method *methodList = class_copyMethodList(c, &methodCount);
    unsigned int i;
    for (int i=0; i<methodCount; i++) {
        [array addObject:NSStringFromSelector(method_getName(methodList[i]))];
    }
    free(methodList);
    return array;
}

static void PrintDescription(NSString *name, id obj)
{
    NSString *str = [NSString stringWithFormat:
                     @"%@: %@\n\tNSObject class %s\n\tRuntime class %s\n\timplements methods <%@>\n\n",
                     name,
                     obj,
                     class_getName([obj class]),
                     class_getName(object_getClass(obj)),
                     [ClassMethodNames(object_getClass(obj)) componentsJoinedByString:@", "]];
    printf("%s\n", [str UTF8String]);
}

int main(int argc, char * argv[]) {
    @autoreleasepool {
        TestClass *x = [[TestClass alloc] init];
        TestClass *y = [[TestClass alloc] init];
        TestClass *xy = [[TestClass alloc] init];
        TestClass *control = [[TestClass alloc] init];
        
        [x addObserver:x forKeyPath:@"x" options:0 context:NULL];
        [xy addObserver:x forKeyPath:@"x" options:0 context:NULL];
        [y addObserver:x forKeyPath:@"y" options:0 context:NULL];
        [xy addObserver:x forKeyPath:@"y" options:0 context:NULL];
        
        PrintDescription(@"control", control);
        PrintDescription(@"x", x);
        PrintDescription(@"y", y);
        PrintDescription(@"xy", xy);
        
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

我们这边创建了一个测试类，里面有3个属性。然后我们在main函数中创建了几个对象用来对比，来看一下在添加了KVO之后，其发生的变化。

control: <TestClass: 0x60800003cde0>
	NSObject class TestClass
	Runtime class TestClass
	implements methods <z, x, y, setX:, setY:, setZ:>


x: <TestClass: 0x60800003cd60>
	NSObject class TestClass
	Runtime class NSKVONotifying_TestClass
	implements methods <setY:, setX:, class, dealloc, _isKVOA>


y: <TestClass: 0x60800003cda0>
	NSObject class TestClass
	Runtime class NSKVONotifying_TestClass
	implements methods <setY:, setX:, class, dealloc, _isKVOA>


xy: <TestClass: 0x60800003cdc0>
	NSObject class TestClass
	Runtime class NSKVONotifying_TestClass
	implements methods <setY:, setX:, class, dealloc, _isKVOA>

我们看到在添加了KVO之后，其NSObject class和Runtime class出现了差异。同时Runtime中新实现的类的方法都实现了class,dealloc和_isKVOA方法。另外，被观察的键值的set方法也被重写了。

KVO的缺点

KVO虽然是一种很强大的功能，但是在使用上，确有很多缺点。

-addObserver:forKeyPath:options:context:方法不能传一个通用的selector来执行回调触发。
在NSNotificationCenter中，你可以传入一个selector来执行回调触发。这可以很好的区分当前类和父类的回调执行。但是当使用KVO时，你必须重写-observeValueForKeyPath:ofObject:change:context:方法，同时得决定是在当前类中处理回调还是传给父类来处理回调。
context参数用处不大。
由于上面的缺陷，所以要引入context参数来区分是子类还是父类。
-removeObserver:forKeyPath:没有足够的参数
这个方法没有context参数。这样如果父类和子类注册同一个key，那么在取消观察时会把两个都取消掉。

优化KVO

虽然KVO很强大，但是使用起来确有很多不便。因此我们可以自己封装一下KVO，同时用BLOCK来返回回调。或者可以按照苹果的思路，自己实现一个KVO。

封装KVO

封装KVO的实现具体可以参考YYKit中的NSObject+YYAddForKVO。其实现原理是内部添加一个实例对象，把观察对象改为这个实例对象。同时通过runtime添加一个数组，用来维护这些实例对象。

- (void)addObserverBlockForKeyPath:(NSString *)keyPath block:(void (^)(__weak id obj, id oldVal, id newVal))block {
    if (!keyPath || !block) return;
    _YYNSObjectKVOBlockTarget *target = [[_YYNSObjectKVOBlockTarget alloc] initWithBlock:block];
    NSMutableDictionary *dic = [self _yy_allNSObjectObserverBlocks];
    NSMutableArray *arr = dic[keyPath];
    if (!arr) {
        arr = [NSMutableArray new];
        dic[keyPath] = arr;
    }
    [arr addObject:target];
    [self addObserver:target forKeyPath:keyPath options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:NULL];
}

- (NSMutableDictionary *)_yy_allNSObjectObserverBlocks {
    NSMutableDictionary *targets = objc_getAssociatedObject(self, &block_key);
    if (!targets) {
        targets = [NSMutableDictionary new];
        objc_setAssociatedObject(self, &block_key, targets, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }
    return targets;
}

自己实现KVO

通过分析KVO的实现原理，我们大概知道如何实现一个KVO，这样我们就可以自己实现一个类似的，同时增加block返回。具体的实现可以参考The ObserverPattern implementation(MRC)或者ImplementKVO(ARC)。

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

@interface NSObject (KVO)

- (void)PG_addObserver:(NSObject *)observer
                forKey:(NSString *)key
             withBlock:(PGObservingBlock)block;

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

@end

首先通过category，增加了两个KVO方法。其PG_addObserver:forKey:withBlock:大致实现如下：

检查对象的类有没有相应的 setter 方法。如果没有抛出异常；
检查对象 isa 指向的类是不是一个 KVO 类。如果不是，新建一个继承原来类的子类，并把 isa 指向这个新建的子类；
检查对象的 KVO 类重写过没有这个 setter 方法。如果没有，添加重写的 setter 方法；
添加这个观察者

- (Class)makeKvoClassWithOriginalClassName:(NSString *)originalClazzName
{
    NSString *kvoClazzName = [kPGKVOClassPrefix stringByAppendingString:originalClazzName];
    Class clazz = NSClassFromString(kvoClazzName);
    
    if (clazz) {
        return clazz;
    }
    
    // class doesn't exist yet, make it
    Class originalClazz = object_getClass(self);
    Class kvoClazz = objc_allocateClassPair(originalClazz, kvoClazzName.UTF8String, 0);
    
    // grab class method's signature so we can borrow it
    Method clazzMethod = class_getInstanceMethod(originalClazz, @selector(class));
    const char *types = method_getTypeEncoding(clazzMethod);
    class_addMethod(kvoClazz, @selector(class), (IMP)kvo_class, types);
    
    objc_registerClassPair(kvoClazz);
    
    return kvoClazz;
}

你需要通过runtime建一个原先类的子类。objc_allocateClassPair和objc_registerClassPair两个方法用来创建和注册子类。同时这边也通过class_addMethod(kvoClazz, @selector(class), (IMP)kvo_class, types)改写了class类来迷惑。

static void kvo_setter(id self, SEL _cmd, id newValue)
{
    NSString *setterName = NSStringFromSelector(_cmd);
    NSString *getterName = getterForSetter(setterName);
    
    if (!getterName) {
        NSString *reason = [NSString stringWithFormat:@"Object %@ does not have setter %@", self, setterName];
        @throw [NSException exceptionWithName:NSInvalidArgumentException
                                       reason:reason
                                     userInfo:nil];
        return;
    }
    
    id oldValue = [self valueForKey:getterName];
    
    struct objc_super superclazz = {
        .receiver = self,
        .super_class = class_getSuperclass(object_getClass(self))
    };
    
    // cast our pointer so the compiler won't complain
    void (*objc_msgSendSuperCasted)(void *, SEL, id) = (void *)objc_msgSendSuper;
    
    // call super's setter, which is original class's setter method
    objc_msgSendSuperCasted(&superclazz, _cmd, newValue);
    
    // look up observers and call the blocks
    NSMutableArray *observers = objc_getAssociatedObject(self, (__bridge const void *)(kPGKVOAssociatedObservers));
    for (PGObservationInfo *each in observers) {
        if ([each.key isEqualToString:getterName]) {
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                each.block(self, getterName, oldValue, newValue);
            });
        }
    }
}

这边重写了新子类的set方法，通知每个观察者。

总结

本文分析了KVO的实现原理及其缺点，同时描述了如何改进现有的KVO和实现自己的KVO。

参考

Key-Value Observing
Key-Value Observing Done Right
如何自己动手实现 KVO
YYKit
By your _cmd