iOS KVO 底层原理

作者: Joker_King | 来源:发表于2020-02-14 12:02 被阅读0次

什么是KVO？

KVO是一种机制，他是建立在KVC的基础上的，他可以将其他对象属性值的变化通知给对象。

1.1、注册KVO

您必须执行以下步骤，才能使对象能够接收KVO兼容属性的键值观察通知：

使用方法addObserver:forKeyPath:options:context:将观察者注册到观察对象。
observeValueForKeyPath:ofObject:change:context:在观察者内部实现这个方法以接收更改通知消息。
removeObserver:forKeyPath:当观察者不再需要接收消息时，使用该方法注销观察者。最晚在从内存释放观察者之前调用此方法。
removeObserver:forKeyPath:context:当我们在注册观察者的时候，如果context参数不为NULL时，应该使用这个方法来移除，这样更安全。

1.2、context参数解释

addObserver:forKeyPath:options:context:方法中的context参数将在相应的observeValueForKeyPath:ofObject:change:context:中回传给观察者。你可以将这个参数指定为NULL，通过依赖keyPath来确定观察属性的来源，但是当有多个对象具有相同的属性被观察时，根据keyPath来判断就显得不那么方便了。

一种更安全，更具扩展性的方法是使用context来进行区分。

context指针的创建。

static void * PersonAccountBalanceContext =＆PersonAccountBalanceContext;
static void * PersonAccountInterestRateContext =＆PersonAccountInterestRateContext;

2.1、接收KVO的通知

当观察到的对象属性值改变时，观察者会收到一条observeValueForKeyPath:ofObject:change:context: 消息。所有观察者都必须实现此方法。

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context {
 
    if (context == PersonAccountBalanceContext) {
        // Do something
 
    } else if (context == PersonAccountInterestRateContext) {
        // Do something
 
    } else {
        // Any unrecognized context must belong to super
        [super observeValueForKeyPath:keyPath
                             ofObject:object
                               change:change
                               context:context];
    }
}

当我们在注册观察者的时候使用context参数时，那么在接收通知的地方就可以使用context来区分是哪个对象的属性触发了通知回调。

如果在注册观察者时用NULL传递个context，那么将使用keyPath来进行比较，已确定是哪个对象的属性进行了更改。

无论如何，观察者应始终observeValueForKeyPath:ofObject:change:context:在其无法识别context（或在简单情况下，是任意的keyPath）时调用父类的实现，因为这意味着父类也已注册了通知。

如果通知传递到类层次结构的顶部，则NSObject抛出，NSInternalInconsistencyException因为这是编程错误：子类无法使用为其注册的通知。

3、移除KVO

通过向被观察对象发送一条removeObserver:forKeyPath:context:消息，指定observer，keyPath和context，可以删除键值观察者。

移除观察者时，请谨记以下几点。

如果移除了一个没有注册的观察者，则将会引发一个NSRangeException异常，你可以将removeObserver:forKeyPath:context:调用放在try / catch块中以处理潜在的异常。
当对象释放后，观察者不会自动被移除，如果被观察对象也没有被释放，那么被观察对象会继续发送通知，和其他的对象一样，向已释放的对象发送消息，会触发内存异常。为此，要确保观察者在对象释放之前，删除自己。
该协议无法询问对象是观察者还是被观察者。为了代码不出现相关的错误。一种典型的做法是在观察者初始化期间（例如在中init或中viewDidLoad）注册为观察者，在释放过程中（通常在中dealloc）注销（确保正确配对和排序的添加和删除消息），并且在对象从内存中释放之前将其注销。。

4、自动通知与手动通知

KVO默认的是自动通知，也就是当我们属性的值变化的时候，就会自动发送通知，我们可以在改类中重写automaticallyNotifiesObserversForKey:方法来控制是否启用自动通知。

+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
    return YES;
}

返回为YES时，是为该对象的所有属性启用自动通知。
返回为NO时，是为该对象的所有对象禁用自动通知。

我们可以根据Key来判断，为某一个属性启用或者禁用自动通知。

另外针对特定的属性启用和禁用自动通知，系统还给我们生成了唯一的方法。

@interface Account : NSObject
@property (nonatomic, assign) double balance;
@property (nonatomic, assign) double interesRate;
@end

以Account中的属性为例，编译器为我们自动生成了两个方法，分别来控制该属性是否启用自动通知。

+ (BOOL)automaticallyNotifiesObserversOfBalance {
    return NO;
}

+ (BOOL)automaticallyNotifiesObserversOfInteresRate {
    return NO;
}

automaticallyNotifiesObserversForKey:方法的优先级大于特定属性生成的方法，如果实现了automaticallyNotifiesObserversForKey:方法，那么特定属性的方法将不会被调用。

要实现手动观察者通知，请手动调用willChangeValueForKey:在更改值之前和didChangeValueForKey:更改值之后。以balance属性实现了手动通知。

- (void)setBalance:(double)theBalance {
    [self willChangeValueForKey:@"balance"];
    _balance = theBalance;
    [self didChangeValueForKey:@"balance"];
}

5、可变集合的KVO

当我们监听的对象的属性是可变集合或者是可变数组时，如果我们想要得到数组或者集合内容变化时的通知，我们需要做一些特殊的处理。

使用mutableArrayValueForKey:方法取出对象中的数组，然后在对可变数组进行操作，此时我们就可以得到数组内容变化的通知了。

NSMutableArray *mArray = [self.account mutableArrayValueForKey:@"transactions"];
[mArray addObject:@"4"];

可变集合的操作和这个类似，使用mutableSetValueForKey:。

6、属性依赖

当一个属性的值是依赖于其他几个属性来决定的时候，我们可以使用keyPathsForValuesAffectingValueForKey:方法或者使用遵循命名方式的keyPathsForValuesAffectingValueFor<Key>来建立以来关系。

例如，一个人的全名取决于名字和姓氏。返回全名的方法可以编写如下：

- (NSString *)fullName {
    return [NSString stringWithFormat:@"%@ %@",firstName, lastName];
}

我们在外部监听fullName，当firstName或者lastName的值发生改变时，则应该触发回调。
下面介绍两种建立依赖的方法。

+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key {
 
    NSSet *keyPaths = [super keyPathsForValuesAffectingValueForKey:key];
 
    if ([key isEqualToString:@"fullName"]) {
        NSArray *affectingKeys = @[@"lastName", @"firstName"];
        keyPaths = [keyPaths setByAddingObjectsFromArray:affectingKeys];
    }
    return keyPaths;
}

+ (NSSet *)keyPathsForValuesAffectingFullName {
    return [NSSet setWithObjects:@"lastName", @"firstName", nil];
}

KVO实现原理

KVO是使用isa-swizzling技术实现的，简单来说就是修改了对象的isa指针，使其指向中间类而不是真正的类，所以isa指针的值并不能反映实例的实际类，所以应该使用class方法来确定对象的实际类。

1.1、KVO验证

接下来我们就做一个简单的验证。
现在我们有一个Person类

@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@end

我们分别在添加KVO之前和添加KVO只有来输出对象的isa指针看看。

self.person = [Person new];
{
    Class cls = object_getClass(self.person);
    NSLog(@"%@", NSStringFromClass(cls));
}

[self.person addObserver:self forKeyPath:@"name" options:(NSKeyValueObservingOptionNew) context:NULL];
{
    Class cls = object_getClass(self.person);
    NSLog(@"%@", NSStringFromClass(cls));
}

输出结果如下

2020-02-14 10:24:32.252254+0800 KVO原理探索[23368:1376988] Person
2020-02-14 10:24:32.252750+0800 KVO原理探索[23368:1376988] NSKVONotifying_Person

我们发现两次输出的结果不一样，对象没有添加KVO之前，isa指针指向的是Person类，添加了KVO之后对象的isa指针，指向的是NSKVONotifying_Person。至此我们可以得出对象在添加KVO之后，在运行时为我们动态的生成了一个NSKVONotifying_Person的类，并且将这个对象的isa指针指向了这个新的类。

1.2、动态类的继承关系

我们都知道，在OC中，所有的类，都有一个父类，我们来看看NSKVONotifying_Person的继承关系。

Class cls = object_getClass(self.person);
NSLog(@"%@", NSStringFromClass(cls));

Class supCls = cls;
do {
    supCls = [supCls superclass];
    NSLog(@"%@", NSStringFromClass(supCls));
} while (supCls);

这段代码将会输出类的所有父类。

2020-02-14 10:37:24.826558+0800 KVO原理探索[23558:1388700] NSKVONotifying_Person
2020-02-14 10:37:24.826718+0800 KVO原理探索[23558:1388700] Person
2020-02-14 10:37:24.826840+0800 KVO原理探索[23558:1388700] NSObject
2020-02-14 10:37:24.826945+0800 KVO原理探索[23558:1388700] (null)

通过验证，我们发现NSKVONotifying_Person是直接继承与Person的。

1.3、动态类方法探究

接下来我们看看这个动态生成的类中都有那写方法，我们使用Runtime的API来输出这个类中的所有方法以及他们的实现。

- (void)printClassAllMethod:(Class)cls {
    unsigned int count = 0;
    Method *methods = class_copyMethodList(cls, &count);
    for (int i = 0; i < count; i++) {
        Method method = methods[i];
        SEL methodSel = method_getName(method);
        IMP methodImp = method_getImplementation(method);
        NSLog(@"%@-%p", NSStringFromSelector(methodSel), methodImp);
    }
    free(methods);
}

调用上面的这段代码就可以输出这个类中都定义了哪些方法，我们来看看NSKVONotifying_Person中都有哪些。

2020-02-14 11:43:09.706699+0800 KVO原理探索[24582:1444989] setName:-0x7fff25721c7a
2020-02-14 11:43:09.706794+0800 KVO原理探索[24582:1444989] class-0x7fff2572073d
2020-02-14 11:43:09.706871+0800 KVO原理探索[24582:1444989] dealloc-0x7fff257204a2
2020-02-14 11:43:09.706973+0800 KVO原理探索[24582:1444989] _isKVOA-0x7fff2572049a

我们发现它重写了三个方法并且自定义了一个方法，最主要的是它重写了属性的setter方法。

这里我们也输出一下Person类中的所有方法。

2020-02-14 11:41:12.101584+0800 KVO原理探索[24582:1444989] .cxx_destruct-0x108053ee0
2020-02-14 11:41:12.101732+0800 KVO原理探索[24582:1444989] name-0x108053e70
2020-02-14 11:41:12.101854+0800 KVO原理探索[24582:1444989] setName:-0x108053ea0

接下来我们来看看，添加KVO之后设置属性时，有哪些变化。

没有添加KVO

我们可以看到对象在没有添加KVO时，直接调用了属性的setter方法对属性进行赋值。通过方法的地址可以验证。

2020-02-14 11:41:12.101854+0800 KVO原理探索[24582:1444989] setName:-0x108053ea0

上面setter方法的地址和调用地址是一样的，由此可以得出是直接调用了setter方法。

添加了KVO

当对象在添加了KVO之后，我们再对属性进行赋值的时候调用的不一样了。我们发现这里调用的方法的地址就是我们动态类中setter方法的地址。

2020-02-14 11:43:09.706699+0800 KVO原理探索[24582:1444989] setName:-0x7fff25721c7a

所以当对象添加了KVO之后，再对属性进行赋值时调用的是动态类中重写的方法。在这个方法中我们发现它调用了willChangeValueForKey:和didChangeValueForKey:，根据官网的介绍可知，这两个方法是用来发送通知的。

调用堆栈
最后调用父类的setter方法来赋值。

调用堆栈

2、原理总结

监听者监听Person对象的某一个属性的变化，系统会动态为类Person创建一个子类NSKVONotifying_Person，并将Person对象的isa指针重新指向该子类
系统会重写Person对象的setter方法。( 赋值前后分别调用willChangeValueForKey和didChangeValueForKey跟踪新旧值 )。在对象赋值时是调用父类的setter方法来处理的。
当Person对象的属性发生改变时，系统通知监听者，调用observeValueForKey：ofObject：change：context方法即可。

问题。
当我们的对象添加了KVO之后，为什么通过class方法获取到的类是Person呢？
因为NSKVONotifying_Person重写了class方法，在这个方法中返回为Person。但是object_getClass获取到的是isa指针，所以调用object_getClass返回的是NSKVONotifying_Person。