OC底层原理16 ：KVO 底层原理

KVO，全称为Key-Value observing，中文名为键值观察，KVO是一种机制，它允许将其他对象的指定属性的更改通知给对象。

在Key-Value Observing Programming Guide官方文档中，又这么一句话：理解KVO之前，必须先理解KVC（即KVO是基于KVC基础之上，KVO底层也是由KVC实现的）

In order to understand key-value observing, you must first understand key-value coding.
KVC是键值编码，在对象创建完成后，可以动态的给对象属性赋值.
而KVO是键值观察，提供了一种监听机制，当指定的对象的属性被修改后，则对象会收到通知，所以可以看出KVO是基于KVC的基础上对属性动态变化的监听.

在iOS日常开发中，经常使用KVO来监听对象属性的变化，并及时做出响应，即当指定的被观察的对象的属性被修改后，KVO会自动通知相应的观察者，那么KVO与NSNotificatioCenter有什么区别呢？

• 相同点

  • 1、两者的实现原理都是观察者模式，都是用于监听
  • 2、都能实现一对多的操作

• 不同点

  • 1、KVO只能用于监听对象属性的变化，并且属性名都是通过NSString来查找，编译器不会帮你检测对错和补全,纯手敲会比较容易出错
  • 2、NSNotification的发送监听（post）的操作我们可以控制，kvo由系统控制。
  • 3、KVO可以记录新旧值变化

KVO 使用注意事项

1、基本使用

KVO的基本使用主要分为3步：

• 注册观察者addObserver:forKeyPath:options:context

[self.person addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];//context的类型是 nullable void *，应该是NULL，而不是nil

• 实现KVO回调observeValueForKeyPath:ofObject:change:context

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
    if ([keyPath isEqualToString:@"name"]) {
        NSLog(@"%@",change);
    }
}

• 移除观察者removeObserver:forKeyPath:context

[self.person removeObserver:self forKeyPath:@"nick" context:NULL];

2、context使用

在官方文档中，针对参数context有如下说明： 大致含义就是：addObserver：forKeyPath：options：context：方法中的上下文context指针包含任意数据，这些数据将在相应的更改通知中传递回观察者。
可以通过指定context为NULL，依靠keyPath即键路径字符串确定更改通知的来源，但是这种方法可能会导致对象的父类 由于不同的原因也观察到相同的键路径而导致问题。所以可以为每个观察到的keyPath创建一个不同的context，从而完全不需要进行字符串比较，从而可以更有效地进行通知解析.

通俗的讲，context上下文主要是用于区分不同对象的同名属性，从而在KVO回调方法中可以直接使用context进行区分，可以大大提升性能，以及代码的可读性.

context使用总结

• 不使用context，使用keyPath区分通知来源

//context的类型是 nullable void *，应该是NULL，而不是nil
[self.person addObserver:self forKeyPath:@"nick" options:NSKeyValueObservingOptionNew context:NULL];

• 使用context区分通知来源

//定义context
static void *PersonNickContext = &PersonNickContext;
static void *PersonNameContext = &PersonNameContext;

//注册观察者
[self.person addObserver:self forKeyPath:@"nick" options:NSKeyValueObservingOptionNew context:PersonNickContext];
[self.person addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:PersonNameContext];
    
    
//KVO回调
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
    if (context == PersonNickContext) {
        NSLog(@"%@",change);
    }else if (context == PersonNameContext){
        NSLog(@"%@",change);
    }
}

3、移除KVO通知的必要性

在官方文档中，针对KVO的移除有以下几点说明 删除观察者时，请记住以下几点：

• 要求被移除为观察者（如果尚未注册为观察者）会导致NSRangeException。您可以对removeObserver：forKeyPath：context：进行一次调用，以对应对addObserver：forKeyPath：options：context：的调用，或者，如果在您的应用中不可行，则将removeObserver：forKeyPath：context：调用在try / catch块内处理潜在的异常。
• 释放后，观察者不会自动将其自身移除。被观察对象继续发送通知，而忽略了观察者的状态。但是，与发送到已释放对象的任何其他消息一样，更改通知会触发内存访问异常。因此，您可以确保观察者在从内存中消失之前将自己删除。
• 该协议无法询问对象是观察者还是被观察者。构造代码以避免发布相关的错误。一种典型的模式是在观察者初始化期间（例如，在init或viewDidLoad中）注册为观察者，并在释放过程中（通常在dealloc中）注销，以确保成对和有序地添加和删除消息，并确保观察者在注册之前被取消注册，从内存中释放出来。

所以，总的来说，KVO注册观察者 和移除观察者是需要成对出现的，如果只注册，不移除，会出现类似野指针的崩溃，如下图所示:

崩溃的原因是，由于第一次注册KVO观察者后没有移除，再次进入界面，会导致第二次注册KVO观察者，导致KVO观察的重复注册，而且第一次的通知对象还在内存中，没有进行释放，此时接收到属性值变化的通知，会出现找不到原有的通知对象，只能找到现有的通知对象，即第二次KVO注册的观察者，所以导致了类似野指针的崩溃，即一直保持着一个野通知，且一直在监听.

注：这里的崩溃案例是通过单例对象实现（崩溃有很大的几率，不是每次必现），因为单例对象在内存是常驻的，针对一般的类对象，貌似不移除也是可以的，但是为了防止线上意外，建议还是移除比较好.

如果未注册，却移除，则会报错***** Terminating app due to uncaught exception 'NSRangeException', reason: 'Cannot remove an observer <LGViewController 0x7fcfc7208cf0> for the key path "监测的keyPath" from <LGPerson 0x6000016a1dc0> because it is not registered as an observer.'**

所以注册和移除一定是成对出现。

4、KVO的自动触发与手动触发

KVO观察的开启和关闭有两种方式，自动和手动

// 自动开关
+ (BOOL) automaticallyNotifiesObserversForKey:(NSString *)key{
      //if([key isEqualToString:@"age"]){
      //    return NO;
      // }
    return YES;
}

• 自动开关，返回NO，就监听不到，返回YES，表示监听
  • 若返回YES打开自动开关后，会自动实现setName方法，可不用户手动实现
  • 针对开发中 如果某情形下观察某情形不观察 可以在这里设置宏条件区分处理
• 自动开关关闭的时候，可以通过手动开关监听

- (void)setName:(NSString *)name{
    //手动开关
    [self willChangeValueForKey:@"name"];
    _name = name;
    [self didChangeValueForKey:@"name"];
}

使用手动开关的好处就是你想监听就监听，不想监听关闭即可，比自动触发更方便灵活。

5、KVO观察：一对多 (嵌套)

KVO观察中的一对多，意思是通过注册一个KVO观察者，可以监听多个属性的变化

以下载进度为例，比如目前有一个需求，需要根据总的下载量totalData 和当前下载量currentData 来计算当前的下载进度currentProcess，实现有两种方式

• 分别观察 总的下载量totalData 和当前下载量currentData 两个属性，当其中一个发生变化计算 当前下载进度currentProcess
• 实现keyPathsForValuesAffectingValueForKey方法，将两个观察合为一个观察，即观察当前下载进度currentProcess

//1、合二为一的观察方法
+ (NSSet<NSString *> *)keyPathsForValuesAffectingValueForKey:(NSString *)key{
    
    NSSet *keyPaths = [super keyPathsForValuesAffectingValueForKey:key];
    if ([key isEqualToString:@"currentProcess"]) {
        NSArray *affectingKeys = @[@"totalData", @"currentData"];
        keyPaths = [keyPaths setByAddingObjectsFromArray:affectingKeys];
    }
    return keyPaths;
}

//2、注册KVO观察
[self.person addObserver:self forKeyPath:@"currentProcess" options:(NSKeyValueObservingOptionNew) context:NULL];

//3、触发属性值变化
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    self.person.currentData += 10;
    self.person.totalData  += 1;
}

//4、移除观察者
- (void)dealloc{
    [self.person removeObserver:self forKeyPath:@"currentProcess"];
}

6、KVO观察 可变数组

KVO是基于KVC基础之上的，所以可变数组如果直接添加数据，是不会调用setter方法的，所有对可变数组的KVO观察下面这种方式不生效的,即直接通过[self.person.dateArray addObject:@"1"];向数组添加元素，是不会触发kvo通知回调的.

//1、注册可变数组KVO观察者
self.person.dateArray = [NSMutableArray arrayWithCapacity:1];
    [self.person addObserver:self forKeyPath:@"dateArray" options:(NSKeyValueObservingOptionNew) context:NULL];
    
//2、KVO回调
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
    NSLog(@"%@",change);
}

//3、移除观察者
- (void)dealloc{
 [self.person removeObserver:self forKeyPath:@"dateArray"];
}

//4、触发数组添加数据
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    [self.person.dateArray addObject:@"1"]; //不会触发kvo通知回调
}

在KVC官方文档中，针对可变数组的集合类型，有如下说明，即访问集合对象需要需要通过mutableArrayValueForKey方法，这样才能将元素添加到可变数组中:

修改

将4中的代码修改如下:

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    // KVC 集合 array
    [[self.person mutableArrayValueForKey:@"dateArray"] addObject:@"1"];
}

运行结果如下，可以看到，元素被添加到可变数组了:

其中的kind表示键值变化的类型，是一个枚举，主要有以下4种:

typedef NS_ENUM(NSUInteger, NSKeyValueChange) {
    NSKeyValueChangeSetting = 1,//设值
    NSKeyValueChangeInsertion = 2,//插入
    NSKeyValueChangeRemoval = 3,//移除
    NSKeyValueChangeReplacement = 4,//替换
};

一般的属性与集合的KVO观察是有区别的，其kind不同，以属性name 和 可变数组为例

• 属性的kind一般是设值

• 可变数组的kind一般是插入

KVO 底层原理探索

测试代码

在KVO的官方使用指南中，有如下说明：

• KVO是使用isa-swizzling的技术实现的。

• 顾名思义，isa指针指向维护分配表的对象的类。该分派表实质上包含指向该类实现的方法的指针以及其他数据。

• 当为对象的属性注册观察者时，将修改观察对象的isa指针，指向中间类而不是真实类。结果，isa指针的值不一定反映实例的实际类。

• 您永远不应依靠isa指针来确定类成员身份。相反，您应该使用class方法来确定对象实例的类。

代码调试探索

1、KVO只对属性观察

在LGPerson中有一个成员变量name 和 属性nickName，分别注册KVO观察，触发属性变化时，会有什么现象？

• 分别为成员变量name 和 属性nickName注册KVO观察：

self.person = [[LGPerson alloc] init];
[self.person addObserver:self forKeyPath:@"nickName" options:(NSKeyValueObservingOptionNew) context:NULL];
[self.person addObserver:self forKeyPath:@"name" options:(NSKeyValueObservingOptionNew) context:NULL];

• KVO通知触发操作

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    NSLog(@"实际情况:%@-%@",self.person.nickName,self.person->name);
    self.person.nickName = @"KC";
    self.person->name    = @"Cooci";
}

运行结果如下：

结论：KVO对成员变量不观察，只对属性观察，属性和成员变量的区别在于属性多一个 setter 方法，而KVO恰好观察的是setter 方法.

2、中间类

根据官方文档所述，在注册KVO观察者后，观察对象的isa指针指向会发生改变

• 注册观察者之前：实例对象person的isa指针指向LGPerson
• 注册观察者之后：实例对象person的isa指针指向NSKVONotifying_LGPerson 综上所述，在注册观察者后，实例对象的isa指针指向由LGPerson类变为了NSKVONotifying_LGPerson中间类，即实例对象的isa指针指向发生了变化.

2-1、判断中间类是否是派生类 即子类？

那么这个动态生成的中间类NSKVONotifying_LGPerson和LGPerson类 有什么关系？下面通过代码来验证

可以通过下面封装的方法，获取LGPerson的相关类:

#pragma mark - 遍历类以及子类
- (void)printClasses:(Class)cls{
    
    // 注册类的总数
    int count = objc_getClassList(NULL, 0);
    // 创建一个数组， 其中包含给定对象
    NSMutableArray *mArray = [NSMutableArray arrayWithObject:cls];
    // 获取所有已注册的类
    Class* classes = (Class*)malloc(sizeof(Class)*count);
    objc_getClassList(classes, count);
    for (int i = 0; i<count; i++) {
        if (cls == class_getSuperclass(classes[i])) {
            [mArray addObject:classes[i]];
        }
    }
    free(classes);
    NSLog(@"classes = %@", mArray);
}

//********调用********
[self printClasses:[LGPerson class]];

打印结果如下所示:

从结果中可以说明NSKVONotifying_LGPerson是LGPerson的子类.

2-2、中间类中有什么？

可以通过下面的方法获取NSKVONotifying_LGPerson类中的所有方法

#pragma mark - 遍历方法-ivar-property
- (void)printClassAllMethod:(Class)cls{
    unsigned int count = 0;
    Method *methodList = class_copyMethodList(cls, &count);
    for (int i = 0; i<count; i++) {
        Method method = methodList[i];
        SEL sel = method_getName(method);
        IMP imp = class_getMethodImplementation(cls, sel);
        NSLog(@"%@-%p",NSStringFromSelector(sel),imp);
    }
    free(methodList);
}

//********调用********
[self printClassAllMethod:objc_getClass("NSKVONotifying_LGPerson")];

输出结果如下：

从结果中可以看出有四个方法，分别是setNickName 、 class 、 dealloc 、 _isKVOA，这些方法是继承还是重写？

• 我们新建一个类LGStudent，继承自LGPerson，打印LGStudent类的所有方法
• 在LGStudent中重写setNickName方法，获取LGStudent类的所有方法

与中间类的方法进行的对比说明只有重写的方法，才会在子类的方法列表中遍历打印出来，而继承的方法不会在子类遍历出来。

• 获取LGPerson和NSKVONotifying_LGPerson的方法列表进行对比 综上所述，有如下结论：

• NSKVONotifying_LGPerson中间类重写了父类LGPerson的setNickName方法

• NSKVONotifying_LGPerson中间类重写了基类NSObject的class 、 dealloc 、 _isKVOA方法

  • 其中dealloc是释放方法
  • _isKVOA判断当前是否是kvo类

2-3、dealloc中移除观察者后，isa指向是谁，以及中间类是否会销毁？

• 移除观察者之前：实例对象的isa指向仍是NSKVONotifying_LGPerson中间类

• 移除观察者之后：实例对象的isa指向更改为LGPerson类

所以，在移除kvo观察者后，isa的指向由NSKVONotifying_LGPerson变成了LGPerson.

细节：如果注册了name，在dealloc中未移除name，则isa还是指向LGPerson

那么中间类NSKVONotifying_LGPerson从创建后，到dealloc方法中移除观察者之后，是否还存在？

• 在上一级界面打印LGPerson的子类情况，用于判断中间类是否销毁

通过子类的打印结果可以看出，中间类一旦生成，没有移除，没有销毁，还在内存中 -- 主要是考虑重用的想法，即中间类注册到内存中，为了考虑后续的重用问题，所以中间类一直存在.

总结

综上所述，关于中间类，有如下说明：

• 实例对象isa的指向在注册KVO观察者之后，由原有类更改为指向中间类
• 中间类重写了观察属性的setter方法、class、dealloc、_isKVOA方法
• dealloc方法中，移除KVO观察者之后，实例对象isa指向由中间类更改为原有类
• 中间类从创建后，就一直存在内存中，不会被销毁

自定义KVO

完整代码

说明： 关于文中前缀cjl或lg，cjl是参考作者文章的图和代码 本文有些是我后续补充的点是用的lg 不必纠结这个细节

自定KVO的流程，跟系统一致，只是在系统的基础上针对其中的部分做了一些优化处理。

• 1、将注册和响应通过函数式编程，即block的方法结合在一起
• 2、去掉系统繁琐的三部曲，实现KVO自动销毁机制

  注册观察者
  [self.person addObserver:self forKeyPath:@"nickName" options:(NSKeyValueObservingOptionNew) context:NULL];
  
  KVO相应回调
  - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
      NSLog(@"%@",change);
  }
  移除观察者
  - (void)dealloc{
      [self.person removeObserver:self forKeyPath:@"nickName"];
  }
  

在系统中，注册观察者和KVO响应属于响应式编程，是分开写的，在自定义KVO中 为了代码更好的协调，使用block的形式，将注册和回调的逻辑组合在一起，即采用函数式编程方式，还是分为三部分:

• 注册观察者

  //*********定义block*********
  typedef void(^LGKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);
  
  //*********注册观察者*********
  - (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block;
  

• KVO响应 这部分主要是通过重写setter方法，在中间类的setter方法中，通过block的方式传递给外部进行响应
• 移除观察者

  //*********移除观察者*********
  - (void)lg_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;
  

创建NSObject分类LGKVO,主要在此文件实现自定义的KVO方法。

注册观察者

在注册观察者方法中，主要有以下几部分操作：

1、判断当前观察值keyPath的setter方法是否存在

#pragma mark - 验证是否存在setter方法
- (void)judgeSetterMethodFromKeyPath:(NSString *)keyPath
{
    Class superClass = object_getClass(self);
    SEL setterSelector = NSSelectorFromString(setterForGetter(keyPath));
    Method setterMethod = class_getInstanceMethod(superClass, setterSelector);
    if (!setterMethod) {
        @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"CJLKVO - 没有当前%@的setter方法", keyPath] userInfo:nil];
    }
    
}

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

2、动态生成子类，将需要重写的class方法添加到中间类中

#pragma mark - 动态生成子类
- (Class)createChildClassWithKeyPath:(NSString *)keyPath
{
    //获取原本的类名
    NSString  *oldClassName = NSStringFromClass([self class]);
    //拼接新的类名
    NSString *newClassName = [NSString stringWithFormat:@"%@%@",kCJLKVOPrefix,oldClassName];//kLGKVOPrefix = @"LGKVONotifying_";
    //获取新类
    Class newClass = NSClassFromString(newClassName);
    //如果子类存在，则直接返回 防止重复创建生成新类
    if (newClass) return newClass;
    //2.1 申请类
    /**
     * 如果内存不存在,创建生成
     * 参数一: 父类
     * 参数二: 新类的名字
     * 参数三: 新类的开辟的额外空间
     */
    newClass = objc_allocateClassPair([self class], newClassName.UTF8String, 0);
    //2.2 注册类
    objc_registerClassPair(newClass);
    //2.3 添加class（重写class方法） : class的指向是LGPerson
    SEL classSel = @selector(class);
    Method classMethod = class_getInstanceMethod([self class], classSel);
    const char *classType = method_getTypeEncoding(classMethod);
    class_addMethod(newClass, classSel, (IMP)cjl_class, classType);

    return newClass;
}

//*********class方法*********
#pragma mark - 重写class方法，为了与系统类对外保持一致
Class cjl_class(id self, SEL _cmd){
    //在外界调用class返回CJLPerson类
    return class_getSuperclass(object_getClass(self));//通过[self class]获取会造成死循环
}

3、isa指向由原有类，改为指向中间类

object_setClass(self, newClass);

4、保存信息：为了方便演示这里用的数组，也可以使用map，需要创建信息的model模型类

//*********KVO信息的模型类/*********
#pragma mark 信息model类
@interface CJLKVOInfo : NSObject

@property(nonatomic, weak) NSObject *observer;
@property(nonatomic, copy) NSString *keyPath;
@property(nonatomic, copy) LGKVOBlock handleBlock;

- (instancetype)initWithObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block;

@end
@implementation CJLKVOInfo

- (instancetype)initWithObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block{
    if (self = [super init]) {
        _observer = observer;
        _keyPath = keyPath;
        _handleBlock = block;
    }
    return self;  
}
@end

//*********保存信息*********
//- 保存多个信息
CJLKVOInfo *info = [[CJLKVOInfo alloc] initWithObserver:observer forKeyPath:keyPath handleBlock:block];
//使用数组存储 -- 也可以使用map
NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey));
if (!mArray) {//如果mArray不存在，则重新创建
    mArray = [NSMutableArray arrayWithCapacity:1];
    objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey), mArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
[mArray addObject:info];

完整的注册观察者代码如下：

#pragma mark - 注册观察者 - 函数式编程
- (void)cjl_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block{
    
    //1、验证是否存在setter方法
    [self judgeSetterMethodFromKeyPath:keyPath];
    
    //保存信息
    //- 保存多个信息
    CJLKVOInfo *info = [[CJLKVOInfo alloc] initWithObserver:observer forKeyPath:keyPath handleBlock:block];
    //使用数组存储 -- 也可以使用map
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey));
    if (!mArray) {//如果mArray不存在，则重新创建
        mArray = [NSMutableArray arrayWithCapacity:1];
        objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey), mArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }
    [mArray addObject:info];
    
    //判断automaticallyNotifiesObserversForKey方法返回的布尔值
    BOOL isAutomatically = [self cjl_performSelectorWithMethodName:@"automaticallyNotifiesObserversForKey:" keyPath:keyPath];
    if (!isAutomatically) return;
    
    //2、动态生成子类、
    /*
        2.1 申请类
        2.2 注册
        2.3 添加方法（重写setter方法）
     */
    Class newClass = [self createChildClassWithKeyPath:keyPath];
    //3、isa指向
    object_setClass(self, newClass);
    
    //重写setter方法
    //获取sel
    SEL setterSel = NSSelectorFromString(setterForGetter(keyPath));
    //获取setter实例方法
    Method method = class_getInstanceMethod([self class], setterSel);
    //方法签名
    const char *type = method_getTypeEncoding(method);
    //添加一个setter方法
    class_addMethod(newClass, setterSel, (IMP)cjl_setter, type); 
}

注意点

• 关于objc_msgSend的检查关闭：target -> Build Setting -> Enable Strict Checking of objc_msgSend Calls 设置为NO

• class方法必须重写，其目的是为了与系统一样，对外的类保持一致。

  先补充下class和``源码实现：

  - (Class)class {
      return object_getClass(self);
  }
  
  /***********************************************************************
  * object_getClassName.
  **********************************************************************/
  const char *object_getClassName(id obj)
  {
      return class_getName(obj ? obj->getIsa() : nil);
  }
  
  
  /***********************************************************************
  * object_getClass.
  * Locking: None. If you add locking, tell gdb (rdar://7516456).
  **********************************************************************/
  Class object_getClass(id obj)
  {
      if (obj) return obj->getIsa();
      else return Nil;
  }
  

  • 系统的KVO，在添加观察者前后，实例对象person的类一直都是CJLPerson

    

    • 通过class打印和object_getClassName打印如下： 系统KVO会自动在中间类NSKVONotifying_LGPerson重写class方法 而用object_getClassName是获取的真实的类名

  • 自定义KVO

    • 如果没有重写class方法，自定的KVO在注册前后的实例对象person的class就会看到是不一致的,注册后是CJLKVONotifying_LGPerson
    • 重写后class方法后的自定义KVO，在注册观察者前后其实例对象类的显示，与系统的显示是一致的

KVO响应

主要是给子类动态添加setter方法，其目的是为了在setter方法中向父类发送消息，告知其属性值的变化。

5、将setter方法重写添加到子类中（主要是在注册观察者方法中添加）

//获取sel
    SEL setterSel = NSSelectorFromString(setterForGetter(keyPath));
    //获取setter实例方法
    Method method = class_getInstanceMethod([self class], setterSel);
    //方法签名
    const char *type = method_getTypeEncoding(method);
    //添加一个setter方法
    class_addMethod(newClass, setterSel, (IMP)cjl_setter, type);

6、通过将系统的objc_msgSendSuper强制类型转换自定义的消息发送cjl_msgSendSuper

//往父类LGPerson发消息 - 通过objc_msgSendSuper
//通过系统强制类型转换自定义objc_msgSendSuper
void (*cjl_msgSendSuper)(void *, SEL, id) = (void *)objc_msgSendSuper;
//定义一个结构体
struct objc_super superStruct = {
    .receiver = self, //消息接收者 为 当前的self
    .super_class = class_getSuperclass(object_getClass(self)), //第一次快捷查找的类 为 父类
};
//调用自定义的发送消息函数
cjl_msgSendSuper(&superStruct, _cmd, newValue);

7、告知vc去响应：获取信息，通过block传递

/*---函数式编程*/
    NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));
    id oldValue = [self valueForKey:keyPath];
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey));
    for (CJLKVOInfo *info in mArray) {
        NSMutableDictionary<NSKeyValueChangeKey, id> *change = [NSMutableDictionary dictionaryWithCapacity:1];
        if ([info.keyPath isEqualToString:keyPath] && info.handleBlock) {    
           info.handleBlock(info.observer, keyPath, oldValue, newValue);
        }
    }

完整的setter方法代码如下：

static void cjl_setter(id self, SEL _cmd, id newValue){
    NSLog(@"来了:%@",newValue);
   
    //往父类LGPerson发消息 - 通过objc_msgSendSuper
    //通过系统强制类型转换自定义objc_msgSendSuper
    void (*cjl_msgSendSuper)(void *, SEL, id) = (void *)objc_msgSendSuper;
    //定义一个结构体
    struct objc_super superStruct = {
        .receiver = self, //消息接收者 为 当前的self
        .super_class = class_getSuperclass(object_getClass(self)), //第一次快捷查找的类 为 父类
    };
    //调用自定义的发送消息函数
    cjl_msgSendSuper(&superStruct, _cmd, newValue);
    
    //此时应该有didChange的代码
    
    //让vc去响应
    /*---函数式编程*/
    NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));
    id oldValue = [self valueForKey:keyPath];
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey));
    for (CJLKVOInfo *info in mArray) {
        NSMutableDictionary<NSKeyValueChangeKey, id> *change = [NSMutableDictionary dictionaryWithCapacity:1];
        if ([info.keyPath isEqualToString:keyPath] && info.handleBlock) {
            
           info.handleBlock(info.observer, keyPath, oldValue, newValue);
        }
    }
}

移除观察者

为了避免在外界不断的调用removeObserver方法，在自定义KVO中实现自动移除观察者

8、实现cjl_removeObserver:forKeyPath:方法，主要是清空数组，以及isa指向更改

- (void)cjl_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath{
    
    //清空数组
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey));
    if (mArray.count <= 0) {
        return;
    }
    
    for (CJLKVOInfo *info in mArray) {
        if ([info.keyPath isEqualToString:keyPath]) {
            [mArray removeObject:info];
            objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kCJLKVOAssociateKey), mArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
        }
    }
    
    if (mArray.count <= 0) {
        //isa指回父类
        Class superClass = [self class];
        object_setClass(self, superClass);
    }
}

9、在子类中重写dealloc方法，当子类销毁时，会自动调用dealloc方法（在动态生成子类的方法中添加）

#pragma mark - 动态生成子类
- (Class)createChildClassWithKeyPath:(NSString *)keyPath
{
    //...
    
    //添加dealloc 方法
    SEL deallocSel = NSSelectorFromString(@"dealloc");
    Method deallocMethod = class_getInstanceMethod([self class], deallocSel);
    const char *deallocType = method_getTypeEncoding(deallocMethod);
    class_addMethod(newClass, deallocSel, (IMP)cjl_dealloc, deallocType);
    
    return newClass;
}

//************重写dealloc方法*************
void cjl_dealloc(id self, SEL _cmd){
    NSLog(@"来了");
    Class superClass = [self class];
    object_setClass(self, superClass);
}

其原理主要是：CJLPerson发送消息释放即dealloc了，就会自动走到重写的cjl_dealloc方法中（原因是因为person对象的isa指向变了，指向中间类，但是实例对象的地址是不变的，所以子类的释放，相当于释放了外界的person，而重写的cjl_dealloc相当于是重写了CJLPerson的dealloc方法，所以会走到cjl_dealloc方法中），达到自动移除观察者的目的

总结

综上所述，自定义KVO大致分为以下几步

• 注册观察者 & 响应

  • 1、验证是否存在setter方法
  • 2、保存信息
  • 3、动态生成子类，需要重写class、setter方法
  • 4、在子类的setter方法中向父类发消息，即自定义消息发送
  • 5、让观察者响应

• 移除观察者

  • 1、更改isa指向为原有类
  • 2、重写子类的dealloc方法

拓展

以上自定义的逻辑并不完善，只是阐述了KVO底层原来实现的大致逻辑，具体的可以参考facebook的KVO三方框架FBKVOController

引用

本文学习引用iOS-底层原理 23：KVO 底层原理,在此致谢

文章列表