探究KVO底层原理

作者: ChinaChong | 来源:发表于2018-09-11 19:18 被阅读387次

2018-02-14
探究KVC的底层实现原理
自定义KVO
探究KVO底层原理
iOS面试题整理
底层原理探究（一）KVO
十：KVO底层原理探究
Today面试
IOS底层（三） KVO底层实现原理
探究KVO的底层实现原理

本文将会分成三部分，一是简述KVO的底层原理，二是详解系统的KVO，三是自己手动实现KVO，我们通过断点调试、NSLog输出等辅助手段提供的信息来证实结论的正确。

KVO的底层原理

先用几句话说一下KVO的底层原理，以下的原理是根据网上各位大神的博客和自己手动实现KVO时的总结。

若有A是XXX类的实例对象，A对象添加过监听者之后(addObserver)，A对象的isa指针指向将被修改，由之前的指向XXX类对象变为指向NSKVONotifying_XXX类对象。
NSKVONotifying_XXX是XXX的子类，其superclass指针是指向XXX类对象的，NSKVONotifying_XXX是runtime在运行时生成的。
经过KVO监听之后，NSKVONotifying_XXX类内部修改了XXX类中的两个方法：赋值方法和class方法。
1. 赋值方法：
  A的赋值方法实现(IMP)的地址发生了变化，A的赋值方法的实现(IMP)转换为Foundation框架的NSSetObjectValueAndNotify等系列函数。
2. class方法：
  修改class方法，使class的返回值由NSKVONotifying_XXX变为XXX，以此来混淆当前对象isa已被修改指向的事实。
```
- (Class) class {
     // 得到类对象，再找到类对象父类
     return class_getSuperclass(object_getClass(self));
}
```
经过KVO监听之后，修改属性赋值方法的执行顺序：
1. 首先调用willChangeValueForKey
2. 调用父类的赋值方法为属性赋值
3. 最后调用didChangeValueForKey。
4. didChangeValueForKey中会调用监听器的监听方法，即observeValueForKeyPath:ofObject:change:context:

以上就是KVO大致的底层原理，只看文字难免会难以理解，接下来开始上代码，用代码来佐证以上原理的正确

详解系统KVO

和我上一篇博客一样，这次举例仍然用清新简洁的TestObject。我们先定义一个TestObject类。以下是TestObject的 .h 和 .m 文件代码。

//
//  TestObject.h
//  KVO
//
//  Created by 崇 on 2018/9/10.
//  Copyright © 2018年 崇. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface TestObject : NSObject

@property (nonatomic, copy) NSString *name;

@end

//
//  TestObject.m
//  KVO
//
//  Created by 崇 on 2018/9/10.
//  Copyright © 2018年 崇. All rights reserved.
//

#import "TestObject.h"

@implementation TestObject

- (void)setName:(NSString *)name {
    _name = name;
    NSLog(@"执行原赋值方法");
}

- (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");
}

定义完TestObject后，我们在ViewController.m中给TestObject的name属性添加监听。

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testSystemKVO];
}

- (void)testSystemKVO {
    TestObject *obj = [TestObject new];
    [self checkIMP:obj];
    
    [obj addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew context:nil];
    
    obj.name = @"Tom";
    [self checkIMP:obj];
}

上面代码中的checkIMP:方法用来跟踪对象obj赋值方法实现(IMP)。首先我们在checkIMP:方法中打断点，并在checkIMP:方法中输出obj的isa指针指向的类、class方法返回的类和添加监听(addObserver:)前后两次的IMP地址。然后在testSystemKVO方法中[obj addObserver:self forKeyPath:@"name"...这一行打断点。

用接下来的代码来验证最开始关于KVO原理的结论。

运行Xcode，程序停在checkIMP:方法中的断点处，输出以下内容：

image.png

此时还没有执行`addObserver:`,现在的情况是：

obj的isa指向TestObject，class指向TestObject，imp地址=0x104a06140
原imp类型：(KVO`-[TestObject setName:]at TestObject.m:23)

跳过断点，程序停在testSystemKVO方法中[obj addObserver:self forKeyPath:@"name"...这一行断点处，单步跳过，程序停在obj.name = @"Tom";这一行。

image.png
在添加过监听者后(addObserver:)，根据最开始的结论此时obj的isa指针已经被修改了指向，obj的isa指针指向了NSKVONotifying_TestObject。下图提供证明。

image.png
接下来单步跳过，程序停在testSystemKVO方法中的[self checkIMP:obj];这一行我们来看看添加监听者之后控制台的输出情况：

image.png

image.png 根据控制台的输出，可以证明：

obj的isa指针已经被修改，指向了NSKVONotifying_TestObject。
obj的确是TestObject的子类，其SuperClass指向TestObject。
给obj的name属性赋值这一操作，先调用了willChangeValueForKey，然后执行了原赋值方法，最后调用了didChangeValueForKey方法，并且监听方法observeValueForKeyPath:ofObject:change:context:是在didChangeValueForKey方法开始调用后、结束调用前被调用。也就是说系统的observeValueForKeyPath:ofObject:change:context:方法是在didChangeValueForKey方法执行过程中被调用的。

接下来继续，跳过断点，程序停在checkIMP:方法中的断点。看看控制台：
image.png

此时已经执行`addObserver:`,现在的情况是：

obj的isa指向NSKVONotifying_TestObject，class指向TestObject，imp地址=0x104d48a7a
修改后的imp类型：(Foundation`_NSSetObjectValueAndNotify)

前后对比可以发现：

赋值方法在添加监听之前imp地址0x104a06140、类型：(KVO'-[TestObject setName:]at TestObject.m:23)，添加监听之后imp地址0x104d48a7a，类型：(Foundation'_NSSetObjectValueAndNotify)，因此证明添加监听后obj的赋值方法被修改为NSSetObjectValueAndNotify等系列函数。
class方法在添加监听之前返回TestObject，添加监听之后也返回TestObject，在控制台输出中我们可以看到obj的isa指针已经被修改，此时class应该返回NSKVONotifying_TestObject，因此证明obj的class方法被修改。

至此，已经证明最开始的结论是正确的，这就是系统KVO的底层原理。

自己手动实现KVO

下面是我自己实现KVO的大致思路：

KVO的addObserver和observeValueForKeyPath:ofObject:change:context:等方法都是NSObject的各种类目NSKeyValueObserving.h中的方法，为了方便，我在TestObject中定义了一个代理协议

@protocol TestKVOProtocol<NSObject>

- (void)testObserveValueForKeyPath:(NSString *)keyPath change:(NSDictionary *)change;

@end

在TestObject的内部延展中定义了一个属性observer用来接受观察者

@interface TestObject()

@property (nonatomic, strong) id<TestKVOProtocol> observer;

@end

定义了一个testAddObserver:(id)observer forKeyPath:(NSString *)keyPath方法，用来模仿系统的addObserver

- (void)testAddObserver:(id)observer forKeyPath:(NSString *)keyPath {
    self.observer = observer;
    
    if ([NSStringFromClass(object_getClass(self)) containsString:@"GCKVONotifiying"]) {
        NSString *selName = [NSString stringWithFormat:@"set%@:",uppercaseFirstLetter(keyPath)];
        class_addMethod(object_getClass(self), NSSelectorFromString(selName), (IMP)GCSetObjectValueAndNotify, "v@:@");
    }
    else {
        NSString *kvoClsName = [NSString stringWithFormat:@"GCKVONotifiying_%@",NSStringFromClass(object_getClass(self))];
        NSString *selName = [NSString stringWithFormat:@"set%@:",uppercaseFirstLetter(keyPath)];
        
        Class kvoCls = objc_allocateClassPair(object_getClass(self), [kvoClsName UTF8String], 0);
        class_addMethod(kvoCls, NSSelectorFromString(selName), (IMP)GCSetObjectValueAndNotify, "v@:@");
        class_addMethod(kvoCls, NSSelectorFromString(@"class"), (IMP)GCClass, "#@:@");
        
        objc_registerClassPair(kvoCls);
        object_setClass(self, kvoCls);
    }
}

定义了GCSetObjectValueAndNotify函数，用来模仿系统的(Foundation`_NSSetObjectValueAndNotify)

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

    NSString *setMethodName = NSStringFromSelector(_cmd);
    NSString *getMethodNameTemp = lowercaseFirstLetter([setMethodName stringByReplacingOccurrencesOfString:@"set" withString:@""]);
    NSString *getMethodName = [getMethodNameTemp stringByReplacingOccurrencesOfString:@":" withString:@""];
    
    // 1.判断新值与旧值是否相同
    id oldValue = objc_getAssociatedObject(self,NSSelectorFromString(getMethodName));
    if ([value isEqual:oldValue]) return;

    Class subCls = object_getClass(self);
    Class supCls = class_getSuperclass(subCls);
    struct objc_super superInfo = {
        self,
        supCls
    };

    // 2.触发testWillChangeValueForKey
    ((void (*) (void * , SEL, ...))objc_msgSendSuper)(&superInfo, NSSelectorFromString(@"testWillChangeValueForKey:"), getMethodName);

    // 3.调用父类赋值方法给属性赋新值
    ((void (*) (void * , SEL, ...))objc_msgSendSuper)(&superInfo, _cmd, value);

    // 4.触发testDidChangeValueForKey
    ((void (*) (void * , SEL, ...))objc_msgSendSuper)(&superInfo, NSSelectorFromString(@"testDidChangeValueForKey:"), getMethodName);

    // 5.保存旧值
    objc_setAssociatedObject(self, NSSelectorFromString(getMethodName), value, OBJC_ASSOCIATION_RETAIN);
}

定义了GCClass函数，用来模仿系统替换class方法的操作

static Class GCClass(id self, SEL _cmd) {
    Class selfClass = object_getClass(self);
    return class_getSuperclass(selfClass);
}

定义了changeValueForKey的两个方法

- (void)testWillChangeValueForKey:(NSString *)key {
    NSLog(@"自定义%s",__func__);
}

- (void)testDidChangeValueForKey:(NSString *)key {
    NSLog(@"自定义%s",__func__);
    if (self.observer && [self.observer respondsToSelector:@selector(testObserveValueForKeyPath:change:)]) {
        NSMutableDictionary *dict = [NSMutableDictionary dictionary];
        
        if (!objc_getAssociatedObject(self, NSSelectorFromString(key))) {
            [dict setObject:@"<null>" forKey:@"old"];
        }
        else {
            [dict setObject:objc_getAssociatedObject(self, NSSelectorFromString(key)) forKey:@"old"];
        }
        [dict setObject:[self valueForKey:key] forKey:@"new"];
        [self.observer testObserveValueForKeyPath:key change:dict];
    }
}

使用时需要遵循协议

@interface ViewController ()<TestKVOProtocol>

@end

- (void)viewDidLoad {
    [super viewDidLoad];
    [self testMyKVO];
}

- (void)testMyKVO {
    TestObject *obj = [TestObject new];
    [self checkIMP:obj];
    
    [obj testAddObserver:self forKeyPath:@"name"];

    obj.name = @"Sam";
    [self checkIMP:obj];
}

使用结果和系统的KVO几乎几乎几乎完全一致。😁
手动实现的源码：https://github.com/ChinaChong/GCKVOTest

都是自己的拙见，如有错误，欢迎指正！

2018-02-14
探究KVO的底层实现原理 addObserver:forKeyPath:options:context:各个参数的...
探究KVC的底层实现原理
慕课网地址以前写了关于的实现原理的文章，探究KVO的底层实现原理，现在我们也探究一下的底层实现原理的全称是K...
自定义KVO
导语：如果对KVO原理不是很熟悉的，可以参考下简书另一篇文章《ios KVO原理探究》，主要是通过模拟KVO底层...
探究KVO底层原理
本文将会分成三部分，一是简述KVO的底层原理，二是详解系统的KVO，三是自己手动实现KVO，我们通过断点调试、N...
iOS面试题整理
1.探究KVO的底层实现原理 https://www.jianshu.com/p/829864680648 ·KV...
底层原理探究（一）KVO
问题：1、KVO的使用？实现原理？（为什么要创建子类来实现）2、KVC的使用？实现原理？（KVC拿到key以后，是...
十：KVO底层原理探究
KVO介绍： KVO，全称为Key-Value observing，中文名为键值观察，KVO是一种机制，它允许将其...
Today面试
Runloop 底层原理Kvo 底层原理ARC 底层原理如何实现GCD 底层原理Block 底层原理Aut...
IOS底层（三） KVO底层实现原理
@[TOC](IOS底层（三） KVO底层实现原理 ) 一，KVO简述 KVO的全称 Key-Value Obse...
探究KVO的底层实现原理
KVO基本原理：1.KVO是基于runtime机制实现的 2.当某个类的属性对象第一次被观察时，系统就会在运行期动...