KVO 基础知识

KVO, 英文全称 Key-Value observing, 中文全称键值观察。KVO是一种机制，当指定的对象属性被修改后，则对象就会接受到通知（简单的说就是每次指定的被观察的对象属性被修改后，KVO 就会自动通知相应的观察者）。

通过 Key-Value Observing Programming Guide 官方文档，我们了解到

1. KVO 是建立在 KVC 基础之上

KVC 是键值编码，创建对象后，可以通过 KVC 动态的给对象属性赋值。
KVO 是键值观察，提供一种监听机制。当指定的对象属性被修改后，则对象会收到通知。
因此可以看出 KVO 是建立在 KVC 的基础上对属性动态变化的监听。

2. KVO 基本使用（注册、实现回调、移除）三部曲

- 注册观察者

objectivec 复制代码

[self.person addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];

参数observer为观察者：观察对象通过上面方法发送消息向观察对象进行注册，并将自身作为观察者传递。
参数keyPath为属性路径：在注册时观察者将观察的属性路径专递给观察对象。
参数options为观察选项：影响通知中提供的字典的内容以及生成通知的方式。枚举类型：NSKeyValueObservingOptions

objectivec 复制代码

typedef NS_OPTIONS(NSUInteger, NSKeyValueObservingOptions) {
    NSKeyValueObservingOptionNew,     // 使通知中发送的字典中包含 NSKeyValueChangeNewKey 键，用于包含属性发生改变后的新值
    NSKeyValueObservingOptionOld,     // 使通知中发送的字典中包含NSKeyValueObservingOptionOld键，用于包含属性发生改变前的旧值
    NSKeyValueObservingOptionInitial, // 会在注册的时候使观察方法调用一次
    NSKeyValueObservingOptionPrior    // 会在观察属性值改变的前后均调用一次。其中在变化前调用那一次，会使 NSKeyValueObservingOptionNew 对应的值为 NULL，而 NSKeyValueObservingOptionOld 对应改变前的值。多用在开发者手动创建支持的 KVO 中
};

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

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

*不使用 context 时, 则直接传 NULL，而不是 nil。因为 context 的类型是 nullable void 。

objectivec 复制代码

[self.person addObserver:self forKeyPath:@"nick" options:NSKeyValueObservingOptionNew context:NULL];

使用 context

objectivec 复制代码

//定义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);
    }
}

- 实现 KVO 回调

erlang 复制代码

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

- 移除 KVO

objectivec 复制代码

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

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 的自动触发和手动触发

自动开关：重写这个方法，返回 NO，则不监听。返回 YES, 则监听。默认不重写则返回 YES。

objectivec 复制代码

+ (BOOL) automaticallyNotifiesObserversForKey:(NSString *)key{
    return YES;
}

自动开关设置为 NO 时，也可以通过手动开启监听。使用手动开关的好处就是你想监听就监听，不想监听关闭即可，比自动触发更方便灵活。

ini 复制代码

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

5. KVO 观察一对多

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

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

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

objectivec 复制代码

//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 通知回调的。所以必须通过[[self.person mutableArrayValueForKey:@"dateArray"] addObject:@"1"]这种方式。

从图中我们可以看到kind表示键值变化的类型，是一个枚举。主要有以下4种：

objectivec 复制代码

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 只对属性观察

分别定义成员变量 userName 和属性 nickName。

less 复制代码

@interface LGPerson : NSObject{
    @public
    NSString *userName;
}
@property (nonatomic, copy) NSString *nickName;

分别为成员变量userName 和属性 nickName注册KVO观察。

objectivec 复制代码

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

KVO通知触发操作。

objectivec 复制代码

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    NSLog(@"实际情况:%@-%@",self.person.nickName,self.person->userName);
    self.person->userName = @"Justin";
    self.person.nickName = @"黑之契约者";
}

运行结果如图：结论：通过代码测试发现 KVO 只对属性观察，成员变量不观察。属性和成员变量的区别在于属性多一个 setter 方法，而KVO恰好观察的是 setter 方法

2. 中间类

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

注册观察者之前：实例对象person的isa指针指向LGPerson

注册观察者之后：实例对象person的isa指针指向NSKVONotifying_LGPerson

结论：通过代码调试发现在注册观察者后，实例对象的 isa 指针指向由LGPerson类变成了NSKVONotifying_LGPerson中间类，即实例对象的isa指针指向发生了变化。
2.1 问题1：动态生成的中间类 NSKVONotifying_LGPerson 和 LGPerson 类有什么关系？ 可以通过下面封装的方法来验证，此方法可以遍历LGPerson类中的子类。

ini 复制代码

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

运行结果如图：结论：分别在添加 KVO 前和添加 KVO 后调用printClasses方法，从结果中可以说明NSKVONotifying_LGPerson是LGPerson的子类。

2.2 问题2：动态生成的中间类内部有哪些东西？

可以通过下面封装的方法来验证，此方法可以获取NSKVONotifying_LGPerson类中的所有方法。

ini 复制代码

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

运行结果如图：

从运行结果中我们看到有四个方法，分别是setNickName、class、dealloc、_isKVOA。这些方法是继承还是重写？

答：重写。可以新建一个LGStudent类继承LGPerson类，重写setNickName。然后调用

ini 复制代码

[self printClassAllMethod:[LGStudent Class]];

运行结果如图：

运行结果说明只有重写才会在子类的方法列表中遍历打印出来，而继承的不会在子类遍历出来。

因此结论：

NSKVONotifying_LGPerson中间类重写了父类LGPerson的setNickName方法
NSKVONotifying_LGPerson中间类重写了基类NSObject的class 、 dealloc 、 _isKVOA方法
其中dealloc是释放方法
_isKVOA判断当前是否是 KVO 类

2.3 问题3：dealloc 中移除观察者后，isa指向是谁，以及中间类是否会销毁？

移除观察者之前如图：

移除观察者之后如图：

结论：移除观察者之前，实例对象的 isa 指向仍是NSKVONotifying_LGPerson中间类。移除观察者之后：实例对象的 isa 指向更改为LGPerson类

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

运行结果：结论：当我们返回到上级之后，通过调用printClasses打印发现动态生成的子类还是存在的。由此可以确定中间类一旦生成，没有移除，没有销毁，还在内存中。主要是考虑重用的想法，即中间类注册到内存中，为了考虑后续的重用问题，所以中间类一直存在。
总结

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

自定义 KVO

自定义 KVO 只是帮助我们更好的理解 KVO 底层实现原理，个人并不建议在项目中去定义 KVO。想在项目中安全便捷的使用 KVO 的话，推荐使用 facebook 的开源第三方框架 KVOController有兴趣的小伙伴可以自行下载源码学习。

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

注册观察者

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

scss 复制代码

#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方法添加到中间类中。

objectivec 复制代码

#pragma mark - 动态生成子类
- (Class)createChildClassWithKeyPath:(NSString *)keyPath
{
    //获取原本的类名
    NSString *oldClassName = NSStringFromClass([self class]);
    //拼接新的类名
    NSString *newClassName = [NSString stringWithFormat:@"%@%@",kMPKVOPrefix,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 添加 class 方法
    SEL classSel = @selector(class);
    Method classMethod = class_getInstanceMethod([self class], classSel);
    const char *classType = method_getTypeEncoding(classMethod);
    class_addMethod(newClass, classSel, (IMP)mp_class, classType);
    return newClass;
}

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

isa 指向中间类。

scss 复制代码

object_setClass(self, newClass);

保存信息：这里用的数组，也可以使用 map，需要创建信息的model模型类。

objectivec 复制代码

//*********KVO信息的模型类/*********
#pragma mark 信息model类
@interface MPKVOInfo : 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 MPKVOInfo

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

//*********保存信息*********
//- 保存多个信息
MPKVOInfo *info = [[MPKVOInfo 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];

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

objectivec 复制代码

#pragma mark - 注册观察者 - 函数式编程
- (void)mp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(MPKVOBlock)block{
    
    //1、验证是否存在setter方法
    [self judgeSetterMethodFromKeyPath:keyPath];
    
    //保存信息
    //- 保存多个信息
    MPKVOInfo *info = [[MPKVOInfo alloc] initWithObserver:observer forKeyPath:keyPath handleBlock:block];
    //使用数组存储 -- 也可以使用map
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kMPKVOAssociateKey));
    if (!mArray) {//如果mArray不存在，则重新创建
        mArray = [NSMutableArray arrayWithCapacity:1];
        objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kMPKVOAssociateKey), mArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }
    [mArray addObject:info];
    
    //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)mp_setter, type); 
}

注：class方法必须重写，其目的是为了与系统一样，对外的类保持一致。
系统的KVO，在添加观察者前后，实例对象person的类一直都是CJLPerson。
如果没有重写class方法，自定的KVO在注册前后的实例对象person的 class 就会看到是不一致的，返回的isa 更改后的类，即中间类。
重写后 class 方法后的自定义 KVO，在注册观察者前后其实例对象类的显示，与系统的显示是一致的。

KVO 响应主要是给子类动态添加setter方法，其目的是为了在setter方法中向父类发送消息，通过block的方式传递给外部进行响应。 5、将setter方法重写添加到子类中（主要是在注册观察者方法中添加）。

scss 复制代码

//获取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)mp_setter, type);

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

scss 复制代码

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

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

ini 复制代码

/*---函数式编程*/
    NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));
    id oldValue = [self valueForKey:keyPath];
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kMPKVOAssociateKey));
    for (MPKVOInfo *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 方法代码如下:

objectivec 复制代码

static void mp_setter(id self, SEL _cmd, id newValue) {
    NSLog(@"来了:%@",newValue);
    //此时应该有willChange的代码
    //往父类LGPerson发消息 - 通过objc_msgSendSuper
    //通过系统强制类型转换自定义objc_msgSendSuper
    void (*mp_msgSendSuper)(void *, SEL, id) = (void *)objc_msgSendSuper;
    //定义一个结构体
    struct objc_super superStruct = {
        .receiver = self, //消息接收者 为 当前的self
        .super_class = class_getSuperclass(object_getClass(self)), //第一次快捷查找的类 为 父类
    };
    //调用自定义的发送消息函数
    mp_msgSendSuper(&superStruct, _cmd, newValue);
    //让vc去响应
    /*---函数式编程*/
    NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));
    id oldValue = [self valueForKey:keyPath];
    NSMutableArray *mArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kMPKVOAssociateKey));
    for (MPKVOInfo *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.实现mp_removeObserver:forKeyPath:方法，主要是清空数组，以及isa指向更改。

objectivec 复制代码

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

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

objectivec 复制代码

#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)mp_dealloc, deallocType);
    return newClass;
}

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

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

总结

自定义 KVO 大致分为以下几步：

注册观察者 & 响应
1.验证是否存在setter方法。
2.保存信息。
3.动态生成子类，需要重写class、setter方法。
4.在子类的setter方法中向父类发消息，即自定义消息发送。
5.让观察者响应。
移除观察者
1.更改isa指向为原有类。
2.重写子类的dealloc方法。

iOS 深入了解 KVO 本质

KVO 基础知识

1. KVO 是建立在 KVC 基础之上

2. KVO 基本使用（注册、实现回调、移除）三部曲

4. KVO 的自动触发和手动触发

5. KVO 观察一对多

6. KVO 观察可变数组

KVO 底层原理（重点）

1. KVO 只对属性观察

2. 中间类

自定义 KVO

总结