1. 自定义KVO

仿照KVO的实现方式，自定义NSObject的分类LGKVO

1.1 准备工作

定义全局静态常量：

  1. static NSString *const kLGKVOPrefix = @"LGKVONotifying_";
  2. static NSString *const kLGKVOAssiociateKey = @"kLGKVO_AssiociateKey";

实现setterForGetter方法：

  2. #pragma mark - 从get方法获取set方法的名称 key ===>>> setKey:
  3. static NSString *setterForGetter(NSString *getter){
  5.     if (getter.length <= 0) { return nil;}
  7.     NSString *firstString = [[getter substringToIndex:1] uppercaseString];
  8.     NSString *leaveString = [getter substringFromIndex:1];
  10.     return [NSString stringWithFormat:@"set%@%@:",firstString,leaveString];
  11. }

实现getterForSetter方法：

  1. #pragma mark - 从set方法获取getter方法的名称 set<Key>:===> key
  2. static NSString *getterForSetter(NSString *setter){
  4.     if (setter.length <= 0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) { return nil;}
  6.     NSRange range = NSMakeRange(3, setter.length-4);
  7.     NSString *getter = [setter substringWithRange:range];
  8.     NSString *firstString = [[getter substringToIndex:1] lowercaseString];
  9.     return  [getter stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:firstString];
  10. }

1.2 注册观察者

实现lg_addObserver方法：

  1. - (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(LGKeyValueObservingOptions)options context:(nullable void *)context{
  3.     // 1: 验证是否存在setter方法 : 不让实例进来
  4.     [self judgeSetterMethodFromKeyPath:keyPath];
  5.     // 2: 动态生成子类
  6.     Class newClass = [self createChildClassWithKeyPath:keyPath];
  7.     // 3: isa的指向 : LGKVONotifying_LGPerson
  8.     object_setClass(self, newClass);
  9.     // 4: 保存观察者信息
  10.     [self lg_addInfoWithObserver:observer forKeyPath:keyPath options:options];
  11. }

  • 【第一步】验证被监听者为属性，必须存在setter方法

  • 【第二步】动态生成子类

  • 【第三步】修改isa指向

  • 【第四步】保存观察者信息

1.2.1 验证被监听者

实现judgeSetterMethodFromKeyPath方法：

  1. - (void)judgeSetterMethodFromKeyPath:(NSString *)keyPath{
  2.     Class superClass    = object_getClass(self);
  3.     SEL setterSeletor   = NSSelectorFromString(setterForGetter(keyPath));
  4.     Method setterMethod = class_getInstanceMethod(superClass, setterSeletor);
  5.     if (!setterMethod) {
  6.         @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"当前%@不存在setter方法",keyPath] userInfo:nil];
  7.     }
  8. }

1.2.2 动态生成子类

实现createChildClassWithKeyPath方法：

  1. - (Class)createChildClassWithKeyPath:(NSString *)keyPath{
  3.     NSString *oldClassName = NSStringFromClass([self class]);
  4.     NSString *newClassName = [NSString stringWithFormat:@"%@%@",kLGKVOPrefix,oldClassName];
  5.     Class newClass = NSClassFromString(newClassName);
  6.     // 防止重复创建生成新类
  7.     if (newClass) return newClass;
  8.     /**
  9.      * 如果内存不存在,创建生成
  10.      * 参数一: 父类
  11.      * 参数二: 新类的名字
  12.      * 参数三: 新类的开辟的额外空间
  13.      */
  14.     // 2.1 : 申请类
  15.     newClass = objc_allocateClassPair([self class], newClassName.UTF8String, 0);
  16.     // 2.2 : 注册类
  17.     objc_registerClassPair(newClass);
  18.     // 2.3.1 : 添加class : class的指向是LGPerson
  19.     SEL classSEL = NSSelectorFromString(@"class");
  20.     Method classMethod = class_getInstanceMethod([self class], classSEL);
  21.     const char *classTypes = method_getTypeEncoding(classMethod);
  22.     class_addMethod(newClass, classSEL, (IMP)lg_class, classTypes);
  23.     // 2.3.2 : 添加setter
  24.     SEL setterSEL = NSSelectorFromString(setterForGetter(keyPath));
  25.     Method setterMethod = class_getInstanceMethod([self class], setterSEL);
  26.     const char *setterTypes = method_getTypeEncoding(setterMethod);
  27.     class_addMethod(newClass, setterSEL, (IMP)lg_setter, setterTypes);
  28.     return newClass;
  29. }

  • 【第一步】验证动态子类是否已经创建

    • 已创建，直接返回

    • 未创建，进入【第二步】

  • 【第二步】创建子类

    • 申请类，需要父类、新类的名称、开辟的额外空间

    • 注册类

    • 添加方法，需要class、setter方法

1.2.3 保存观察者信息

创建LGKVOInfo，用来存储观察者信息

  1. #import <Foundation/Foundation.h>
  3. typedef NS_OPTIONS(NSUInteger, LGKeyValueObservingOptions) {
  5.     LGKeyValueObservingOptionNew = 0x01,
  6.     LGKeyValueObservingOptionOld = 0x02,
  7. };
  9. @interface LGKVOInfo : NSObject
  11. @property (nonatomic, weak) NSObject  *observer;
  12. @property (nonatomic, copy) NSString    *keyPath;
  13. @property (nonatomic, assign) LGKeyValueObservingOptions options;
  15. - (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(LGKeyValueObservingOptions)options;
  17. @end
  19. @implementation LGKVOInfo
  21. - (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(LGKeyValueObservingOptions)options{
  22.     self = [super init];
  23.     if (self) {
  24.         self.observer = observer;
  25.         self.keyPath  = keyPath;
  26.         self.options  = options;
  27.     }
  28.     return self;
  29. }
  31. @end

实现lg_addInfoWithObserver方法：

  1. -(void)lg_addInfoWithObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(LGKeyValueObservingOptions)options {
  3.     LGKVOInfo *info = [[LGKVOInfo alloc] initWitObserver:observer forKeyPath:keyPath options:options];
  4.     NSMutableArray *observerArr = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey));
  6.     if (!observerArr) {
  7.         observerArr = [NSMutableArray arrayWithCapacity:1];
  8.         [observerArr addObject:info];
  9.         objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey), observerArr, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
  10.     }
  11. }

1.3 实现子类方法

动态生成子类时，添加的class和setter方法，它们的IMP分别指向lg_class和lg_setter函数地址

1.3.1 lg_class

实现lg_class函数：

  1. Class lg_class(id self,SEL _cmd){
  2.     return class_getSuperclass(object_getClass(self));
  3. }

使用中间类重写后的class方法，获取的还是原始类对象，仿佛KVO所做的一切都不存在

1.3.2 lg_setter

实现lg_setter函数：

  1. static void lg_setter(id self,SEL _cmd,id newValue){
  3.     // 1：消息转发：转发给父类，改变父类的值
  4.     NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));
  5.     id oldValue       = [self valueForKey:keyPath];
  7.     void (*lg_msgSendSuper)(void *,SEL , id) = (void *)objc_msgSendSuper;
  9.     struct objc_super superStruct = {
  10.         .receiver = self,
  11.         .super_class = class_getSuperclass(object_getClass(self)),
  12.     };
  14.     lg_msgSendSuper(&superStruct,_cmd,newValue);
  15.     // 2：获取观察者
  16.     NSMutableArray *observerArr = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey));
  18.     for (LGKVOInfo *info in observerArr) {
  19.         if ([info.keyPath isEqualToString:keyPath]) {
  20.             dispatch_async(dispatch_get_global_queue(0, 0), ^{
  21.                 NSMutableDictionary<NSKeyValueChangeKey,id> *change = [NSMutableDictionary dictionaryWithCapacity:1];
  22.                 // 3：对新、旧值进行处理
  23.                 if (info.options & LGKeyValueObservingOptionNew) {
  24.                     [change setObject:newValue forKey:NSKeyValueChangeNewKey];
  25.                 }
  26.                 if (info.options & LGKeyValueObservingOptionOld) {
  28.                     if (oldValue) {
  29.                         [change setObject:oldValue forKey:NSKeyValueChangeOldKey];
  30.                     }
  31.                     else{
  32.                         [change setObject:@"" forKey:NSKeyValueChangeOldKey];
  33.                     }
  34.                 }
  35.                 // 4：发送消息给观察者
  36.                 SEL observerSEL = @selector(lg_observeValueForKeyPath:ofObject:change:context:);
  37.                 ((void (*) (id, SEL, NSString *, id, NSDictionary *, void *)) objc_msgSend)(info.observer,observerSEL,keyPath,self,change,NULL);
  38.             });
  39.         }
  40.     }
  41. }

  • 【第一步】消息转发：转发给父类，改变父类的值

  • 【第二步】获取观察者

  • 【第三步】对新、旧值进行处理

  • 【第四步】发送消息给观察者

1.4 移除观察者

实现lg_removeObserver方法：

  1. - (void)lg_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath{
  3.     NSMutableArray *observerArr = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey));
  4.     if (observerArr.count<=0) {
  5.         return;
  6.     }
  8.     for (LGKVOInfo *info in observerArr) {
  9.         if ([info.keyPath isEqualToString:keyPath]) {
  10.             [observerArr removeObject:info];
  11.             objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey), observerArr, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
  12.             break;
  13.         }
  14.     }
  16.     if (observerArr.count<=0) {
  17.         // 指回给父类
  18.         Class superClass = [self class];
  19.         object_setClass(self, superClass);
  20.     }
  21. }

  • 【第一步】移除观察者

  • 【第二步】isa指回原始类对象

1.5 自定义KVO的使用

  1. - (void)viewDidLoad {
  2.     [super viewDidLoad];
  4.     self.person = [[LGPerson alloc] init];
  6.     NSLog(@"注册观察者之前：%s",object_getClassName(self.person));
  8.     [self.person lg_addObserver:self forKeyPath:@"nickName" options:(LGKeyValueObservingOptionNew|LGKeyValueObservingOptionOld) context:NULL];
  10.     NSLog(@"注册观察者之后：%s",object_getClassName(self.person));
  11. }
  13. - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
  14.     self.person.nickName = @"KC";
  15. }
  17. - (void)lg_observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
  18.     NSLog(@"KVO回调：%@",change);
  19. }
  21. - (void)dealloc{
  23.     NSLog(@"移除观察者之前：%s",object_getClassName(self.person));
  25.     [self.person lg_removeObserver:self forKeyPath:@"nickName"];
  27.     NSLog(@"移除观察者之后：%s",object_getClassName(self.person));
  28. }
  30. -------------------------
  32. //输出以下内容：
  33. 注册观察者之前：LGPerson
  34. 注册观察者之后：LGKVONotifying_LGPerson
  35. KVO回调：{
  36.     new = KC;
  37.     old = "";
  38. }
  39. 移除观察者之前：LGKVONotifying_LGPerson
  40. 移除观察者之后：LGPerson

2. 函数式KVO

函数式编程是一种编程方式，把运算过程写成一系列嵌套的函数调用。函数编程支持函数作为第一类对象，有时称为闭包或者仿函数（functor）对象

函数式编程的优点：

  • 代码简洁，开发快速

    • 函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快

  • 接近自然语言，易于理解

    • 函数式编程的自由度很高，可以写出很接近自然语言的代码

  • 更方便的代码管理

    • 函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果必定相同。因此，每一个函数都可以被看做独立单元，很有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合

  • 易于并发编程

    • 函数式编程不需要考虑死锁（deadlock），因为它不修改变量，所以根本不存在锁线程的问题。不必担心一个线程的数据，被另一个线程修改，所以可以很放心地把工作分摊到多个线程，部署并发编程（concurrency）

2.1 注册观察者

定义LGKVOBlock：

  1. typedef void(^LGKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);

修改lg_addObserver方法，将block作为方法参数

  1. - (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(LGKVOBlock)block{
  3.     // 1: 验证是否存在setter方法 : 不让实例进来
  4.     [self judgeSetterMethodFromKeyPath:keyPath];
  5.     // 2: 动态生成子类
  6.     Class newClass = [self createChildClassWithKeyPath:keyPath];
  7.     // 3: isa的指向 : LGKVONotifying_LGPerson
  8.     object_setClass(self, newClass);
  9.     // 4: 保存观察者信息
  10.     [self lg_addInfoWithObserver:observer forKeyPath:keyPath block:block];
  11. }

2.1.1 保存观察者信息

修改LGKVOInfo，增加block属性，初始化方法增加block参数

  1. #import <Foundation/Foundation.h>
  3. typedef NS_OPTIONS(NSUInteger, LGKeyValueObservingOptions) {
  5.     LGKeyValueObservingOptionNew = 0x01,
  6.     LGKeyValueObservingOptionOld = 0x02,
  7. };
  9. @interface LGKVOInfo : NSObject
  11. @property (nonatomic, weak) NSObject  *observer;
  12. @property (nonatomic, copy) NSString    *keyPath;
  13. @property (nonatomic, copy) LGKVOBlock  handleBlock;
  15. - (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block;
  17. @end
  19. @implementation LGKVOInfo
  21. - (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block{
  22.     if (self=[super init]) {
  23.         _observer = observer;
  24.         _keyPath  = keyPath;
  25.         _handleBlock = block;
  26.     }
  27.     return self;
  28. }
  30. @end

修改lg_addInfoWithObserver方法，将block作为方法参数

  1. -(void)lg_addInfoWithObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(LGKVOBlock)block {
  3.     LGKVOInfo *info = [[LGKVOInfo alloc] initWitObserver:observer forKeyPath:keyPath handleBlock:block];
  4.     NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey));
  5.     if (!mArray) {
  6.         mArray = [NSMutableArray arrayWithCapacity:1];
  7.         objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey), mArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
  8.     }
  9.     [mArray addObject:info];
  10. }

2.2 实现子类方法

修改子类的setter方法，使用函数式编程，传入的block为回调方法。所以在setter方法中，无需调用KVO回调方法，改为调用info中保存的block即可

2.2.1 lg_setter

修改lg_setter函数，将调用KVO回调方法，改为调用info中保存的block

  1. static void lg_setter(id self,SEL _cmd,id newValue){
  3.     // 1：消息转发：转发给父类，改变父类的值
  4.     NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));
  5.     id oldValue = [self valueForKey:keyPath];
  7.     void (*lg_msgSendSuper)(void *,SEL , id) = (void *)objc_msgSendSuper;
  9.     struct objc_super superStruct = {
  10.         .receiver = self,
  11.         .super_class = class_getSuperclass(object_getClass(self)),
  12.     };
  14.     lg_msgSendSuper(&superStruct,_cmd,newValue);
  16.     // 2：获取观察者
  17.     NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kLGKVOAssiociateKey));
  19.     for (LGKVOInfo *info in mArray) {
  21.         // 3：调用block
  22.         if ([info.keyPath isEqualToString:keyPath] && info.handleBlock) {
  23.             info.handleBlock(info.observer, keyPath, oldValue, newValue);
  24.         }
  25.     }
  26. }

2.3 函数式KVO的使用

  1. - (void)viewDidLoad {
  2.     [super viewDidLoad];
  4.     self.person = [[LGPerson alloc] init];
  6.     NSLog(@"注册观察者之前：%s",object_getClassName(self.person));
  8.     [self.person lg_addObserver:self forKeyPath:@"nickName" block:^(id  _Nonnull observer, NSString * _Nonnull keyPath, id  _Nonnull oldValue, id  _Nonnull newValue) {
  9.         NSLog(@"回调方法：%@ - %@",oldValue,newValue);
  10.     }];
  12.     NSLog(@"注册观察者之后：%s",object_getClassName(self.person));
  13. }
  15. - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
  16.     self.person.nickName = @"KC";
  17. }
  19. - (void)dealloc{
  21.     NSLog(@"移除观察者之前：%s",object_getClassName(self.person));
  23.     [self.person lg_removeObserver:self forKeyPath:@"nickName"];
  25.     NSLog(@"移除观察者之后：%s",object_getClassName(self.person));
  26. }
  28. -------------------------
  30. //输出以下内容：
  31. 注册观察者之前：LGPerson
  32. 注册观察者之后：LGKVONotifying_LGPerson
  33. 回调方法：(null) - KC
  34. 移除观察者之前：LGKVONotifying_LGPerson
  35. 移除观察者之后：LGPerson

3. 自动销毁机制

使用KVO必须手动移除观察者，我们是否可以重写子类的dealloc方法，在其销毁的时候，自动移除观察者

3.1 动态生成子类

修改createChildClassWithKeyPath方法，添加dealloc方法

  1. - (Class)createChildClassWithKeyPath:(NSString *)keyPath{
  3.     ...
  5.     // 2.3.3 : 添加dealloc
  6.     SEL deallocSEL = NSSelectorFromString(@"dealloc");
  7.     Method deallocMethod = class_getInstanceMethod([self class], deallocSEL);
  8.     const char *deallocTypes = method_getTypeEncoding(deallocMethod);
  9.     class_addMethod(newClass, deallocSEL, (IMP)lg_dealloc, deallocTypes);
  11.     return newClass;
  12. }

3.2 实现子类方法

动态生成子类时，添加的dealloc方法，IMP指向lg_dealloc函数地址

3.2.1 lg_dealloc

实现lg_dealloc函数：

  1. static void lg_dealloc(id self,SEL _cmd){
  3.     NSLog(@"自动销毁之前：%s",object_getClassName(self));
  5.     Class superClass = [self class];
  6.     object_setClass(self, superClass);
  8.     NSLog(@"自动销毁之后：%s",object_getClassName(self));
  9. }

3.3 自动销毁机制的使用

  1. - (void)dealloc{
  2.     // LGViewController中的dealloc什么都不处理
  3.     // 依赖子类中的lg_dealloc自动销毁
  4. }
  7. -------------------------
  9. //输出以下内容：
  10. 注册观察者之前：LGPerson
  11. 注册观察者之后：LGKVONotifying_LGPerson
  12. 回调方法：(null) - KC
  13. 自动销毁之前：LGKVONotifying_LGPerson
  14. 自动销毁之后：LGPerson

4. FBKVOController

上述案例中，自定义的KVO代码并不完善，目的只是阐述KVO的底层原理，列举KVO使用中的一些痛点

更完善的自定义KVO，已经被 Facebook实现并开源：

  • 采用中介者设计模式，对常用的KVO机制进行了额外的一层封装

  • 使用数组形式，可同时对model中多个属性进行监听

  • 提供action和block两种方式进行回调，避免KVO的相关代码四处散落

  • 提供自动销毁机制，无需在dealloc方法中移除观察者

4.1 基本使用

4.1.1 使用block回调

  1. #import "ViewController.h"
  2. #import <FBKVOController.h>
  3. #import "LGPerson.h"
  5. @interface ViewController ()
  7. @property (nonatomic, strong) FBKVOController *kvoCtrl;
  9. @property (nonatomic, strong) LGPerson *person;
  11. @end
  13. @implementation ViewController
  15. - (void)viewDidLoad {
  16.     [super viewDidLoad];
  18.     self.person = [[LGPerson alloc] init];
  20.     [self.kvoCtrl observe:self.person keyPath:@"name" options:(NSKeyValueObservingOptionNew) block:^(id  _Nullable observer, id  _Nonnull object, NSDictionary<NSString *,id> * _Nonnull change) {
  21.         NSLog(@"****%@****",change);
  22.     }];
  23. }
  25. - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
  26.     self.person.name = @"KC";
  27. }
  29. - (FBKVOController *)kvoCtrl{
  30.     if (!_kvoCtrl) {
  31.         _kvoCtrl = [FBKVOController controllerWithObserver:self];
  32.     }
  33.     return _kvoCtrl;
  34. }
  36. @end

4.1.2 使用action回调

  1. [self.kvoCtrl observe:self.person keyPath:@"age" options:NSKeyValueObservingOptionNew action:@selector(lg_observerAge)];

4.1.3 对可变数组的监听

  1. [self.kvoCtrl observe:self.person keyPath:@"mArray" options:(NSKeyValueObservingOptionNew) block:^(id  _Nullable observer, id  _Nonnull object, NSDictionary<NSString *,id> * _Nonnull change) {
  2.     NSLog(@"****%@****",change);
  3. }];

4.2 源码解析

4.2.1 FBKVOController的初始化

  1. - (instancetype)initWithObserver:(nullable id)observer retainObserved:(BOOL)retainObserved
  2. {
  3.   self = [super init];
  4.   if (nil != self) {
  6.       //一般情况下 observer 会持有 FBKVOController 为了避免循环引用，此处的_observer 的内存管理语义是弱引用
  7.       _observer = observer;
  9.       //定义 NSMapTable key的内存管理策略，在默认情况，传入的参数 retainObserved = YES
  10.       NSPointerFunctionsOptions keyOptions = retainObserved ? NSPointerFunctionsStrongMemory|NSPointerFunctionsObjectPointerPersonality : NSPointerFunctionsWeakMemory|NSPointerFunctionsObjectPointerPersonality;
  12.       //创建 NSMapTable  key 为 id 类型，value 为 NSMutableSet 类型
  13.       _objectInfosMap = [[NSMapTable alloc] initWithKeyOptions:keyOptions valueOptions:NSPointerFunctionsStrongMemory|NSPointerFunctionsObjectPersonality capacity:0];
  15.       //初始化互斥锁，避免多线程间的数据竞争
  16.       pthread_mutex_init(&_lock, NULL);
  17.   }
  18.   return self;
  19. }

4.2.2 注册观察者

  1. - (void)observe:(nullable id)object keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(FBKVONotificationBlock)block
  2. {
  3.   NSAssert(0 != keyPath.length && NULL != block, @"missing required parameters observe:%@ keyPath:%@ block:%p", object, keyPath, block);
  4.   if (nil == object || 0 == keyPath.length || NULL == block) {
  5.     return;
  6.   }
  8.   // create info
  9.   _FBKVOInfo *info = [[_FBKVOInfo alloc] initWithController:self keyPath:keyPath options:options block:block];
  11.   // observe object with info
  12.   [self _observe:object info:info];
  13. }

  • _FBKVOInfo类，存储观察者信息，包含：FBKVOController、keyPath、options、block

  • 添加observe和info的关联

4.2.3 observe和info的关联

  1. - (void)_observe:(id)object info:(_FBKVOInfo *)info
  2. {
  3.   // lock
  4.   pthread_mutex_lock(&_lock);
  6.   NSMutableSet *infos = [_objectInfosMap objectForKey:object];
  8.   // check for info existence
  9.   _FBKVOInfo *existingInfo = [infos member:info];
  10.   if (nil != existingInfo) {
  11.     // observation info already exists; do not observe it again
  13.     // unlock and return
  14.     pthread_mutex_unlock(&_lock);
  15.     return;
  16.   }
  18.   // lazilly create set of infos
  19.   if (nil == infos) {
  20.     infos = [NSMutableSet set];
  21.     [_objectInfosMap setObject:infos forKey:object];
  22.   }
  24.   // add info and oberve
  25.   [infos addObject:info];
  27.   // unlock prior to callout
  28.   pthread_mutex_unlock(&_lock);
  30.   [[_FBKVOSharedController sharedController] observe:object info:info];
  31. }

  • FBKVOController中持有NSMapTable，使用NSMapTable代替关联对象

  • object作为key，获取NSMutableSet

  • NSMutableSet中存储_FBKVOInfo

  • 如果infos不存在，进行创建，并添加到NSMapTable中

  • 将info对象添加到NSMutableSet类型的infos中

  • _FBKVOSharedController为单例模式的中介者，负责真正的KVO操作

4.2.4 中介者-注册系统KVO

  1. - (void)observe:(id)object info:(nullable _FBKVOInfo *)info
  2. {
  3.   if (nil == info) {
  4.     return;
  5.   }
  7.   // register info
  8.   pthread_mutex_lock(&_mutex);
  9.   [_infos addObject:info];
  10.   pthread_mutex_unlock(&_mutex);
  12.   // add observer
  13.   [object addObserver:self forKeyPath:info->_keyPath options:info->_options context:(void *)info];
  15.   if (info->_state == _FBKVOInfoStateInitial) {
  16.     info->_state = _FBKVOInfoStateObserving;
  17.   } else if (info->_state == _FBKVOInfoStateNotObserving) {
  18.     // this could happen when `NSKeyValueObservingOptionInitial` is one of the NSKeyValueObservingOptions,
  19.     // and the observer is unregistered within the callback block.
  20.     // at this time the object has been registered as an observer (in Foundation KVO),
  21.     // so we can safely unobserve it.
  22.     [object removeObserver:self forKeyPath:info->_keyPath context:(void *)info];
  23.   }
  24. }

  • 传入的object为实例对象，调用系统KVO的注册观察者，开始对属性监听

  • 传入addObserver方法的self为当前单例的中介者

  • 中介者中持有NSHashTable，以弱引用的方式存储_FBKVOInfo

  • 通过_FBKVOInfo的_state成员变量，根据枚举值_FBKVOInfoStateInitial、_FBKVOInfoStateObserving、_FBKVOInfoStateNotObserving决定新增或删除KVO

4.2.5 中介者-实现回调

  1. - (void)observeValueForKeyPath:(nullable NSString *)keyPath
  2.                       ofObject:(nullable id)object
  3.                         change:(nullable NSDictionary<NSString *, id> *)change
  4.                        context:(nullable void *)context
  5. {
  6.   NSAssert(context, @"missing context keyPath:%@ object:%@ change:%@", keyPath, object, change);
  8.   _FBKVOInfo *info;
  10.   {
  11.     // lookup context in registered infos, taking out a strong reference only if it exists
  12.     pthread_mutex_lock(&_mutex);
  13.     info = [_infos member:(__bridge id)context];
  14.     pthread_mutex_unlock(&_mutex);
  15.   }
  17.   if (nil != info) {
  19.     // take strong reference to controller
  20.     FBKVOController *controller = info->_controller;
  21.     if (nil != controller) {
  23.       // take strong reference to observer
  24.       id observer = controller.observer;
  25.       if (nil != observer) {
  27.         // dispatch custom block or action, fall back to default action
  28.         if (info->_block) {
  29.           NSDictionary<NSString *, id> *changeWithKeyPath = change;
  30.           // add the keyPath to the change dictionary for clarity when mulitple keyPaths are being observed
  31.           if (keyPath) {
  32.             NSMutableDictionary<NSString *, id> *mChange = [NSMutableDictionary dictionaryWithObject:keyPath forKey:FBKVONotificationKeyPathKey];
  33.             [mChange addEntriesFromDictionary:change];
  34.             changeWithKeyPath = [mChange copy];
  35.           }
  36.           info->_block(observer, object, changeWithKeyPath);
  37.         } else if (info->_action) {
  38. #pragma clang diagnostic push
  39. #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
  40.           [observer performSelector:info->_action withObject:change withObject:object];
  41. #pragma clang diagnostic pop
  42.         } else {
  43.           [observer observeValueForKeyPath:keyPath ofObject:object change:change context:info->_context];
  44.         }
  45.       }
  46.     }
  47.   }
  48. }

  • 通过info获取FBKVOController

  • 从FBKVOController中，获取observer，也就是真正的VC

  • 通过info获取block并调用，传入必要的参数

4.2.6 FBKVOController的销毁

  1. - (void)dealloc
  2. {
  3.   [self unobserveAll];
  4.   pthread_mutex_destroy(&_lock);
  5. }
  7. - (void)unobserveAll
  8. {
  9.   [self _unobserveAll];
  10. }
  12. - (void)_unobserveAll
  13. {
  14.   // lock
  15.   pthread_mutex_lock(&_lock);
  17.   NSMapTable *objectInfoMaps = [_objectInfosMap copy];
  19.   // clear table and map
  20.   [_objectInfosMap removeAllObjects];
  22.   // unlock
  23.   pthread_mutex_unlock(&_lock);
  25.   _FBKVOSharedController *shareController = [_FBKVOSharedController sharedController];
  27.   for (id object in objectInfoMaps) {
  28.     // unobserve each registered object and infos
  29.     NSSet *infos = [objectInfoMaps objectForKey:object];
  30.     [shareController unobserve:object infos:infos];
  31.   }
  32. }

  • 当VC销毁时，控制器中初始化的FBKVOController也会跟随销毁

  • FBKVOController的dealloc方法，先拷贝自身持有的NSMapTable到临时表，然后将其清空，再遍历临时表，从单例的中介者中，取消实例对象和infos的关联

4.2.7 中介者-移除系统KVO的监听

  1. - (void)unobserve:(id)object infos:(nullable NSSet<_FBKVOInfo *> *)infos
  2. {
  3.   if (0 == infos.count) {
  4.     return;
  5.   }
  7.   // unregister info
  8.   pthread_mutex_lock(&_mutex);
  9.   for (_FBKVOInfo *info in infos) {
  10.     [_infos removeObject:info];
  11.   }
  12.   pthread_mutex_unlock(&_mutex);
  14.   // remove observer
  15.   for (_FBKVOInfo *info in infos) {
  16.     if (info->_state == _FBKVOInfoStateObserving) {
  17.       [object removeObserver:self forKeyPath:info->_keyPath context:(void *)info];
  18.     }
  19.     info->_state = _FBKVOInfoStateNotObserving;
  20.   }
  21. }

  • 调用系统KVO的removeObserver方法，移除观察者

  • 销毁流程：VC销毁→FBKVOController销毁→调用中介者的unobserve方法→移除观察者

4.3 扩展

4.3.1 NSSet与NSHashTable

  • NSSet是排重后的object集合，NSHashTable是NSSet的容器，并且只有可变版本，允许对添加到容器中的对象是弱引用的持有关系，当NSHashTable中的对象销毁时，该对象也会从容器中移除

4.3.2 NSDictionary与NSMapTable

  • NSMapTable与NSDictionary类似，唯一区别是多一个功能，可设置key和value的NSPointerFunctionsOptions

  • NSDictionary的key策略固定是copy，考虑到开销问题，一般使用简单的数字或字符串作为key。但如果碰到使用object作为key的场景，使用NSMapTable更为适宜

  • NSMapTable可通过NSFunctionsPointer来分别定义对key和value的内存管理策略，简单可以分为 strong、weak以及copy

4.3.3 NSSet的member方法

在FBKVOController中，注册观察者方法，每次都创建_FBKVOInfo类型的临时变量info
image.png

将info传入关联方法中，使用NSSet的member方法，判断info是否存在
image.png

这里有个疑问，既然info是每次都创建的临时变量，每次的地址一定是不同的，使用NSSet的member方法，是根据什么来判断info是否存在的？

NSSet的member方法：确定给定的对象是否存在于集合中，如果存在则返回该对象

  1. - (ObjectType)member:(ObjectType)object;
  • 将检查集合中的每个元素是否与object相等，直到找到匹配项或到达集合的末尾。如果isEqual:返回YES，则认为对象是相等的

也就是说，NSSet的member方法，依赖于object对象的isEqual:方法，如果该方法返回YES，则认为对象是相等的

找到_FBKVOInfo的isEqual方法：

  1. - (BOOL)isEqual:(id)object
  2. {
  3.   if (nil == object) {
  4.     return NO;
  5.   }
  6.   if (self == object) {
  7.     return YES;
  8.   }
  9.   if (![object isKindOfClass:[self class]]) {
  10.     return NO;
  11.   }
  12.   return [_keyPath isEqualToString:((_FBKVOInfo *)object)->_keyPath];
  13. }
  • 最终判断两个对象的keyPath是否相同，所以即使info的地址不一样，也有可能被判断为相同对象

5. GNUstep Base

5.1 addObserver

image.png

  • setup：开始准备阶段
  • replacementForClass：生成动态子类

image.png

  • 保存info

image.png

  • 多级keyPath的处理

5.1.1 setup

image.png

  • 开始准备阶段

5.1.2 replacementForClass

image.png

  • 通过c查找r，存在直接返回
  • 不存在，调用GSKVOReplacement的initWithClass初始化r，添加到表中

5.1.3 GSKVOReplacement的initWithClass方法

image.png

  • GSObjCMakeClass：动态生成子类
  • GSObjCAddClasses：注册到内存
  • GSObjCAddClassBehavior：添加方法并重写

5.2 setter

image.png

  • 判断automaticallyNotifiesObserversForKey方法的返回
  • 返回YES
    • 调用willChangeValueForKey
    • 调用imp
    • 调用didChangeValueForKey
  • 返回NO
    • 调用imp

5.2.1 didChangeValueForKey

image.png

  • notifyForKey：发送通知

5.2.2 notifyForKey

image.png

  • 让观察者触发相应，触发KVO的observeValueForKeyPath回调

5.3 removeObserver

image.png

  • 通过哈希表找到pathInfo
  • pathInfo不为空，获取到observer
  • 开始移除观察者

对于isa的处理，重写GSKVOBase的dealloc方法

  1. - (void) dealloc
  2. {
  3.   // Turn off KVO for self ... then call the real dealloc implementation.
  4.   [self setObservationInfo: nil];
  5.   object_setClass(self, [self class]);
  6.   [self dealloc];
  7.   GSNOSUPERDEALLOC;
  8. }