iOS - FBKVOController 实现原理

本文导读:

1.系统KVO的问题
2.FBKVOController优点
3.FBKVOController的架构设计图
4.FBKVOController源码详读
5.FBKVOController总结

一.系统KVO的问题

  • 当观察者被销毁之前,需要手动移除观察者,否则会出现程序异常(向已经销毁的对象发送消息);
  • 可能会对同一个被监听的属性多次添加监听,这样我们会接收到多次监听的回调结果;
  • 当观察者对多个对象的不同属性进行监听,处理监听结果时,需要在监听回调的方法中,作出大量的if判断;
  • 当对同一个被监听的属性进行两次removeObserver时,会导致程序crash。这种情况通常出现在父类中有一个KVO,在父类的dealloc中remove一次,而在子类中再次remove。

二. FBKVOController优点

  • 可以同时对一个对象的多个属性进行监听,写法简洁;
  • 通知不会向已释放的观察者发送消息;
  • 增加了block和自定义操作对NSKeyValueObserving回调的处理支持;
  • 不需要在dealloc 方法中手动移除观察者,而且移除观察者不会抛出异常,当FBKVOController对象被释放时, 观察者被隐式移除;

三.FBKVOController架构设计图

FBKVOController_00.png

四.FBKVOController源码详解

FBKVOController源码详解分四部分:分别是对两个私有类_FBKVOInfo,_FBKVOSharedController和两个公开类FBKVOController,NSObject+FBKVOController的源码解读:

(一)FBKVOController

首先我们创建一个FBKVOController的实例对象时,有以下三种方法,一个类方法和两个对象方法,

//该方法是一个全能初始化的对象方法,其他初始化方法内部均调用该方法
//参数:observer是观察者,retainObserved:表示是否强引用被观察的对象
- (instancetype)initWithObserver:(nullable id)observer retainObserved:(BOOL)retainObserved 

//该初始化方法内部调用上一个初始化方法,默认强引用被观察的对象
- (instancetype)initWithObserver:(nullable id)observer;

//该初始化方法内部调用上一个初始化方法,默认强引用被观察的对象
+ (instancetype)controllerWithObserver:(nullable id)observer;
NS_DESIGNATED_INITIALIZER;

我们先来看全能初始化方法内部的实现,该方法对三个实例变量_observer(观察者),_objectInfosMap(NSMapTable,被监听对象->被监听属性集合之间的映射关系),pthread_mutex_init(互斥锁):

//全能初始化方法
- (instancetype)initWithObserver:(nullable id)observer retainObserved:(BOOL)retainObserved
{
  self = [super init];
  if (nil != self) {
      
    //观察者
    _observer = observer;

//NSMapTable中的key可以为对象,而且可以对其中的key和value弱引用
NSPointerFunctionsOptions keyOptions = retainObserved ? NSPointerFunctionsStrongMemory|NSPointerFunctionsObjectPointerPersonality : NSPointerFunctionsWeakMemory|NSPointerFunctionsObjectPointerPersonality;
    _objectInfosMap = [[NSMapTable alloc] initWithKeyOptions:keyOptions valueOptions:NSPointerFunctionsStrongMemory|NSPointerFunctionsObjectPersonality capacity:0];
      
//对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER
//对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy
    pthread_mutex_init(&_lock, NULL);
  }
  return self;
}

这里请先思考以下问题:

  • 属性observer为何使用weak,它和哪个对象之间会导致循环引用问题,是如何导致循环引用问题的?
  • 为何不使用字典来保存被监听对象和被监听属性集合之间的关系?
  • NSDictionary的局限性有哪些?NSMapTable相对字典,有哪些优点?
  • 互斥锁是为了保证哪些数据的线程安全?

带着这些问题我们来看FBKVOController内部是如何实现监听的,这里我们只看带Block回调的一个监听方法,其他几个方法和这个方法内部实现是相同的。下面的方法内部做了如下工作:
1.传入的参数keyPath,block为空时,程序闪退,同时报出误提示;
2.对传入参数为空的判读;
3.利用传入的参数创建_FBKVOInfo对象;
4.调用内部私有方法实现注册监听;

//观察者监听object中健值路径(keyPath)所对应属性的变化
- (void)observe:(nullable id)object keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(FBKVONotificationBlock)block
{
//NSAssert是一个预处理宏, 它可以让开发者比较便捷的捕获错误, 让程序闪退, 同时报出错误提示
  NSAssert(0 != keyPath.length && NULL != block, @"missing required parameters observe:%@ keyPath:%@ block:%p", object, keyPath, block);

//首先判断被监听的对象是否为空,被监听的健值路径是否为空,回调的block是否为空
  if (nil == object || 0 == keyPath.length || NULL == block) {
    return;
  }

  // 根据传进来的参数创建_FBKVOInfo对象,将这些参数封装到_FBKVOInfo对象中
  _FBKVOInfo *info = [[_FBKVOInfo alloc] initWithController:self keyPath:keyPath options:options block:block];

  // 监听对象object的属性信息(_FBKVOInfo对象)
  [self _observe:object info:info];
}

该私有方法内部并没有实现真正的注册监听,这里使用NSMapTable保存了被监听对象object-> _FBKVOInfo对象集合的关系,具体的监听是在_FBKVOSharedController类中实现的。观察者可以监听多个对象,而每个对象中可能有多个属性被监听,其关系如下图:


FBKVOController_01.png

内部实现思路:

  • 对当前线程访问的数据_objectInfosMap进行加锁;
  • 根据被监听对象object到_objectInfosMap取出被监听的属性信息对象集合infos;
  • 判断被监听的属性对象info是否存在集合中;
  • 如果已经存在,则不需要再次添加监听,防止多次监听;
  • 如果获取的集合infos为空,则建存放_FBKVOInfo对象的集合infos,保存映射关系:object->infos;
  • 将被监听的信息_FBKVOInfo对象存到集合infos中;
  • 解锁,其他线程可以访问该数据;
  • 调用_FBKVOSharedController 的方法实现监听;
//该方法是内部私有方法
- (void)_observe:(id)object info:(_FBKVOInfo *)info
{
  //先加锁,访问_objectInfosMap
  pthread_mutex_lock(&_lock);

    //到_objectInfosMap中根据key(被监听的对象)获取被监听的属性信息集合
  NSMutableSet *infos = [_objectInfosMap objectForKey:object];

   //判断infos集合中是否存在被监听属性信息对象info
  _FBKVOInfo *existingInfo = [infos member:info];

    //被监听对象的属性已经存在,不需要再次监听,防止多次添加监听
  if (nil != existingInfo) {
  
  //解锁,其他线程可以再次访问_objectInfosMap中的数据
    pthread_mutex_unlock(&_lock);
    return;
  }

  //根据被监听对象在_objectInfosMap获取的被监听属性信息的集合为空
  if (nil == infos) {
    //懒加载创建存放_FBKVOInfo对象的set集合infos
    infos = [NSMutableSet set];

    //保存被监听对象和被监听属性信息的映射关系object->infos
    [_objectInfosMap setObject:infos forKey:object];
  }

  // 将被监听的信息_FBKVOInfo对象存到集合infos中
  [infos addObject:info];

  //解锁
  pthread_mutex_unlock(&_lock);

   //最终的监听方法是通过_FBKVOSharedController中的方法来实现
  //_FBKVOSharedController内部实现系统KVO方法
  [[_FBKVOSharedController sharedController] observe:object info:info];
}
(二)_FBKVOInfo

_FBKVOInfo私有类的内部很简单,没有任何业务逻辑,只是一个简单的Model,主要是将以下的实例变量封装到对象中,方便访问:

{
@public
//weak,防止循环引用
  __weak FBKVOController *_controller;
   //被监听属性的健值路径
  NSString *_keyPath;

//NSKeyValueObservingOptionNew:观察修改前的值
// NSKeyValueObservingOptionOld:观察修改后的值
//NSKeyValueObservingOptionInitial:观察最初的值(在注册观察服务时会调用一次触发方法)
//NSKeyValueObservingOptionPrior:分别在值修改前后触发方法(一次修改有两次触发)
  NSKeyValueObservingOptions _options;

//被监听属性值变化时的回调方法
  SEL _action;

//上下文信息(void * 任何类型)
  void *_context;
//被监听属性值变化时的回调block
  FBKVONotificationBlock _block;
//监听状态
  _FBKVOInfoState _state;
}

_FBKVOInfo私有类提供了一个全能初始化方法,来初始化以上实例变量。其他几个部分初始化方法内部均调用该全能初始化方法。

//全能初始化方法
- (instancetype)initWithController:(FBKVOController *)controller
                           keyPath:(NSString *)keyPath
                           options:(NSKeyValueObservingOptions)options
                             block:(nullable FBKVONotificationBlock)block
                            action:(nullable SEL)action
                           context:(nullable void *)context
{
  self = [super init];
  if (nil != self) {
    _controller = controller;
    _block = [block copy];
    _keyPath = [keyPath copy];
    _options = options;
    _action = action;
    _context = context;
  }
  return self;
}

同时_FBKVOInfo私有类还重写了isEqual:和hash方法,用来进行_FBKVOInfo对象的判等性。当我们在自定义对象时,需要重写isEqual:和hash方法,作为自定义对象相等性的判断。

  • 优化判断对象相等性的效率:
    1.首先判断hash值是否相等,若相等则进行第2步;若不等,则直接判断不等;hash值是对象判等的必要非充分条件;(即没它一定不行,有它不一定行)
    2.在hash值相等的情况下,再进行对象判等, 作为判等的结果;
    关于对象相等性判断,请看大神Mattt Thompson的一篇博客 Equality
//当重写hash方法时,我们可以将关键属性的hash值进行位或运算来作为hash值
- (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];
}

//输出对象的调试信息
//description: 使用NSLog从控制台输出对象的信息
 //debugDescription:通过断点po打印输出对象的信息
- (NSString *)debugDescription
{
  NSMutableString *s = [NSMutableString stringWithFormat:@"<%@:%p keyPath:%@", NSStringFromClass([self class]), self, _keyPath];
  if (0 != _options) {
    [s appendFormat:@" options:%@", describe_options(_options)];
  }
  if (NULL != _action) {
    [s appendFormat:@" action:%@", NSStringFromSelector(_action)];
  }
  if (NULL != _context) {
    [s appendFormat:@" context:%p", _context];
  }
  if (NULL != _block) {
    [s appendFormat:@" block:%p", _block];
  }
  [s appendString:@">"];
  return s;
}
  • 请分析如果将实例变量__weak FBKVOController *_controller前的 __weak去掉,它和_FBKVOInfo对象之间的循环引用环是如何形成的?
(三)_FBKVOSharedController

_FBKVOSharedController私有类内部实现了系统KVO的方法,用来接收和转发KVO的通知。接口中提供了监听和移除监听的方法。其接口如下:

@interface _FBKVOSharedController : NSObject

// 单例初始化方法
+ (instancetype)sharedController;

// 监听object的属性
- (void)observe:(id)object info:(nullable _FBKVOInfo *)info;

//移除对object中属性的监听
- (void)unobserve:(id)object info:(nullable _FBKVOInfo *)info;

// 移除对object中多个属性的监听
- (void)unobserve:(id)object infos:(nullable NSSet *)infos;

@end

_FBKVOSharedController私有类内部有两个私有成员变量,_infos是用来存放_FBKVOInfo对象,_infos可以对其中的成员变量弱引用,这也是为何使用NSHashTable,而不使用NSSet来存放_FBKVOInfo对象的原因。_mutex是互斥锁:

{
    //存放被监听属性的信息对象
  NSHashTable<_FBKVOInfo *> *_infos;
    //互斥锁
  pthread_mutex_t _mutex;
}

_FBKVOSharedController私有类的初始化方法,支持iOS 系统和Mac系统,初始化实例变量_infos,指定了_infos对存放在其中的成员变量弱引用,及判等性方式:

//提供全局的单例初始化方法,该单例对象的生命周期与程序的生命周期相同
+ (instancetype)sharedController
{
  static _FBKVOSharedController *_controller = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    _controller = [[_FBKVOSharedController alloc] init];
  });
  return _controller;
}
//初始化成员变量_infos和_mutex
- (instancetype)init
{
  self = [super init];
  if (nil != self) {
    //初始化实例变量
    NSHashTable *infos = [NSHashTable alloc];
      
   // iOS 系统下:hashTable中的对象是弱引用,对象的判等方式:位移指针的hash值和直接判等
#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
    _infos = [infos initWithOptions:NSPointerFunctionsWeakMemory|NSPointerFunctionsObjectPointerPersonality capacity:0];

  //MAC系统下
#elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
    if ([NSHashTable respondsToSelector:@selector(weakObjectsHashTable)]) {
      _infos = [infos initWithOptions:NSPointerFunctionsWeakMemory|NSPointerFunctionsObjectPointerPersonality capacity:0];
    } else {
      // silence deprecated warnings
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
      _infos = [infos initWithOptions:NSPointerFunctionsZeroingWeakMemory|NSPointerFunctionsObjectPointerPersonality capacity:0];
#pragma clang diagnostic pop
    }

#endif
      //初始化互斥锁
    pthread_mutex_init(&_mutex, NULL);
  }
  return self;
}

- (void)dealloc
{
    //对象被销毁时,销毁互斥锁
  pthread_mutex_destroy(&_mutex);
}

_FBKVOSharedController在这个方法中,调用系统KVO方法,将自己注册为观察者,思路如下:
1.首先将被监听的信息对象_FBKVOInfo保存到_infos中;
2.然后调用系统KVO方法将自己注册为被监听对象object的观察者;
3.最后修改监听的状态;当不再监听时,安全移除观察者;

//添加监听
- (void)observe:(id)object info:(nullable _FBKVOInfo *)info
{
    //被监听的属性信息_FBKVOInfo对象为空时,直接返回
  if (nil == info) {
    return;
  }

    // 加锁,防止多线程访问时,出现数据竞争
  pthread_mutex_lock(&_mutex);

   // 将被监听的属性信息info对象添加到_infos中,_infos对成员变量info是弱引用
  [_infos addObject:info];   
 
    //添加完成之后,解锁,其他线程可以访问
  pthread_mutex_unlock(&_mutex);
  
  // 添加监听
  [object addObserver:self forKeyPath:info->_keyPath options:info->_options context:(void *)info];

  //修改监听状态
  if (info->_state == _FBKVOInfoStateInitial) {
      
    info->_state = _FBKVOInfoStateObserving;
      
  } else if (info->_state == _FBKVOInfoStateNotObserving) {
      
      //不再监听时安全移除观察者
    // this could happen when `NSKeyValueObservingOptionInitial` is one of the NSKeyValueObservingOptions,
    // and the observer is unregistered within the callback block.
    // at this time the object has been registered as an observer (in Foundation KVO),
    // so we can safely unobserve it.
    [object removeObserver:self forKeyPath:info->_keyPath context:(void *)info];
  }
}

实现系统KVO监听回调的方法

//被监听属性更改时的回调
- (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;
  {
    pthread_mutex_lock(&_mutex);
  //确定_infos是否包含给定的对象context,若存在返回该对象,否则返回nil;
  //所使用的相等性比较取决于所选择的选项
  //例如,使用NSPointerFunctionsObjectPersonality选项将使用isEqual:方法来判断相等。
    info = [_infos member:(__bridge id)context];
    pthread_mutex_unlock(&_mutex);
  }

//通过上下文参数context传过来的被监听的_FBKVOInfo对象,已经存在_infos中
  if (nil != info) {
  
 //_FBKVOSharedController对象强引用FBKVOController对象,防止被提前释放
 //因为在_FBKVOInfo中,对FBKVOController对象是弱引用
    FBKVOController *controller = info->_controller;
    if (nil != controller) {

      //强引用观察者,在FBKVOController中,FBKVOController对象弱引用观察者observer,防止在使用时已经被释放
      id observer = controller.observer;
      if (nil != observer) {

        //使用自定义block回传监听结果
        if (info->_block) {

          NSDictionary<NSString *, id> *changeWithKeyPath = change;

          //将keyPath添加到字典中以便在观察多个keyPath时,能够清晰知道监听的是哪个keyPath
          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];
        }
      }
    }
  }
}

_FBKVOSharedController实现了移除观察者的方法,思路如下:
1.首先从_infos中移除被监听的属性信息对象info;
2.然后根据监听状态,通过调用系统的方法,移除正在被监听的属性信息对象info;
3.最后修改监听状态;

- (void)unobserve:(id)object info:(nullable _FBKVOInfo *)info
{
  if (nil == info) {
    return;
  }

    //先从HashTable中移除被监听的属性信息对象
  pthread_mutex_lock(&_mutex);
  [_infos removeObject:info];
  pthread_mutex_unlock(&_mutex);

  // 当正在监听时,则移除监听
  if (info->_state == _FBKVOInfoStateObserving) {
    [object removeObserver:self forKeyPath:info->_keyPath context:(void *)info];
  }
    //修改被监听的状态
  info->_state = _FBKVOInfoStateNotObserving;
}
(四)NSObject+FBKVOController

NSObject+FBKVOController 分类比较简单,它主要通过runtime方法,以懒加载的形式给 NSObject ,创建并关联一个 FBKVOController 的对象。

@interface NSObject (FBKVOController)
@property (nonatomic, strong) FBKVOController *KVOController;
@property (nonatomic, strong) FBKVOController *KVOControllerNonRetaining;
@end

五.FBKVOController总结

FBKVOController是线程安全的,相对于系统的KVO而言,使用起来更方便,安全,简洁。
1.NSHashTable和NSMapTable的使用;
2.互斥锁pthread_mutex_t的使用
3.FBKVOController和Observer之间循环引用的形成和解决;
4.FBKVOController和_FBKVOInfo之间循环引用的形成和解决;

推荐阅读更多精彩内容