iOS KVO 底层原理

什么是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:消息,指定observerkeyPathcontext,可以删除键值观察者。

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

  • 如果移除了一个没有注册的观察者,则将会引发一个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来建立以来关系。

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

- (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方法。( 赋值前后分别调用willChangeValueForKeydidChangeValueForKey跟踪新旧值 )。在对象赋值时是调用父类的setter方法来处理的。
  • Person对象的属性发生改变时,系统通知监听者,调用observeValueForKey:ofObject:change:context方法即可。

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

你可能感兴趣的:(iOS KVO 底层原理)