KVO 底层原理

本文介绍: KVO，全称为Ke y-Value o b serv in g，中文名为键值观察，KVO是一种机制，它允许将其他对象的指定属性的更改通知给对象。在Ke y-Value Ob serv ing Program ming Guid e 官方文档中，又这么一句话：理解KVO之前，必须先理解KVC（即KVO是基于KVC基础之上，KVO底层也是由KVC实现的）In order t o unde rst and key–value observ ing, you must first unde rst and key–value coding.K

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

在Ke y-Value Observ ing Progr a m ming Guid e 官方文档中，又这么一句话：理解KVO之前，必须先理解KVC（即KVO是基于KVC基础之上，KVO底层也是由KVC实现的）

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

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

相同点

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

1、KVO只能用于监听对象属性的变化，并且属性名都是通过NSString来查找，编译器不会帮你检测对错和补全,纯手敲会比较容易出错
2、NSNoti fi cat ion的发送监听（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:ofObjec t:change:context

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

移除观察者 rem oveObserver:forKeyPath:context

[self.person removeObserver:self forKeyPath:@"nick" context:NULL];
复制代码

2、c on text 使用
在官方文档中，针对参数 c on text有如下说明：

在这里插入图片描述

大致含义就是：addObserver：forKeyPath：options：c on text：方法中的上下文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 = &amp;PersonNickContext;
static void *PersonNameContext = &amp;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的移除有以下几点说明

在这里插入图片描述

删除观察者时，请记住以下几点：

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

在这里插入图片描述

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

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

如果未注册，却移除，则会报错***** Terminating app due to uncaught exception ‘NSRangeExc ept ion’, reason: ‘Cannot remo ve an observer <LGViewController 0x7fcfc7208cf0> for the key path “监测的keyPath” fro m <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官方文档中，针对可变数组的集合类型，有如下说明，即访问集合对象需要需要通过mu tableArrayValueForKey方法，这样才能将元素添加到可变数组中:
在这里插入图片描述

修改

将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, &amp;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方法
最后
如果你觉得此文对你有一丁点帮助，点个赞。或者可以加入我的开发交流群：1025263163相互学习，我们会有专业的技术答疑解惑

如果你觉得这篇文章对你有点用的话，麻烦请给我们的开源项目点点star:http://github.crmeb.net/u/defu不胜感激！

PHP学习手册：https://doc.crmeb.com
技术交流论坛：https://q.crmeb.com

原文地址:https://blog.csdn.net/CRMEB/article/details/123368925

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。