每个设备只有一个IDFA，不同APP在同一设备上获取IDFA的结果是一样的
设备重启不会产生新的IDFA
但IDFA存在重新生成的情况:
用户完全重置系统(设置程序 -> 通用 -> 还原 -> 还原位置与隐私)
用户明确还原广告(设置程序-> 通用 -> 关于本机 -> 广告 -> 还原广告标示符)
注意：Appstore禁止不使用广告而采集IDFA的app上架。请参考:如何防止应用因获取IDFA被AppStore拒绝

##IDFV-identifierForVendor
依赖：UIKit.framework
系统支持：iOS6及以上系统
获取方式：[UIDevice currentDevice].identifierForVendor.UUIDString
定义：由数字和字母组成的用来标识唯一设备的字符串。
特点： 根据vendor的值，如果vendor相同，则返回同一字符串；如果vendor不同，则返回不同的字符串。
vendor解释：英文解释为卖家，小贩。根据xcode文档解释，正常情况下，会根据App Store提供的数据进行判断。但是如果app不是通过app store进行安装的(如企业应用或开发调试阶段)，那么会根据bundle ID判断。
判断准则

如：com.example.app1和com.example.app2,只有最后的后缀不同，所以会产生相同的vendor ID

详细参考:iOS唯一标示符引导
:https://possiblemobile.com/2013/04/unique-identifiers/

简书:iOS怎样获取设备唯一标识符

转载:http://www.uml.org.cn/c++/200902104.asp

1、先来几个常用的：

// 是否高清屏
#define isRetina ([UIScreen instancesRespondToSelector:@selector(currentMode)] ? CGSizeEqualToSize(CGSizeMake(640, 960), [[UIScreen mainScreen] currentMode].size) : NO)
// 是否模拟器
#define isSimulator (NSNotFound != [[[UIDevice currentDevice] model] rangeOfString:@"Simulator"].location)
// 是否iPad
#define isPad (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)
// 是否iPad
#define someThing (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)? ipad: iphone

2、基本的使用：

//定义π值 3.1415926  
#define PI 3.1415926   
//则在程序用可以如下使用     
double i=2*PI*3;   
//效果相当于  double i=2*3.1415926*3;  

//预处理命令可以定义任何符合格式的形式，例如判断年份是否闰年
#define  IS_LEAP_YEAR  year%4==0&&year%100!=0||year%400==0  
//使用时则可以直接  
if(IS_LEAP_YEAR)  
 
//或者可以定义一个参数    
#define  IS_LEAP_YEAR(y)  y%4==0&&y%100!=0||y%400==0  
//使用时则可以直接   
int ys=2012;   
if(IS_LEAP_YEAR(ys))     
  
//通常预处理程序定义在一行 如果好分行 比如说太长需要换行  需要使用“/”符号 表示还有下一行，多行分列也是如此，例：  
#Define  IS_LEAP_YEAR  year%4==0&&year%100!=0/  
           ||year%400==0   
//宏定义参数后边放一个# 那么在调用该宏时，预处理程序将根据宏参数创建C风格的常量字符串 例：  
#define STR(x) # x  
//将会使得 随后调用的    

NSLOG(STR(Programming in Objective-c./n));  
//显示结果为 Programming in Objective-c./n

3、关于#与##的操作符：

1. 宏定义中字符串化操作符#：
   #的功能是将其后面的宏参数进行字符串化操作，意思就是对它所应用的宏变量通过替换后在其左右各加上一个双引号。例如

#define WARN_IF(EXPR)\
do {\
if (EXPR)\
fprintf(stderr, "Warning: " #EXPR "\n");\
} while(0)

上面代码中的反斜线\主要用来转译换行符，即屏蔽换行符。

那么如下的代码调用：
WARN_IF(divider == 0);

将被解析为：
do {\
if (divider == 0)\
fprintf(stderr, "Warning: " "divider == 0" "\n");\
} while(0);

注意能够字符串化操作的必须是宏参数，不是随随便便的某个子串（token）都行的。

2. 宏定义中的连接符##：
   连接符##用来将两个token连接为一个token，但它不可以位于第一个token之前or最后一个token之后。注意这里连接的对象只要是token就行，而不一定是宏参数,但是##又必须位于宏定义中才有效，因其为编译期概念（比较绕）。

#define LINK_MULTIPLE(a, b, c, d) a##_##b##_##c##_##d
typedef struct _record_type LINK_MULTIPLE(name, company, position, salary);
/*
* 上面的代码将被替换为
* typedef struct _record_type name_company_position_salary;
*/

又如下面的例子：
#define PARSER(N) printf("token" #N " = %d\n", token##N)

int token64 = 64;

如下调用宏：
PARSER(64);

将被解析为：
printf("token" "64" " = %d\n", token64);

在obj-c中，如果我有如下定义：
#define _X(A, B) (A#B)
#define _XX(A, B) _X([NSString stringWithFormat:@"%@_c", A], B)
gcc将报错！
正确的写法为：
#define _XX(A, B) _X(([NSString stringWithFormat:@"%@_c", A]), B)

4、再来个宏定义 object-c 单例

#define GTMOBJECT_SINGLETON_BOILERPLATE(_object_name_, _shared_obj_name_)
static _object_name_ *z##_shared_obj_name_ = nil; 
+ (_object_name_ *)_shared_obj_name_ {            
@synchronized(self) {                           
if (z##_shared_obj_name_ == nil) {            
/* Note that ‘self’ may not be the same as _object_name_ */                              
/* first assignment done in allocWithZone but we must reassign in case init fails */     
z##_shared_obj_name_ = [[self alloc] init];                                              
_GTMDevAssert((z##_shared_obj_name_ != nil), @”didn’t catch singleton allocation”);      
}                                             
}                                               
return z##_shared_obj_name_;                    
}                                                 

+ (id)allocWithZone:(NSZone *)zone {              
@synchronized(self) {                           
if (z##_shared_obj_name_ == nil) {            
z##_shared_obj_name_ = [super allocWithZone:zone];
return z##_shared_obj_name_;                
}                                             
}                                               
 
/* We can’t return the shared instance, because it’s been init’d */
_GTMDevAssert(NO, @”use the singleton API, not alloc+init”);       
return nil;                                     
}                                                 

- (id)retain {                                    
return self;                                    
}                                                 

- (NSUInteger)retainCount {                       
return NSUIntegerMax;                           
}                                                 

- (void)release {                                 
}                                                 

- (id)autorelease {                               
return self;                                    
}                                                 

- (id)copyWithZone:(NSZone *)zone {               
return self;                                    
}

5、条件编译：

#if !defined(FCDebug) || FCDebug == 0
#define FCLOG(...) do {} while (0)
#define FCLOGINFO(...) do {} while (0)
#define FCLOGERROR(...) do {} while (0)
    
#elif FCDebug == 1
#define FCLOG(...) NSLog(__VA_ARGS__)
#define FCLOGERROR(...) NSLog(__VA_ARGS__)
#define FCLOGINFO(...) do {} while (0)
    
#elif FCDebug > 1
#define FCLOG(...) NSLog(__VA_ARGS__)
#define FCLOGERROR(...) NSLog(__VA_ARGS__)
#define FCLOGINFO(...) NSLog(__VA_ARGS__)
#endif

6、参照C语言的预处理命令简介 ：

＃define              定义一个预处理宏
＃undef               取消宏的定义
＃include            包含文件命令
＃include_next   与＃include相似， 但它有着特殊的用途
＃if                      编译预处理中的条件命令， 相当于C语法中的if语句
＃ifdef                判断某个宏是否被定义， 若已定义， 执行随后的语句
＃ifndef             与＃ifdef相反， 判断某个宏是否未被定义
＃elif                  若＃if， ＃ifdef， ＃ifndef或前面的＃elif条件不满足， 则执行＃elif之后的语句， 相当于C语法中的else-if
＃else                与＃if， ＃ifdef， ＃ifndef对应， 若这些条件不满足， 则执行＃else之后的语句， 相当于C语法中的else
＃endif              ＃if， ＃ifdef， ＃ifndef这些条件命令的结束标志.
defined            与＃if， ＃elif配合使用， 判断某个宏是否被定义
＃line                标志该语句所在的行号
＃                      将宏参数替代为以参数值为内容的字符窜常量
＃＃                   将两个相邻的标记（token）连接为一个单独的标记
＃pragma        说明编译器信息＃warning       显示编译警告信息
＃error            显示编译错误信息
#define SAFE_RELEASE(obj) if(obj){[obj release];obj=nil;} 释放

From:How Do I Declare A Block in Objective-C?

简单翻译一下：

作为本地变量的声明方法:

returnType (^blockName)(parameterTypes) = ^returnType(parameters) {...};

属性的声明:

@property (nonatomic, copy, nullability) returnType (^blockName)(parameterTypes);

作为方法的参数声明:

- (void)someMethodThatTakesABlock:(returnType (^nullability)(parameterTypes))blockName;

作为参数被方法调用的声明:

[someObject someMethodThatTakesABlock:^returnType (parameters) {...}];

作为结构体的声明方法:

typedef returnType (^TypeName)(parameterTypes);
TypeName blockName = ^returnType(parameters) {...};

参考:Apple官方的Block编程指南

From:https://mikeash.com/pyblog/friday-qa-2009-01-23.html
##一，前言

Objective-C 中的键(key)-值(value)观察(KVO)并不是什么新鲜事物，它来源于设计模式中的观察者模式，其基本思想就是：

一个目标对象管理所有依赖于它的观察者对象，并在它自身的状态改变时主动通知观察者对象。这个主动通知通常是通过调用各观察者对象所提供的接口方法来实现的。观察者模式较完美地将目标对象与观察者对象解耦。

在 Objective-C 中有两种使用键值观察的方式：手动或自动，此外还支持注册依赖键（即一个键依赖于其他键，其他键的变化也会作用到该键）。下面将一一讲述这些，并会深入 Objective-C 内部一窥键值观察是如何实现的。

本文源码下载：点此下载

##二，运用键值观察

###1，注册与解除注册

如果我们已经有了包含可供键值观察属性的类，那么就可以通过在该类的对象（被观察对象）上调用名为 NSKeyValueObserverRegistration 的 category 方法将观察者对象与被观察者对象注册与解除注册：

- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context;
- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;

这两个方法的定义在 Foundation/NSKeyValueObserving.h 中，NSObject，NSArray，NSSet均实现了以上方法，因此我们不仅可以观察普通对象，还可以观察数组或结合类对象。在该头文件中，我们还可以看到 NSObject 还实现了 NSKeyValueObserverNotification 的 category 方法（更多类似方法，请查看该头文件）：

- (void)willChangeValueForKey:(NSString *)key;
- (void)didChangeValueForKey:(NSString *)key;

这两个方法在手动实现键值观察时会用到，暂且不提。

值得注意的是：不要忘记解除注册，否则会导致资源泄露。

###2，设置属性

将观察者与被观察者注册好之后，就可以对观察者对象的属性进行操作，这些变更操作就会被通知给观察者对象。注意，只有遵循 KVO 方式来设置属性，观察者对象才会获取通知，也就是说遵循使用属性的 setter 方法，或通过 key-path 来设置：

[target setAge:30]; 
[target setValue:[NSNumber numberWithInt:30] forKey:@"age"];

###3，处理变更通知

观察者需要实现名为 NSKeyValueObserving 的 category 方法来处理收到的变更通知：

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context;

在这里，change 这个字典保存了变更信息，具体是哪些信息取决于注册时的 NSKeyValueObservingOptions。

###4，下面来看看一个完整的使用示例：

观察者类：

// Observer.h
@interface Observer : NSObject
@end

// Observer.m
#import "Observer.h"
#import <objc/runtime.h>
#import "Target.h"

@implementation Observer

- (void) observeValueForKeyPath:(NSString *)keyPath
                       ofObject:(id)object 
                         change:(NSDictionary *)change
                        context:(void *)context
{
    if ([keyPath isEqualToString:@"age"])
    {
        Class classInfo = (Class)context;
        NSString * className = [NSString stringWithCString:object_getClassName(classInfo)
                                                  encoding:NSUTF8StringEncoding];
        NSLog(@" >> class: %@, Age changed", className);

        NSLog(@" old age is %@", [change objectForKey:@"old"]);
        NSLog(@" new age is %@", [change objectForKey:@"new"]);
    }
    else
    {
        [super observeValueForKeyPath:keyPath
                             ofObject:object
                               change:change
                              context:context];
    }
}

@end

注意：在实现处理变更通知方法 observeValueForKeyPath 时，要将不能处理的 key 转发给 super 的 observeValueForKeyPath 来处理。

使用示例：

Observer * observer = [[[Observer alloc] init] autorelease];

Target * target = [[[Target alloc] init] autorelease];
[target addObserver:observer
         forKeyPath:@"age"
            options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
            context:[Target class]];

[target setAge:30];
//[target setValue:[NSNumber numberWithInt:30] forKey:@"age"];

[target removeObserver:observer forKeyPath:@"age"];

在这里 observer 观察 target 的 age 属性变化，运行结果如下：

  >> class: Target, Age changed

  old age is 10

  new age is 30

##三，手动实现键值观察

上面的 Target 应该怎么实现呢？首先来看手动实现。

@interface Target : NSObject
{
    int age;
}

// for manual KVO - age
- (int) age;
- (void) setAge:(int)theAge;

@end

@implementation Target

- (id) init
{
    self = [super init];
    if (nil != self)
    {
        age = 10;
    }
    
    return self;
}

// for manual KVO - age
- (int) age
{
    return age;
}

- (void) setAge:(int)theAge
{
    [self willChangeValueForKey:@"age"];
    age = theAge;
    [self didChangeValueForKey:@"age"];
}

+ (BOOL) automaticallyNotifiesObserversForKey:(NSString *)key {
    if ([key isEqualToString:@"age"]) {
        return NO;
    }

    return [super automaticallyNotifiesObserversForKey:key];
}

@end

首先，需要手动实现属性的 setter 方法，并在设置操作的前后分别调用 willChangeValueForKey: 和 didChangeValueForKey方法，这两个方法用于通知系统该 key 的属性值即将和已经变更了；

其次，要实现类方法 automaticallyNotifiesObserversForKey，并在其中设置对该 key 不自动发送通知（返回 NO 即可）。这里要注意，对其它非手动实现的 key，要转交给 super 来处理。

##四，自动实现键值观察

自动实现键值观察就非常简单了，只要使用了属性即可。

@interface Target : NSObject// for automatic KVO - age
@property (nonatomic, readwrite) int age;
@end

@implementation Target
@synthesize age; // for automatic KVO - age

- (id) init
{
    self = [super init];
    if (nil != self)
    {
        age = 10;
    }
    
    return self;
}

@end
 

##五，键值观察依赖键

有时候一个属性的值依赖于另一对象中的一个或多个属性，如果这些属性中任一属性的值发生变更，被依赖的属性值也应当为其变更进行标记。因此，object 引入了依赖键。

###1，观察依赖键

观察依赖键的方式与前面描述的一样，下面先在 Observer 的 observeValueForKeyPath:ofObject:change:context: 中添加处理变更通知的代码：

#import "TargetWrapper.h"

- (void) observeValueForKeyPath:(NSString *)keyPath
                       ofObject:(id)object 
                         change:(NSDictionary *)change
                        context:(void *)context
{
    if ([keyPath isEqualToString:@"age"])
    {
        Class classInfo = (Class)context;
        NSString * className = [NSString stringWithCString:object_getClassName(classInfo)
                                                  encoding:NSUTF8StringEncoding];
        NSLog(@" >> class: %@, Age changed", className);

        NSLog(@" old age is %@", [change objectForKey:@"old"]);
        NSLog(@" new age is %@", [change objectForKey:@"new"]);
    }
    else if ([keyPath isEqualToString:@"information"])
    {
        Class classInfo = (Class)context;
        NSString * className = [NSString stringWithCString:object_getClassName(classInfo)
                                                  encoding:NSUTF8StringEncoding];
        NSLog(@" >> class: %@, Information changed", className);
        NSLog(@" old information is %@", [change objectForKey:@"old"]);
        NSLog(@" new information is %@", [change objectForKey:@"new"]);
    }
    else
    {
        [super observeValueForKeyPath:keyPath
                             ofObject:object
                               change:change
                              context:context];
    }
}

###2，实现依赖键

在这里，观察的是 TargetWrapper 类的 information 属性，该属性是依赖于 Target 类的 age 和 grade 属性。为此，我在 Target 中添加了 grade 属性：

@interface Target : NSObject
@property (nonatomic, readwrite) int grade;
@property (nonatomic, readwrite) int age;
@end

@implementation Target
@synthesize age; // for automatic KVO - age
@synthesize grade;
@end
下面来看看 TragetWrapper 中的依赖键属性是如何实现的。

@class Target;

@interface TargetWrapper : NSObject
{
@private
    Target * _target;
}

@property(nonatomic, assign) NSString * information;
@property(nonatomic, retain) Target * target;

-(id) init:(Target *)aTarget;

@end

#import "TargetWrapper.h"
#import "Target.h"

@implementation TargetWrapper

@synthesize target = _target;

-(id) init:(Target *)aTarget
{
    self = [super init];
    if (nil != self) {
        _target = [aTarget retain];
    }
    
    return self;
}

-(void) dealloc
{
    self.target = nil;
    [super dealloc];
}

- (NSString *)information
{
    return [[[NSString alloc] initWithFormat:@"%d#%d", [_target grade], [_target age]] autorelease];
}

- (void)setInformation:(NSString *)theInformation
{
    NSArray * array = [theInformation componentsSeparatedByString:@"#"];
    [_target setGrade:[[array objectAtIndex:0] intValue]];
    [_target setAge:[[array objectAtIndex:1] intValue]];
}

+ (NSSet *)keyPathsForValuesAffectingInformation
{
    NSSet * keyPaths = [NSSet setWithObjects:@"target.age", @"target.grade", nil];
    return keyPaths;
}

//+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
//{
//    NSSet * keyPaths = [super keyPathsForValuesAffectingValueForKey:key];
//    NSArray * moreKeyPaths = nil;
//    
//    if ([key isEqualToString:@"information"])
//    {
//        moreKeyPaths = [NSArray arrayWithObjects:@"target.age", @"target.grade", nil];
//    }
//    
//    if (moreKeyPaths)
//    {
//        keyPaths = [keyPaths setByAddingObjectsFromArray:moreKeyPaths];
//    }
//    
//    return keyPaths;
//}

@end

首先，要手动实现属性 information 的 setter/getter 方法，在其中使用 Target 的属性来完成其 setter 和 getter。

其次，要实现 keyPathsForValuesAffectingInformation 或 keyPathsForValuesAffectingValueForKey: 方法来告诉系统 information 属性依赖于哪些其他属性，这两个方法都返回一个key-path 的集合。在这里要多说几句，如果选择实现 keyPathsForValuesAffectingValueForKey，要先获取 super 返回的结果 set，然后判断 key 是不是目标 key，如果是就将依赖属性的 key-path 结合追加到 super 返回的结果 set 中，否则直接返回 super的结果。

在这里，information 属性依赖于 target 的 age 和 grade 属性，target 的 age/grade 属性任一发生变化，information 的观察者都会得到通知。

###3，使用示例：

Observer * observer = [[[Observer alloc] init] autorelease];
Target * target = [[[Target alloc] init] autorelease];

TargetWrapper * wrapper = [[[TargetWrapper alloc] init:target] autorelease];
[wrapper addObserver:observer
          forKeyPath:@"information"
             options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
             context:[TargetWrapper class]];

[target setAge:30];
[target setGrade:1];
[wrapper removeObserver:observer forKeyPath:@"information"];

输出结果：

 >> class: TargetWrapper, Information changed

  old information is 0#10

  new information is 0#30

  >> class: TargetWrapper, Information changed

  old information is 0#30

  new information is 1#30

 

##六，键值观察是如何实现的

###1，实现机理

键值观察用处很多，Core Binding 背后的实现就有它的身影，那键值观察背后的实现又如何呢？想一想在上面的自动实现方式中，我们并不需要在被观察对象 Target 中添加额外的代码，就能获得键值观察的功能，这很好很强大，这是怎么做到的呢？答案就是 Objective C 强大的 runtime 动态能力，下面我们一起来窥探下其内部实现过程。

当某个类的对象第一次被观察时，系统就会在运行期动态地创建该类的一个派生类，在这个派生类中重写基类中任何被观察属性的 setter 方法。

派生类在被重写的 setter 方法实现真正的通知机制，就如前面手动实现键值观察那样。这么做是基于设置属性会调用 setter 方法，而通过重写就获得了 KVO 需要的通知机制。当然前提是要通过遵循 KVO 的属性设置方式来变更属性值，如果仅是直接修改属性对应的成员变量，是无法实现 KVO 的。

同时派生类还重写了 class 方法以“欺骗”外部调用者它就是起初的那个类。然后系统将这个对象的 isa 指针指向这个新诞生的派生类，因此这个对象就成为该派生类的对象了，因而在该对象上对 setter 的调用就会调用重写的 setter，从而激活键值通知机制。此外，派生类还重写了 dealloc 方法来释放资源。

如果你对类和对象的关系不太明白，请阅读《深入浅出Cocoa之类与对象》；如果你对如何动态创建类不太明白，请阅读《深入浅出Cocoa 之动态创建类》。

苹果官方文档说得很简洁：

Key-Value Observing Implementation Details

Automatic key-value observing is implemented using a technique called isa-swizzling.

The isa pointer, as the name suggests, points to the object's class which maintains a dispatch table. This dispatch table essentially contains pointers to the methods the class implements, among other data.

When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class. As a result the value of the isa pointer does not necessarily reflect the actual class of the instance.

You should never rely on the isa pointer to determine class membership. Instead, you should use the class method to determine the class of an object instance.

###2，代码分析

由于派生类中被重写的 class 对我们撒谎（它说它就是起初的基类），我们只有通过调用 runtime 函数才能揭开派生类的真面目。 下面来看 Mike Ash 的代码：

首先是带有 x, y, z 三个属性的观察目标 Foo：

@interface Foo : NSObject
{
    int x;
    int y;
    int z;
}

@property int x;
@property int y;
@property int z;

@end

@implementation Foo
@synthesize x, y, z;
@end

下面是检验代码：

#import <objc/runtime.h>

static NSArray * ClassMethodNames(Class c)
{
    NSMutableArray * array = [NSMutableArray array];
    
    unsigned int methodCount = 0;
    Method * methodList = class_copyMethodList(c, &methodCount);
    unsigned int i;
    for(i = 0; i < methodCount; i++) {
        [array addObject: NSStringFromSelector(method_getName(methodList[i]))];
    }

    free(methodList);
    
    return array;
}

static void PrintDescription(NSString * name, id obj)
{
    NSString * str = [NSString stringWithFormat:
                      @"\n\t%@: %@\n\tNSObject class %s\n\tlibobjc class %s\n\timplements methods <%@>",
                      name,
                      obj,
                      class_getName([obj class]),
                      class_getName(obj->isa),
                      [ClassMethodNames(obj->isa) componentsJoinedByString:@", "]];
    NSLog(@"%@", str);
}

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        // Deep into KVO: kesalin@gmail.com
        //
        Foo * anything = [[Foo alloc] init];
        Foo * x = [[Foo alloc] init];
        Foo * y = [[Foo alloc] init];
        Foo * xy = [[Foo alloc] init];
        Foo * control = [[Foo alloc] init];
        
        [x addObserver:anything forKeyPath:@"x" options:0 context:NULL];
        [y addObserver:anything forKeyPath:@"y" options:0 context:NULL];
        
        [xy addObserver:anything forKeyPath:@"x" options:0 context:NULL];
        [xy addObserver:anything forKeyPath:@"y" options:0 context:NULL];
        
        PrintDescription(@"control", control);
        PrintDescription(@"x", x);
        PrintDescription(@"y", y);
        PrintDescription(@"xy", xy);
        
        NSLog(@"\n\tUsing NSObject methods, normal setX: is %p, overridden setX: is %p\n",
               [control methodForSelector:@selector(setX:)],
               [x methodForSelector:@selector(setX:)]);
        NSLog(@"\n\tUsing libobjc functions, normal setX: is %p, overridden setX: is %p\n",
               method_getImplementation(class_getInstanceMethod(object_getClass(control),
                                                                @selector(setX:))),
               method_getImplementation(class_getInstanceMethod(object_getClass(x),
                                                                @selector(setX:))));
    }

    return 0;
}

在上面的代码中，辅助函数 ClassMethodNames 使用 runtime 函数来获取类的方法列表，PrintDescription 打印对象的信息，包括通过 -class 获取的类名， isa 指针指向的类的名字以及其中方法列表。

在这里，我创建了四个对象，x 对象的 x 属性被观察，y 对象的 y 属性被观察，xy 对象的 x 和 y 属性均被观察，参照对象 control 没有属性被观察。在代码的最后部分，分别通过两种方式(对象方法和 runtime 方法)打印出参数对象 control 和被观察对象 x 对象的 setX 方面的实现地址，来对比显示正常情况下 setter 实现以及派生类中重写的 setter 实现。

编译运行，输出如下：

control: <Foo: 0x10010c980>

NSObject class Foo

libobjc class Foo

implements methods <x, setX:, y, setY:, z, setZ:>

x: <Foo: 0x10010c920>

NSObject class Foo

libobjc class NSKVONotifying_Foo

implements methods <setY:, setX:, class, dealloc, _isKVOA>

y: <Foo: 0x10010c940>

NSObject class Foo

libobjc class NSKVONotifying_Foo

implements methods <setY:, setX:, class, dealloc, _isKVOA>

xy: <Foo: 0x10010c960>

NSObject class Foo

libobjc class NSKVONotifying_Foo

implements methods <setY:, setX:, class, dealloc, _isKVOA>

Using NSObject methods, normal setX: is 0x100001df0, overridden setX: is 0x100001df0

Using libobjc functions, normal setX: is 0x100001df0, overridden setX: is 0x7fff8458e025

从上面的输出可以看到，如果使用对象的 -class 方面输出类名始终为：Foo，这是因为新诞生的派生类重写了 -class 方法声称它就是起初的基类，只有使用 runtime 函数 object_getClass 才能一睹芳容：NSKVONotifying_Foo。注意看：x，y 以及 xy 三个被观察对象真正的类型都是 NSKVONotifying_Foo，而且该类实现了：setY:, setX:, class, dealloc, _isKVOA 这些方法。其中 setX:, setY:, class 和 dealloc 前面已经讲到过，私有方法 _isKVOA 估计是用来标示该类是一个 KVO 机制声称的类。在这里 Objective C 做了一些优化，它对所有被观察对象只生成一个派生类，该派生类实现所有被观察对象的 setter 方法，这样就减少了派生类的数量，提供了效率。所有 NSKVONotifying_Foo 这个派生类重写了 setX，setY方法（留意:没有必要重写 setZ 方法）。

接着来看最后两行输出，地址 0x100001df0 是 Foo 类中的实现，而地址是 0x7fff8458e025 是派生类 NSKVONotifying_Foo 类中的实现。那后面那个地址到底是什么呢？可以通过 GDB 的 info 命令加 symbol 参数来查看该地址的信息：

 (gdb) info symbol 0x7fff8458e025

_NSSetIntValueAndNotify in section LC_SEGMENT.__TEXT.__text of /System/Library/Frameworks/Foundation.framework/Versions/C/Foundation

看起来它是 Foundation 框架提供的私有函数：_NSSetIntValueAndNotify。更进一步，我们来看看 Foundation 到底提供了哪些用于 KVO 的辅助函数。打开 terminal，使用 nm -a 命令查看 Foundation 中的信息：

nm -a /System/Library/Frameworks/Foundation.framework/Versions/C/Foundation

其中查找到我们关注的函数：

00000000000233e7 t __NSSetDoubleValueAndNotify
00000000000f32ba t __NSSetFloatValueAndNotify
0000000000025025 t __NSSetIntValueAndNotify
000000000007fbb5 t __NSSetLongLongValueAndNotify
00000000000f33e8 t __NSSetLongValueAndNotify
000000000002d36c t __NSSetObjectValueAndNotify
0000000000024dc5 t __NSSetPointValueAndNotify
00000000000f39ba t __NSSetRangeValueAndNotify
00000000000f3aeb t __NSSetRectValueAndNotify
00000000000f3512 t __NSSetShortValueAndNotify
00000000000f3c2f t __NSSetSizeValueAndNotify
00000000000f363b t __NSSetUnsignedCharValueAndNotify
000000000006e91f t __NSSetUnsignedIntValueAndNotify
0000000000034b5b t __NSSetUnsignedLongLongValueAndNotify
00000000000f3766 t __NSSetUnsignedLongValueAndNotify
00000000000f3890 t __NSSetUnsignedShortValueAndNotify
00000000000f3060 t __NSSetValueAndNotifyForKeyInIvar
00000000000f30d7 t __NSSetValueAndNotifyForUndefinedKey

Foundation 提供了大部分基础数据类型的辅助函数（Objective C中的 Boolean 只是 unsigned char 的 typedef，所以包括了，但没有 C++中的 bool），此外还包括一些常见的 Cocoa 结构体如 Point, Range, Rect, Size，这表明这些结构体也可以用于自动键值观察，但要注意除此之外的结构体就不能用于自动键值观察了。对于所有 Objective C 对象对应的是 __NSSetObjectValueAndNotify 方法。

###七，总结

KVO 并不是什么新事物，换汤不换药，它只是观察者模式在 Objective C 中的一种运用，这是 KVO 的指导思想所在。其他语言实现中也有“KVO”，如 WPF 中的 binding。而在 Objective C 中又是通过强大的 runtime 来实现自动键值观察的。至此，对 KVO 的使用以及注意事项，内部实现都介绍完毕，对 KVO 的理解又深入一层了。Objective 中的 KVO 虽然可以用，但却非完美，有兴趣的了解朋友请查看《KVO 的缺陷》 以及改良实现 MAKVONotificationCenter 。

###八，引用

Key-value observing：官方文档

Key-Value Observing Done Right : 官方 KVO 实现的缺陷

MAKVONotificationCenter : 一个改良的 Notification 实现，托管在 GitHub 上

Controller-->Manager: Request
Note left of Manager: 多个管理类进行数据处理
Manager->Controller:

Note right of Manager: HTTP,Cache,数据处理
Manager->Controller: Model
Controller->View: Data

//Block
typedef void (^OperationCompleteBlock)(AFHTTPRequestOperation *operation, NWResult *result);

2. 缓存工具类|NWCache
   NWOperationManager是一个网络请求基础工具类，它实现了网络请求的GET,POST等请求功能，同时也实现了缓存管理，当然如果和服务器进行配合可以较好的实现缓存详情参考：iOS网络缓存扫盲篇，但是目前服务器还未有该功能设计，而且由于该工程在最初的版本的时候是没有缓存设计的，是后来功能需求增加，所以需要一个缓存工具来实现，NWCache缓存设计的初步思想如下:

st=>start: 发起数据请求
e=>end: 数据
op=>operation: 本地缓存
op1=>operation: 发起网络请求
op2=>operation: 存储数据
cond=>condition: 缓存有效？

st->op->cond
cond(yes)->e(left)

cond(no)->op1->e
op1->op2(left)->e

NWCache类包含缓存的存储有效时间，和存储路径等作为最底层的工具封装。在网络模块中缓存的实现是请求工具类中处理的，管理类中只负责具体请求的缓存要求，
在请求工具类中其中一个基础接口是：

- (AFHTTPRequestOperation *)requestURL:(NSString *)URLString
                               inQueue:(dispatch_queue_t)queue
                               inGroup:(dispatch_group_t)group
                            HttpMethod:(HttpMethod)method
                            parameters:(NSDictionary *)parameters
                    cacheBodyWithBlock:(void (^)(id<NWCacheArgumentProtocol> cacheArgumentProtocol))block
                operationCompleteBlock:(OperationCompleteBlock)completeBlock;

NWCacheArgumentProtocol 是一个缓存的配置协议：

@protocol NWCacheArgumentProtocol <NSObject>
- (void)cacheResponseWithIgnoreCache:(BOOL)ignoreCache
                      supportOffLine:(BOOL)supportOffLine
                  cacheTimeInSeconds:(NSInteger)cacheTimeInSeconds;
@end
@interface NWCacheArgument : NSObject<NWCacheArgumentProtocol>
@property (nonatomic, strong, readonly) NSString *key;
/** 忽略缓存直接请求*/
@property (nonatomic, assign) BOOL ignoreCache;
/** 是否支持离线缓存,默认不支持*/
@property (nonatomic, assign) BOOL supportOffLine;
@property (nonatomic, assign) NSInteger cacheTimeInSeconds;

- (id)initWithKey:(NSString *)key;
@end

数据管理类中某一个请求是这样的：

- (void)fetchReferencesShopsWithNextCursor:(NSInteger)nextCursor
                                  useCache:(BOOL)useCache
                               expiredTime:(NSInteger)expiredTime
                             completeBlock:(CompleteBlock)completeBlock

可以看到该方法中有两个参数是有关缓存的，是否缓存和过期时间，在具体实现的时候有一个方法来处理这两个参数

#pragma mark private base method
- (void)httpRequestMethod:(HttpMethod)method
                      url:(NSString *)url
               parameters:(NSDictionary *)parameters
                 useCache:(BOOL)useCache
              expiredTime:(NSInteger)expiredTime
     requestCompleteBlock:(RequestCompleteBlock)requestCompleteBlock{
    AFHTTPRequestOperation *opreration = nil;
    NSMutableDictionary *param = [self commonArgumentWithUserParameters:parameters];
    DDLogInfo(@"%@:%@",url,param);
    opreration = [[NWOperationManager sharedClient] requestURL:url
                                                       inQueue:self.httpRequest_queue_t
                                                       inGroup:self.httpRequest_group_t
                                                    HttpMethod:method
                                                    parameters:param
                                            cacheBodyWithBlock:^(id<NWCacheArgumentProtocol> cacheArgumentProtocol) {
                                                [cacheArgumentProtocol cacheResponseWithIgnoreCache:!useCache supportOffLine:YES cacheTimeInSeconds:expiredTime];
                                            } operationCompleteBlock:^(AFHTTPRequestOperation *operation, NWResult *result) {
                                                [self requestURI:url operationCompleteBlock:requestCompleteBlock result:result];
                                                DDLogInfo(@"%@:%@",url,result.response);
                                            }];
}

cacheBodyWithBlock该Block就是配置该请求的缓存设置的，

该设计在没有大改早先控制器方法调用的基础上只是修改了 管理类的请求工具调用和增加缓存工具类就实现了自定义的网络请求缓存，目前还能够满足需求。

当然在具体实现中遇到的一些问题是要避免的，首先在缓存数据的时候是有一个Key是很关键的，该key由接口和识别参数，是该参数是需要注意分页中的页码和诸如经纬度等，避免出错。

总之数据管理类的功能是管理和处理数据请求的，解放控制器，让控制器不再进行数据逻辑处理，控制器只负责简单的数据请求，它只要数据不必管这个数据是来自缓存还是来此云端。数据管请求工具返回的数据是简单封装的原始数据（NWResult），然后数据管理进行数据的再封装转为model返回给控制器，当要进行UI展示的时候将数据传输给视图View,这里的数据不建议是model传输，因为要保证解耦，不能让视图与model过多的联系，所以建议以原始数据的形式进行传输。