iOS plusiOS Developer

KVC && KVO

2017-07-06  本文已影响82人  Liberalism

1.KVC

关于KVC和KVO,我之前的总结文章有写过，但是实际上我在平日工作里，KVC和KVO使用的相对较少，不是KVC和KVO的功能不够强大，这实际上和项目的架构有比较大的关系，以前的我对于KVC和KVO的使用也是趋于表面，没有探究其内部真正的实现原理和进阶用法，这次总结正好给了我很好的学习机会，在此深入的总结一下KVC和KVO吧。

KVC，即是指 NSKeyValueCoding，一个非正式的 Protocol，提供一种机制来间接访问对象的属性。KVO 就是基于 KVC 实现的关键技术之一。

KVC在iOS中的定义

Objective-C中KVC的定义是对NSObject的扩展来实现的。所以对于所有继承了NSObject在类型，都可以使用KVC，下面是KVC最为重要的四个方法

- (nullable id)valueForKey:(NSString *)key;                          //直接通过Key来取值
- (void)setValue:(nullable id)value forKey:(NSString *)key;          //通过Key来设值
- (nullable id)valueForKeyPath:(NSString *)keyPath;                  //通过KeyPath来取值
- (void)setValue:(nullable id)value forKeyPath:(NSString *)keyPath;  //通过KeyPath来设值

一般来讲，Obj-C 对象中都会有一些属性。如代码所示

#import <Foundation/Foundation.h>
@interface Person : NSObject

/** name */
@property (nonatomic,copy  ) NSString *name;

/** Address */
@property (nonatomic,copy  ) NSString *address;

@end

上面的Person对象所拥有的两个属性，以 KVC的角度来看，就是Person对象的name,address这两个属性分别有一个Value对应他们的Key值。

KVC 为存取值提供了两个最基础的方法。

    Person *man = [Person new];
    
    // 存值
    [man setValue:@"LiMing" forKey:@"name"];
    
    // 取值
    NSString *name = [man valueForKey:@"name"];
    
    NSLog(@"%@",name);

KVC 为了便于使用还提供了另外两个方法。

假设我们之前创建的这个对象有一个配偶，配偶也是一个Person对象,此时我们想在man这里读出woman的name属性

可以这样操作

    Person *woman = [Person new];
    
    man.spouse = woman;
    
    [man setValue:@"Lily" forKeyPath:@"spouse.name"];
    
    NSLog(@"%@",[man valueForKeyPath:@"spouse.name"]);
    
    //  Key 与 KeyPath 要区分开来
    //  Key 可以让你从一个对象中获取值
    //  KeyPath  可以让你通过连续的多个Key获取值，着多个key值用点号 “.” 分割连接起来

简单对比一下

    //  结果一样的，但是用 KeyPath 更简单
    [man valueForKeyPath:@"spouse.name"]

    [[man valueForKey:@"spouse"] valueForKey:@"name"];

KVC寻找Key值过程

KVC在某种程度上提供了访问器的替代方案，不过只要有可能，KVC也是在访问器方法的帮助下工作。KVC按照以下顺序寻找Key值。

1.赋值

当程序调用

- (void)setValue:(nullable id)value forKey:(NSString *)key;
1.优先寻找访问器方法

程序会优先调用setKey的属性值方法，代码直接通过Setter方法完成设置。这里的key值指的是成员变量名，Key值首字母大写要符合Setter和Getter方法的命名规则。

2.寻找_key

如果没有找到setKey的访问器方法，KVC机制会检查

+ (BOOL)accessInstanceVariablesDirectly

的返回值是否为NO，此方法默认返回的是YES。如果开发者重写了该方法让这个返回值为NO时，接下来KVC会直接调用

- (void)setValue:(id)value forUndefinedKey:(NSString *)key

这个时候如果你不做其他操作，就要报出异常了，所以一般人都不会这么做。

接下来KVC机制会搜索该类里面有没有_key的成员变量，无论你是在声明文件中定义，还是在实现文件中定义，也无论使用了什么样的属性修饰符，只要存在着_key命名的变量，KVC都可以对该成员变量赋值。

3.寻找_isKey

如果该类即没有setKey：的访问器方法，也没有_key成员变量，KVC机制会搜索_isKey的成员变量。

4.寻找Key和isKey

和上面一样，如果该类即没有setKey：的访问器方法，也没有_key和_isKey成员变量，KVC机制再会继续搜索key和isKey的成员变量。再给它们赋值。

如果上面列出的方法或者成员变量都不存在，系统将会执行该对象的setValue：forUNdefinedKey：方法，默认是抛出异常。

如果开发者想让这个类禁用KVC里，那么重写+ (BOOL)accessInstanceVariablesDirectly方法让其返回NO即可，这样的话如果KVC没有找到set<Key>:属性名时，会直接用setValue：forUNdefinedKey：方法。

2.取值

当程序调用

- (nullable id)valueForKey:(NSString *)key;
1.优先查找访问器的方法

首先按getKey、key、isKey的顺序查找getter方法，找到直接调用。如果是bool、int等内建值类型，会做NSNumber的转换。

2.有序集合中查找

上面的getter没有找到，查找countOfKey、objectInKeyAtIndex:、KeyAtIndexes格式的方法。
如果countOfKey和另外两个方法中的一个找到，那么就会返回一个可以响应NSArray所有方法的代理集合。发送给这个代理集合的NSArray消息方法，就会以countOfKey、objectInKeyAtIndex:、KeyAtIndexes这几个方法组合的形式调用。还有一个可选的 getKey:range: 方法。

3.无序集合中查找

还没查到，那么查找countOfKey、enumeratorOfKey、memberOfKey:格式的方法。
如果这三个方法都找到，那么就返回一个可以响应NSSet所有方法的代理集合。发送给这个代理集合的NSSet消息方法，就会以countOfKey、enumeratorOfKey、memberOfKey:组合的形式调用。

4.搜索成员变量名

还是没查到，那么如果类方法accessInstanceVariablesDirectly返回YES，那么按_key，_isKey，key，iskey的顺序直接搜索成员名。

5.报出异常

再找不到，调用ValueForUndefinedKey:，默认报出异常

针对集合的KVC

我们上面讲的KVC是一对一关系,比如Person类中的name属性。但也有一对多的关系，比如Person中有一个friendsName属性，保存的是一个人的所有朋友的名字，这时候就需要集合来处理了。

对于集合类的处理，我们有两种选择

1.通过KVC将集合类先取出，然后在针对集合进行处理

2.采用KVC提供的模板方法

有序集合

这里面的Key，就是被监听的属性名称

-countOfKey  
//必须实现，对应于NSArray的基本方法count:  

- objectInKeyAtIndex:
- keyAtIndexes:  
//这两个必须实现一个，对应于 NSArray 的方法 objectAtIndex: 和 objectsAtIndexes: 
 
- getKey:range:  
//不是必须实现的，但实现后可以提高性能，其对应于 NSArray 方法 
- getObjects:range:  
  
- insertObject:inKeyAtIndex:  
- insertKey:atIndexes:  
//两个必须实现一个，类似于 NSMutableArray 的方法 insertObject:atIndex: 和 insertObjects:atIndexes:  

- removeObjectFromKeyAtIndex:  
- removeKeyAtIndexes:  
//两个必须实现一个，类似于 NSMutableArray 的方法 removeObjectAtIndex: 和 removeObjectsAtIndexes:  

- replaceObjectInKeyAtIndex:withObject:  
- replaceKeyAtIndexes:withKey:  
//可选的，如果在此类操作上有性能问题，就需要考虑实现之
无序集合
- countOfKey 
//必须实现，对应于NSArray的基本方法count: 
 
- objectInKeyAtIndex:  
- keyAtIndexes:  
//这两个必须实现一个，对应于 NSArray 的方法 objectAtIndex: 和 objectsAtIndexes:

- getKey:range:  
//不是必须实现的，但实现后可以提高性能，其对应于 NSArray 方法 
- getObjects:range:  
  
- insertObject:inKeyAtIndex:  
- insertKey:atIndexes:
//两个必须实现一个，类似于 NSMutableArray 的方法 insertObject:atIndex: 和 insertObjects:atIndexes:  

- removeObjectFromKeyAtIndex:  
- removeKeyAtIndexes:  
//两个必须实现一个，类似于 NSMutableArray 的方法 removeObjectAtIndex: 和 removeObjectsAtIndexes:

- replaceObjectInKeyAtIndex:withObject:  
- replaceKeyAtIndexes:withKey:  
//这两个都是可选的，如果在此类操作上有性能问题，就需要考虑实现之

KVC对基本数据类型和结构体的支持

1.对基本数据类型会以 NSNumber 进行包装
+ (NSNumber *)numberWithChar:(char)value;  
+ (NSNumber *)numberWithUnsignedChar:(unsigned char)value;  
+ (NSNumber *)numberWithShort:(short)value;  
+ (NSNumber *)numberWithUnsignedShort:(unsigned short)value;  
+ (NSNumber *)numberWithInt:(int)value;  
+ (NSNumber *)numberWithUnsignedInt:(unsigned int)value;  
+ (NSNumber *)numberWithLong:(long)value;  
+ (NSNumber *)numberWithUnsignedLong:(unsigned long)value;  
+ (NSNumber *)numberWithLongLong:(long long)value;  
+ (NSNumber *)numberWithUnsignedLongLong:(unsigned long long)value;  
+ (NSNumber *)numberWithFloat:(float)value;  
+ (NSNumber *)numberWithDouble:(double)value;  
+ (NSNumber *)numberWithBool:(BOOL)value;  
+ (NSNumber *)numberWithInteger:(NSInteger)value NS_AVAILABLE(10_5, 2_0);  
+ (NSNumber *)numberWithUnsignedInteger:(NSUInteger)value NS_AVAILABLE(10_5, 2_0);
2.对结构体会以 NSValue 进行包装
+ (NSValue *)valueWithCGPoint:(CGPoint)point;  
+ (NSValue *)valueWithCGSize:(CGSize)size;  
+ (NSValue *)valueWithCGRect:(CGRect)rect;  
+ (NSValue *)valueWithCGAffineTransform:(CGAffineTransform)transform;  
+ (NSValue *)valueWithUIEdgeInsets:(UIEdgeInsets)insets;  
+ (NSValue *)valueWithUIOffset:(UIOffset)insets NS_AVAILABLE_IOS(5_0);

所有的结构体都支持以NSValue进行封装

KVC中的集合运算符

集合运算符是一个特殊的KeyPath，可以作为参数传递给valueForKeyPath：方法

1.简单的集合运算符

简单的集合运算符有以下几个 @avg，@count，@max，@min，@sum5

2.对象运算符

对象运算符有@distinctUnionOfObjects,
@unionOfObjects,这两个运算符返回的对象都是NSArray。

1.@distinctUnionOfObjects会将集合在剔除重复对象之后返回

2.@unionOfObjects会直接返回所有对象

NSKeyValueCoding其他方法

+ (BOOL)accessInstanceVariablesDirectly;
//默认返回YES，表示如果没有找到SetKey方法的话，会按照_key，_iskey，key，iskey的顺序搜索成员，设置成NO就会直接抛出异常。

- (BOOL)validateValue:(inout id __nullable * __nonnull)ioValue forKey:(NSString *)inKey error:(out NSError **)outError;
//KVC提供属性值确认的API，它可以用来检查set的值是否正确、为不正确的值做一个替换值或者拒绝设置新值并返回错误原因。

- (NSMutableArray *)mutableArrayValueForKey:(NSString *)key;
//这是集合操作的API，里面还有一系列这样的API，如果属性是一个NSMutableArray，那么可以用这个方法来返回

- (nullable id)valueForUndefinedKey:(NSString *)key;
//如果Key不存在，且没有KVC无法搜索到任何和Key有关的字段或者属性，则会调用这个方法，默认是抛出异常

- (void)setValue:(nullable id)value forUndefinedKey:(NSString *)key;
//和上一个方法一样，只不过是设值。

- (void)setNilValueForKey:(NSString *)key;
//如果你在SetValue方法时面给Value传nil，则会调用这个方法

- (NSDictionary<NSString *, id> *)dictionaryWithValuesForKeys:(NSArray<NSString *> *)keys;
//输入一组key,返回该组key对应的Value，再转成字典返回，用于将Model转到字典。

没想到光一个KVC就写了这么多的内容，而越深入写就越觉得自己写的不过是皮毛，接下来再说说KVO吧。

2.KVO

1.认识KVO

KVO类似于观察者模式，我们利用简单的代码来了解什么是KVO。

//  注册一个Person类
#import <Foundation/Foundation.h>

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

// 再注册一个Dog类
#import <Foundation/Foundation.h>

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

我们在ViewController中引入头文件，并创建两个全局的属性。我们希望Person作为Dog的观察者，当Dog的name属性发生变化的时候，Person可以第一时间知道。这时我们就可以运用KVO的技术。

    Person *p = [Person new];
    self.p = p;
    Dog *dog = [Dog new];
    self.dog = dog;
   
   // 成为其他对象的观察者要进行注册
   // KeyPath代表监听对象的具体属性
   // Observe就是观察者喽
   // Options可以指定管擦得值得新旧等
   // Context可以是任何对象，可以向观察者传递信息，也可以用指定的标识对不同的观察者进行区分
    [dog addObserver:p
          forKeyPath:@"name"
             options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld)
             context:nil];

    dog.name = @"旺财";

监听选项Options是由枚举NSKeyValueObservingOptions定义的，他决定了哪些值可以被传入到观察者内部实现的方法中。

定义如下：

enum {
       // 提供新值
    NSKeyValueObservingOptionNew = 0x01,
    
    // 提供旧值
    NSKeyValueObservingOptionOld = 0x02,
    
    // 添加观察者时立即发送一个通知给观察者，
    // 并且是在注册观察者方法返回之前
    NSKeyValueObservingOptionInitial = 0x04,
    
    // 如果指定，则在每次修改属性时，会在修改通知被发送之前预先发送一条通知给观察者，
    // 这与-willChangeValueForKey:被触发的时间是相对应的。
    // 这样，在每次修改属性时，实际上是会发送两条通知。
    NSKeyValueObservingOptionPrior = 0x08 
};
typedef NSUInteger NSKeyValueObservingOptions;
//  选项值可以支持多个选项

注册之后，我们要在观察者内部实现如下方法

// 此时，当被观察者的属性发生变更，观察者就会自动调用如下方法
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    
    // keyPath被观察的属性值
    NSLog(@"keyPath = %@",keyPath);
    
    // object被观察的对象
    NSLog(@"object = %@",object);
    
    // 被观察属性值得变化，后面还会讲
    NSLog(@"change = %@",change);
    
    // 上下文，也可以是任意的额外数据
    // 这个Context的作用十分重要，我在后面会强调
    NSLog(@"context = %@",context);
}
// 我们通过这个方法，可以得到一些关键信息

Change选项，它记录了被监听属性的变化情况。可以通过key来获取值：


// 属性变化的类型，是一个NSNumber对象，包含NSKeyValueChange枚举相关的值
NSString *const NSKeyValueChangeKindKey;

// 属性的新值。当NSKeyValueChangeKindKey是 NSKeyValueChangeSetting，
// 且添加观察的方法设置了NSKeyValueObservingOptionNew时，我们能获取到属性的新值。
// 如果NSKeyValueChangeKindKey是NSKeyValueChangeInsertion或者NSKeyValueChangeReplacement，
// 且指定了NSKeyValueObservingOptionNew时，则我们能获取到一个NSArray对象，包含被插入的对象或
// 用于替换其它对象的对象。
NSString *const NSKeyValueChangeNewKey;

// 属性的旧值。当NSKeyValueChangeKindKey是 NSKeyValueChangeSetting，
// 且添加观察的方法设置了NSKeyValueObservingOptionOld时，我们能获取到属性的旧值。
// 如果NSKeyValueChangeKindKey是NSKeyValueChangeRemoval或者NSKeyValueChangeReplacement，
// 且指定了NSKeyValueObservingOptionOld时，则我们能获取到一个NSArray对象，包含被移除的对象或
// 被替换的对象。
NSString *const NSKeyValueChangeOldKey;

// 如果NSKeyValueChangeKindKey的值是NSKeyValueChangeInsertion、NSKeyValueChangeRemoval
// 或者NSKeyValueChangeReplacement，则这个key对应的值是一个NSIndexSet对象，
// 包含了被插入、移除或替换的对象的索引
NSString *const NSKeyValueChangeIndexesKey;

// 当指定了NSKeyValueObservingOptionPrior选项时，在属性被修改的通知发送前，
// 会先发送一条通知给观察者。我们可以使用NSKeyValueChangeNotificationIsPriorKey
// 来获取到通知是否是预先发送的，如果是，获取到的值总是@(YES)
NSString *const NSKeyValueChangeNotificationIsPriorKey;

NSKeyValueChangeKindKey的值取自于NSKeyValueChange，这是一个枚举值，定义如下

enum {
    // 设置一个新值。被监听的属性可以是一个对象，也可以是一对一关系的属性或一对多关系的属性。
    NSKeyValueChangeSetting = 1,
    
    // 表示一个对象被插入到一对多关系的属性。
    NSKeyValueChangeInsertion = 2,
    
    // 表示一个对象被从一对多关系的属性中移除。
    NSKeyValueChangeRemoval = 3,
    
    // 表示一个对象在一对多的关系的属性中被替换
    NSKeyValueChangeReplacement = 4
};
typedef NSUInteger NSKeyValueChange;

注意，观察者在不需要使用的时候一定要移除，否则会产生崩溃

- (void)dealloc {

    [self.dog removeObserver:self.p forKeyPath:@"name"];
}

通过上面简要的代码示例，我们可以得知，时运观察者只需要实现简单的几步。

  1. 注册观察者
  2. 观察者实现相应的方法
  3. 移除观察者

2.KVC和KVO的实现原理

KVC和KVO是基于强大的Runtime来实现的。其中使用到的技术就是isa-swilling,isa-swilling这项技术也是一个重点，我们会在后续的Runtime部分会讲到。如果有看到此处不明白的同学也请保持耐心。

网上有一篇文章针对实现原理写的很好，链接在此。

整体来说就是，当某个类的对象第一次被观察时，系统会在运行期间动态的为这个类创建一个派生类，假如被监听类名为ClassA，那么派生类的名称就为NSKVONotifying_ClassA。

1.原有对象的isa指针会指向全新的派生类，派生类为了混淆，避免别人知道他不是原来的类，所以派生类重写了Class的类方法。

2.同时重写了Dealloc方法，用于资源的销毁处理。

3.还重写了_isKVOA,这个是一个标记，用于标示这个类是遵守KVO机制的。

4.最关键的是重写了被监听属性的Setter方法，这是实现KVO的关键。至于为什么，后面会讲解到。

简单的画了张图，可能会有助于理解。


我们上面讲重写了被观察对象属性的Setter方法是十分关键的，这就要说起另外两个十分重要的方法

// 在属性值即将被修改的时候，会调用这个方法
- (void)willChangeValueForKey:(NSString *)key;

// 在属性值已经被修改的时候，会调用这个方法
- (void)didChangeValueForKey:(NSString *)key;

// didChangeValueForKey:方法会显式的调用
- (void)observeValueForKeyPath:(NSString *)keyPath 
                      ofObject:(id)object 
                        change:(NSDictionary<NSKeyValueChangeKey,id> *)change 
                       context:(void *)context {
                       }

其实我个人猜测，重写Setter方法内部应该这样实现的

[self willChangeValueForKey:@"name"];
[super setName:name];
[self didChangeValueForKey:@"name"];

说到这里，相信你应该完整的明白KVO的实现机制了。

// 这才是KVO机制触发的关键
- (void)didChangeValueForKey:(NSString *)key;

3.调用KVO的三种方法

综合上面KVO的实现原理，我们可以得出如下结论：

1.使用了KVC

使用了KVC，如果有访问器方法，则运行时会在访问器方法中调用will/didChangeValueForKey:方法；
没用访问器方法，运行时会在setValue:forKey方法中调用will/didChangeValueForKey:方法。

2.有访问器方法

运行时会重写访问器方法调用will/didChangeValueForKey:方法。
因此，直接调用访问器方法改变属性值时，KVO也能监听到。

3.直接调用

显式调用will/didChangeValueForKey:方法。

4.KVO自动通知、手动通知

通常意义下我们使用的都是自动通知，注册观察者之后，当触发will/didChangeValueForKey:方法后，观察者对象的- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context { }方法会被调用。

如果像实现手动通知，我们需要借助一个额外的方法

+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key

这个方法默认返回YES,用来标记Key指定的属性是否支持KVO，如果返回值为NO，则需要我们手动更新。

我们还是用我们最上面的例子，监听Person的name属性，不过这次我们采取手动通知的方式。

#import "Person.h"

@implementation Person

+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {

    BOOL automaic = NO;
    if ([key isEqualToString:@"name"])
    {
        automaic = NO;
    }
    else
    {
        // 此处需要注意，没有被处理的其他属性要调用父类的原有方法
        automaic = [super automaticallyNotifiesObserversForKey:key];
    }
    return automaic;
}
@end

这样我们就已经标记好当Person的name属性发生改变时，手动发送通知，代码如下：

@implementation Person

- (void)setName:(NSString *)name {
    
    if(name != _name)// 加一处判断，如果值相同，就无需发送通知了
    {   
        // 我们需要在值修改前调用`will...`方法
        [self willChangeValueForKey:@"name"];
        _name = name;
        // 我们还需要在修改后调用`did...`方法，显式调用观察者的方法
        [self didChangeValueForKey:@"name"];
    }
}
@end

手动发送通知一对一的操作方法如上，如果是一对多的案例，则可以使用如下方法

- (void)willChange:(NSKeyValueChange)change valuesAtIndexes:(NSIndexSet *)indexes forKey:(NSString *)key
- (void)didChange:(NSKeyValueChange)change valuesAtIndexes:(NSIndexSet *)indexes forKey:(NSString *)key
  
- (void)willChangeValueForKey:(NSString *)key withSetMutation:(NSKeyValueSetMutationKind)mutationKind usingObjects:(NSSet *)objects
- (void)didChangeValueForKey:(NSString *)key withSetMutation:(NSKeyValueSetMutationKind)mutationKind usingObjects:(NSSet *)objects

5.注册依赖键

实际开发过程中可能会遇到这种场景，某个变量的值取决于其他的值。

我们还是看一个例子吧：

// 声明一个Person类，有三个属性
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic,copy) NSString *fullName;
@property (nonatomic,copy) NSString *firstName;
@property (nonatomic,copy) NSString *lastName;

@end

// 其中 fullName 取决于 firstName 和 lastName的值.
// 同时如果 firstName 和 lastName发生改变的话,fullName也会受到影响。

#import "Person.h"

@implementation Person

// 注册 fullName依赖于 firstName 和 lastName
+ (NSSet<NSString *> *)keyPathsForValuesAffectingFullName {

    return [NSSet setWithObjects:@"firstName",@"lastName",nil];
}

- (NSString *)fullName {

    NSString *tempName = _fullName;
    
    if (_firstName || _lastName)
    {
        tempName = [NSString stringWithFormat:@"%@-%@",_firstName,_lastName];
    }

    return tempName;
}

回到Controller：

- (void)viewDidLoad {
    
    [super viewDidLoad];
    
    Person *p = [Person new];
    self.p = p;
    
    [self.p  addObserver:self
        forKeyPath:NSStringFromSelector(@selector(name))
           options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew
           context:ContextMark];
    
    self.p.fullName = @"lilei";
    NSLog(@"fullName = %@",self.p.fullName);
    
    self.p.firstName = @"lala";
    NSLog(@"fullName = %@",self.p.fullName);

    self.p.lastName = @"papa";
    NSLog(@"fullName = %@",self.p.fullName);
}

// 打印结果如下
fullName = lilei
fullName = lala-(null)
fullName = lala-papa

6.KVO使用中的"坑"

最近我在看这方面资料的时候，发现大家都以 tableView和ContentOffset作为例子。咱们就用这个最常见的控件来说明一下吧。

1.keyPath为字符串

众所周知，KVO里面的KeyPath是NSString类型，结合Obj-C动态语言的特性，在编译时是不做检查的，只有运行到执行的时候，才会动态的去方法列表、实例变量列表中去查找，所以一旦我们写错了KeyPath，不运行的时候很难发现。

基于这个问题，我们用以下的方法规避

// 这样就不会写错了
NSStringFromSelector(@selector(contentSize))
2.多层继承、共用同一个回调方法

假如父类的控制器监听了tableView的ContentOffset属性，同时该控制器还监听了其他控件的一些属性，但是同一个对象或者控制器作为多个对象属性的观察者，实际上最后调用的都是同一个回调方法- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context { }，这样写极其容易混淆，所以我们为了解决这个问题，把代码写成如下的样子

- (void)observeValueForKeyPath:(NSString *)keyPath 
                      ofObject:(id)object
                        change:(NSDictionary *)change 
                       context:(void *)context
{
    if (object == _tableView && [keyPath isEqualToString:@"contentOffset"]) 
    {
        [self doSomethingWhenContentOffsetChanges];
 　　} 
}

但是光这样写是不全面的，因为当前的这个类很可能有父类，并且它的父类可能绑定了一些其他的KVO,上面的代码只有一个条件判断，一旦不成立，此次KVO的触发操作也就断了。而当前类无法捕捉的这个KVO事件很可能就在它的父类里，或者是父类的父类，上述操作，将这一链条截断，所以正确的方法应该如下：

- (void)observeValueForKeyPath:(NSString *)keyPath 
                      ofObject:(id)object
                        change:(NSDictionary *)change 
                       context:(void *)context
{
    if (object == _tableView && [keyPath isEqualToString:@"contentOffset"]) 
    {
        [self doSomethingWhenContentOffsetChanges];
 　　} 
 　　else
 　　{
 　　    [super observeValueForKeyPath:keyPath 
 　　                         ofObject:object 
 　　                           change:change 
 　　                          context:context];
 　　}
}

这样做这一链条就完整的保留了。

3.观察者的注销

上面的方法做完之后还是有隐患的。我们知道KVO不用的时候是需要注销的。我们知道当你对同一个KVO注销两次的时候，系统默认是抛出异常的。

你可能会好奇，什么时候我会对同一个Observer注销多次呢？

这个时候我们可以想一下我们注销Observer的时机，是不是多在Dealloc方法中？

在Obj-C中，有很多系统的方法被重写时需要调用super xxxxxxx等方法，这是Obj-C的继承关系决定的。

例如：

// 在重写init方法时，我们要调用一下父类的init方法
- (instancetype)init {

    [super init];
}

// 布局子控件时，要调用一下父类的layoutSubviews方法
- (void)layoutSubviews {

    [super layoutSubviews];
}

还有些方法，不需要调用父类的方法，自动就会帮你调用，就如我们所说的Dealloc。其实只有在ARC模式下才不需要调用父类，MRC下的Dealloc还是要手动调用super dealloc的。

所以我们在注销观察者的时候就这么写

- (void)dealloc {

    [_tableView removeObserver:self forKeyPath:@"contentOffset"];
}

假设我们有三个类 ClassA（父类），ClassB（子类），ClassC（孙子类）。这三个类都作为观察者，观察tableView的contentOffset属性。

如果我们在ClassC（孙子类）的Dealloc方法中释放观察者

- (void)dealloc {

    [_tableView removeObserver:self forKeyPath:@"contentOffset"];
}

当ClassC（孙子类）的Dealloc执行完毕后，就会自动去ClassB（子类）的Dealloc方法中，释放观察者

- (void)dealloc {

    [_tableView removeObserver:self forKeyPath:@"contentOffset"];
}

这个时候就出现崩溃了，因为我们在前面提到过这样会导致相同的removeObserver被执行两次，于是导致crash。

4.正确写法

针对这种类型的Crash，我们就要谈一下在注册Observer似的一个关键的参数Context，之前我是不知道这个Context是做啥用的，对于KVO的使用只是流于表面，所以对于这个神秘的Context的作用一直没有深究，现在我们将使用Context来为每一个Observer做区分，避免多次调用相同的removeObserver。

KVO的三个关键方法

//  注册观察者
- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context;

// 观察者响应方法
- (void)observeValueForKeyPath:(nullable NSString *)keyPath ofObject:(nullable id)object change:(nullable NSDictionary<NSKeyValueChangeKey, id> *)change context:(nullable void *)context;

// 移除观察者（有两个方法）
- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(nullable void *)context NS_AVAILABLE(10_7, 5_0);

- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;

相比细心的同学已经看出来了，我们在注册、响应、移除的三个步骤里，都可以找到Context这个关键字。所以为了保持注册、响应、移除的一致性，正确的写法应该如下：

// 首先我们应在使用KVO的类中，创建一个独一无二的Context，用来和其他类进行区分
static Void *ContextMark = &ContextMark;

// 接下来注册的时候用
 [_tableView addObserver:self
              forKeyPath:NSStringFromSelector(@selector(contentSize))
                 options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld)
                 context:ContextMark];
                 
// 响应的时候用
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    
    if (context == ContextMark)
    {
        // do someThing
    }
    else
    {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

// 注销的时候用
- (void)dealloc {
    [_tableView removeObserver:self 
                    forKeyPath:NSStringFromSelector(@selector(contentSize)) 
                       context:ContextMark];
}

如果还不放心，也可以使用@try @catch去捕获异常

7.总结、

KVO这套 API 真麻烦~~~~~

上一篇下一篇

猜你喜欢

热点阅读