runtime總結 iOS

Runtime的特性主要是消息(方法)傳遞，若是消息(方法)在對象中找不到，就進行轉發，具體怎麼實現的呢。咱們從下面幾個方面探尋Runtime的實現機制。

• Runtime介紹
• Runtime消息傳遞
• Runtime消息轉發
• Runtime應用

Runtime介紹

Objective-C 擴展了 C 語言，並加入了面向對象特性和 Smalltalk 式的消息傳遞機制。而這個擴展的核心是一個用 C 和 編譯語言 寫的 Runtime 庫。它是 Objective-C 面向對象和動態機制的基石。

Objective-C 是一個動態語言，這意味着它不只須要一個編譯器，也須要一個運行時系統來動態得建立類和對象、進行消息傳遞和轉發。理解 Objective-C 的 Runtime 機制能夠幫咱們更好的瞭解這個語言，適當的時候還能對語言進行擴展，從系統層面解決項目中的一些設計或技術問題。瞭解 Runtime ，要先了解它的核心 - 消息傳遞 （Messaging）。

Runtime其實有兩個版本: 「modern」 和 「legacy」。咱們如今用的 Objective-C 2.0 採用的是現行 (Modern) 版的 Runtime 系統，只能運行在 iOS 和 macOS 10.5 以後的 64 位程序中。而 macOS 較老的32位程序仍採用 Objective-C 1 中的（早期）Legacy 版本的 Runtime 系統。這兩個版本最大的區別在於當你更改一個類的實例變量的佈局時，在早期版本中你須要從新編譯它的子類，而現行版就不須要。

Runtime 基本是用 C 和彙編寫的，可見蘋果爲了動態系統的高效而做出的努力。你能夠在這裏下到蘋果維護的開源代碼。蘋果和GNU各自維護一個開源的 runtime 版本，這兩個版本之間都在努力的保持一致。

平時的業務中主要是使用官方Api，解決咱們框架性的需求。

高級編程語言想要成爲可執行文件須要先編譯爲彙編語言再彙編爲機器語言，機器語言也是計算機可以識別的惟一語言，可是OC並不能直接編譯爲彙編語言，而是要先轉寫爲純C語言再進行編譯和彙編的操做，從OC到C語言的過渡就是由runtime來實現的。然而咱們使用OC進行面向對象開發，而C語言更多的是面向過程開發，這就須要將面向對象的類轉變爲面向過程的結構體。

Runtime消息傳遞

一個對象的方法像這樣[obj foo]，編譯器轉成消息發送objc_msgSend(obj, foo)，Runtime時執行的流程是這樣的：

• 首先，經過obj的isa指針找到它的 class ;
• 在 class 的 method list 找 foo ;
• 若是 class 中沒到 foo，繼續往它的 superclass 中找 ;
• 一旦找到 foo 這個函數，就去執行它的實現IMP 。

但這種實現有個問題，效率低。但一個class 每每只有 20% 的函數會被常常調用，可能佔總調用次數的 80% 。每一個消息都須要遍歷一次objc_method_list 並不合理。若是把常常被調用的函數緩存下來，那能夠大大提升函數查詢的效率。這也就是objc_class 中另外一個重要成員objc_cache 作的事情 - 再找到foo 以後，把foo 的method_name 做爲key ，method_imp做爲value 給存起來。當再次收到foo 消息的時候，能夠直接在cache 裏找到，避免去遍歷objc_method_list。從前面的源代碼能夠看到objc_cache是存在objc_class 結構體中的。

objec_msgSend的方法定義以下：

OBJC_EXPORT id objc_msgSend(id self, SEL op, ...) 

那消息傳遞是怎麼實現的呢？咱們看看對象(object)，類(class)，方法(method)這幾個的結構體：

//對象 struct objc_object { Class isa OBJC_ISA_AVAILABILITY; }; //類 struct objc_class { Class isa OBJC_ISA_AVAILABILITY; #if !__OBJC2__ Class super_class OBJC2_UNAVAILABLE; const char *name OBJC2_UNAVAILABLE; long version OBJC2_UNAVAILABLE; long info OBJC2_UNAVAILABLE; long instance_size OBJC2_UNAVAILABLE; struct objc_ivar_list *ivars OBJC2_UNAVAILABLE; struct objc_method_list **methodLists OBJC2_UNAVAILABLE; struct objc_cache *cache OBJC2_UNAVAILABLE; struct objc_protocol_list *protocols OBJC2_UNAVAILABLE; #endif } OBJC2_UNAVAILABLE; //方法列表 struct objc_method_list { struct objc_method_list *obsolete OBJC2_UNAVAILABLE; int method_count OBJC2_UNAVAILABLE; #ifdef __LP64__ int space OBJC2_UNAVAILABLE; #endif /* variable length structure */ struct objc_method method_list[1] OBJC2_UNAVAILABLE; } OBJC2_UNAVAILABLE; //方法 struct objc_method { SEL method_name OBJC2_UNAVAILABLE; char *method_types OBJC2_UNAVAILABLE; IMP method_imp OBJC2_UNAVAILABLE; } 

1. 系統首先找到消息的接收對象，而後經過對象的isa找到它的類。
2. 在它的類中查找method_list，是否有selector方法。
3. 沒有則查找父類的method_list。
4. 找到對應的method，執行它的IMP。
5. 轉發IMP的return值。

下面講講消息傳遞用到的一些概念：

• 類對象(objc_class)
• 實例(objc_object)
• 元類(Meta Class)
• Method(objc_method)
• SEL(objc_selector)
• IMP
• 類緩存(objc_cache)
• Category(objc_category)

類對象(objc_class)

Objective-C類是由Class類型來表示的，它其實是一個指向objc_class結構體的指針。

typedef struct objc_class *Class; 

查看objc/runtime.h中objc_class結構體的定義以下：

struct objc_class { Class _Nonnull isa OBJC_ISA_AVAILABILITY; #if !__OBJC2__ Class _Nullable super_class OBJC2_UNAVAILABLE; const char * _Nonnull name OBJC2_UNAVAILABLE; long version OBJC2_UNAVAILABLE; long info OBJC2_UNAVAILABLE; long instance_size OBJC2_UNAVAILABLE; struct objc_ivar_list * _Nullable ivars OBJC2_UNAVAILABLE; struct objc_method_list * _Nullable * _Nullable methodLists OBJC2_UNAVAILABLE; struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE; struct objc_protocol_list * _Nullable protocols OBJC2_UNAVAILABLE; #endif } OBJC2_UNAVAILABLE; 

struct objc_class結構體定義了不少變量，經過命名不難發現，
結構體裏保存了指向父類的指針、類的名字、版本、實例大小、實例變量列表、方法列表、緩存、遵照的協議列表等，
一個類包含的信息也不就正是這些嗎？沒錯，類對象就是一個結構體struct objc_class，這個結構體存放的數據稱爲元數據(metadata)，
該結構體的第一個成員變量也是isa指針，這就說明了Class自己其實也是一個對象，所以咱們稱之爲類對象，類對象在編譯期產生用於建立實例對象，是單例。

實例(objc_object)

/// Represents an instance of a class. struct objc_object { Class isa OBJC_ISA_AVAILABILITY; }; /// A pointer to an instance of a class. typedef struct objc_object *id; 

類對象中的元數據存儲的都是如何建立一個實例的相關信息，那麼類對象和類方法應該從哪裏建立呢？
就是從isa指針指向的結構體建立，類對象的isa指針指向的咱們稱之爲元類(metaclass)，
元類中保存了建立類對象以及類方法所需的全部信息，所以整個結構應該以下圖所示:

 

 

元類(Meta Class)

經過上圖咱們能夠看出整個體系構成了一個自閉環，struct objc_object結構體實例它的isa指針指向類對象，
類對象的isa指針指向了元類，super_class指針指向了父類的類對象，
而元類的super_class指針指向了父類的元類，那元類的isa指針又指向了本身。

元類(Meta Class)是一個類對象的類。
在上面咱們提到，全部的類自身也是一個對象，咱們能夠向這個對象發送消息(即調用類方法)。
爲了調用類方法，這個類的isa指針必須指向一個包含這些類方法的一個objc_class結構體。這就引出了meta-class的概念，元類中保存了建立類對象以及類方法所需的全部信息。
任何NSObject繼承體系下的meta-class都使用NSObject的meta-class做爲本身的所屬類，而基類的meta-class的isa指針是指向它本身。

Method(objc_method)

先看下定義

runtime.h
/// An opaque type that represents a method in a class definition.表明類定義中一個方法的不透明類型 typedef struct objc_method *Method; struct objc_method { SEL method_name OBJC2_UNAVAILABLE; char *method_types OBJC2_UNAVAILABLE; IMP method_imp OBJC2_UNAVAILABLE; 

Method和咱們平時理解的函數是一致的，就是表示可以獨立完成一個功能的一段代碼，好比：

- (void)logName { NSLog(@"name"); } 

這段代碼，就是一個函數。

咱們來看下objc_method這個結構體的內容：

• SEL method_name 方法名
• char *method_types 方法類型
• IMP method_imp 方法實現

在這個結構體重，咱們已經看到了SEL和IMP，說明SEL和IMP其實都是Method的屬性。

咱們接着來看SEL。

SEL(objc_selector)

先看下定義

Objc.h
/// An opaque type that represents a method selector.表明一個方法的不透明類型 typedef struct objc_selector *SEL; 

objc_msgSend函數第二個參數類型爲SEL，它是selector在Objective-C中的表示類型（Swift中是Selector類）。selector是方法選擇器，能夠理解爲區分方法的 ID，而這個 ID 的數據結構是SEL:

@property SEL selector; 

能夠看到selector是SEL的一個實例。

A method selector is a C string that has been registered (or 「mapped「) with the Objective-C runtime. Selectors generated by the compiler are automatically mapped by the runtime when the class is loaded. 

其實selector就是個映射到方法的C字符串，你能夠用 Objective-C 編譯器命令@selector()或者 Runtime 系統的sel_registerName函數來得到一個 SEL 類型的方法選擇器。

selector既然是一個string，我以爲應該是相似className+method的組合，命名規則有兩條：

• 同一個類，selector不能重複
• 不一樣的類，selector能夠重複

這也帶來了一個弊端，咱們在寫C代碼的時候，常常會用到函數重載，就是函數名相同，參數不一樣，可是這在Objective-C中是行不通的，由於selector只記了method的name，沒有參數，因此無法區分不一樣的method。

好比：

- (void)caculate(NSInteger)num; - (void)caculate(CGFloat)num; 

是會報錯的。

咱們只能經過命名來區別：

- (void)caculateWithInt(NSInteger)num; - (void)caculateWithFloat(CGFloat)num; 

在不一樣類中相同名字的方法所對應的方法選擇器是相同的，即便方法名字相同而變量類型不一樣也會致使它們具備相同的方法選擇器。

IMP

看下IMP的定義

/// A pointer to the function of a method implementation. 指向一個方法實現的指針 typedef id (*IMP)(id, SEL, ...); #endif 

就是指向最終實現程序的內存地址的指針。

在iOS的Runtime中，Method經過selector和IMP兩個屬性，實現了快速查詢方法及實現，相對提升了性能，又保持了靈活性。

類緩存(objc_cache)

當Objective-C運行時經過跟蹤它的isa指針檢查對象時，它能夠找到一個實現許多方法的對象。然而，你可能只調用它們的一小部分，而且每次查找時，搜索全部選擇器的類分派表沒有意義。因此類實現一個緩存，每當你搜索一個類分派表，並找到相應的選擇器，它把它放入它的緩存。因此當objc_msgSend查找一個類的選擇器，它首先搜索類緩存。這是基於這樣的理論：若是你在類上調用一個消息，你可能之後再次調用該消息。

爲了加速消息分發， 系統會對方法和對應的地址進行緩存，就放在上述的objc_cache，因此在實際運行中，大部分經常使用的方法都是會被緩存起來的，Runtime系統實際上很是快，接近直接執行內存地址的程序速度。

Category(objc_category)

Category是表示一個指向分類的結構體的指針，其定義以下：

struct category_t { const char *name; classref_t cls; struct method_list_t *instanceMethods; struct method_list_t *classMethods; struct protocol_list_t *protocols; struct property_list_t *instanceProperties; }; 

name：是指 class_name 而不是 category_name。
cls：要擴展的類對象，編譯期間是不會定義的，而是在Runtime階段經過name對 應到對應的類對象。
instanceMethods：category中全部給類添加的實例方法的列表。
classMethods：category中全部添加的類方法的列表。
protocols：category實現的全部協議的列表。
instanceProperties：表示Category裏全部的properties，這就是咱們能夠經過objc_setAssociatedObject和objc_getAssociatedObject增長實例變量的緣由，不過這個和通常的實例變量是不同的。

從上面的category_t的結構體中能夠看出，分類中能夠添加實例方法，類方法，甚至能夠實現協議，添加屬性，不能夠添加成員變量。

Runtime消息轉發

前文介紹了進行一次發送消息會在相關的類對象中搜索方法列表，若是找不到則會沿着繼承樹向上一直搜索知道繼承樹根部（一般爲NSObject），若是仍是找不到而且消息轉發都失敗了就回執行doesNotRecognizeSelector:方法報unrecognized selector錯。那麼消息轉發究竟是什麼呢？接下來將會逐一介紹最後的三次機會。

• 動態方法解析
• 備用接收者
• 完整消息轉發

 

 

動態方法解析

首先，Objective-C運行時會調用 +resolveInstanceMethod:或者 +resolveClassMethod:，讓你有機會提供一個函數實現。若是你添加了函數並返回YES， 那運行時系統就會從新啓動一次消息發送的過程。

實現一個動態方法解析的例子以下：

- (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view, typically from a nib. //執行foo函數 [self performSelector:@selector(foo:)]; } + (BOOL)resolveInstanceMethod:(SEL)sel { if (sel == @selector(foo:)) {//若是是執行foo函數，就動態解析，指定新的IMP class_addMethod([self class], sel, (IMP)fooMethod, "v@:"); return YES; } return [super resolveInstanceMethod:sel]; } void fooMethod(id obj, SEL _cmd) { NSLog(@"Doing foo");//新的foo函數 } 

打印結果：
2018-04-01 12:23:35.952670+0800 ocram[87546:23235469] Doing foo

能夠看到雖然沒有實現foo:這個函數，可是咱們經過class_addMethod動態添加fooMethod函數，並執行fooMethod這個函數的IMP。從打印結果看，成功實現了。

若是resolve方法返回 NO ，運行時就會移到下一步：forwardingTargetForSelector。

備用接收者

若是目標對象實現了-forwardingTargetForSelector:，Runtime 這時就會調用這個方法，給你把這個消息轉發給其餘對象的機會。

實現一個備用接收者的例子以下：

#import "ViewController.h" #import "objc/runtime.h" @interface Person: NSObject @end @implementation Person - (void)foo { NSLog(@"Doing foo");//Person的foo函數 } @end @interface ViewController () @end @implementation ViewController - (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view, typically from a nib. //執行foo函數 [self performSelector:@selector(foo)]; } + (BOOL)resolveInstanceMethod:(SEL)sel { return YES;//返回YES，進入下一步轉發 } - (id)forwardingTargetForSelector:(SEL)aSelector { if (aSelector == @selector(foo)) { return [Person new];//返回Person對象，讓Person對象接收這個消息 } return [super forwardingTargetForSelector:aSelector]; } @end 

打印結果：
2018-04-01 12:45:04.757929+0800 ocram[88023:23260346] Doing foo

能夠看到咱們經過forwardingTargetForSelector把當前ViewController的方法轉發給了Person去執行了。打印結果也證實咱們成功實現了轉發。

完整消息轉發

若是在上一步還不能處理未知消息，則惟一能作的就是啓用完整的消息轉發機制了。
首先它會發送-methodSignatureForSelector:消息得到函數的參數和返回值類型。若是-methodSignatureForSelector:返回nil ，Runtime則會發出 -doesNotRecognizeSelector: 消息，程序這時也就掛掉了。若是返回了一個函數簽名，Runtime就會建立一個NSInvocation 對象併發送 -forwardInvocation:消息給目標對象。

實現一個完整轉發的例子以下：

#import "ViewController.h" #import "objc/runtime.h" @interface Person: NSObject @end @implementation Person - (void)foo { NSLog(@"Doing foo");//Person的foo函數 } @end @interface ViewController () @end @implementation ViewController - (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view, typically from a nib. //執行foo函數 [self performSelector:@selector(foo)]; } + (BOOL)resolveInstanceMethod:(SEL)sel { return YES;//返回YES，進入下一步轉發 } - (id)forwardingTargetForSelector:(SEL)aSelector { return nil;//返回nil，進入下一步轉發 } - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector { if ([NSStringFromSelector(aSelector) isEqualToString:@"foo"]) { return [NSMethodSignature signatureWithObjCTypes:"v@:"];//簽名，進入forwardInvocation } return [super methodSignatureForSelector:aSelector]; } - (void)forwardInvocation:(NSInvocation *)anInvocation { SEL sel = anInvocation.selector; Person *p = [Person new]; if([p respondsToSelector:sel]) { [anInvocation invokeWithTarget:p]; } else { [self doesNotRecognizeSelector:sel]; } } @end 

打印結果：
2018-04-01 13:00:45.423385+0800 ocram[88353:23279961] Doing foo

從打印結果來看，咱們實現了完整的轉發。經過簽名，Runtime生成了一個對象anInvocation，發送給了forwardInvocation，咱們在forwardInvocation方法裏面讓Person對象去執行了foo函數。簽名參數v@:怎麼解釋呢，這裏蘋果文檔Type Encodings有詳細的解釋。

以上就是Runtime的三次轉發流程。下面咱們講講Runtime的實際應用。

Runtime應用

Runtime簡直就是作大型框架的利器。它的應用場景很是多，下面就介紹一些常見的應用場景。

• 關聯對象(Objective-C Associated Objects)給分類增長屬性
• 方法魔法(Method Swizzling)方法添加和替換和KVO實現
• 消息轉發(熱更新)解決Bug(JSPatch)
• 實現NSCoding的自動歸檔和自動解檔
• 實現字典和模型的自動轉換(MJExtension)

關聯對象(Objective-C Associated Objects)給分類增長屬性

咱們都是知道分類是不能自定義屬性和變量的。下面經過關聯對象實現給分類添加屬性。

關聯對象Runtime提供了下面幾個接口：

//關聯對象 void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) //獲取關聯的對象 id objc_getAssociatedObject(id object, const void *key) //移除關聯的對象 void objc_removeAssociatedObjects(id object) 

參數解釋

id object：被關聯的對象 const void *key：關聯的key，要求惟一 id value：關聯的對象 objc_AssociationPolicy policy：內存管理的策略 

內存管理的策略

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) { OBJC_ASSOCIATION_ASSIGN = 0, /**< Specifies a weak reference to the associated object. */ OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object. * The association is not made atomically. */ OBJC_ASSOCIATION_COPY_NONATOMIC = 3, /**< Specifies that the associated object is copied. * The association is not made atomically. */ OBJC_ASSOCIATION_RETAIN = 01401, /**< Specifies a strong reference to the associated object. * The association is made atomically. */ OBJC_ASSOCIATION_COPY = 01403 /**< Specifies that the associated object is copied. * The association is made atomically. */ }; 

下面實現一個UIView的Category添加自定義屬性defaultColor。

#import "ViewController.h" #import "objc/runtime.h" @interface UIView (DefaultColor) @property (nonatomic, strong) UIColor *defaultColor; @end @implementation UIView (DefaultColor) @dynamic defaultColor; static char kDefaultColorKey; - (void)setDefaultColor:(UIColor *)defaultColor { objc_setAssociatedObject(self, &kDefaultColorKey, defaultColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC); } - (id)defaultColor { return objc_getAssociatedObject(self, &kDefaultColorKey); } @end @interface ViewController () @end @implementation ViewController - (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view, typically from a nib. UIView *test = [UIView new]; test.defaultColor = [UIColor blackColor]; NSLog(@"%@", test.defaultColor); } @end 

打印結果：
2018-04-01 15:41:44.977732+0800 ocram[2053:63739] UIExtendedGrayColorSpace 0 1

打印結果來看，咱們成功在分類上添加了一個屬性，實現了它的setter和getter方法。
經過關聯對象實現的屬性的內存管理也是有ARC管理的，因此咱們只須要給定適當的內存策略就好了，不須要操心對象的釋放。

咱們看看內存測量對於的屬性修飾。

內存策略	屬性修飾	描述
OBJC_ASSOCIATION_ASSIGN	@property (assign) 或 @property (unsafe_unretained)	指定一個關聯對象的弱引用。
OBJC_ASSOCIATION_RETAIN_NONATOMIC	@property (nonatomic, strong)	@property (nonatomic, strong) 指定一個關聯對象的強引用，不能被原子化使用。
OBJC_ASSOCIATION_COPY_NONATOMIC	@property (nonatomic, copy)	指定一個關聯對象的copy引用，不能被原子化使用。
OBJC_ASSOCIATION_RETAIN	@property (atomic, strong)	指定一個關聯對象的強引用，能被原子化使用。
OBJC_ASSOCIATION_COPY	@property (atomic, copy)	指定一個關聯對象的copy引用，能被原子化使用。

方法魔法(Method Swizzling)方法添加和替換和KVO實現

方法添加

實際上添加方法剛纔在講消息轉發的時候，動態方法解析的時候就提到了。

//class_addMethod(Class _Nullable __unsafe_unretained cls, SEL _Nonnull name, IMP _Nonnull imp, const char * _Nullable types) class_addMethod([self class], sel, (IMP)fooMethod, "v@:"); 

• cls 被添加方法的類
• name 添加的方法的名稱的SEL
• imp 方法的實現。該函數必須至少要有兩個參數，self,_cmd
• 類型編碼

方法替換

下面實現一個替換ViewController的viewDidLoad方法的例子。

@implementation ViewController + (void)load { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ Class class = [self class]; SEL originalSelector = @selector(viewDidLoad); SEL swizzledSelector = @selector(jkviewDidLoad); Method originalMethod = class_getInstanceMethod(class,originalSelector); Method swizzledMethod = class_getInstanceMethod(class,swizzledSelector); //judge the method named swizzledMethod is already existed. BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod)); // if swizzledMethod is already existed. if (didAddMethod) { class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod)); } else { method_exchangeImplementations(originalMethod, swizzledMethod); } }); } - (void)jkviewDidLoad { NSLog(@"替換的方法"); [self jkviewDidLoad]; } - (void)viewDidLoad { NSLog(@"自帶的方法"); [super viewDidLoad]; } @end 

swizzling應該只在+load中完成。 在 Objective-C 的運行時中，每一個類有兩個方法都會自動調用。+load 是在一個類被初始裝載時調用，+initialize 是在應用第一次調用該類的類方法或實例方法前調用的。兩個方法都是可選的，而且只有在方法被實現的狀況下才會被調用。

swizzling應該只在dispatch_once 中完成,因爲swizzling 改變了全局的狀態，因此咱們須要確保每一個預防措施在運行時都是可用的。原子操做就是這樣一個用於確保代碼只會被執行一次的預防措施，就算是在不一樣的線程中也能確保代碼只執行一次。Grand Central Dispatch 的 dispatch_once知足了所須要的需求，而且應該被當作使用swizzling 的初始化單例方法的標準。

實現圖解以下圖。

 

 

從圖中能夠看出，咱們經過swizzling特性，將selectorC的方法實現IMPc與selectorN的方法實現IMPn交換了，當咱們調用selectorC，也就是給對象發送selectorC消息時，所查找到的對應的方法實現就是IMPn而不是IMPc了。

KVO實現

全稱是Key-value observing，翻譯成鍵值觀察。提供了一種當其它對象屬性被修改的時候能通知當前對象的機制。再MVC大行其道的Cocoa中，KVO機制很適合實現model和controller類之間的通信。

KVO的實現依賴於 Objective-C 強大的 Runtime，當觀察某對象 A 時，KVO 機制動態建立一個對象A當前類的子類，併爲這個新的子類重寫了被觀察屬性 keyPath 的 setter 方法。setter 方法隨後負責通知觀察對象屬性的改變情況。

Apple 使用了 isa-swizzling 來實現 KVO 。當觀察對象A時，KVO機制動態建立一個新的名爲：NSKVONotifying_A的新類，該類繼承自對象A的本類，且 KVO 爲 NSKVONotifying_A 重寫觀察屬性的 setter 方法，setter 方法會負責在調用原 setter 方法以前和以後，通知全部觀察對象屬性值的更改狀況。

• NSKVONotifying_A 類剖析

NSLog(@"self->isa:%@",self->isa); NSLog(@"self class:%@",[self class]); 

在創建KVO監聽前，打印結果爲：

self->isa:A self class:A 

在創建KVO監聽以後，打印結果爲：

self->isa:NSKVONotifying_A self class:A 

在這個過程，被觀察對象的 isa 指針從指向原來的 A 類，被KVO 機制修改成指向系統新建立的子類NSKVONotifying_A 類，來實現當前類屬性值改變的監聽；
因此當咱們從應用層面上看來，徹底沒有意識到有新的類出現，這是系統「隱瞞」了對 KVO 的底層實現過程，讓咱們誤覺得仍是原來的類。可是此時若是咱們建立一個新的名爲「NSKVONotifying_A」的類，就會發現系統運行到註冊 KVO 的那段代碼時程序就崩潰，由於系統在註冊監聽的時候動態建立了名爲 NSKVONotifying_A 的中間類，並指向這個中間類了。

• 子類setter方法剖析

KVO 的鍵值觀察通知依賴於 NSObject 的兩個方法:willChangeValueForKey:和 didChangeValueForKey: ，在存取數值的先後分別調用 2 個方法：
被觀察屬性發生改變以前，willChangeValueForKey:被調用，通知系統該 keyPath 的屬性值即將變動；
當改變發生後， didChangeValueForKey: 被調用，通知系統該keyPath 的屬性值已經變動；以後， observeValueForKey:ofObject:change:context:也會被調用。且重寫觀察屬性的setter 方法這種繼承方式的注入是在運行時而不是編譯時實現的。

KVO 爲子類的觀察者屬性重寫調用存取方法的工做原理在代碼中至關於：

- (void)setName:(NSString *)newName { [self willChangeValueForKey:@"name"]; //KVO 在調用存取方法以前總調用 [super setValue:newName forKey:@"name"]; //調用父類的存取方法 [self didChangeValueForKey:@"name"]; //KVO 在調用存取方法以後總調用 } 

消息轉發(熱更新)解決Bug(JSPatch)

JSPatch 是一個 iOS 動態更新框架，只需在項目中引入極小的引擎，就可使用 JavaScript 調用任何 Objective-C 原生接口，得到腳本語言的優點：爲項目動態添加模塊，或替換項目原生代碼動態修復 bug。

關於消息轉發，前面已經講到過了，消息轉發分爲三級，咱們能夠在每級實現替換功能，實現消息轉發，從而不會形成崩潰。JSPatch不只可以實現消息轉發，還能夠實現方法添加、替換能一系列功能。

實現NSCoding的自動歸檔和自動解檔

原理描述：用runtime提供的函數遍歷Model自身全部屬性，並對屬性進行encode和decode操做。
核心方法：在Model的基類中重寫方法：

- (id)initWithCoder:(NSCoder *)aDecoder { if (self = [super init]) { unsigned int outCount; Ivar * ivars = class_copyIvarList([self class], &outCount); for (int i = 0; i < outCount; i ++) { Ivar ivar = ivars[i]; NSString * key = [NSString stringWithUTF8String:ivar_getName(ivar)]; [self setValue:[aDecoder decodeObjectForKey:key] forKey:key]; } } return self; } - (void)encodeWithCoder:(NSCoder *)aCoder { unsigned int outCount; Ivar * ivars = class_copyIvarList([self class], &outCount); for (int i = 0; i < outCount; i ++) { Ivar ivar = ivars[i]; NSString * key = [NSString stringWithUTF8String:ivar_getName(ivar)]; [aCoder encodeObject:[self valueForKey:key] forKey:key]; } } 

實現字典和模型的自動轉換(MJExtension)

原理描述：用runtime提供的函數遍歷Model自身全部屬性，若是屬性在json中有對應的值，則將其賦值。
核心方法：在NSObject的分類中添加方法

- (instancetype)initWithDict:(NSDictionary *)dict { if (self = [self init]) { //(1)獲取類的屬性及屬性對應的類型 NSMutableArray * keys = [NSMutableArray array]; NSMutableArray * attributes = [NSMutableArray array]; /* * 例子 * name = value3 attribute = T@"NSString",C,N,V_value3 * name = value4 attribute = T^i,N,V_value4 */ unsigned int outCount; objc_property_t * properties = class_copyPropertyList([self class], &outCount); for (int i = 0; i < outCount; i ++) { objc_property_t property = properties[i]; //經過property_getName函數得到屬性的名字 NSString * propertyName = [NSString stringWithCString:property_getName(property) encoding:NSUTF8StringEncoding]; [keys addObject:propertyName]; //經過property_getAttributes函數能夠得到屬性的名字和@encode編碼 NSString * propertyAttribute = [NSString stringWithCString:property_getAttributes(property) encoding:NSUTF8StringEncoding]; [attributes addObject:propertyAttribute]; } //當即釋放properties指向的內存 free(properties); //(2)根據類型給屬性賦值 for (NSString * key in keys) { if ([dict valueForKey:key] == nil) continue; [self setValue:[dict valueForKey:key] forKey:key]; } } return self; } 

做者：jackyshan 連接：https://www.jianshu.com/p/6ebda3cd8052 來源：簡書 簡書著做權歸做者全部，任何形式的轉載都請聯繫做者得到受權並註明出處。