iOS kvc和kvo实现代码原理分析

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunused-variable"

#import

#import "ASClassA.h"

#import "ASClassB.h"

#import "ASClassC.h"

NSArray *getProperties(Class aClass) {

    unsigned int count;

    objc_property_t *properties = class_copyPropertyList(aClass, &count);

    NSMutableArray *mArray = [NSMutableArray array];

    for (int i = 0; i < count; i++) {

        objc_property_t property = properties[i];

        const char *cName = property_getName(property);

        NSString *name = [NSString stringWithCString:cName encoding:NSUTF8StringEncoding];

        [mArray addObject:name];

    }

    return mArray.copy;

}

NSArray *getIvars(Class aClass) {

    unsigned int count;

    Ivar *ivars = class_copyIvarList(aClass, &count);

    NSMutableArray *mArray = [NSMutableArray array];

    for (int i = 0; i < count; i++) {

        Ivar ivar = ivars[i];

        const char *cName = ivar_getName(ivar);

        NSString *name = [NSString stringWithCString:cName encoding:NSUTF8StringEncoding];

        [mArray addObject:name];

    }

    return mArray.copy;

}

NSArray *getMethods(Class aClass) {

    unsigned int count;

    Method *methods = class_copyMethodList(aClass, &count);

    NSMutableArray *mArray = [NSMutableArray array];

    for (int i = 0; i < count; i++) {

        Method method = methods[i];

        SEL selector = method_getName(method);

        NSString *selectorName = NSStringFromSelector(selector);

        [mArray addObject:selectorName];

    }

    return mArray.copy;

}

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        ASClassA *objectA = [[ASClassA alloc] init];

        ASClassB *objectB = [[ASClassB alloc] init];

        ASClassC *objectC = [[ASClassC alloc] init];

        NSString *bbb = objectB.classssss;

        //objectB.classssss = @"";

        Class classA1 = object_getClass(objectA);

        Class classA1C = [objectA class]; // objectA.class;

        NSLog(@"before objectA: %@", classA1);

        NSArray *propertiesA1 = getProperties(classA1);

        NSArray *ivarsA1 = getIvars(classA1);

        NSArray *methodsA1 = getMethods(classA1);

        IMP setterA1IMP = objectA.imp;

        IMP classA1IMP = objectA.classImp;

          Class classB1 = object_getClass(objectB);

          NSLog(@"before objectA: %@", classB1);

          NSArray *propertiesB1 = getProperties(classB1);

          NSArray *ivarsB1 = getIvars(classB1);

          NSArray *methodsB1 = getMethods(classB1);

        [objectA addObserver:objectB forKeyPath:@"value" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];

        [objectA addObserver:objectC forKeyPath:@"value" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];

        Class classA2 = object_getClass(objectA);

        Class classA2C = [objectA class];

        BOOL isSame = [objectA isEqual:[objectA self]];

        id xxxx = [[classA2 alloc] init];

        NSLog(@"after objectA: %@", classA2);

        NSArray *propertiesA2 = getProperties(classA2);

        NSArray *ivarsA2 = getIvars(classA2);

        NSArray *methodsA2 = getMethods(classA2);

        IMP setterA2IMP = objectA.imp;

        IMP classA2IMP = objectA.classImp;

          Class classB2 = object_getClass(objectB);

          NSLog(@"before objectA: %@", classB2);

          NSArray *propertiesB2 = getProperties(classB2);

          NSArray *ivarsB2 = getIvars(classB2);

          NSArray *methodsB2 = getMethods(classB2);

            NSObject *object = [[NSObject alloc] init];

            NSArray *propertiesObj = getProperties([object class]);

            NSArray *methodsObj = getMethods([object class]);

            NSArray *ivarsObj = getIvars([object class]);

        BOOL isSameClass = [classA1 isEqual:classA2];

        BOOL isSubClass = [classA2 isSubclassOfClass:classA1];

        objectA.value = 10;

        [objectA removeObserver:objectB forKeyPath:@"value"];

        [objectA removeObserver:objectC forKeyPath:@"value"];

        NSNumber *integerNumber = [NSNumber numberWithInteger:1];

        Class integerNumberClass = object_getClass(integerNumber);

        NSNumber *boolNumber = [NSNumber numberWithBool:YES];

        Class boolNumberClass = object_getClass(boolNumber);

    }

    return 0;

}

#pragma clang diagnostic pop

分析以上结果

我们通过抓取objectA在被objectB, objectC观察前和观察后的 类的类型，属性列表，变量列表，方法列表，得出：

① class: 被观察前，objectA为ASClassA类型， 被观察后，变为了NSKVONotifying_ASClassA类型，且这个类为ASClassA的子类(通过isa指向改变，事实上，object_getClass(objectA)和objectA->isa方法等价)。

② 属性，实例变量：无变化。

③ 方法列表：NSKVONotifying_ASClassA出现了四个新的方法，

我们可以注意到，被观察的值setValue:方法的实现由([ASClassA setValue:] at ASClassA.m)变为了(Foundation_NSSetUnsignedLongLongValueAndNotify)。这个被重写的setter方法在原有的实现前后插入了[self willChangeValueForKey:@“name”];调用存取方法之前总调[super setValue:newName forKey:@”name”]; [self didChangeValueForKey:@”name”];等，以触发观察者的响应。然后class方法由(libobjc.A.dylib -[NSObject class])变为了(Foundation_NSKVOClass),

这也解释了我们在被观察前被观察后执行[objectA class]方法得到结果不同的原因，-(Class)class方法的实现本来就是object_getClass，但在被观察后class方法和object_getClass结果却不一样，事实是class方法被重写了，class方法总能得到ASClassA

dealloc方法: 观察移除后使class变回去ASClassA(通过isa指向),_isKVO: 判断被观察者自己是否同时也观察了其他对象

简而言之，苹果使用了一种isa交换的技术，当objectA被观察后，objectA对象的isa指针被指向了一个新建的ASClassA的子类NSKVONotifying_ASClassA，且这个子类重写了被观察值的setter方法和class方法，dealloc和_isKVO方法，然后使objectA对象的isa指针指向这个新建的类，然后事实上objectA变为了NSKVONotifying_ASClassA的实例对象，执行方法要从这个类的方法列表里找。(同时苹果警告我们，通过isa获取类的类型是不可靠的，通过class方法总是能得到正确的类=_=!!).

KVO实现原理

当某个类的对象第一次被观察时，系统就会在运行期动态地创建该类的一个派生类，在这个派生类中重写基类中任何被观察属性的 setter 方法。 派生类在被重写的 setter 方法实现真正的通知机制，就如前面手动实现键值观察那样。这么做是基于设置属性会调用 setter 方法，而通过重写就获得了 KVO 需要的通知机制。当然前提是要通过遵循 KVO 的属性设置方式来变更属性值，如果仅是直接修改属性对应的成员变量，是无法实现 KVO 的。 同时派生类还重写了 class 方法以“欺骗”外部调用者它就是起初的那个类。然后系统将这个对象的 isa 指针指向这个新诞生的派生类，因此这个对象就成为该派生类的对象了，因而在该对象上对 setter 的调用就会调用重写的 setter，从而激活键值通知机制。此外，派生类还重写了 dealloc 方法来释放资源。

派生类NSKVONotifying_Person剖析

在这个过程，被观察对象的 isa 指针从指向原来的 Person 类，被 KVO 机制修改为指向系统新创建的子类 NSKVONotifying_Person 类，来实现当前类属性值改变的监听。

所以当我们从应用层面上看来，完全没有意识到有新的类出现，这是系统“隐瞒”了对 KVO 的底层实现过程，让我们误以为还是原来的类。但是此时如果我们创建一个新的名为 NSKVONotifying_Person 的类()，就会发现系统运行到注册 KVO 的那段代码时程序就崩溃，因为系统在注册监听的时候动态创建了名为 NSKVONotifying_Person 的中间类，并指向这个中间类了。

因而在该对象上对 setter 的调用就会调用已重写的 setter，从而激活键值通知机制。这也是 KVO 回调机制，为什么都俗称 KVO 技术为黑魔法的原因之一吧：内部神秘、外观简洁。

子类setter方法剖析

KVO 在调用存取方法之前总是调用 willChangeValueForKey:，通知系统该 keyPath 的属性值即将变更。 当改变发生后，didChangeValueForKey: 被调用，通知系统该 keyPath 的属性值已经变更。 之后，observeValueForKey:ofObject:change:context: 也会被调用。

重写观察属性的 setter 方法这种方式是在运行时而不是编译时实现的。 KVO 为子类的观察者属性重写调用存取方法的工作原理在代码中相当于：

- (void)setName:(NSString *)newName{

    [self willChangeValueForKey:@"name"];    // KVO在调用存取方法之前总调用

    [super setValue:newName forKey:@"name"]; // 调用父类的存取方法

    [self didChangeValueForKey:@"name"];    // KVO在调用存取方法之后总调用

}

总结

KVO 的本质就是监听对象的属性进行赋值的时候有没有调用 setter 方法

系统会动态创建一个继承于 Person 的 NSKVONotifying_Person

person 的 isa 指针指向的类 Person 变成 NSKVONotifying_Person，所以接下来的 person.age = newAge 的时候，他调用的不是 Person 的 setter 方法，而是 NSKVONotifying_Person（子类）的 setter 方法

重写NSKVONotifying_Person的setter方法：[super setName:newName]

通知观察者告诉属性改变。

优点：

不需要通过 setter、getter 方法去访问对象的属性，可以访问对象的私有属性

可以轻松处理集合类(NSArray)。

缺点：

一旦使用KVC你的编译器无法检查出错误，即不会对设置的键、键值路径进行错误检查。

执行效率要低于 setter 和 getter 方法。因为使用 KVC 键值编码，它必须先解析字符串，然后在设置或者访问对象的实例变量。

使用 KVC 会破坏类的封装性。

一定要注意：在实现处理变更通知方法 observeValueForKeyPath 时，要将不能处理的 key 转发给 super 的 observeValueForKeyPath 来处理。

经过查阅资料我们可以了解到。

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

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

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

//移除观察者

- (void)dealloc

{

    [self.person removeObserver:self forKeyPath:@"age"];

}

/**

1. self.person：要监听的对象

2. 参数说明：

    * @param addObserver  观察者，负责处理监听事件的对象

    * @param forKeyPath 要监听的属性

    * @param  options 观察的选项（观察新、旧值，也可以都观察）

    * @param context 上下文，用于传递数据，可以利用上下文区分不同的监听

*/[self.person addObserver:selfforKeyPath:@"name"options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOldcontext:@"Person Name"];/**

*  当监控的某个属性的值改变了就会调用

*

*  @param keyPath 监听的属性名

*  @param object  属性所属的对象

*  @param change  属性的修改情况（属性原来的值`oldValue`、属性最新的值`newValue`）

*  @param context 传递的上下文数据，与监听的时候传递的一致，可以利用上下文区分不同的监听

*/- (void)observeValueForKeyPath:(NSString*)keyPath ofObject:(id)object change:(NSDictionary*)change context:(void*)context{NSLog(@"%@对象的%@属性改变了：%@", object, keyPath, change);

KVO的实现依赖于Runtime的强大动态能力。

即当一个类型为 ObjectA 的对象，被添加了观察后，系统会生成一个 NSKVONotifying_ObjectA 类，并将对象的isa指针指向新的类，也就是说这个对象的类型发生了变化。这个类相比较于ObjectA，会重写以下几个方法。

重写setter

在 setter 中，会添加以下两个方法的调用。

- (void)willChangeValueForKey:(NSString*)key;

- (void)didChangeValueForKey:(NSString*)key;

然后在 didChangeValueForKey: 中，去调用：

- (void)observeValueForKeyPath:(nullableNSString*)keyPath ofObject:(nullableid)object change:(nullableNSDictionary *)change context:(nullablevoid*)context;

包含了新值和旧值的通知。

于是实现了属性值修改的通知。因为 KVO 的原理是修改 setter 方法，因此使用 KVO 必须调用 setter 。若直接访问属性对象则没有效果。

重写class

当修改了isa指向后，class的返回值不会变，但isa的值则发生改变。

//生成对象ObjectA *objA = [[ObjectA alloc] init]; 

 ObjectB *objB = [[ObjectB alloc] init];// 添加Observer之后

[objA addObserver:objB forKeyPath:@"age"options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOldcontext:nil];

// 输出ObjectANSLog(@"%@", [objAclass]);

// 输出NSKVONotifying_ObjectA（object_getClass方法返回isa指向）

NSLog(@"%@", object_getClass(objA));

打印结果：

2018-05-06 22:47:05.538899+0800 KVCKVO[38474:13343992] ObjectA

2018-05-06 22:47:05.539242+0800 KVCKVO[38474:13343992] NSKVONotifying_ObjectA

重写dealloc

系统重写 dealloc 方法来释放资源。

重写_isKVOA

这个私有方法是用来标示该类是一个 KVO 机制声称的类。