转载

对于KVO，你真的了解么？

关于面试
官方文档
核心代码 (Key-Value Observing)
进阶（手动创建KVO）
关于isa指针
参考文章链接

一、关于面试

面试官：谈一谈你对KVO的理解？

A：添加响应者，监听对象变化，当对象改变时调用代理。

B：动态创建NSKVONotifying_XX类，修改被监听对象isa指针指向，只要调用对象的set方法,
就会调用NSKVONotifying_XX的set方法。本质：判断对象的set方法有没有被调用

二、苹果官方文档描述

Automatic key-value observing is implemented using a technique called isa-swizzling... 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 ..

以上文档的基本内容是：

“当对象注册观察者时，对象的ISA指针被修改，指向中间类，而不是原来真正的类...”，这是苹果官方给出的文档。听到是不是很懵？没关系，未了解之前，我和你一样，看了这篇文章后你将和我一样（小装一下，勿喷）。

举例说明：（监听一个Person类底层实现）

2.1)、动态创建NSKVONotifying_Person,NSKVONotifying_Person是Person子类，做KVO；

2.2)、修改当前对象的isa指针->NSKVONotifying_Person；

2.3)、只要调用对象的set,就会调用NSKVONotifying_Person的set方法；

2.4)、重写NSKVONotifying_Person的set方法，1[super set:] 2、通知观察者，告诉属性改变。

三、核心代码

/**
 添加观察者 （addObserver: forKeyPath: options: context:）
 @param observer 观察者
 @param keyPath 监听对象属性
 @param options 属性配置
 @param context 上下文
 */
- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath
            options:(NSKeyValueObservingOptions)options
            context:(void *)context
{
    /*
     * options
     *
     * NSKeyValueObservingOptionNew       // change字典包括改变后的值
     * NSKeyValueObservingOptionOld       // change字典包括改变前的值
     * NSKeyValueObservingOptionInitial   // 注册后立刻触发KVO通知
     * NSKeyValueObservingOptionPrior     // 值改变前是否也要通知（通知两次）
     */
}
/**
 监听按钮状态改变的方法
 @param keyPath 改变的属性
 @param object 被监听对象
 @param change 改变后的数据
 @param context 注册监听时context传递过来的值
 */
- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context
{

}

到此为止，这是我以前了解的所有KVO了，就这么点东西，用起来嗖嗖嗖啊。但是，大神永远是最骚的。前几天看到一个大神觉得系统的KVO不好用，自定义了一个，居然还是15年写的，我勒个槽槽槽，如何自己动手实现 KVO,就是这篇文章，读了半天，终于弄明白了，总结总结吧，别白看了。

首先，怀着虚荣的心先了解一下，为什么要自定义？对啊，苹果给的多好用，干嘛还要自定义去，脱裤子放屁（多此一举嘛），别着急，听听big borther 怎么说。

四、进阶

4.1、KVO 缺陷

big brother原话：
"KVO 很强大，没错。知道它内部实现，或许能帮助更好地使用它，或在它出错时更方便调试。但官方实现的 KVO 提供的 API 实在不怎么样。
比如，你只能通过重写 -observeValueForKeyPath:ofObject:change:context: 方法来获得通知。想要提供自定义的 selector ，不行；想要传一个 block ，门都没有。而且你还要处理父类的情况 - 父类同样监听同一个对象的同一个属性。但有时候，你不知道父类是不是对这个消息有兴趣。虽然 context 这个参数就是干这个的，也可以解决这个问题 - 在 -addObserver:forKeyPath:options:context: 传进去一个父类不知道的 context。但总觉得框在这个 API 的设计下，代码写的很别扭。至少至少，也应该支持 block 吧。
有不少人都觉得官方 KVO 不好使的。Mike Ash 的 Key-Value Observing Done Right，以及获得不少分享讨论的 KVO Considered Harmful 都把 KVO 拿出来吊打了一番。所以在实际开发中 KVO 使用的情景并不多，更多时候还是用 Delegate 或 NotificationCenter。"

目的：自定义一个KVO

操作：创建 NSObject+KVO 类，封装自定义API；

4.2、创建一个NSObject的Category,?.h文件中暴露两个API，用于添加和删除KVO。例：

#import // 宏定义
NSString *const kPGKVOClassPrefix = @"PGKVOClassPrefix_";
NSString *const kPGKVOAssociatedObservers = @"PGKVOAssociatedObservers";
/** 监听回调用block */
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

.m内部实践

/*
 * 1、检查对象的类有没有相应的 setter 方法。如果没有抛出异常；
 * 2、检查对象 isa 指向的类是不是一个 KVO 类。如果不是，新建一个继承原来类的子类，并把 isa 指向这个新建的子类；
 * 3、检查对象的 KVO 类重写过没有这个 setter 方法。如果没有，添加重写的 setter 方法；
 * 4、添加这个观察者
 */
- (void)PG_addObserver:(NSObject *)observer
                forKey:(NSString *)key
             withBlock:(PGObservingBlock)block
{
    /*
     一、 检查对象的类有没有相应的setter方法，如果没有抛出异常
     
    具体细节：
        1.1)、先通过 setterForGetter() 方法获得相应的 setter 的名字（SEL）。
        1.2)、把key的首字母大写； 前面加上set； key就变成了setKey。
        1.3)、再用class_getInstanceMethod去获得setKey:的实现（Method），如果没有，自然要抛出异常
     */
    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;
    }
    
    /*
     二、检查对象isa指向的类是不是一个KVO类。如果不是，新建一个继承原来类的子类，并把isa指向这个新建的子类
     */
    
    Class clazz = object_getClass(self);
    NSString *clazzName = NSStringFromClass(clazz);
    
    // 2.1)、先看类名有没有我们定义的前缀。如果没有，我们就去创建新的子类
    if (![clazzName hasPrefix:kPGKVOClassPrefix])
    {
        clazz = [self makeKvoClassWithOriginalClassName:clazzName];
        object_setClass(self, clazz);
    }
    // 2.2)、到这里为止, object的类已不是原类了, 而是KVO新建的类
    // 2.3)、例如官方的API: Person -> NSKVONotifying_Person()
    // 2.4)、kPGKVOClassPrefix是自己定义的一个宏，便于区分系统
    
    
    /*
     三、重写setter方法。新的setter在调用原setter方法后，通知每个观察者（调用之前传入的block）
     */
    if (![self hasSelector:setterSelector])
    {
        const char *types = method_getTypeEncoding(setterMethod);
        class_addMethod(clazz, setterSelector, (IMP)kvo_setter, types);
    }
    
    /*
     四、把这个观察的相关信息存在associatedObject里。
     
     具体相关：
        观察的相关信息（观察者，被观察的 key, 和传入的 block ）封装在 PGObservationInfo 类里。
     */
    PGObservationInfo *info = [[PGObservationInfo alloc] initWithObserver:observer Key:key block:block];
    NSMutableArray *observers = objc_getAssociatedObject(self, (__bridge const void *)(kPGKVOAssociatedObservers));
    if (!observers)
    {
        observers = [NSMutableArray array];
        objc_setAssociatedObject(self, (__bridge const void *)(kPGKVOAssociatedObservers), observers, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }
    [observers addObject:info];
}

这就是自定义的核心代码了，内容注视都整理在里面，有几个方法需要具体介绍一下：

4.3、核心方法解读：

setterForGetter
getterForSetter
makeKvoClassWithOriginalClassName
kvo_class
PG_removeObserver

4.3.1、setterForGetter （name -> Name -> setName:）

/** 根据getter方法名获得对应的setter方法名 */
static NSString * setterForGetter(NSString *getter)
{
    if (getter.length <= 0) {
        return nil;
    }
    
    // upper case the first letter
    NSString *firstLetter = [[getter substringToIndex:1] uppercaseString];
    NSString *remainingLetters = [getter substringFromIndex:1];
    
    // add 'set' at the begining and ':' at the end
    NSString *setter = [NSString stringWithFormat:@"set%@%@:", firstLetter, remainingLetters];
    
    return setter;
}

4.3.2、getterForSetter（setName: -> Name -> name）

/** 根据setter方法名获得对应的getter方法名 */
static NSString * getterForSetter(NSString *setter)
{
    if (setter.length <=0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) {
        return nil;
    }
    
    // remove 'set' at the begining and ':' at the end
    NSRange range = NSMakeRange(3, setter.length - 4);
    NSString *key = [setter substringWithRange:range];
    
    // lower case the first letter
    NSString *firstLetter = [[key substringToIndex:1] lowercaseString];
    key = [key stringByReplacingCharactersInRange:NSMakeRange(0, 1)
                                       withString:firstLetter]; 
    return key;
}

4.3.3、makeKvoClassWithOriginalClassName

- (Class)makeKvoClassWithOriginalClassName:(NSString *)originalClazzName
{
    // 生成kPGKVOClassPrefix_class的类名
    NSString *kvoClazzName = [kPGKVOClassPrefix stringByAppendingString:originalClazzName];
    Class clazz = NSClassFromString(kvoClazzName);
    
    // 如果kvo class已经被注册过了, 则直接返回
    if (clazz) {
        return clazz;
    }
    
    /*
     *  如果kvo class不存在, 则创建这个类
     *  class doesn't exist yet, make it
     */
    Class originalClazz = object_getClass(self);
    Class kvoClazz = objc_allocateClassPair(originalClazz, kvoClazzName.UTF8String, 0);
    
    /*
     *  修改kvo class方法的实现, 学习Apple的做法, 隐瞒这个kvo_class
     *  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);
    
    // 注册kvo_class
    objc_registerClassPair(kvoClazz);
    
    return kvoClazz;
}

4.3.4、kvo_class

static Class kvo_class(id self, SEL _cmd)
{
    return class_getSuperclass(object_getClass(self));
}

4.3.5、kvo_setter

#pragma mark - Overridden Methods
/** 重写setter方法, 新方法在调用原方法后, 通知每个观察者(调用传入的block) */
static void kvo_setter(id self, SEL _cmd, id newValue)
{
    NSString *setterName = NSStringFromSelector(_cmd);
    NSString *getterName = getterForSetter(setterName);
    
    // 如果不存在getter方法
    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];
    
    // 调用原类的setter方法
    struct objc_super superclazz = {
        .receiver = self,
        .super_class = class_getSuperclass(object_getClass(self))
    };
    /*
     *   这里需要做个类型强转, 否则会报too many argument的错误
     *   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);
    
    /*
     *  找出观察者的数组, 调用对应对象的callback
     *  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])
        {
            // gcd异步调用callback
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                each.block(self, getterName, oldValue, newValue);
            });
        }
    }
}

4.3.6、PG_removeObserver

/** 移除观察者 */
- (void)PG_removeObserver:(NSObject *)observer forKey:(NSString *)key
{
    NSMutableArray* observers = objc_getAssociatedObject(self, (__bridge const void *)(kPGKVOAssociatedObservers));
    PGObservationInfo *infoToRemove;
    for (PGObservationInfo* info in observers)
    {
        if (info.observer == observer && [info.key isEqual:key])
        {
            infoToRemove = info;
            break;
        }
    }
    [observers removeObject:infoToRemove];
}

4.3.7、调用

[self.message PG_addObserver:self forKey:NSStringFromSelector(@selector(text)) withBlock:^(id observedObject, NSString *observedKey, id oldValue, id newValue) {
    
}];

参考文章链接