动手实现 KVO

相关链接：http://tech.glowing.com/cn/implement-kvo/

概念

apple 实现 KVO 的方式

KVO 的实现依赖于 isa-swizzling 技术。

• 当对象的一个属性被注册监听后，对象的 isa 指针转而指向一个中间类，而非原来的类对象了。

• 中间类对象：继承自原来的类对象。但重写了被观察的属性 setter 方法。

• 重写 setter 方法：在原来 setter 方法之前之后（willChangeValueForKey、didChangevlueForKey），通知所有观察对象：值的改变。

• 继而会调用observeValueForKey:ofObject:change:context:。

**之后，apple 重写了 -class 方法，返回原来的类：隐藏了该中间类的细节。

KVO 缺陷

• 只能通过-observeValueForKeyPath:ofObject:change:context:方法来获得通知。
• 需要处理父类的情况：若父类监听同一个对象的同一属性。（context 可以解决这个问题：添加监听时传进一个不同于父类的 context）

自己实现 KVO

1. 创建 NSObject 的 category，h 文件添加：

   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
   
   

2. 实现 m 文件

   • 提示：

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

   • 实现：

     - (void)PG_addObserver:(NSObject *)observer
             forKey:(NSString *)key
          withBlock:(PGObservingBlock)block
          {
          // Step 1: 若该类和父类均无该 setter 的实现
          SEL setterSelector = NSSelectorFromString(setterForGetter(key))
          Method setterMethod = class_getInstanceMethod([self class], setterSelector);
          if (!setterMethod) {
          // throw invalid argument exception
          }
        
        Class clazz = object_getClass(self);
        NSString *clazzName = NSStringFromClass(clazz);
     
     // Step 2: 若是首次添加 KVO，并且该类不是 KVO 类时，则生成 KVO 类
     if (![clazzName hasPrefix:kPGKVOClassPrefix]) {
     clazz = [self makeKvoClassWithOriginalClassName:clazzName];
     object_setClass(self, clazz);
     

   }

   // Step 3: Add our kvo setter method if its class (not superclasses)
   // hasn't implemented the setter

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

   }
   // Step 4: Add this observation info to saved observation objects
   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];
   }

    ```
   

   第一步里，先通过 setterForGetter() 方法获得相应的 setter 的名字（SEL）。也就是把 key 的首字母大写，然后前面加上 set 后面加上 :，这样 key 就变成了 setKey:。然后再用 class_getInstanceMethod 去获得 setKey: 的实现（Method）。如果没有，自然要抛出异常。

   第二步，我们先看类名有没有我们定义的前缀。如果没有，我们就去创建新的子类，并通过 object_setClass() 修改 isa 指针。

   - (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;

}
```

动态创建新的类需要用 objc/runtime.h 中定义的 objc\_allocateClassPair() 函数。传一个父类，类名，然后额外的空间（通常为 0），它返回给你一个类。然后就给这个类添加方法，也可以添加变量。这里，我们只重写了 class 方法。哈哈，跟 Apple 一样，这时候我们也企图隐藏这个子类的存在。最后 objc\_registerClassPair() 告诉 Runtime 这个类的存在。



* 第三步，重写 setter 方法。新的 setter 在调用原 setter 方法后，通知每个观察者（调用之前传入的 block ）：

```
static void kvo_setter(id self, SEL _cmd, id newValue)  

{
NSString *setterName = NSStringFromSelector(_cmd);
NSString *getterName = getterForSetter(setterName);

if (!getterName) {
    // throw invalid argument exception
}

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);
        });
    }
}

}

```