#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
#import <Foundation/Foundation.h>
#import "ASClassA.h"
#import "ASClassB.h"
#import "ASClassC.h"
NSArray<NSString *> *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<NSString *> *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<NSString *> *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 机制声称的类。
网友评论