【iOS KVO(下) KVO的内部结构和源码】

最新推荐文章于 2024-09-06 09:00:00 发布
最新推荐文章于 2024-09-06 09:00:00 发布
阅读量1k 收藏 1
点赞数 1
文章标签： ios objective-c 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61639290/article/details/130516318
版权

前言

学习KVO的过程，我分为了KVO的实现过程分析和内部结构的学习，学习了实现过程，接下来看KVO是通过何种内部结构实现如此通知📢和监听。

1 KVO的存储结构

KVO的实现过程离不开合理的存储结构，用到了如下几个类

  • GSKVOInfo
  • GSKVOPathInfo
  • GSKVOObervation

1.1 GSKVOInfo

KVO是基于NSObject类别实现的非正式协议，所以所有继承于NSObject的类都可以使用KVO，其中可以通过- (void*) observationInfo方法获取对象相关联的所有KVO信息，而返回值就是GSKVOInfo

@interface  GSKVOInfo : NSObject
{
  NSObject          *instance;  // Not retained.
  GSLazyRecursiveLock           *iLock;
  NSMapTable            *paths;
}
  • 它保存了一个对象的实例，重点 Not retained 由于没有持有，也不是weak，- 所以当释放之后，在调用会崩溃，需要在对象销毁前，移除所有观察者
    paths 用于保存keyPath 到 GSKVOPathInfo 的映射：

1.2 GSKVOPathInfo

GSKVOPathInfo 是一个自定义的用于管理KVO路径的类，它可以帮助我们在使用KVO时更加便捷地管理被观察对象的属性路径。

在iOS开发中，使用KVO机制进行观察时，我们可以通过注册被观察对象的属性路径来进行观察。属性路径由一个或多个属性名组成，用“.”连接起来表示属性之间的层次关系，例如 person.address.street 表示 person 对象的 address 属性的 street 子属性。

@interface  GSKVOPathInfo : NSObject
{
@public
  unsigned              recursion;
  unsigned              allOptions;
  NSMutableArray        *observations;
  NSMutableDictionary   *change;
}

它保存了一个keypath对应的所有观察者

  • observations 保存了所有的观察者（GSKVOObservation 类型）
  • allOptions 保存了观察者的options集合
  • change 保存了KVO触发要传递的内容

1.3 GSKVOObervation

在iOS开发中，使用KVO机制进行观察时，系统会自动为我们创建一个观察者对象，并在属性发生变化时调用该观察者的回调方法

它保存了单个观察者的所有信息

@interface  GSKVOObservation : NSObject
{
@public
  NSObject      *observer;      // Not retained (zeroing weak pointer)
  void          *context;
  int           options;
}
@end
  • observer ：观察者对象，即注册 KVO 观察时传入的观察者对象。（Not retained)
  • keyPath ：被观察的属性名。
  • context ：上下文信息，用于在回调方法中区分不同的 KVO 观察。

1.3 有什么关联

GSKVOInfo、GSKVOObservation 和 GSKVOPathInfo 都是在 iOS 开发中使用 KVO 机制时可能会用到的自定义类或结构体，它们之间有一定的关联。

在 KVO 机制中，我们可以通过注册被观察对象的属性路径来进行观察。而 GSKVOPathInfo 类就是用于解析和管理这些属性路径的。每个 GSKVOPathInfo 对象代表一个属性路径。

在注册 KVO 观察时，系统会自动为我们创建一个观察者对象，并在属性发生变化时调用该观察者的回调方法。而在某些情况下，我们可能需要手动管理观察者对象，这时就可以使用 GSKVOObservation 结构体。每个 GSKVOObservation 对象代表一个 KVO 观察。

GSKVOInfo 类则是将 GSKVOPathInfo 和 GSKVOObservation 结合起来，用于管理一个对象的所有 KVO 观察。每个 GSKVOInfo 对象代表一个被观察对象，它包含一个 GSKVOPathInfo 对象列表，表示该对象所有被观察的属性路径，以及一个 GSKVOObservation 结构体列表，表示该对象所有的 KVO 观察。

因此，可以说 GSKVOPathInfo、GSKVOObservation 和 GSKVOInfo 三者之间有一定的层级关系，它们共同构成了 KVO 机制的基本组成部分。

请添加图片描述

2 KVO如何实现属性变化产生通知？

KVO是通过isa-swizzling技术实现的(这句话是整个KVO实现的重点)。在运行时根据原类创建一个中间类，这个中间类是原类的子类，并动态修改当前对象的isa指向中间类。并且将class方法重写，返回原类的Class。所以苹果建议在开发中不应该依赖isa指针，而是通过class实例方法来获取对象类型。

在这里插入图片描述

我的理解

在使用 KVO 机制时，我们可以通过调用 addObserver:forKeyPath:options:context: 方法来注册观察者，并在被观察对象的属性发生变化时，系统会自动调用观察者的回调方法。那么系统是如何实现这一机制的呢？

KVO 机制实际上是通过 isa-swizzling 技术来实现的。当我们注册一个观察者时，系统会生成一个新的子类，继承自被观察对象的类，并将被观察对象的 isa 指针指向这个新生成的子类。这个子类会重写被观察对象的 setter 方法，在 setter 方法中调用原有的 setter 方法，并触发 KVO 机制。也就是说，在设置属性值时，会先调用被观察对象的 setter 方法，然后再调用观察者的回调方法。

因为被观察对象的 isa 指针被修改了，所以这个被观察对象就不再是原有类的实例，而是新生成子类的实例，这个子类中重写了被观察属性的 setter 方法。这样，当属性值发生变化时，就会调用这个新生成子类中的 setter 方法，从而触发 KVO 机制。

2.1 实现isa-swizzling的结构

实现isa-swizzling技术需要用到以下类

  • GSKVOReplacement
  • GSKVOBase
  • GSKVOSetter

2.1.1 GSKVOReplacement

GSKVOReplacement 是 GSKVOObservation 中的一个重要结构体，用于存储在 KVO 机制中替换掉原有 setter 方法的新方法的实现。

GSKVOReplacement 结构体就是用来存储这个被替换掉的原有 setter 方法的实现和新的 setter 方法的实现的

@interface  GSKVOReplacement : NSObject
{
  Class         original;       /* The original class */
  Class         replacement;    /* The replacement class */
  NSMutableSet  *keys;          /* The observed setter keys */
}
- (id) initWithClass: (Class)aClass;
- (void) overrideSetterFor: (NSString*)aKey;
- (Class) replacement;
@end

// 创建
- (id) initWithClass: (Class)aClass
{
  NSValue       *template;
  NSString      *superName;
  NSString      *name;

  original = aClass;

  /*
   * Create subclass of the original, and override some methods
   * with implementations from our abstract base class.
   * 创建原始的子类，并覆盖一些方法
	*使用来自我们抽象基类的实现。
   */
  superName = NSStringFromClass(original);      // original == Temp
  name = [@"GSKVO" stringByAppendingString: superName];    // name = GSKVOTemp
  template = GSObjCMakeClass(name, superName, nil);   // template = GSKVOTemp
  GSObjCAddClasses([NSArray arrayWithObject: template]);
  replacement = NSClassFromString(name);
  GSObjCAddClassBehavior(replacement, baseClass);

  /* Create the set of setter methods overridden.
  	创建一组被重写的setter方法。
   */
  keys = [NSMutableSet new];

  return self;
}
  • 这个类保存了被观察对象原始类信息 original
  • 创建一个原始类的子类 命名为GSKVO<原类名>，iOS系统使用命名规则为NSKVONotifying_原类名
  • 拷贝GSKVOBase类中的方法到新类中
  • 后续会通过object_setClass, 将被观察对象的isa指向这个新类，也就是isa-swizzling技术，而isa保存的是类的信息，也就是说被观察者对象就变成了新类的实例，这个新类用于实现KVO通知机制

2.1.2 GSKVOBase

这个类默认提供了几个方法，都是对NSObject方法的重写，而从上面得知，这些方法都要拷贝到新创建的替换类中。也就是被观察者会拥有这几个方法的实现

- (void) dealloc对象释放后，移除KVO数据，将对象重新指向原始类

- (void) dealloc
{
  // Turn off KVO for self ... then call the real dealloc implementation.
  [self setObservationInfo: nil];
  object_setClass(self, [self class]);
  [self dealloc];
  GSNOSUPERDEALLOC;
}

- (Class) class此方法用来隐藏替换类信息，应用层获取类的信息，仍然是原始类的信息. 所以苹果建议在开发中不应该依赖isa指针，而是通过class实例方法来获取对象类型。

- (Class) class
{
  return class_getSuperclass(object_getClass(self));
}

- (Class) superclass此方法和class方法原理相同

- (Class) superclass
{
  return class_getSuperclass(class_getSuperclass(object_getClass(self)));
}

- (void) setValue: (id)anObject forKey: (NSString*)aKey这个方法是属于KVC中的，重写这个方法，实现在原始类KVC调用前后添加[self willChangeValueForKey: aKey]和[self didChangeValueForKey: aKey],而这两个方法是触发KVO通知的关键。
所以说KVO是基于KVC的，而KVC正是KVO触发的入口。

- (void) setValue: (id)anObject forKey: (NSString*)aKey
{
  Class     c = [self class];
  void      (*imp)(id,SEL,id,id);

  imp = (void (*)(id,SEL,id,id))[c instanceMethodForSelector: _cmd];

  if ([[self class] automaticallyNotifiesObserversForKey: aKey])
    {
      [self willChangeValueForKey: aKey];
      imp(self,_cmd,anObject,aKey);
      [self didChangeValueForKey: aKey];
    }
  else
    {
      imp(self,_cmd,anObject,aKey);
    }
}

2.1.3 GSKVOSetter

@interface  GSKVOSetter : NSObject
- (void) setter: (void*)val;
- (void) setterChar: (unsigned char)val;
- (void) setterDouble: (double)val;
- (void) setterFloat: (float)val;
- (void) setterInt: (unsigned int)val;
- (void) setterLong: (unsigned long)val;
#ifdef  _C_LNG_LNG
- (void) setterLongLong: (unsigned long long)val;
#endif
- (void) setterShort: (unsigned short)val;
- (void) setterRange: (NSRange)val;
- (void) setterPoint: (NSPoint)val;
- (void) setterSize: (NSSize)val;
- (void) setterRect: (NSRect)rect;
@end

这个类和上面重写KVC方法原理相同，将来会替换被观察者keypath的setter方法实现。会在原始setter方法前后添加[self willChangeValueForKey: aKey]和[self didChangeValueForKey: aKey]`

isa-swizzling小结

通过isa-swizzling技术, 替换被观察的类信息，并且hook被观察keyPath setter方法，在原始方法调用前后添加[self willChangeValueForKey: aKey]和[self didChangeValueForKey: aKey]，从而达到监听属性变化的功能

3 KVO的实现过程源码

3.1 - (void) addObserver: (NSObject*)anObserver… 添加观察者.方法

- (void) addObserver: (NSObject*)anObserver
      forKeyPath: (NSString*)aPath
         options: (NSKeyValueObservingOptions)options
         context: (void*)aContext
{
  GSKVOInfo             *info;
  GSKVOReplacement      *r;
  NSKeyValueObservationForwarder *forwarder;
  NSRange               dot;

  setup();
  [kvoLock lock];

  // Use the original class
  r = replacementForClass([self class]);

  /*
   * Get the existing observation information, creating it (and changing
   * the receiver to start key-value-observing by switching its class)
   * if necessary.
   */
  info = (GSKVOInfo*)[self observationInfo];
  if (info == nil)
    {
      info = [[GSKVOInfo alloc] initWithInstance: self];
      [self setObservationInfo: info];
      object_setClass(self, [r replacement]);
    }

  /*
   * Now add the observer.
   */
  dot = [aPath rangeOfString:@"."];
  if (dot.location != NSNotFound)
    {
      forwarder = [[NSKeyValueObservationForwarder alloc]
        initWithKeyPath: aPath
           ofObject: self
         withTarget: anObserver
        context: aContext];
      [info addObserver: anObserver
             forKeyPath: aPath
                options: options
                context: forwarder];
    }
  else
    {
      [r overrideSetterFor: aPath];
      [info addObserver: anObserver
             forKeyPath: aPath
                options: options
                context: aContext];
    }

  [kvoLock unlock];
}

KVO的入口，添加观察者方法，主要做了以下几件事

  • replacementForClass，创建替换类，并且加入到全局classTable中，方便以后使用
    获取对象的监听者数据GSKVOInfo，如果没有就创建新的
info = (GSKVOInfo*)[self observationInfo];
  if (info == nil)
    {
      info = [[GSKVOInfo alloc] initWithInstance: self];
      [self setObservationInfo: info];
      object_setClass(self, [r replacement]);
    }
  • 接下来分为两种情况
    • 1️⃣ 如果利用了点语法(self.keyPath.keyPath), 会利用NSKeyValueObservationForwarder递归创建子对象监听，子对象在将监听到的变化转发到上层，以后再具体分析
if (dot.location != NSNotFound)
    {
      forwarder = [[NSKeyValueObservationForwarder alloc]
        initWithKeyPath: aPath
           ofObject: self
         withTarget: anObserver
        context: aContext];
      [info addObserver: anObserver
             forKeyPath: aPath
                options: options
                context: forwarder];
    }
    • 2️⃣ 默认情况（keyPath）直接监听对象的某个属性，则会调用overrideSetterFor方法，hook属性的setter方法，将setter方法的实现替换为相应参数类型的GSKVOSetter中的方法实现
 else
    {
      [r overrideSetterFor: aPath];
      [info addObserver: anObserver
             forKeyPath: aPath
                options: options
                context: aContext];
    }

然后调用[info addObserver: anObserver forKeyPath: aPath options: options context: aContext];方法，将新的监听保存起来。

3.2 GSKVOInfo 中的添加的方法

- (void) addObserver: (NSObject*)anObserver
      forKeyPath: (NSString*)aPath
         options: (NSKeyValueObservingOptions)options
         context: (void*)aContext
{
  GSKVOPathInfo         *pathInfo;
  GSKVOObservation      *observation;
  unsigned              count;

  if ([anObserver respondsToSelector:
    @selector(observeValueForKeyPath:ofObject:change:context:)] == NO)
    {
      return;
    }
  [iLock lock];
  pathInfo = (GSKVOPathInfo*)NSMapGet(paths, (void*)aPath);
  if (pathInfo == nil)
    {
      pathInfo = [GSKVOPathInfo new];
      // use immutable object for map key
      aPath = [aPath copy];
      NSMapInsert(paths, (void*)aPath, (void*)pathInfo);
      [pathInfo release];
      [aPath release];
    }

  observation = nil;
  pathInfo->allOptions = 0;
  count = [pathInfo->observations count];
  while (count-- > 0)
    {
      GSKVOObservation      *o;

      o = [pathInfo->observations objectAtIndex: count];
      if (o->observer == anObserver)
        {
          o->context = aContext;
          o->options = options;
          observation = o;
        }
      pathInfo->allOptions |= o->options;
    }
  if (observation == nil)
    {
      observation = [GSKVOObservation new];
      GSAssignZeroingWeakPointer((void**)&observation->observer,
    (void*)anObserver);
      observation->context = aContext;
      observation->options = options;
      [pathInfo->observations addObject: observation];
      [observation release];
      pathInfo->allOptions |= options;
    }

  if (options & NSKeyValueObservingOptionInitial)
    {
      /* If the NSKeyValueObservingOptionInitial option is set,
       * we must send an immediate notification containing the
       * existing value in the NSKeyValueChangeNewKey
       */
      [pathInfo->change setObject: [NSNumber numberWithInt: 1]
                           forKey:  NSKeyValueChangeKindKey];
      if (options & NSKeyValueObservingOptionNew)
        {
          id    value;

          value = [instance valueForKeyPath: aPath];
          if (value == nil)
            {
              value = null;
            }
          [pathInfo->change setObject: value
                               forKey: NSKeyValueChangeNewKey];
        }
      [anObserver observeValueForKeyPath: aPath
                                ofObject: instance
                                  change: pathInfo->change
                                 context: aContext];
    }
  [iLock unlock];
}

此方法主要是保存观察者信息

  • 查询相应的GSKVOPathInfo --GSKVOObservation如果有就更新，如果没有就创建新的并保存
  • 如果options中包含NSKeyValueObservingOptionInitial，则立马调用[anObserver observeValueForKeyPath: aPath ofObject: instance change: pathInfo->change context: aContext];发送消息给观察者
  • 其中获取当前值通过KVC中的[instance valueForKeyPath: aPath];获取

3.3 willChangeValueForKey 和 didChangeValueForKey

这两个方法分别添加在setter和KVC 赋值前后，用来保存属性值的变化，以及发送消息给观察者

  • willChangeValueForKey ：
    主要记录属性值的 oldValue保存到pathInfo->change中，如果options包含NSKeyValueObservingOptionPrior，则会遍历所有观察者，立马发送消息给观察者NSKeyValueObservingOptionPrior 表示属性值修改前后都会收到通知
  • didChangeValueForKey
    根据options保存属性的新旧值，遍历所有的观察者，发送消息

3.4 移除观察者

此方法主要用来移除相应keyPath的观察者，方法实现很简单，根据参数传入的anObserver和aPath在前面介绍的数据结构中查询并移除

/*
 * removes the observer
 */
- (void) removeObserver: (NSObject*)anObserver forKeyPath: (NSString*)aPath
{
  GSKVOPathInfo *pathInfo;

  [iLock lock];
  pathInfo = (GSKVOPathInfo*)NSMapGet(paths, (void*)aPath);
  if (pathInfo != nil)
    {
      unsigned  count = [pathInfo->observations count];

      pathInfo->allOptions = 0;
      while (count-- > 0)
        {
          GSKVOObservation      *o;

          o = [pathInfo->observations objectAtIndex: count];
          if (o->observer == anObserver || o->observer == nil)
            {
              [pathInfo->observations removeObjectAtIndex: count];
              if ([pathInfo->observations count] == 0)
                {
                  NSMapRemove(paths, (void*)aPath);
                }
            }
          else
            {
              pathInfo->allOptions |= o->options;
            }
    }
    }
  [iLock unlock];
}

3.5 NSKeyValueObservationForwarder

NSKeyValueObservationForwarder 是一个私有类，用于在 KVO 机制中实现观察者的转发。它主要用于管理观察者和被观察对象之间的关系，并在被观察对象的属性值发生变化时，通知观察者。

@interface NSKeyValueObservationForwarder : NSObject
{
  id                                    target;
  NSKeyValueObservationForwarder        *child;
  void                                  *contextToForward;
  id                                    observedObjectForUpdate;
  NSString                              *keyForUpdate;
  id                                    observedObjectForForwarding;
  NSString                              *keyForForwarding;
  NSString                              *keyPathToForward;
}

NSKeyValueObservationForwarder 类的作用在 KVO 机制中是非常重要的。它实现了观察者和被观察对象之间的关系，保证了观察者可以及时地接收到属性值的变化通知，并且在被观察对象销毁时，可以自动移除所有的观察者，避免内存泄漏。

3.5.1 NSKeyValueObservationForwarder的转发机制

NSKeyValueObservationForwarder 类中的主要方法是 observeValueForKeyPath:ofObject:change:context: 和 dealloc。observeValueForKeyPath:ofObject:change:context: 方法用于在被观察对象的属性值发生变化时，通知所有的观察者。dealloc 方法用于在被观察对象销毁时，移除所有的观察者。

例如 对于keyPath的访问过程，按照key1.key2.key3的路径访问 NSKeyValueObservationForwarder会完成如下事情

请添加图片描述
其中观察者会依次相互引用

- (void) observeValueForKeyPath: (NSString *)keyPath
                       ofObject: (id)anObject
                         change: (NSDictionary *)change
                        context: (void *)context
{
  if (anObject == observedObjectForUpdate)
    {
      [self keyPathChanged: nil];
    }
  else
    {
      [target observeValueForKeyPath: keyPathToForward
                            ofObject: observedObjectForUpdate
                              change: change
                             context: contextToForward];
    }
}

4 KVO总结

  • 主要用了isa-swizzling,修改了观察者的类信息，并且hooksetter方法，当setter方法调用时发送消息给所有观察者
  • 观察者、被观察者的引用都是Not Retain, 所以对象释放前一定要移除观察者。
  • 消息的发送主要由[self willChangeValueForKey: key], [self didChangeValueForKey: key]触发，并且必须成对出现，automaticallyNotifiesObserversForKey方法用来控制，是否要主要添加上述的两个方法，默认返回值为YES，如果返回NO则不会自动添加，也就是说setter的调用以及KVC修改都不会触发通知
  • KVO内部多次用到了KVC
    1️⃣ 重写 setValue:forKey
    2️⃣ 使用valueForKey --- valueForKeyPath获取属性的值，尤其是在使用点语法的时候，只有valueForKeyPath可以获得深层次的属性值。

所以KVO是基于KVC而实现的。

5 KVO和KVC的联系

KVO 和 KVC 都是 Cocoa 框架中的重要机制，它们可以帮助开发者更加方便地操作对象的属性和状态。

  • KVO（Key-Value Observing）是一种基于观察者模式的机制，用于监听对象属性的变化。当一个对象的属性发生变化时，系统会自动通知所有观察这个属性的对象，让它们能够及时地获取到最新的属性值。KVO 的实现依赖于 Objective-C 的动态特性，通过 isa-swizzling 技术实现。

KVO 的使用非常简单，只需要在被观察对象上调用 addObserver:forKeyPath:options:context: 方法，指定观察者对象和被观察的属性，就可以开始监听属性的变化了。当属性的值发生变化时，系统会自动调用观察者对象的 observeValueForKeyPath:ofObject:change:context: 方法，将变化的信息传递给观察者。

  • KVC（Key-Value Coding）是一种通过键值来访问对象属性的机制。通过 KVC，开发者可以直接使用字符串来访问对象的属性，而不需要手动调用 getter 和 setter 方法。KVC 的实现依赖于 Objective-C 的 Runtime 特性，通过方法调用和消息转发机制实现。

KVC 的使用非常灵活，可以用于访问普通对象的属性、集合对象的元素、属性路径等。开发者只需要使用字符串指定要访问的属性或者属性路径，就可以获取或者设置对象的属性值了。KVC 还支持一些高级的特性，比如自动集合操作、键值验证、键值观察等。

KVO 和 KVC 都是 Cocoa 框架中非常重要的机制，它们可以帮助开发者更加方便地操作对象的属性和状态。KVO 主要用于监听对象属性的变化，而 KVC 主要用于通过键值来访问对象属性。在实际开发中，我们通常会同时使用 KVO 和 KVC，以便更好地处理对象的状态和变化

总结

参考
KVO的结构和源码内部实现
KVO KVC的八股文
KVC/KVO的实现

KVC学习了主要的实现过程，KVO的学习是先学会实现的过程，调用什么方法，熟悉过程。然后学习KVO的源码的内部实现才能看懂对应的源码过程。

KVO的学习比较KVC更为复杂，KVO的内部结构和源码更为复杂，2天的学习完全不够 还需要重写阅读博客一步一步在学习过程

Clearlove_Dianfen
关注
KVO实验室
02-20
KVO实验室
IOS KVO Demo
02-19
**iOS KVO (Key-Value Observing) 演示** KVO，即Key-Value Observing，是Objective-C中的一个强大的机制，...通过"SeanKVO"这样的示例，开发者可以更好地理解和掌握KVO的使用，将其有效地应用于iOS应用程序开发中。
iOS KVO (验证Object-C实现流程)
weixin_34191845的博客
09-22 164
前言 在Object-C中有一种观察者模式，即是Key-Value-Observing(KVO)。 利用KVO可以很容易实现视图组件和数据模型的分离。当数据模型的值改变时，会马上触发视图组件，更新视图组件。 在Objc中要实现KVO，必须实现NSKeyValueObServing协议，所幸的是NSObject已经实现该协议，也就是说，几乎所有的Objc对象都可以使用KVO。 本质是: 重写set...
iOS面试：addObserver:forKeyPath:options:context:各个参数的作用分别是什么，observer中需要实现哪个方法才能获得KVO回调？
最新发布
androiios的博客
09-06 480
类型的指针，用于传递任何必要的上下文信息到观察者。通常用于在观察者中区分不同的观察（如：观察同一个对象的不同时刻）或传递状态。这个参数是一个字符串，指定了要观察的属性的键路径。方法来处理这些变化。在实际工作中，正确使用 KVO 可以实现灵活的响应式编程模式，增强应用程序的动态内容更新能力。这个参数指定了观察者对象，也就是当所监控的属性发生变化时，会接收到通知的对象。方法进行 KVO 注册，能够让观察者在某个对象的指定属性发生变化时获得通知。: 发生变化的对象，即你所观察的对象。: 指示被观察的属性的路径。
iOS开发之KVO
黎明的博客
03-14 684
iOS开发之KVO KVO简介： KVO（Key - Value Observing）键值观察，是一种观察者模式的应用。当观察者将被观察者的某个属性设置为观察的对象时，若被观察的该属性值发生变化时，就会触发观察者对象所实现的KVO接口方法，从而达到通知观察者的目的。KVO的定义也是在NSObject的扩展类（NSKeyValueObserving）中实现的，所以只有继承了NSObject的类才...
iOS--KVO的实现原理与具体应用
weixin_30421525的博客
05-03 142
本文分为2个部分：概念与应用。 概念部分旨在剖析KVO这一设计模式的实现原理，应用部分通过创建的项目，以说明KVO技术在iOS开发中所带来的作用； 如果是作为是刚接触KVO的初学者，可以在了解基本原理后粗略看几遍底层实现原理，再认真阅读第二部分的应用内容“学会”怎么去使用KVO，往后再慢慢深入了解KVO这一“黑魔法”技术的实现原理。 【本次开发环境： Xcode:7.2 ...
IOS开发－KVO
三.爷
10-20 238
一、什么是kvo？ key-value observing,观察者模式 观察者，观察对象属性的变化，当被观察者该属性发生变化时，观察者会接收到通知，可以在回调函数中做相应的处理   二、有什么作用？ 变化处理操作可以在同一个函数中进行，先前本人都会在每次修改属性值的地方调用后续操作，比较繁琐，修改的地方也比较多，现在只要在同一个函数中操作就可以 用kvo只要做监控就行，更加方便易用
ios-KVO底层实现--利用runtime简单的实现KVO底层原理.zip
07-11
在iOS开发中，KVO广泛应用于数据绑定和响应式编程。然而，KVO的底层实现往往被开发者视为黑盒。本篇文章将探讨如何利用Objective-C的Runtime机制来实现KVO的基本功能，以增进对这一机制的理解。 1. **Runtime简介**...
iOS-KVO模式源码Demo
05-14
**iOS-KVO模式源码分析** Key-Value Observing（KVO）是Objective-C中一种强大的数据绑定技术，它允许对象监听其他对象的属性变化。KVO是Apple为Foundation和AppKit框架提供的一种机制，使得对象能够自动接收其某个...
IOS源码——ios适用于iOS 5、iOS 6和iOS 7的自定义NavigationBar.zip
10-09
此压缩包"IOS源码——ios适用于iOS 5、iOS 6和iOS 7的自定义NavigationBar.zip"包含了适用于这三个iOS版本的自定义NavigationBar的源代码。以下是关于自定义NavigationBar的一些关键知识点和实现细节： 1. **了解...
IOS源码应用Demo：KVC与KVO监听技术实践
KVC（键值编码）和KVO（键值观察）是iOS开发中的重要技术点，它们允许开发者无需通过访问器方法即可直接读写对象的属性，并且能够观察属性值的变化。KVO机制本质上是通过一种发布-订阅模式来实现的。当被观察的对象...
iOS KVO
kangpp的博客
04-27 1033
KVO今天写一下KVO的实现原理。一、应用1、API（1）给对象添加KVO监听- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context
iOS-KVO
Mazy's Blog
02-28 492
**KVO**
IOS-KVO
Coding_Physical的专栏
05-11 141
KVO（键值观察）机制实现技术，通过修改object对象的ISA指针指向中间代理类NSKVONotifying_xxx,NSKVONotifying_xxx的super_class指针指向原有的观察类对象object class NSKVONotifying_xx生成的中间类重写被观察的对象的四个方法 class ，setter，dealloc，_isKVOA 001 重写class方法 是为了让观察对象调用[object class]返回的原有的类实例 002 重写setter方法 是为了能够监听到
ios-KVO
rv0p111
07-16 371
KVO,即：Key-Value Observing，它提供一种机制，当指定的对象的属性被修改后，则对象就会接受到通知。简单的说就是每次指定的被观察的对象的属性被修改后，KVO就会自动通知相应的观察者了。我们只需要以下步骤来使用就好了1. 注册，指定被观察者的属性 2. 实现回调方法 3. 移除观察。 注册监听对象 //A对象监听B对象中某个属性值的修改，在B对象上添加监听 添加监听： [B
iOS之KVO
SHTLoveXX的专栏
03-09 264
简介： KVO的全称是Key-Value Observing , 翻译过来就是键值监听，可以用于监听某个对象属性值的改变。 常用API : 1: 添加观察者： addObserve：forKeyPatch:option:context: 2:实现观察相应方法： observeValueForKeyPath：ofObject：change：contex...
IOS之KVO
Ho Ho
12-08 489
KVO,即Key Value Observing ，它提供了一种机制，就是指定的对象的属性的值被修改后，则对象就会接受到通知，简而言之，每次被指定的的被观察者的对象的属性被修改后，KVO则自动通知观察者！        做了一个简单的例子，如下： #import "ViewController.h" #import "Persion.h" @interface
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值