[iOS]-KVO+KVC

最新推荐文章于 2024-04-26 09:49:34 发布
最新推荐文章于 2024-04-26 09:49:34 发布
阅读量319 收藏
点赞数
文章标签： ios objective-c xcode KVO KVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52192682/article/details/125990263
版权

目录:

参考的博客：

GNUstep KVC/KVO探索（二）：KVO的内部实现此博客KVO原理讲解的非常到位
iOS八股文（十九）KVC、KVO
[iOS开发]KVO+KVC
教你一行代码使用 KVO（Facebook 出品 FBKVOController 源码使用及解读）

KVO

什么是KVO

KVO全称Key Value Observing，其是苹果提供的一套事件通知机制。允许对象监听另一个对象特定属性的改变，并在改变时接收到事件。观察者模式

由于KVO的实现机制，只针对属性才会发生作用，一般继承自NSObject的对象都默认支持KVO

KVO可以监听单个属性的变化，也可以监听集合对象的变化。集合对象包含NSArray和NSSet。通过KVC的mutableArrayValueForKey：等方法获得代理对象，当代理对象的内部对象发生改变时，会回调KVO监听的方法。

Key-Value Observing 可翻译成健值观察，是观察者模式再iOS开发中的具体体现，同时也是Object-C动态性的具体表现。在开发过程中，如果需要外部动态的获得对象的某个属性变化的时机以及变化前后的值，这时候就可以使用KVO来完成。显然KVO也属于信息传递的一种方式。

KVO的基本使用

主要分为三个步骤：

  • 通过addObserver:forKeyPath:options:context:方法注册观察者
    • observer:观察者，监听属性变化的对象。该对象必须必须实现observeValueForKeyPath:ofObject:change:context:方法。
    • keyPath:要观察的属性名称。要和属性声明的名称一致
    • options:回调方法里收到被观察的属性的旧值或新值，枚举类型，系统为我们提供了4个方法
      • NSKeyValueObservingOptionOld：change中会包含key变化之前的值old
      • NSKeyValueObservingOptionNew：change中会包含key变化之后的值new
      • NSKeyValueObservingOptionInitial：change中不包含key的值，会在kvo注册时候立即发通知
      • NSKeyValueObservingOptionPrior：会在值发生改变前发出一次通知，改变后通知依然发出，也就是每个change会有两个通知。值变化之前发送通知的 change 中包含notificationIsPrior = 1; 值发生变化之后的的通知 change 不包含上面提到的notificationIsPrior ,可以跟 willChange 手动通知搭配使用
      • 我们也可以中间以竖线来进行多种选择NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew这样change既有new又有old
  • 观察对象发生改变，回调方法observeValueForKeyPath:ofObject:change:context:
    • keyPath：被观察对象的属性
    • object：被观察的对象
    • change：字典类型，存放相关的值，根据options传入的枚举来返回新值旧值或者noticationlsPrior = 1
    • context：注册观察者时候context传入的值
  • 当观察者不需要监听时，可以调用removeObserver:forKeyPath:方法将KVO移除，我们需要在观察者消失之前进行处理，否则就crash了

具体的使用样例可以详见我之前的博客：[iOS]-KVO基础

对于对已经注册的KVO观察者的dealloc来说还存在一些问题：

在这里插入图片描述在这里插入图片描述
也就是说，我们调用addObserver:selector:name:object:方法创建的观察者就没有必要自己写[xxx removeObserver:self forKeyPath:@"xxxx"];来删除观察者了。

KVO使用注意事项

但是在使用KVO的时候很容易引起crash，所以需要多多注意：

  1. keyPath 不能为空字符串
  2. 注意在适合的地方removeObersver，如果观察实例比被观察实例先释放，这时候改变观察属性，会产生崩溃。
  3. 没有添加，直接移除观察关系，也会产生崩溃

注意这个移除观察者的方法：[xxx removeObserver:self forKeyPath:@"xxxx"];

  • observer：观察者
  • keyPath：被观察对象的属性

手动调用KVO

KVO没法实现对数组元素内部的监听，此时就需要我们手动调用KVO

KVO在属性发生改变时的调用时自动的，如果想要手动控制这个调用时机，或想要自己实现KVO属性的调用，则可以通过KVO提供的方法进行调用。

  1. 如果想要手动调用或者自己实现KVO需要重写下面的方法。该方法返回YES表示允许系统自动调用KVO，NO表示不允许系统自动调用
+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)theKey {
    BOOL automatic = NO;
    if ([theKey isEqualToString:@"date"]) {
        automatic = NO;//对该key禁用系统自动通知，若要直接禁用该类的KVO则直接返回NO；
    }
    else {
        automatic = [super automaticallyNotifiesObserversForKey:theKey];
    }
    return automatic;
}
  1. 另外我们需要重写setter方法：
- (void)setDate:(NSString *)date {
    if (date != _date) {
        [self willChangeValueForKey:@"date"];
        _date = date;
        [self didChangeValueForKey:@"date"];
    }
}

不过一般情况下手动出发KVO没有什么必要，这样的话即使在没有注册监听者前调用setter方法为属性赋值的时候都会调用道KVO的响应事件，打印结果如下：
请添加图片描述
所以我们不采用这种方法，直接在注册监听者之后再对被监听的属性重新赋值的时候在赋值操作前后分别调用willChangeValueForKey和didChangeValueForKey，例子如下(以对数组进行监听为例)：

Apple.h文件中：
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface Apple : NSObject

@property (nonatomic, strong) NSMutableArray *arrayTest;

@end

NS_ASSUME_NONNULL_END


Apple.m文件中：
#import "Apple.h"

@implementation Apple

- (void)setDate:(NSString *)date {
    _date = date;
    NSLog(@"setDate:");
}
//由于数组的旧值不能被observeValueForKeyPath方法的change获取到，所以我们将打印旧值的操作移动到willChangeValueForKey中
- (void)willChangeValueForKey:(NSString *)key{
    [super willChangeValueForKey:key];
    NSLog(@"willChangeValueForKey");
    if ([key isEqual:@"arrayTest"]) {
        NSLog(@"old value is: %@", self.arrayTest);
    }
}

- (void)didChangeValueForKey:(NSString *)key{
    NSLog(@"didChangeValueForKey - begin");
    [super didChangeValueForKey:key];
    NSLog(@"didChangeValueForKey - end");
}

@end


ViewController.h文件中：
#import <UIKit/UIKit.h>
#import "Apple.h"

@interface ViewController : UIViewController

@property (nonatomic, strong) Apple *apple;

@end


ViewController.m文件中：
#import "ViewController.h"
#import "objc/runtime.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    _apple = [[Apple alloc] init];
    self.apple.arrayTest = [[NSMutableArray alloc] init];

    [self.apple addObserver:self forKeyPath:@"arrayTest" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];
        
    [self.apple willChangeValueForKey:@"arrayTest"];
    [self.apple.arrayTest addObject:@"First!"];
    [self.apple didChangeValueForKey:@"arrayTest"];
    
}

//当属性变化时会激发该监听方法
- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    //打印监听结果
    if ([keyPath isEqual:@"arrayTest"]) {
        //NSLog(@"old value is: %@", [change objectForKey:@"old"]);
        NSLog(@"new value is: %@", [change objectForKey:@"new"]);
    }  
}

@end

该例子的打印结果如下：
请添加图片描述
可以发现我们已经监听到数组的旧值和新值了。

KVO本质

KVO是基于runtime机制实现的 ，具体的KVO底层实现可以参考该博客：GNUstep KVC/KVO探索（二）：KVO的内部实现

在运行时根据原类创建一个中间类，这个中间类是原类的子类，并动态修改当前对象的isa指针指向中间类。并且将class方法重写，返回原类的class，例子如下：

前提：我们创建一个继承自NSObject类的Apple类，其中定义了一个名为date的字符串属性，并引入其类的头文件：

ViewController.h文件中：
#import <UIKit/UIKit.h>
#import "Apple.h"

@interface ViewController : UIViewController
//声明apple属性，因为KVO只能监听属性
@property (nonatomic, strong) Apple *apple;

@end

ViewController.m文件中：
#import "ViewController.h"
#import "objc/runtime.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    _apple = [[Apple alloc] init];
    NSLog(@"类对象 -%@", object_getClass(self.apple));
    NSLog(@"方法实现 -%p", [self.apple methodForSelector:@selector(setDate:)]);
    NSLog(@"元类对象 -%@", object_getClass(object_getClass(self.apple)));
        
    //开启对apple属性的键值监听
    [self.apple addObserver:self forKeyPath:@"date" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];
        
    NSLog(@"类对象 -%@", object_getClass(self.apple));
    NSLog(@"方法实现 -%p", [self.apple methodForSelector:@selector(setDate:)]);
    NSLog(@"元类对象 -%@", object_getClass(object_getClass(self.apple))); 
}

@end

打印结果如下：
请添加图片描述
从打印结果的图中，我们可以清晰地看到：

  • apple指向的类对象和元类对象以及对应监听的属性的set方法都发生了改变
  • 添加KVO后，apple中的isa指向了NSKVONotifying_Apple类对象
  • 添加KVO后，setDate:的实现调用的是：Foundation中的_NSSetObjectValueAndNotify方法

isa-swizzling（类指针交换）：
就是把当前某个实例对象的isa指针指向一个新建造的中间类，在这个新建造的中间类上面做hook方法或者别的事情，这样不会影响这个类的其他实例对象，仅仅影响当前的实例对象。
下图对于这个类指针交换讲解的就非常生动：
在这里插入图片描述

NSKVONotifying_Apple内部实现


- setName：最主要的重写方法，set值时调用通知函数
- class：返回原来类的class
- dealloc
- _isKVOA判断这个类有没有被KVO动态生成子类

- (void)setDate:(NSString *)date {

}

- (Class)class {
    return [Apple class];
}

- (void)dealloc {
    // 收尾工作
}

- (BOOL)_isKVOA {
    return YES;
}

isa指向中间类之后如何调用方法：

  • 调用监听的属性的设置方法，例如：setDate:，都会先调用NSKVONotify_Apple对应的属性设置方法
  • 调用非监听属性的设置方法，如print方法，就会通过NSKVONotify_Apple的superClass来找到Apple类对象，在调用其Apple类对象中的test方法

为什么要重写class方法：

  • 如果没有重写class方法，当该对象调用class方法时,会在自己的方法缓存列表,方法列表,父类缓存,方法列表一直向上去查找该方法,因为class方法是NSObject中的方法,如果不重写最终可能会返回NSKVONotifying_Apple,就会将该类暴露出来

setter的实现不同

截图中我们可以看到set方法的实现在调用KVO后变成调用_NSSetObjectValueAndNotify这样一个C函数
我们不知道其本身是什么样，不过我们可以进行测试：

Apple.h文件中:
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface Apple : NSObject

@property (nonatomic, copy) NSString *date;

@end

NS_ASSUME_NONNULL_END


Apple.m文件里：
#import "Apple.h"

@implementation Apple

- (void)setDate:(NSString *)date {
    _date = date;
    NSLog(@"setDate:");
}

- (void)willChangeValueForKey:(NSString *)key{
    [super willChangeValueForKey:key];
    NSLog(@"willChangeValueForKey");
}

- (void)didChangeValueForKey:(NSString *)key{
    NSLog(@"didChangeValueForKey - begin");
    [super didChangeValueForKey:key];
    NSLog(@"didChangeValueForKey - end");
}

@end


ViewController.h文件里：
#import <UIKit/UIKit.h>
#import "Apple.h"

@interface ViewController : UIViewController

@property (nonatomic, strong) Apple *apple;

@end


ViewController.m文件里：
#import "ViewController.h"
#import "objc/runtime.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    _apple = [[Apple alloc] init];
    self.apple.date = @"7Days!";
        
    [self.apple addObserver:self forKeyPath:@"date" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];
        
    self.apple.date = @"25Days!";
    
    
}

//当属性变化时会激发该监听方法
- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    //打印监听结果
    if ([keyPath isEqual:@"date"]) {
        NSLog(@"old value is: %@", [change objectForKey:@"old"]);
        NSLog(@"new value is: %@", [change objectForKey:@"new"]);
    }
    
}

@end

要实现该测试样例必须要注意：

  1. 监听者必须实现observeValueForKeyPath:ofObject:change:context:方法
  2. Apple.m中实现的那三个方法是测试的关键

该样例的打印结果如下：请添加图片描述
我们发现：

  • 先调用willChangeValueForKey方法
  • 接着调用原来的setDate方法
  • 最后调用didChangeValueForKey方法，并且通知监听者属性值已经改变，然后监听者执行observeValueForKeyPath:ofObject:change:context:处理监听事务。

KVO部分相关问题

  1. KVO的本质是什么？
  • 利用runtime的API动态生成一个子类，并让实例对象的isa指向这个全新的子类
  • 当修改实例变量对象的属性时候，在全新子类的set方法中会调用Foundation的_NSSetXXXValueAndNotify函数
  • willChangeValueForKey
  • 调用原来的setter
  • didChangeValueForKey：内部会触发监听器的监听方法
  1. 手动触发KVO（详见上方讲解）
  2. 直接修改成员变量会触发KVO嘛？
    答案是不会

接着我们总结一下KVO的应用场景：

  1. 需要接收动态变化的时候
  2. 例如在AVFounditon中获取AVPlayer的播放进度，播放状态，也需要使用KVO来观察。
#pragma mark - 监听
- (void)currentItemAddObserver {
    // 监控状态属性，注意AVPlayer也有一个status属性，通过监控它的status也可以获得播放状态
    [self.player.currentItem addObserver:self forKeyPath:@"status" options: (NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew) context:nil];
    // 监控缓冲加载情况属性
    [self.player.currentItem addObserver:self forKeyPath:@"loadedTimeRanges" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];
    // 缓冲不足暂停了
    [self.player.currentItem addObserver:self forKeyPath:@"playbackBufferEmpty" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];
    // playbackLikelyToKeepUp
    [self.player.currentItem addObserver:self forKeyPath:@"playbackLikelyToKeepUp" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];
    // rate
    [self.player addObserver:self forKeyPath:@"rate" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];
}

最后总结一下KVO的实现原理

  1. 在addObserver:forKeyPath:options:context:context调用的时候，会自动生成并注册一个该对象（被观察的对象）对应类的子类，取名NSKVONotify_Class,并且将该对象的isa指针指向这个新的中间类。
  2. 在该子类内部实现4个方法-被观察属性的set方法、class方法、isKVO、delloc。
  3. 最关键的是set方法中，先调用willChangeValueForKey，再给成员变量赋值，最后调用didChangeValueForKey，willChangeValueForKey和didChangeValueForKey需要成对出现才能生效，在didChangeValueForKey中会去调用观察者的observeValueForKeyPath: ofObject: 方法。
  4. 重写class方法，这样避免外部感知子类的存在，同时防止在一些使用isKindOfClass判断的时候出错。
  5. isKVO方法作为实现KVO功能的一个标识。
  6. delloc里面还原isa指针。

到这里，我们已经知道了KVO的原理和其使用以及注意事项，人们对于KVO可谓是又爱又恨，因为其原理让我们在类之前通信增加了一种方式，但确实容易crash，针对这个问题，FaceBook的开发者的第三方库FBKVOController就巧妙的解决了这一问题，下面我们详细讲解一下FBKVOController第三方库。

FBKVOController浅析

首先介绍一下FBKVOController的用法：

  1. 使用前先利用cocoa向项目中下载FBKVOController第三方库，具体第三方库的下载流程详见：[iOS]-Masonry的使用博客中前面的讲解。
  2. 在文件中引入下方头文件：
#import "FBKVOController.h"
#import "NSObject+FBKVOController.h"

接下来我们就可以开始正常的使用了

使用例子如下：

ViewController.h文件中：
#import <UIKit/UIKit.h>
#import "Apple.h"

@interface ViewController : UIViewController

@property (nonatomic, strong) Apple *apple;

@end

#import "ViewController.h"
#import "objc/runtime.h"
#import "FBKVOController.h"
#import "NSObject+FBKVOController.h"
@interface ViewController ()
@property (nonatomic, strong) FBKVOController *kvoController;
@end


ViewController.m文件中：
@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    NSLog(@"hello world!");
    
    //创建被观察的类
    _apple = [[Apple alloc] init];
    //初始化设置_apple的属性值
    self.apple.date = @"7Days!";
    self.apple.arrayTest = [[NSMutableArray alloc] init];
    
    //方法一：创建 FBKVOController 对象，并被 VC 强引用，否则出了当前作用域，就会被销毁
    FBKVOController *kvoController = [[FBKVOController alloc] initWithObserver:self];
    _kvoController = kvoController;
    
    //添加观察
    [kvoController observe:self.apple keyPath:@"date" options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew block:^(id  _Nullable observer, id  _Nonnull object, NSDictionary<NSKeyValueChangeKey,id> * _Nonnull change) {     NSLog(@"我的旧名字是：%@", change[NSKeyValueChangeOldKey]);
            NSLog(@"我的新名字是：%@", change[NSKeyValueChangeNewKey]);
    }];
    
    
    //方法二：无需主动创建 FBKVOController 对象，self.KVOController 直接懒加载创建FBKVOController 对象
    //可以直接对某个对象的多个成员变量执行 KVO
    //------真正实现一行代码搞定 KVO------
    [self.KVOController observe:self.apple keyPaths:@[@"date", @"arrayTest"] options:  NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew block:^(id observer, id object, NSDictionary *change) {

        NSString *changedKeyPath = change[FBKVONotificationKeyPathKey];

        if ([changedKeyPath isEqualToString:@"date"]) {
            NSLog(@"修改了日期!");
        } else if ([changedKeyPath isEqualToString:@"arrayTest"]) {
            NSLog(@"修改了数组!");
        }

        NSLog(@"旧值是：%@", change[NSKeyValueChangeOldKey]);
        NSLog(@"新值是：%@", change[NSKeyValueChangeNewKey]);
    }];

    //修改被监听的值
    self.apple.date = @"31Days!"; 
}

@end


Apple.h文件中：
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface Apple : NSObject

@property (nonatomic, copy) NSString *date;

@property (nonatomic, strong) NSMutableArray *arrayTest;

@end

NS_ASSUME_NONNULL_END


Apple.m文件中：
#import "Apple.h"

@implementation Apple

- (void)setDate:(NSString *)date {
    _date = date;
    NSLog(@"setDate:");
}

- (void)willChangeValueForKey:(NSString *)key{
    [super willChangeValueForKey:key];
    NSLog(@"willChangeValueForKey");
    if ([key isEqual:@"arrayTest"]) {
        NSLog(@"old value is: %@", self.arrayTest);
    }
}

- (void)didChangeValueForKey:(NSString *)key{
    NSLog(@"didChangeValueForKey - begin");
    [super didChangeValueForKey:key];
    NSLog(@"didChangeValueForKey - end");
}

@end

可以看到上方有两种方法可以注册监听，而且都是非常简洁好用。

接着我们就分析一下这个库的好用的原因：

  1. 统一观察者
    在FBKVOController中有个单例[_FBKVOSharedController sharedController]来统一观察所有的对象，所有的观察回调也都先来到_FBKVOSharedController中的observeValueForKeyPath:ofObject: change:context:方法中，然后再派发给对应KVOController的Block或者Action(Seletor)。
+ (instancetype)sharedController
{
  static _FBKVOSharedController *_controller = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    _controller = [[_FBKVOSharedController alloc] init];
  });
  return _controller;
}

- (void)observeValueForKeyPath:(nullable NSString *)keyPath
                      ofObject:(nullable id)object
                        change:(nullable NSDictionary<NSString *, id> *)change
                       context:(nullable void *)context
{
  NSAssert(context, @"missing context keyPath:%@ object:%@ change:%@", keyPath, object, change);

  _FBKVOInfo *info;

  {
    // lookup context in registered infos, taking out a strong reference only if it exists
    pthread_mutex_lock(&_mutex);
    info = [_infos member:(__bridge id)context];
    pthread_mutex_unlock(&_mutex);
  }

  if (nil != info) {

    // take strong reference to controller
    FBKVOController *controller = info->_controller;
    if (nil != controller) {

      // take strong reference to observer
      id observer = controller.observer;
      if (nil != observer) {

        // dispatch custom block or action, fall back to default action
        if (info->_block) {
          NSDictionary<NSString *, id> *changeWithKeyPath = change;
          // add the keyPath to the change dictionary for clarity when mulitple keyPaths are being observed
          if (keyPath) {
            NSMutableDictionary<NSString *, id> *mChange = [NSMutableDictionary dictionaryWithObject:keyPath forKey:FBKVONotificationKeyPathKey];
            [mChange addEntriesFromDictionary:change];
            changeWithKeyPath = [mChange copy];
          }
          info->_block(observer, object, changeWithKeyPath);
        } else if (info->_action) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
          [observer performSelector:info->_action withObject:change withObject:object];
#pragma clang diagnostic pop
        } else {
          [observer observeValueForKeyPath:keyPath ofObject:object change:change context:info->_context];
        }
      }
    }
  }
}

在添加观察者的时候,会把添加的信息生成一个_FBKVOInfo对象。

@interface _FBKVOInfo : NSObject
@end

@implementation _FBKVOInfo
{
@public
  __weak FBKVOController *_controller;
  NSString *_keyPath;
  NSKeyValueObservingOptions _options;
  SEL _action;
  void *_context;
  FBKVONotificationBlock _block;
  _FBKVOInfoState _state;
}
  1. 移除观察者时机 在使用FBKVOController添加观察者的时候会动态关联对象，该对象的类为FBKVOController，而在类释放的时候，会调用类的delloc方法，关联的对象也会走delloc方法，而在这个时候统一去移除观察者。
- (void)dealloc
{
  [self unobserveAll];
  pthread_mutex_destroy(&_lock);
}

- (void)_unobserveAll
{
  // lock
  pthread_mutex_lock(&_lock);

  NSMapTable *objectInfoMaps = [_objectInfosMap copy];

  // clear table and map
  [_objectInfosMap removeAllObjects];

  // unlock
  pthread_mutex_unlock(&_lock);

  _FBKVOSharedController *shareController = [_FBKVOSharedController sharedController];

  for (id object in objectInfoMaps) {
    // unobserve each registered object and infos
    NSSet *infos = [objectInfoMaps objectForKey:object];
    [shareController unobserve:object infos:infos];
  }
}
  1. 防止重复添加
    在添加的时候会把_FBKVOInfo对象存起来，再次添加的时候去比较，如果存在，就不继续添加，在判断重复的时候重写了_FBKVOInfo中的hash方法，即keyPath重复就不继续添加。
- (void)_observe:(id)object info:(_FBKVOInfo *)info
{
  // lock
  pthread_mutex_lock(&_lock);

  NSMutableSet *infos = [_objectInfosMap objectForKey:object];

  // check for info existence
  _FBKVOInfo *existingInfo = [infos member:info];
  if (nil != existingInfo) {
    // observation info already exists; do not observe it again

    // unlock and return
    pthread_mutex_unlock(&_lock);
    //此处就是之前已经存在相应的_FBKVOInfo对象了，所以直接返回
    return;
  }

  // lazilly create set of infos
  if (nil == infos) {
    infos = [NSMutableSet set];
    [_objectInfosMap setObject:infos forKey:object];
  }

  // add info and oberve
  [infos addObject:info];

  // unlock prior to callout
  pthread_mutex_unlock(&_lock);

  [[_FBKVOSharedController sharedController] observe:object info:info];
}

hash查找_FBKVOInfo对象和判断找到的对象是否与之前的_FBKVOInfo相等的方法如下：

- (NSUInteger)hash
{
  return [_keyPath hash];
}

- (BOOL)isEqual:(id)object
{
  if (nil == object) {
    return NO;
  }
  if (self == object) {
    return YES;
  }
  if (![object isKindOfClass:[self class]]) {
    return NO;
  }
  return [_keyPath isEqualToString:((_FBKVOInfo *)object)->_keyPath];
}

手动关闭/打开KVO

在被观察的类中，重写automaticallyNotifiesObserversForKey:方法，对应被观察的key返回NO，这时候就会不再调用观察者的observeValueForKeyPath:ofObject: change:context:方法：

/// 手动关闭KVO（具体实现的时候我们可以根据key来if else决定那些被监听的值需要手动监听，那些不需要自动监听，需要手动监听就返回NO，需要自动监听就返回YES）
+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
    return NO;
}

而在被观察的类中，成对的调用willChangeValueForKey和didChangeValueForKey，即使被观察的key没有发生变化也会手动的触发KVO的回调：

//手动调用这个方法来查看我们监听的值的变化情况
- (void)invokeKVO{
    [self willChangeValueForKey:@"name"];
    
    [self didChangeValueForKey:@"name"];
}

KVC

什么是KVC

定义在NSKeyValueCoding.h中，是一个非正式的协议。KVC提供了一种间接访问其属性方法或成员变量的机制，可以通过字符串来访问对应的属性方法或成员变量

在NSKeyValueCoding中提供了KVC通用的访问方法，分别是getter方法valueForKey和setter方法setValue:forKey，以及其衍生的keyPath方法，这两个方法是各个类通用的。并且由KVC提供默认的实现，我们也可以自己重写对应的方法来改变实现。

基础操作

KVC主要对三种类型进行操作，基础数据类型及常量、对象类型、集合类型。
在使用KVC时，直接将属性名当作key，并设置value，即可对属性进行赋值：

    _apple = [[Apple alloc] init];
    //初始化设置_apple的属性值
    self.apple.date = @"7Days!";
    self.apple.arrayTest = [[NSMutableArray alloc] init];
    
    [self.apple setValue:@"14Days!" forKey:@"date"];
    NSLog(@"%@", self.apple.date);

打印结果：
请添加图片描述

多级访问

除了对当前对象的属性进行赋值外，还可以对其更深层的对象进行赋值。例如对当前对象的address属性的street属性进行赋值。

KVC进行多级访问时，类似于属性调用一样用点语法进行访问即可[myInformation setValue:@"123" forKeyPath:@"address.street"];:

实际代码例子如下：

    _apple = [[Apple alloc] init];
    
    self.apple.littleApple = [[sonOfApple alloc] init];
    
    [self.apple setValue:@66 forKeyPath:@"littleApple.flag"];
    NSLog(@"%@", self.apple.littleApple.flag);

运行结果：
请添加图片描述

传参nil

如果对非对象传递一个nil值，KVC会调用setNIlValueForKey方法
我们可以重写这个方法来避免

不重写setNIlValueForKey时：

    _apple = [[Apple alloc] init];
    [self.apple setValue:nil forKey:@"flagTest"];

运行结果：程序崩溃
请添加图片描述

重写setNIlValueForKey后：

首先在Apple.m文件中重写setNIlValueForKey方法为如下（默认的该方法接收到nil之后会打印日志报错）：
- (void) setNilValueForKey:(NSString *)key {
    return;
}

//再去执行该代码
_apple = [[Apple alloc] init];
[self.apple setValue:nil forKey:@"flagTest"];

运行结果没有报错！

处理非对象

  • setValue时，如果要赋值的对象是基本类型，需要将值封装成NSNumber或者NSValue类型
  • valueForKey时，返回的是id类型的对象，基本数据类型也会被封装成NSNumber或者NSValue

valueForKey可以自动将值封装成对象，但是setValue:forKey:却不行。我们必须手动讲值类型转换成NSNumber/NSValue类型才能进行传递

KVC获取值的过程

setValue:forKey

在KVO里面，我们使用setValue:forKey这一部分会导致触发KVO监听的过程，KVC触发调用了will和did

先用一张图展示一下setValue:forKey的过程：
在这里插入图片描述

  • 程序回先通过setter方法对属性进行设置
  • 如果没有找到set方法，KVC机制会检查+(Bool)accessInstanceVariablesDirectly（直接访问实例变量）方法有没有返回YES（默认返回YES）
    • 如果重写方法成了NO，调用-setValueForUndefinedKey:（为未定义项设置值）抛出异常
    • 返回YES就去找成员变量并直接赋值，按照_key，_isKey,key,iskey的顺序找，没找到就抛出异常

赋值顺序的例子如下：

//接口成员变量定义
@interface Apple : NSObject {
    @public
    int cnt;
    int isCnt;
    int _isCnt;
    int _cnt;
}

	//初始化和为成员变量赋值
	_apple = [[Apple alloc] init];
    _apple -> cnt = 10;
    _apple -> _cnt = 11;
    _apple -> _isCnt = 12;
    _apple -> isCnt = 13;
    
    [_apple setValue:@15 forKey:@"cnt"];
    
    NSLog(@"%@", [_apple valueForKey:@"cnt"]);
    NSLog(@"%d %d %d %d", _apple -> cnt, _apple -> _cnt, _apple -> _isCnt, _apple -> isCnt);

打印结果为：
请添加图片描述
我们可以看到，最后成员变量_cnt的值由11变成了15，符合我们刚才说的赋值顺序，就是先找_cnt去赋值，而不是先去找cnt赋值。

valueForKey

先上流程图参考：
在这里插入图片描述

  • 先后顺序搜索getKey、key 、isKey、_getKey、_key五个方法，若某一个方法被实现，取到的即是方法返回的值，后面的方法不再运行。如果是BOOL或者int等类型，会将其包装成一个NSNumber对象
  • 如果五个方法都没有，还是会访问accessInstanceVariablesDirectly方法有没有返回YES（该方法默认返回YES）
    • 如果重写方法成了NO，抛异常
    • 返回YES就去找成员变量并取值，取值顺序为_key、_isKey、key、isKey

查找顺序的例子如下：

//接口成员变量定义
@interface Apple : NSObject {
    @public
    int cnt;
    int isCnt;
    int _isCnt;
    int _cnt;
}

	//初始化和为成员变量赋值
	_apple = [[Apple alloc] init];
    _apple -> cnt = 10;
    _apple -> _cnt = 11;
    _apple -> _isCnt = 12;
    _apple -> isCnt = 13;
    
    NSLog(@"%@", [_apple valueForKey:@"cnt"]);

打印结果为：
请添加图片描述
我们可以看到11是成员变量_cnt的值，我们输入的key是@"cnt"，结果找到的是_cnt的值，这个也符合了我们上方说的查找结果。

NSObject(NSKeyValueCoding)

KVC的Api都声明在NSObject的分类NSKeyValueCoding中，所以如果想使用KVC务必确认该对象是NSObject的子类。

其中比较重要的API有：

@property (class, readonly) BOOL accessInstanceVariablesDirectly;

- (void)setValue:(nullable id)value forKey:(NSString *)key;

- (void)setValue:(nullable id)value forKeyPath:(NSString *)keyPath;

- (id)valueForKey:(NSString *)key;

- (nullable id)valueForKeyPath:(NSString *)keyPath;

key&keyPath的区别，如果某个属性是一个对象，需要设置该属性的某个属性的时候，就可以使用keyPath，一步到位来设置或者获取属性，关于这些的详细使用详见上方的讲解。

KVC的使用场景

  1. crash防护，可以自定义valueForUndefinedKey:从而实现crash到控制台打印的友好处理方式
  2. json转model（这个在接受网络请求来的数据的时候非常好用）
  3. KVO的实现
  4. 访问和修改私有变量（KVC的本质是操作方法列表以及在内存中查找实例变量。我们可以利用这个特性访问类的私有变量。同样如果不想让外界的类使用KVC的方法访问本类的成员变量，可以将accessInstanceVariablesDirectly属性设置为NO）
  5. 修改一些控件的内部属性（很多UI控件都是由内部UI控件组合而成的，但是Apple（苹果官方）没有提供访问这些控件的API，这样我们就无法正常地访问和修改这些空间的样式。而KVC在大多数情况下可以解决这个问题）

另外我们在除了利用KVC 动态地对单取值和设值之外，还可以进行多值操作：

KVC可以根据给定的一组key，获取到一组value，并且以字典的形式返回，获取到字典后可以通过key从字典中获取到value：

- (NSDictionary<NSString *, id> *)dictionaryWithValuesForKeys:(NSArray<NSString *> *)keys;

同样，也可以通过KVC进行批量赋值。在对象调用setValuesForKeysWithDictionary:方法时，可以传入一个包含key、value的字典进去，KVC可以将所有数据按照属性名和字典的key进行匹配，并将value给相应对象的属性赋值（其实这里有点像jsonModel）：

- (void)setValuesForKeysWithDictionary:(NSDictionary<NSString *, id> *)keyedValues;

	NSDictionary *dic = @{@"name" : @"book", @"age" : @"66", @"sex" : @"male"};
	//这个类里面定义了一些属性，这些属性名和传进来的字典的key一致且属性名数量大于等于字典中的key
    StudentModel *model = [[StudentModel alloc] init];
    
    [model setValuesForKeysWithDictionary:dic];
    NSLog(@"%@",model);
    NSDictionary *modelDic = [model dictionaryWithValuesForKeys:@[@"name", @"age", @"studentSex"]];
    NSLog(@"modelDic : %@", modelDic);

如果model 属性和 dic 不匹配，可以重写方法 -(void)setValue:(id)value forUndefinedKey:(NSString *)key：

//比如我们需要赋值的属性是studentSex，而传进来的字典的相关对应的key为sex，我们可以在该方法里面将key为sex的value赋值给studentSex属性进行补救
- (void)setValue:(id)value forUndefinedKey:(NSString *)key {
    if([key isEqualToString:@"sex"]) {
        self.studentSex = (NSString *)value;
    }
}

以上就是本文对KVC的全部总结。

&Carry
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iOS中KVC-KVO例子
06-30
iOS中KVC-KVO例子，
[iOS开发]KVO+KVC
复杂化的博客
08-05 359
文章目录KVO什么是KVOKVO的基本使用手动调用KVOKVO的本质NSKVONotifying_Person内部实现setter的实现不同KVO部分相关问题KVC什么是KVC基础操作多级访问传参nil处理非对象KVC获取值的过程setValue:forKeyvalueForKeyKVC操作使用场景动态的取值和设值多值操作用KVC来访问和修改私有变量修改一些控件的内部属性 KVO 什么是KVO KVO全称Key Value Observing，其是苹果提供的一套事件通知机制。允许对象监听另一个对象特定属性的
iOS面试 - KVO & KVC
weixin_46024722的博客
03-30 198
KVO 1. 概述 KVO，是 Key-Value Observing，它提供一种机制，当指定的对象的属性被修改后，则对象就会接收到通知。 简单的说就是每次指定的被观察的对象的属性被修改后，KVO 就会自动通知相应的观察者了。 2. 实现机制 当某个类的对象第一次被观察时，系统就会在运行时动态地创建该类的一个派生类，在这个派生类中重写原类中被观察属性的 setter 方法，派生类在被重写的 set...
【iOS】--KVC与KVO
weixin_61196797的博客
05-14 396
KVC（Key Value Coding）允许以字符串的形式间接操作对象的属性。
【iOS开发】——KVO与KVC
weixin_51638861的博客
08-03 1176
iOS开发——KVO与KVC
KVO_App:iOS Objective-C中KVC和KVO的基本实现
05-21
KVO_App iOS Objective-C中KVC和KVO的基本实现
ios-KVO底层实现--利用runtime简单的实现KVO底层原理.zip
07-11
利用runtime简单的实现KVO底层原理,主要是提供了一个KVO的底层思路,和runtime的简单用法.仅供学习和交流使用
移动开发(IOS) – Objective-C-10-KVC、谓词、KVO与通知 - iOS知识库1
08-04
1.&.批处理 1.(.KE4的简单运算 2.谓词 2.谓词 2.&.格式占位符
IOS KVC和KVO
10-31
已经拥有一年经验的你真的了解KVC，KVO吗？也许不！以前我以为自己都有上架项目，这都是太基础的东西，但今天我重新回头看了以前做的笔记，真的是书读百遍，其义自见。
iOS 将字符串分割成单个字符| 字符串转成数组
wyz670083956的博客
04-20 309
iOS 将字符串分割成单个字符| 字符串转成数组
Axios
weixin_74144099的博客
04-24 345
Axios 是一个基于 promise 的 HTTP 库，可以用在浏览器和 node.js 中。文档：https://axios.nodejs.cn/我们可以使用自定义配置创建一个新的 axios 实例。
iOS重签名-超详细，附排错
namedlock的博客
04-20 1311
复制 Provisioning Profile 到 Payload 目录：你需要将 Provisioning Profile 复制到解压的 .ipa 文件夹内的 Payload/*.app 目录中，并确保其名字为 embedded.mobileprovision。iOS 证书重签名主要是指使用一个新的开发者证书对已经打包的 iOS 应用（.ipa 文件）进行签名，以便可以在新的设备上安装。参考文档 https://lingjye.com/2020/01/15/coderesign/
滚动条详解：跨平台iOS、Android、小程序滚动条隐藏及自定义样式综合指南
JINGWHALE
04-21 768
随着用户界面体验提升的要求，滚动条自定义样式以及滚动条隐藏精致化的需求日渐增加，本文详细介绍了小程序、iOS、Android平台滚动条的隐藏方法，以及滚动条一般自定义样式的方法。在保持界面整洁、避免内容溢出的同时，确保用户能够访问所有信息，提升浏览体验。
Vue.js（Axios）
Luo3255069063的博客
04-23 622
【代码】Vue.js（Axios）
iOS 64位程序调试环境搭建
douluo998的博客
04-21 839
调试ios程序经常使用gdb，但是gdb还未支持arm64，需要使用XCode的lldb调试IOS下64位程序。最终发现可以使用lldb命令行方式调试，lldb调试方法跟gdb最大的不同，在于前者是用OSX中的lldb远程连接debugserver，由debugserver作为lldb和iOS的中转，执行命令和返回结果；但对于一般的开发、调试来说，区别不大。可能大家使用较多的是gdb，对gdb命令更为熟悉，为了方便大家查阅、对比lldb和gdb命令，罗列出了一些常用命令供大家参考。
iOS 内存泄漏问题总结
sgliquangang的专栏
04-23 573
参考文章1：
iOS(Object C) 插入排序
wyz670083956的博客
04-23 498
iOS(Object C) 插入排序; 插入排序的思想: 可以想象你在打牌,手里有一张牌2, 第一次摸到一张牌5; 5 比1 大,所以摸到的牌5放在1的右边; (此时手里的牌为 2->5) 第二次摸到一张牌3; 3比5小,所以3和5互换位置,再拿3和2比,3比2大,3不动(此时手里的牌为 2-> 3 -> 5) 第三次摸到一张牌1,1比5小,所以1和5互换位置;再拿1和3比,1比3小,所以1和3互换位置;再拿1和3比,1比2小,所以1和2互换位置;
ios不兼容Svg Wave的动画的解决方法
最新发布
word_tian_的博客
04-26 552
ios不兼容Svg Wave的动画的解决方法
flutter和oc kvo
07-28
Flutter和Objective-C（简称OC）都是开发移动应用程序的技术，但它们在很多方面有着不同的特点。 首先，Flutter是一种跨平台的移动应用开发框架，由谷歌开发。它使用Dart语言编写，具有热重载、响应式UI框架和丰富的UI组件等特点。Flutter的一大优势是可以同时在iOS和Android平台上开发应用程序，并且拥有高性能和良好的用户体验。Flutter也支持使用原生代码进行集成，因此可以很好地与Objective-C进行交互。 Objective-C是一种面向对象的编程语言，主要用于iOS和macOS平台的应用程序开发。Objective-C采用了一种称为KVO（Key-Value Observing）的机制，允许对象对属性和值的变化进行观察和响应。通过注册观察者，当被观察对象的属性发生变化时，观察者可以接收到通知并执行相应的操作。KVO是一种非常强大的工具，可以用于实现对象之间的数据绑定和通信。 在使用Flutter开发应用时，可以与Objective-C进行集成，并利用Objective-C提供的KVO机制来实现对Flutter应用内部变量的监视和响应。这可以通过在Flutter与Objective-C之间建立桥接来实现，从而达到在Flutter应用中使用KVO的目的。 总的来说，Flutter和Objective-C KVO是两种不同的技术，Flutter是一个跨平台的移动应用开发框架，而Objective-C KVO是一种可以用于观察和响应对象属性变化的机制。在合适的场景下，可以通过Flutter与Objective-C进行集成，从而利用KVO机制来实现对Flutter应用内部变量的监视和响应。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值