iOS KVO 底层原理

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

在Key-Value Observing Programming Guide官方文档中，又这么一句话：理解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];

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

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)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 *)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注册的观察者，所以导致了类似野指针的崩溃，即一直保持着一个野通知，且一直在监听

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

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

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

自动开关，返回NO，就监听不到，返回YES，表示监听

// 自动开关
+ (BOOL) automaticallyNotifiesObserversForKey:(NSString *)key{
    return YES;
}

自动开关关闭的时候，可以通过手动开关监听

- (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 *)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 *)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 *)change context:(void *)context{
    NSLog(@"%@",change);
}

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

//4、触发数组添加数据
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
    [self.person.dateArray addObject:@"1"];
}

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

修改

将4中的代码修改如下

- (void)touchesBegan:(NSSet *)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一般是插入

代码调试探索

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 *)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

 
 打印结果如下所示 
  
   
    
     
      
       
      
     
     
    
  
 从结果中可以说明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
 
 输出结果如下 
  
   
    
     
      
       
      
     
     
    
  
 从结果中可以看出有四个方法，分别是setNickName 、 class 、 dealloc 、 _isKVOA，这些方法是继承还是重写？ 
  
   在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 
 那么中间类从创建后，到dealloc方法中移除观察者之后，是否还存在？ 
  
   在上一级界面打印LGPerson的子类情况，用于判断中间类是否销毁 
    
     
      
       
      
     
     
   
  
  
 通过子类的打印结果可以看出，中间类一旦生成，没有移除，没有销毁，还在内存中 -- 主要是考虑重用的想法，即中间类注册到内存中，为了考虑后续的重用问题，所以中间类一直存在 
 总结 
 综上所述，关于中间类，有如下说明： 
  
  实例对象isa的指向在注册KVO观察者之后，由原有类更改为指向中间类 
  中间类重写了观察属性的setter方法、class、dealloc、_isKVOA方法 
  dealloc方法中，移除KVO观察者之后，实例对象isa指向由中间类更改为原有类 
  中间类从创建后，就一直存在内存中，不会被销毁 
  
 自定义KVO 
 自定KVO的流程，跟系统一致，只是在系统的基础上针对其中的部分做了一些优化处理。 
  
  1、将注册和响应通过函数式编程，即block的方法结合在一起 
  2、去掉系统繁琐的三部曲，实现KVO自动销毁机制
 在系统中，注册观察者和KVO响应属于响应式编程，是分开写的，在自定义为了代码更好的协调，使用block的形式，将注册和回调的逻辑组合在一起，即采用函数式编程方式，还是分为三部分 
  注册观察者 
  
 //*********定义block*********
typedef void(^LGKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);

//*********注册观察者*********
- (void)cjl_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(LGKVOBlock)block;
 
  
  KVO响应
 这部分主要是通过重写setter方法，在中间类的setter方法中，通过block的方式传递给外部进行响应 
  移除观察者 
  
 //*********移除观察者*********
- (void)cjl_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;
 
 准备条件：创建NSObject类的分类CJLJVO 
 注册观察者 
 在注册观察者方法中，主要有以下几部分操作： 
  
  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];
    }
    
}
 
 2、动态生成子类，将需要重写的class方法添加到中间类中 
 #pragma mark - 动态生成子类
- (Class)createChildClassWithKeyPath:(NSString *)keyPath
{
    //获取原本的类名
    NSString  *oldClassName = NSStringFromClass([self class]);
    //拼接新的类名
    NSString *newClassName = [NSString stringWithFormat:@"%@%@",kCJLKVOPrefix,oldClassName];
    //获取新类
    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 添加方法
    
    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 添加方法
     */
    Class newClass = [self createChildClassWithKeyPath:keyPath];
    //3、isa指向
    object_setClass(self, newClass);

    //获取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方法必须重写，其目的是为了与系统一样，对外的类保持一致，如下所示 
  
   系统的KVO，在添加观察者前后，实例对象person的类一直都是CJLPerson 
    
     
       
      
     
     
   
  
  
 如果没有重写class方法，自定的KVO在注册前后的实例对象person的class就会看到是不一致的,返回的isa更改后的类，即中间类 
  
   
    
     
       
      
     
     
    
  重写后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 *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);
    
    //此时应该有willChange的代码
    
    //往父类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 *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三方框架KVOController

iOS KVO 底层原理

KVO 使用注意事项

1、基本使用

2、context使用

3、移除KVO通知的必要性

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

5、KVO观察：一对多

6、KVO观察 可变数组

代码调试探索

1、KVO只对属性观察

2、中间类

自定义KVO

注册观察者

KVO响应

移除观察者

总结

你可能感兴趣的:(iOS KVO 底层原理)

6、KVO观察可变数组