iOS KVO底层实现原理 (一)

·  阅读 811

iOS KVO底层实现原理 (一)

一,KVO简述

KVO的全称 Key-Value Observing,俗称“键值监听”,可以用于监听某个对象属性值的改变。
带着问题探索:

1.iOS用什么方式实现对一个对象的KVO?(KVO的本质是什么?)

答. 当一个对象使用了KVO监听,iOS系统会修改这个对象的isa指针,
改为指向一个全新的通过Runtime动态创建的子类,子类拥有自己的set方法实现,
set方法实现内部会顺序调用willChangeValueForKey方法、原来的setter方法实现、
didChangeValueForKey方法,而didChangeValueForKey方法内部
又会调用监听器的observeValueForKeyPath:ofObject:change:context:监听方法。
复制代码

2.如何手动触发KVO

答. 被监听的属性的值被修改时,就会自动触发KVO。
如果想要手动触发KVO,则需要我们自己调用willChangeValueForKey和
didChangeValueForKey方法即可在不改变属性值的情况下手动触发KVO
,并且这两个方法缺一不可。
复制代码

3.KVO 底层实现是什么?
4.修改成员变量的值会出发 KVO 吗?
5.KVC 赋值会出发 KVO 吗?
6.

二,KVC 简述

1. KVC定义

KVC: Key-value coding is a mechanism for indirectly accessing anobject’s attributes and relationships using string identifiers. 所谓键值编码,并不是访问器方法的启动和实例变量的访问这种直接的方式,而是使用表示属性的字符串来间接访问对象属性值的一种结构。 

只要存在访问器方法、声明属性或实例变量,就可以将其名字指定为字符串来访问。

之所以说键值编码的访问是接的:

  1. 可以在运行中确定作为键的字符串

  2. 使用者无法知道实际访问属性的方法

键值编码必需的方法在非正式协议NSKeyValueCoding中声明(头文件Foundation/NSKeyValueCoding.h)。默认在NSObject中实现。

2. 方法调用

下面就以下两个方法的调用进行说明:

 (id)  valueForKey: (NSString *) key
复制代码

返回表示属性的键字符串所对应的值。如果不能取得值,则将引起接收器调用方法valueForUndefinedKey:。

 (void)setValue: (id) value  forKey: (NSString*) key
复制代码

将键字符串key所对应的属性的值设置为value。不能设定属性时,将引起接收器调用方法setValue:ForUndefinedKey:。 执行时,有访问器的属性会使用访问器,没有访问器的属性也可以设定值和访问。因为上面两个方法均为实例方法,可以在方法体内访问实例变量。  

访问过程如下:

  1. 接收器中如果有key访问器(或getKey、isKey、_key、_getKey、setKey)则

  2. 使用它。

  3. 没有访问器时,使用接收器的类方法accessInstanceVariablesDirectly来查询。返回YES时,如果存在实例变量key(或_key、isKey、_isKey等)则返回或设置其值。使用引用计数管理方式时,实例变量如果为对象,则旧值会被自动释放,新值被保存并

  4. 代入。

  • (BOOL)accessInstanceVariablesDirectly

    通常定义为返回YES,可以在子类中改变。该类方法返回YES时,使用键值编码可以访问该类的实例变量。返回NO时不可以访问。只要该方法返回YES,实例变量的可视属性即使有@private修饰,也可以

  • 访问。

  1. 既没有访问器也没有实例变量时,将引起接收器调用方法valueForUndefinedKey:或setValue:forUndefinedKey:。

    (id) valueForUndefinedKey: (NSStirng *) key

 不能取得键字符串对应的值时,从方法valueForKey:中调用该方法。默认情况下,该方法的执行会触发NSUndefinedKeyException。不过,通过在子类中修改定义,就可以返回其他对象。

  (void) setValue: (id) value  forUndefinedKey: (NSString *) key
复制代码

不能设置键字符串key对应的属性值时,从方法setValue:forKey中调用该方法。默认情况下,该方法的执行会触发异常NSUndefinedKeyException。不过,通过在子类中修改定义,可以返回其他对象。

  1. 如果该返回值不是对象,则返回被适当的对象包装的值;设置值时也应先包装成相应的对象。

属性为对象时,该对象还可能持有属性。这时候可以用“.”连接表示键的字符串,这种表示方式称为键路径。只要能找到对象,点和键多长都没有关系。

 (id) valueForKeyPath:(NSString *) keyPath
复制代码

以点切分键路径,并使用第一个键向接收器发送valueForKey:方法。然后,再使用键路径的下一个键,向得到的对象发送valueForKey:方法,如此反复操作,返回最后获得的对象。

 (void)setValue: (id) value  forKeyPath:(NSString *) keyPath
复制代码

与valueForKeyPath:方法一样取出对象,这里只对路径中的最后一个键调用setValue:forKey:方法,并设定属性值为value。

3. KVC准则

  1. 随访问器方法而改变。

  2. 使用setValue:forKey:和键进行改变。此时也可能不经由访问

  3. 器。

  4. 使用setValue:forKeyPath:和键路径进行改变。此时也可能不经由访问器。不仅仅是最终的监视对象的属性,当路径中的属性发生变化时,也会被通知。

三,KVO实现原理探索

  1. 首先需要了解KVO基本使用,KVO的全称 Key-Value Observing,俗称“键值监听”,可以用于监听某个对象属性值的改变。KVO:key-value observing,是在KVC基础上实现的,当某个对象的属性发生改变时,通知其它对象的机制。仅仅在以KVC准则来访问访问器或实例变量的情况下,才可以监视属性的变化。在方法内直接改变实例变量的值时,就不能监视了。

    • (void)viewDidLoad { [super viewDidLoad]; Person *p1 = [[Person alloc] init]; Person *p2 = [[Person alloc] init]; p1.age = 1; p1.age = 2; p2.age = 2; // self 监听 p1的 age属性 NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;

      [p1 addObserver:self forKeyPath:@"age" options:options context:nil]; p1.age = 10; [p1 removeObserver:self forKeyPath:@"age"];

    }

    • (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context

    { NSLog(@"监听到%@的%@改变了%@", object, keyPath,change); }

    // 打印内容 监听到<Person: 0x604000205460>的age改变了{ kind = 1; new = 10; old = 2; }

上述代码中可以看出,在添加监听之后,age属性的值在发生改变时,就会通知到监听者,执行监听者的observeValueForKeyPath方法。

1. 探寻KVO底层实现原理

通过上述代码我们发现,一旦age属性的值发生改变时,就会通知到监听者,并且我们知道赋值操作都是调用 set方法,我们可以来到Person类中重写age的set方法,观察是否是KVO在set方法内部做了一些操作来通知监听者。 我们发现即使重写了set方法,p1对象和p2对象调用同样的set方法,但是我们发现p1除了调用set方法之外还会另外执行监听器的observeValueForKeyPath方法。 说明KVO在运行时获取对p1对象做了一些改变。相当于在程序运行过程中,对p1对象做了一些变化,使得p1对象在调用setage方法的时候可能做了一些额外的操作,所以问题出在对象身上,两个对象在内存中肯定不一样,两个对象可能本质上并不一样。接下来来探索KVO内部是怎么实现的。

2. KVO底层实现分析

  • 首先我们对上述代码中添加监听的地方打断点,看观察一下,addObserver方法对p1对象做了什么处理?也就是说p1对象在经过addObserver方法之后发生了什么改变,我们通过打印isa指针如下图所示

addObserver对p1对象的处理
通过上图我们发现,p1对象执行过addObserver操作之后,p1对象的isa指针由之前的指向类对象Person变为指向NSKVONotifyin_Person类对象,而p2对象没有任何改变。也就是说一旦p1对象添加了KVO监听以后,其isa指针就会发生变化,因此set方法的执行效果就不一样了。

那么我们先来观察p2对象在内容中是如何存储的,然后对比p2来观察p1。
首先我们知道,p2在调用setage方法的时候,首先会通过p2对象中的isa指针找到Person类对象,然后在类对象中找到setage方法。然后找到方法对应的实现。如下图所示

未使用KVO监听的对象放大实现路径
但是刚才我们发现p1对象的isa指针在经过KVO监听之后已经指向了NSKVONotifyin_Person类对象,NSKVONotifyin_Person其实是Person的子类,那么也就是说其superclass指针是指向Person类对象的,NSKVONotifyin_Person是runtime在运行时生成的。那么p1对象在调用setage方法的时候,肯定会根据p1的isa找到NSKVONotifyin_Person,在NSKVONotifyin_Person中找setage的方法及实现。

经过查阅资料我们可以了解到。
NSKVONotifyin_Person中的setage方法中其实调用了 Fundation框架中C语言函数 _NSsetIntValueAndNotify,_NSsetIntValueAndNotify内部做的操作相当于,首先调用willChangeValueForKey 将要改变方法,之后调用父类的setage方法对成员变量赋值,最后调用didChangeValueForKey已经改变方法。didChangeValueForKey中会调用监听器的监听方法,最终来到监听者的observeValueForKeyPath方法中。

  • 那么如何验证KVO真的如上面所讲的方式实现?

首先经过之前打断点打印isa指针,我们已经验证了,在执行添加监听的方法时,会将isa指针指向一个通过runtime创建的Person的子类NSKVONotifyin_Person。

另外我们可以通过打印方法实现的地址来看一下p1和p2的setage的方法实现的地址在添加KVO前后有什么变化。

// 通过methodForSelector找到方法实现的地址
NSLog(@"添加KVO监听之前 - p1 = %p, p2 = %p", [p1 methodForSelector: @selector(setAge:)],[p2 methodForSelector: @selector(setAge:)]);
    
NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
[p1 addObserver:self forKeyPath:@"age" options:options context:nil];

NSLog(@"添加KVO监听之后 - p1 = %p, p2 = %p", [p1 methodForSelector: @selector(setAge:)],[p2 methodForSelector: @selector(setAge:)]);
复制代码

setage的方法实现的地址在添加KVO前后的变化

我们发现在添加KVO监听之前,p1和p2的setAge方法实现的地址相同,而经过KVO监听之后,p1的setAge方法实现的地址发生了变化,我们通过打印方法实现来看一下前后的变化发现,确实如我们上面所讲的一样,p1的setAge方法的实现由Person类方法中的setAge方法转换为了C语言的Foundation框架的_NSsetIntValueAndNotify函数。

Foundation框架中会根据属性的类型,调用不同的方法。例如我们之前定义的int类型的age属性,那么我们看到Foundation框架中调用的_NSsetIntValueAndNotify函数。那么我们把age的属性类型变为double重新打印一遍

_NSSetDoubleValueAndNotify函数
我们发现调用的函数变为了_NSSetDoubleValueAndNotify,那么这说明Foundation框架中有许多此类型的函数,通过属性的不同类型调用不同的函数。 那么我们可以推测Foundation框架中还有很多例如_NSSetBoolValueAndNotify、_NSSetCharValueAndNotify、_NSSetFloatValueAndNotify、_NSSetLongValueAndNotify等等函数。 我们可以找到Foundation框架文件,通过命令行查询关键字找到相关函数 

相关函数

  • NSKVONotifyin_Person内部结构是怎样的?

首先我们知道,NSKVONotifyin_Person作为Person的子类,其superclass指针指向Person类,并且NSKVONotifyin_Person内部一定对setAge方法做了单独的实现,那么NSKVONotifyin_Person同Person类的差别可能就在于其内存储的对象方法及实现不同。

我们通过runtime分别打印Person类对象和NSKVONotifyin_Person类对象内存储的对象方法

- (void)viewDidLoad {
    [super viewDidLoad];

    Person *p1 = [[Person alloc] init];
    p1.age = 1.0;
    Person *p2 = [[Person alloc] init];
    p1.age = 2.0;
    // self 监听 p1的 age属性
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [p1 addObserver:self forKeyPath:@"age" options:options context:nil];

    [self printMethods: object_getClass(p2)];
    [self printMethods: object_getClass(p1)];

    [p1 removeObserver:self forKeyPath:@"age"];
}

- (void) printMethods:(Class)cls
{
    unsigned int count ;
    Method *methods = class_copyMethodList(cls, &count);
    NSMutableString *methodNames = [NSMutableString string];
    [methodNames appendFormat:@"%@ - ", cls];
    
    for (int i = 0 ; i < count; i++) {
        Method method = methods[i];
        NSString *methodName  = NSStringFromSelector(method_getName(method));
        
        [methodNames appendString: methodName];
        [methodNames appendString:@" "];
        
    }
    
    NSLog(@"%@",methodNames);
    free(methods);
}
复制代码

上述打印内容如下:

通过上述代码我们发现NSKVONotifyin_Person中有4个对象方法。分别为setAge: class dealloc _isKVOA,那么至此我们可以画出NSKVONotifyin_Person的内存结构以及方法调用顺序。

NSKVONotifyin_Person的内存结构以及方法调用顺序

这里NSKVONotifyin_Person重写class方法是为了隐藏NSKVONotifyin_Person。不被外界所看到。我们在p1添加过KVO监听之后,分别打印p1和p2对象的class可以发现他们都返回Person。

NSLog(@"%@,%@",[p1 class],[p2 class]);
// 打印结果 Person,Person
复制代码

如果NSKVONotifyin_Person不重写class方法,那么当对象要调用class对象方法的时候就会一直向上找来到nsobject,而nsobect的class的实现大致为返回自己isa指向的类,返回p1的isa指向的类那么打印出来的类就是NSKVONotifyin_Person,但是apple不希望将NSKVONotifyin_Person类暴露出来,并且不希望我们知道NSKVONotifyin_Person内部实现,所以在内部重写了class类,直接返回Person类,所以外界在调用p1的class对象方法时,是Person类。这样p1给外界的感觉p1还是Person类,并不知道NSKVONotifyin_Person子类的存在。

那么我们可以猜测NSKVONotifyin_Person内重写的class内部实现大致为:

- (Class) class {
     // 得到类对象,在找到类对象父类
     return class_getSuperclass(object_getClass(self));
}
复制代码
  • 验证didChangeValueForKey:内部会调用observer的observeValueForKeyPath:ofObject:change:context:方法.

我们在Person类中重写willChangeValueForKey:和didChangeValueForKey:方法,模拟他们的实现。

- (void)setAge:(int)age
{
    NSLog(@"setAge:");
    _age = age;
}
- (void)willChangeValueForKey:(NSString *)key
{
    NSLog(@"willChangeValueForKey: - begin");
    [super willChangeValueForKey:key];
    NSLog(@"willChangeValueForKey: - end");
}
- (void)didChangeValueForKey:(NSString *)key
{
    NSLog(@"didChangeValueForKey: - begin");
    [super didChangeValueForKey:key];
    NSLog(@"didChangeValueForKey: - end");
}
复制代码

再次运行来查看didChangeValueForKey的方法内运行过程,通过打印内容可以看到,确实在didChangeValueForKey方法内部已经调用了observer的observeValueForKeyPath:ofObject:change:context:方法。
didChangeValueForKey内运行顺序

四,KVO底层原理

在这里插入图片描述

  1. 首先创建一个 Person 类 内部有个 name 属性,然后 创建p1 和 p2两个实例对象,其中p1添加了kvo监听,p2没有添加 kvo 监听,然后重写了 observeValueForKeyPath 方法 监听Person.name 属性发生改变时候的通知.

 从本质上来看 Person 给name赋值的时候 调用的是 setName 方法 ,无论 p1还是p2 调用的 setter 方法都是一样的,为什么 p1改变 name 属性值就能有通知, p2确没有,调用的 都是同一个 setName:(NSString *)name 方法,区别怎么那么大?

  1. 接下来打印下p1和p2的内存地址 看看p1和p2内存地址能不能一探究竟.

在这里插入图片描述

  1. 从 p1

  2. 和 p2内存地址上也看不出来什么东东.接着打印 p1和 p2 的 class 信息
    在这里插入图片描述

  3. 打印 o

  4. bject_getClass 试试看,我们都知道object_getClass(id) 才会返回这个实例对象的真实 class 类型
    在这里插入图片描述

  5. 打印 s

  6. etName 方法实现IMP指针有没有发生改变,我们知道同一个方法的实现 IMP 地址是不变的.
    在这里插入图片描述

  7. 这里连 setName方法都不一样了 , 为了一探究竟 对上边的 NSKVONotifying_Person 和 添加 KVO 之后的 imp 指针进行进一步研

  8. 究.

  • 首先 在 lldb 上输入 imp1和 imp2
    在这里插入图片描述
    发生了 imp1 方法实现在 Foundation 框架里的 _NSSetObjectValueAndNotify 函数中 ,而 imp2 则调用了 Person setName 方法
    在这里插入图片描述
    也就是说添加了 KVO 之后 p1 修改 name 值之后 不再调用 Person 的 setName方法 ,而 p2没有添加 kvo 监听 依然正常调用 setName:方法 ,由此可以得出 p1 添加完 KVO 监听后 系统修改了默认方法实现,那么既然没有调用 setName: 方法 为什
  • p1.name的值也发生了改变?
  1. 接下来我们准备对刚才 NSKVONotifying_Person 类进行下一步研究, NSKVONotifying_Person 和 Person 有没有内在的联系呢? 研究一下NSKVONotifying_Person和 Person 之间的联系时什么?
    在这里插入图片描述
    通过打印 NSKVONotifying_Person 的 superclass 和 Person 的 superclass 可以得出, NSKVONotifying_Person是一个 Person 子类,那么为什么苹果会动态创建这么一个 子类呢? NSKVONotifying_Person 这个子类 跟 Person 内部有哪些不
  2. 同呢 ?

这个时候 我们去输出下 Person 和 NSKVONotifying_Person 内部的方法列表 和 属性列表 ,看看NSKVONotifying_Person 子类都添加了那些方法和属性.

- (void)viewDidLoad {
    [super viewDidLoad];

    
    Person *p1 = [[Person alloc] init];
    Person *p2 = [[Person alloc] init];
    
    id cls1 = object_getClass(p1);
    id cls2 = object_getClass(p2);
    NSLog(@"添加 KVO 之前: cls1 = %@  cls2 = %@ ",cls1,cls2);
    
    [p1 addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
     cls1 = object_getClass(p1);
     cls2 = object_getClass(p2);
    
    
    NSString *methodList1 = [self printPersonMethods:cls1];
    NSString *methodList2 = [self printPersonMethods:cls2];

    NSLog(@"%@",methodList1);
    NSLog(@"%@",methodList2);

    
//  NSLog(@"添加 KVO 之后: cls1 = %@  cls2 = %@ ",cls1,cls2);
    
//  id super_cls1 = class_getSuperclass(cls1);
//  id super_cls2 = class_getSuperclass(cls2);
//
//  NSLog(@"super_cls1 = %@ ,super_cls2 = %@",super_cls1,super_cls2);
//
//  p1.name = @"dzb";
//  p2.name = @"123";

}

- (NSString *) printPersonMethods:(id)obj {
    
    unsigned int count = 0;
    Method *methods = class_copyMethodList([obj class],&count);
    NSMutableString *methodList = [NSMutableString string];
    [methodList appendString:@"[\n"];
    for (int i = 0; i<count; i++) {
        Method method = methods[i];
        SEL sel = method_getName(method);
        [methodList appendFormat:@"%@",NSStringFromSelector(sel)];
        [methodList appendString:@"\n"];
    }
    
    [methodList appendFormat:@"]"];
    
    free(methods);
    
    return methodList;
}
复制代码

输出结果如下:
在这里插入图片描述
从输出结果可以看出来 NSKVONotifying_Person 内部也有一个 setName:方法 还重写了 class 和 dealloc 方法 , _isKVOA, 那么我们可以大致的得出, p1添加 kVO 后 runtime 动态的生成了一个 NSKVONotifying_Person子类 并重写了 setName 方法 ,那么 setName 内部一定是做了一些事情,才会触发 observeValueForKeyPath 监听方法.

  1. 继续探究 NSKVONotifying_Person 子类 重写 setName 都做了什么?
    其实 setName 方法内部 是调用了 Foundation 的 _NSSetObjectValueAndNotify 函数 ,在
  2. _NSSetObjectValueAndNotify 内部:
    1. 首先会调用 willChangeValueForKey
    1. 然后给 name 属性赋
      1. 最后调用 didChangeValueForKey
      1. 最后调用 observer 的 observeValueForKeyPath 去告诉监听器属性值发生了改变 .

在这里插入图片描述

  1. 由于苹果 Foundation 框架是不
  2. 开源的 ,所以我们依然可以通过重写Person 的 willChangeValueForKey 和 didChangeValueForKey 验证我们的猜想 .
    在这里插入图片描述

首先当我们改变p1.name 的值时 并不是首先执行的 setName: 这个方法 ,而是先调用了 willChangeValueForKey 其次 调用父类的 setter 方法 对属性赋值 ,然后再调用 didChangeValueForKey 方法 ,并在

 didChangeValueForKey 内部 调用监听器的 observeValueForKeyPath方法 告诉外界 属性值发生了改变.

在这里插入图片描述

在这里插入图片描述

至于重写了 dealloc 和 class 方法 是为了做一些 KVO 释放内存 和 隐藏外界对于 NSKVONotifying_Person 子类的存在

在这里插入图片描述

10.这就是我们调用 [p1 class] 和 [p2 class]结果都显示 Person 类 ,让我们误以为 Person 没有发生变化

  • KVC 对属性赋值时候 是会在这个类里边 去查找 _age isAge setAge setIsAge 等方法的 ,最终会调用属性的 setter 方法 ,那么如果添加了 KVO 还是会被触发的 .
    相反 设置成员变量 _age 由于不会触发 setter 方法 ,因此不会去触发 KVO 相关的代码 .

五,KVO底层实现代码

1. 通过代码来自己实现KVO监听

  1. ViewController调用实现

    #import "ViewController.h" #import "Person.h" #import "NSObject+KCKVO.h" #import "Dog.h"

    @interface ViewController () @property (nonatomic, strong) Person *p; @end

    // 分类 @implementation ViewController

    • (void)viewDidLoad { [super viewDidLoad];

      self.p = [[Person alloc] init]; [self.p lg_addObserver:self forKeyPath:@"name"]; self.p.name = @"kongyulu";

    }

    #pragma mark - value 回调

    • (void)lg_observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object newValue:(id)newValue{ NSLog(@"lg_observeValueForKeyPath - %@",newValue);

    }

    #pragma mark - dealloc

    • (void)dealloc{

    }

    • (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{ self.p.name = [NSString stringWithFormat:@"%@+",self.p.name];

    }

    @end

  2. 定义两个类

  • 定义Person类

    #import <Foundation/Foundation.h>

    @interface Person : NSObject{ @public NSString *girl; }

    @property (nonatomic, copy) NSString *name; @property (nonatomic, assign) int age;

    @property (nonatomic, strong) NSMutableArray *mArray;

    • (instancetype)shared;

    @end

    #import "Person.h"

    @implementation Person

    • (void)setName:(NSString *)name{ NSLog(@"设置方法 ");

    }

    • (void)dealloc{ NSLog(@"父走了");

    }

    @end #import "Person.h"

    @implementation Person

    • (void)setName:(NSString *)name{ NSLog(@"设置方法 ");

    }

    • (void)dealloc{ NSLog(@"父走了");

    }

    @end

  • 定义Dog类

    #import <Foundation/Foundation.h> #import "Person.h"

    @interface Dog : Person

    @property (nonatomic, copy) NSString *name; @property (nonatomic, assign) int age;

    @end

    #import "Dog.h"

    @implementation Dog

    • (void)dealloc{ NSLog(@"儿子走了");

    } @end

  1. 定义NSObject的一个实现KVO监听的分类NSObject+KCKVO
  • 头文件

    #import <Foundation/Foundation.h>

    typedef void(^KCKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);

    @interface NSObject (KCKVO)

    • (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;

    • (void)lg_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;

    @end

  • 实现类

    #import "NSObject+KCKVO.h" #import <objc/message.h>

    static NSString *const kKCKVOPrefix = @"KCKVO_"; static NSString *const kKCKVOAssiociateKey = @"kKCKVO_AssiociateKey";

    @implementation NSObject (KCKVO)

    • (void)lg_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath{ // 1: 是否有setter方法 // id superClassName = object_getClassName(self); // person // setName NSString *setterMethodName = setterForGetter(keyPath); // setName: SEL setterSel = NSSelectorFromString(setterMethodName); // method Method method = class_getInstanceMethod([self class], setterSel);// runtime 1900009931 if (!method) { @throw [[NSException alloc] initWithName:NSExtensionItemAttachmentsKey reason:@"没有setter方法" userInfo:nil]; }

      //2: 动态生成子类 Class childClass = [self creatChildClassWithKeypath:keyPath]; if (!childClass) { NSLog(@"创建失败"); } // 3.0 消息转发 // observer // 关联对象 objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kKCKVOAssiociateKey), observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

    }

    #pragma mark - 动态创建子类

    • (Class)creatChildClassWithKeypath:(NSString *)keyPath{

      NSString *oldClassName = NSStringFromClass([self class]);//person NSString *childClassName = [NSString stringWithFormat:@"%@%@",kKCKVOPrefix,oldClassName];

      //2: 动态生成子类 //2.1 申请类 Class childClass = objc_allocateClassPair([self class], childClassName.UTF8String, 0); //2.2 注册类 objc_registerClassPair(childClass); //2.3 添class SEL classSel = NSSelectorFromString(@"class"); Method classMethod = class_getClassMethod([self class], classSel); const char *classType = method_getTypeEncoding(classMethod); class_addMethod(childClass, classSel, (IMP)lg_Class, classType); //2.4 setter : setName: SEL setterSel = NSSelectorFromString(setterForGetter(keyPath)); Method setterMethod = class_getClassMethod([self class], setterSel); const char *setterType = method_getTypeEncoding(setterMethod); class_addMethod(childClass, setterSel, (IMP)lg_setter, setterType); //2.5 isa 指向 object_setClass(self, childClass); return childClass;

    }

    /** 判断是否存在该方法 */

    • (BOOL)hasSeletor:(SEL)selector{

      Class observedClass = object_getClass(self); unsigned int methodCount = 0; //得到一堆方法的名字列表 //class_copyIvarList 实例变量 //class_copyPropertyList 得到所有属性名字 Method *methodList = class_copyMethodList(observedClass, &methodCount);

      for (int i = 0; i<methodCount; i++) { SEL sel = method_getName(methodList[i]); if (selector == sel) { free(methodList); return YES; } } free(methodList); return NO;

    }

    #pragma mark - 函数区域 static Class lg_Class(id self,SEL _cmd){ return class_getSuperclass(object_getClass(self)); }

    static void lg_setter(id self,SEL _cmd,id value){

    NSLog(@"lg_setter - %@",value);
    
    id observer = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kKCKVOAssiociateKey));
    SEL handlSEL = @selector(lg_observeValueForKeyPath: ofObject:newValue:);
    NSString *keypath = getterForSetter(NSStringFromSelector(_cmd));
    objc_msgSend(observer,handlSEL,keypath,self,value);
    复制代码

    // [observer performSelector:@selector(lg_observeValueForKeyPath: ofObject:newValue:) withObject:self afterDelay:0]; }

    #pragma mark - 从get方法获取set方法的名称 name ===>>> setName: 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];
    复制代码

    }

    #pragma mark - 从set方法获取getter方法的名称 setName:===> name static NSString * getterForSetter(NSString *setter){

    if (setter.length <= 0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) { return nil;}
    
    NSRange range = NSMakeRange(3, setter.length-4);
    NSString *getter = [setter substringWithRange:range];
    NSString *firstString = [[getter substringToIndex:1] lowercaseString];
    getter = [getter stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:firstString];
    
    return getter;
    复制代码

    }

    @end

4.运行打印结果:在这里插入图片描述

2. 通过 runtime 动态创建子类方式去实现

  1. 动态创建一个 NSKVONotifying_Person 子类

    /** 运行时动态的创建子类

    @param super_cls 父类 @return 返回子类 */

    • (Class) registerSubClassWithSuperClass:(Class)super_cls { ///动态的创建 子类 NSString *clsName = [NSString stringWithFormat:@"NSKVONotifying_%@",super_cls]; ///一个 NSObject 默认分配16个字节内存 Class sub_cls = objc_allocateClassPair(super_cls,clsName.UTF8String,16); ///注册一个子类 objc_registerClassPair(sub_cls); ///将父类 isa 指针指向 子类 object_setClass(self, sub_cls); return sub_cls;

    }

  2. 动态的给这个子类 动态添加方法 setter 方法 didChangeValueForKey方法 class 方法实现

    ///动态创建子类 NSKVONotifying_xxx Class sub_cls = [self registerSubClassWithSuperClass:super_cls];

    ///给子类动态的添加 class setter  didChangeValueForKey 实现
    Method class_method = class_getInstanceMethod(super_cls, @selector(class));
    Method changeValue_method = class_getInstanceMethod(super_cls, @selector(didChangeValueForKey:));
    
    class_addMethod(sub_cls, @selector(class), (IMP)kvo_class,method_getTypeEncoding(class_method));
    ///给子类动态的添加 didChangeValueForKey
    class_addMethod(sub_cls, @selector(didChangeValueForKey:), (IMP)didChangeValue,method_getTypeEncoding(changeValue_method));
    ///动态的给子类添加 setter 方法
    class_addMethod(sub_cls, setterSel, (IMP)kvo_setter,method_getTypeEncoding(method));
    
    ///将观察者对象跟当前实例 self 关联起来
    objc_setAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedObservers), observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    复制代码
  3. 重写 class 方法实现

    /** 自实现 class 方法

    @param self 当前类实现 @param _cmd class @return 返回父类 Class 外界不会知道 NSKVONotifying_子类存在 */ static Class kvo_class(id self,SEL _cmd) { return class_getSuperclass(object_getClass(self)); }

  4. 重写 setter 方法实现

    /** 自实现 setter 方法

    @param self 当前类实现 @param _cmd setter @param newValue 赋值 */ static void kvo_setter(id self,SEL _cmd,id newValue) {

    NSString *setterName = NSStringFromSelector(_cmd);
    NSString *getterName = getterForSetter(setterName);
    
    ///将要改变属性的值
    [self willChangeValueForKey:getterName];
    
    ///调用 super setter 方法
    struct objc_super suer_cls = {
        .receiver = self,
        .super_class = class_getSuperclass(object_getClass(self))
    };
    
    ///存储旧值
    objc_setAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedOldValue),[self valueForKey:getterName], OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    ///调用父类 setter 方法 设置新值
    objc_msgSendSuper(&suer_cls,_cmd,newValue);
    ///改变监听属性值后 调用 didChangeValueForKey 并在内部 调用
    [self didChangeValueForKey:getterName];
    复制代码

    };

  5. 重写 didChangeValueForKey 方法实现

    /** didChangeValueForkey 实现方法 , 当根据 SEL (didChangeValueForkey:) 会找到方法 IMP 实现 */ static void didChangeValue(id self,SEL _cmd,NSString *key) {

    id newValue = [self valueForKey:key];
    id observer = objc_getAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedObservers));
    id oldValue = objc_getAssociatedObject(self,(__bridge const void * _Nonnull)(KVOAssociatedOldValue));
    
    NSMutableDictionary *change = [NSMutableDictionary dictionary];
    if (oldValue) {
        change[@"oldValue"] = oldValue;
    } else {
        change[@"oldValue"] = [NSNull null];
    }
    if (newValue) {
        change[@"newValue"] = newValue;
    } else {
        change[@"newValue"] = newValue;
    }
    
    [observer observeValueForKeyPath:key ofObject:self change:change context:NULL];
    复制代码

    }

文章接下来还会持续更新,你也可以私信我及时获取最新资料以及面试相关资料。如果你有什么意见和建议欢迎给我留言。

求喜欢IOS的小伙伴关注 !喜欢的话给一个赞吧!谢谢!谢谢!谢谢!

点击获取:iOS面试资料

收录:原文

分类:
iOS
标签:
分类:
iOS
标签: